[English](../../README.md) · [简体中文](README.zh-CN.md) · **Русский** · [हिन्दी](README.hi.md) · [العربية](README.ar.md)

<p align="center">
  <img src="../../assets/banner.png" alt="agent-lsp" width="820">
</p>

<p align="center">
  <a href="#tools"><img src="https://img.shields.io/badge/CI--verified_tools-65%2F65-brightgreen.svg" alt="CI Coverage"></a>
  <a href="#multi-language-support"><img src="https://img.shields.io/badge/languages-30_CI--verified-brightgreen.svg" alt="Languages"></a>
  <a href="https://github.com/blackwell-systems/mcp-assert"><img src="https://raw.githubusercontent.com/blackwell-systems/mcp-assert/main/assets/badge-passing.svg?v=3" alt="mcp-assert: passing" height="20"></a>
  <a href="https://agentskills.io"><img src="../../assets/badge-agentskills.svg" alt="Agent Skills"></a>
  <a href="https://github.com/blackwell-systems/agent-lsp"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/blackwell-systems/agent-lsp/badges/assets/downloads-badge.json" alt="downloads"></a>
  <br>
  <a href="https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/"><img src="https://img.shields.io/badge/LSP-3.17-blue.svg" alt="LSP 3.17"></a>
  <a href="../../LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
  <a href="https://github.com/punkpeye/awesome-mcp-servers"><img src="https://img.shields.io/badge/Awesome-MCP%20Servers-fc60a8" alt="Awesome MCP Servers"></a>
  <a href="https://github.com/blackwell-systems"><img src="https://raw.githubusercontent.com/blackwell-systems/blackwell-docs-theme/main/badge-trademark.svg" alt="Blackwell Systems"></a>
</p>

**Инфраструктура интеллектуального анализа кода для AI-агентов.** 65 инструментов, 32 языка, проверенных в CI, 24 рабочих процесса для агентов. Единый бинарный файл Go.

```bash
curl -fsSL https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.sh | sh && agent-lsp init
```

## Что это такое?

agent-lsp — это **MCP-сервер**, который оркестрирует существующие LSP-серверы (gopls, rust-analyzer, jdtls и т. д.), объединяя их в рабочие процессы, ориентированные на агентов.

**Это не LSP-сервер** — это уровень оркестрации, который управляет языковыми серверами и предоставляет пакетные операции, спекулятивное редактирование и многошаговые рабочие процессы через инструменты MCP.

**Архитектура:**
- **Языковые серверы** (gopls, rust-analyzer и т. д.) → предоставляют интеллектуальный анализ кода
- **agent-lsp** (MCP-сервер) → оркестрирует рабочие процессы, поддерживает «прогретую» среду выполнения
- **AI-агенты** → потребляют через протокол MCP

## Зачем нужен agent-lsp?

**Постоянная «прогретая» среда выполнения**  
Языковые серверы сохраняют проиндексированное состояние между сессиями агента. Первая сессия: индексирует рабочее пространство (~10 с для типичных проектов). Последующие сессии: мгновенно. Никаких издержек на холодный старт при каждом запросе.

**Пакетные операции**  
`blast_radius` → один вызов возвращает все экспорты + всех вызывающих (с разделением на тестовых и нетестовых). Без оркестрации: более 20 последовательных вызовов LSP.

**Спекулятивное редактирование**  
`simulate_edit` → предпросмотр изменений в памяти, проверка дельты диагностики, применение или отмена. Тестируйте правки до того, как коснётесь диска.

**Оркестрация рабочих процессов**  
24 навыка, которые связывают операции LSP в законченные конвейеры:
- `/lsp-refactor` → анализ влияния → предпросмотр → применение → проверка сборки → запуск тестов
- `/lsp-safe-edit` → предпросмотр → дифф диагностики → применение, если безопасно
- `/lsp-verify` → диагностика LSP → сборка → набор тестов

**Много языков, одна сессия**  
Один процесс agent-lsp маршрутизирует `.go` в gopls, `.ts` в tsserver, `.py` в pyright. Никакой переконфигурации при переходе между проектами. Сессия сохраняется между файлами и репозиториями.

> [!TIP]
> **Оптимизированный по токенам вывод:** ответы инструментов кодируются в [GCF](https://gcformat.com) вместо JSON. На 30-84% меньше токенов в зависимости от инструмента (до 92,7% с дедупликацией в рамках сессии). [100%-е понимание LLM на каждой передовой модели](https://gcformat.com/guide/benchmarks.html), 91,2% на сложных графах кода, где JSON в среднем даёт 54,1%. См. [ниже](#token-optimized-output-gcf) измеренную экономию по каждому инструменту.

**Как всё это сочетается:** [LSP](https://microsoft.github.io/language-server-protocol/) (Language Server Protocol) — это способ, которым редакторы получают интеллектуальный анализ кода: автодополнения, диагностику, переход к определению. [MCP](https://modelcontextprotocol.io/) (Model Context Protocol) — стандартный способ, которым AI-инструменты вроде Claude Code обнаруживают и вызывают внешние инструменты. agent-lsp соединяет эти два мира: интеллект языкового сервера, доступный AI-агентам.

## Используйте, когда

- Строите агентные системы генерации кода
- Автоматизируете рефакторинги в больших кодовых базах
- Разрабатываете CI-инструментарий, которому нужен программный интеллектуальный анализ кода
- Любой рабочий процесс, где последовательные вызовы LSP слишком медленны или сложны

### Что говорят агенты

Мы попросили AI-агентов оценить agent-lsp на 10 задачах по написанию кода (найти вызывающих, безопасно переименовать, предпросмотреть правки, обнаружить мёртвый код) и дать честную оценку. Четыре разные модели, четыре независимые оценки, один и тот же вывод:

> **Claude (Opus 4.6):** «Я бы рекомендовал agent-lsp для любого рабочего процесса, связанного с рефакторингом, анализом влияния или безопасным редактированием. Выделяющиеся инструменты — это `blast_radius` (радиус влияния за один вызов, с разделением на тестовых/нетестовых, для воспроизведения которого потребовалось бы 5-10 команд grep), `go_to_implementation` (проверенное типами удовлетворение интерфейсов, чего grep попросту не может), и рабочий процесс сессии симуляции (спекулятивная проверка типов без обращения к диску, у которой вообще нет эквивалента в grep/read).»

> **Cursor (auto):** «Я бы рекомендовал agent-lsp для тяжёлых рефакторингов и навигации по коду, потому что инструменты переименования, ссылок, реализаций, иерархии вызовов и симуляции устраняют массу хрупкой работы с grep и ручным редактированием и делают изменения безопаснее.»

> **GPT-5.5 (через Codex):** «Я бы рекомендовал agent-lsp для работы, учитывающей символы: ссылки, реализации, предпросмотры переименований, диагностика и анализ структуры больших файлов заметно быстрее и менее подвержены ошибкам, чем циклы grep/read.»

> **Gemini 2.5 Pro (через Gemini CLI):** «Я бы настоятельно рекомендовал agent-lsp, потому что он обеспечивает уровень семантической осведомлённости, с которым стандартные инструменты текстового поиска попросту не могут сравниться. Возможность выполнять переименования с высокой уверенностью, находить реализации интерфейсов и предпросматривать диагностическое влияние правок без записи на диск существенно снижает риск внесения регрессий.»

### Проверено, а не предположено

Все прочие реализации MCP-LSP перечисляют поддерживаемые языки в конфигурационном файле. Ни одна из них не запускает реальный языковой сервер в CI, чтобы убедиться, что он работает.

CI agent-lsp запускает **32 реальных языковых сервера** против реальных фикстурных кодовых баз при каждом push: Go, Python, TypeScript, Rust, Java, C, C++, C#, Ruby, PHP, Kotlin, Swift, Scala, Zig, Lua, Elixir, Gleam, Clojure, Dart, Terraform, Nix, Prisma, SQL, MongoDB, MQL и другие. Когда мы говорим «работает с gopls», это проверенное, автоматизированное утверждение, а не надежда.

### Спекулятивное выполнение

Симулируйте изменения в памяти перед записью на диск. Ни одна другая реализация MCP-LSP этого не умеет.

`preview_edit` предпросматривает диагностическое влияние любой правки. Вы точно видите, что сломается, ещё до того, как файл будет затронут. `simulate_chain` оценивает последовательность зависимых правок (переименовать функцию, обновить всех вызывающих, изменить тип возвращаемого значения) и сообщает, какой шаг первым вносит ошибку.

8 инструментов спекулятивного выполнения. Полный рабочий процесс см. в [docs/guide/speculative-execution.md](../../docs/guide/speculative-execution.md).

### Экономия токенов

Структурированные ответы LSP используют **в 5-34 раза меньше токенов**, чем grep/read на тех же задачах. На HashiCorp Consul (319 тыс. строк) анализ радиуса влияния использует 17,7 МБ через grep против 841 КБ через LSP, сокращая 5 534 вызова инструментов до 119. Экономия масштабируется с размером кодовой базы. Полный эксперимент по пяти кодовым базам см. в [docs/guide/token-savings.md](../../docs/guide/token-savings.md).

### Оптимизированный по токенам вывод (GCF)

Ответы инструментов кодируются в [GCF (Graph Compact Format)](https://gcformat.com) вместо JSON. GCF устраняет повторение имён полей, повторение идентификаторов и структурные издержки на каждую запись.

| Профиль | Инструменты | Экономия против JSON |
|---------|-------|----------------|
| Tabular | Все 66 инструментов | **30-51%** |
| Graph | blast_radius, find_callers, explore_symbol, find_references, type_hierarchy, cross_repo, detect_changes, list_symbols | **79-84%** |
| Graph + дедупликация в рамках сессии | То же, через [gcf-proxy](https://github.com/blackwell-systems/gcf-proxy) `--session` | **92,7%** (5-й вызов) |

Сгруппированные/вложенные ответы (вызывающие под символом, диагностика со связанной информацией) тоже табулируются, давая ~14% против JSON на этой форме ([подробности](../../docs/guide/gcf-integration.md#nested-container-responses-grouped-data)).

GCF включён по умолчанию. Чтобы вернуться к JSON:

```bash
export AGENT_LSP_OUTPUT_FORMAT=json
```

Бенчмарк: `go run scripts/gcf-benchmark.go`. Детали архитектуры см. в [docs/guide/gcf-integration.md](../../docs/guide/gcf-integration.md).

**GCF:** [gcformat.com](https://gcformat.com) · [Spec](https://github.com/blackwell-systems/gcf) · [Go](https://github.com/blackwell-systems/gcf-go) · [Python](https://github.com/blackwell-systems/gcf-python) · [TypeScript](https://github.com/blackwell-systems/gcf-typescript) · [Playground](https://gcformat.com/playground.html)

### Почему оркестрация важна

AI-агенты вносят некорректные изменения в код, потому что не видят полной картины: кто вызывает эту функцию, что сломается, если я её переименую, проходит ли сборка по-прежнему. У языковых серверов есть ответы, но сырые инструменты LSP требуют более 20 последовательных вызовов и сложной логики оркестрации.

agent-lsp решает это, кодируя корректные многошаговые операции в единичные вызовы и навыки. `blast_radius` делает за один вызов то, на что у агента ушло бы более 20 вызовов. `/lsp-refactor` связывает влияние → предпросмотр → применение → проверку → тест без пооперационной оркестрации на каждый промпт.

### Режим постоянного демона

Проектам на Python и TypeScript требуются минуты фоновой индексации, прежде чем заработает `find_references`. agent-lsp автоматически порождает постоянный брокер-демон, который переживает переходы между сессиями, так что рабочее пространство остаётся проиндексированным. Первая сессия: демон запускается и индексирует (~10 с для FastAPI). Последующие сессии: мгновенное подключение к прогретому демону. Автоматический выход после 30 минут бездействия. Go, Rust и другие быстро индексируемые языки полностью обходят это (нулевые издержки).

### Принуждение к фазам

Навыки сообщают агентам правильный порядок операций. Принуждение к фазам заставляет среду выполнения *блокировать* нарушения, а не полагаться на то, что агент последует инструкциям.

Когда агент активирует навык, каждый вызов инструмента проверяется на соответствие разрешениям текущей фазы. Вызов `apply_edit` во время анализа радиуса влияния не проходит молча; он возвращает ошибку с конкретным руководством по восстановлению («сначала завершите фазу blast_radius, разрешённые инструменты: [blast_radius, find_references]»). Фазы продвигаются автоматически по мере того, как агент вызывает инструменты из более поздних фаз.

Ни один другой поставщик инструментов MCP не принуждает к порядку рабочего процесса во время выполнения. См. [docs/guide/phase-enforcement.md](../../docs/guide/phase-enforcement.md).

### Анализ конкурентности

Инспектор включает 4 проверки конкурентности, работающие для 25 языков в 4 семействах конкурентности (goroutine, thread, async, actor):

- **Невосстановленная конкурентная точка входа**: goroutine/thread/task без восстановления
- **Непроверенное общее состояние**: голые утверждения типа над sync.Map, ConcurrentHashMap
- **Канал никогда не закрывается**: каналы/очереди, созданные, но никогда не закрытые (утечки goroutine)
- **Общее поле без синхронизации**: поля, к которым обращаются из конкурентных контекстов без синхронизации

`blast_radius` помечает символы как `sync_guarded: true`, когда родительский тип имеет мьютекс. `find_callers` с `cross_concurrent: true` прослеживает цепочки вызовов через границы goroutine/thread. Навык `/lsp-concurrency-audit` формирует отчёт о безопасности на уровне полей для любого типа.

### Автоматическая диагностика

Инструменты редактирования символов (`replace_symbol_body`, `insert_after_symbol`, `insert_before_symbol`, `safe_delete_symbol`) автоматически возвращают счётчики `errors_after` и `warnings_after`. Агенты сразу узнают, сломала ли правка что-либо, без отдельного вызова `get_diagnostics`.

`safe_apply_edit` объединяет предпросмотр и применение в одном вызове: спекулятивно предпросматривает и применяет к диску только если `net_delta == 0` (никаких новых ошибок). Один вызов инструмента вместо трёх.

### Работает с

| AI-инструмент | Транспорт | Настройка |
|---------|-----------|-------|
| [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | stdio | `agent-lsp init` |
| [Cursor](https://cursor.com) | stdio | `agent-lsp init` |
| [Windsurf](https://windsurf.com) | stdio | `agent-lsp init` |
| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | stdio | `agent-lsp init` |
| [Continue](https://continue.dev) | stdio | `agent-lsp init` |
| [Cline](https://github.com/cline/cline) | stdio | `agent-lsp init` |
| Любой MCP-клиент | HTTP+SSE | `agent-lsp --http --port 8080` |

Готовые к копированию конфигурации см. в [docs/getting-started/mcp-clients.md](../../docs/getting-started/mcp-clients.md).

## Навыки

Сырые инструменты игнорируются. Навыки используются. Каждый навык кодирует правильную последовательность инструментов, так что рабочие процессы действительно происходят без пооперационных инструкций по оркестрации на каждый промпт. Навыки доступны как слэш-команды [AgentSkills](https://github.com/anthropics/agent-skills) и как MCP-промпты через `prompts/list` / `prompts/get` для любого MCP-клиента.

Полные описания и руководство по использованию см. в [docs/guide/skills.md](../../docs/guide/skills.md).

**Прежде чем что-либо менять**

| Навык | Назначение |
|-------|---------|
| `/lsp-impact` | Анализ радиуса влияния перед тем, как коснуться символа или файла |
| `/lsp-implement` | Найти все конкретные реализации интерфейса |
| `/lsp-dead-code` | Обнаружить экспорты с нулевым числом ссылок перед очисткой |

**Безопасное редактирование**

| Навык | Назначение |
|-------|---------|
| `/lsp-safe-edit` | Спекулятивный предпросмотр до записи на диск; дифф диагностики до/после; выводит действия над кодом при ошибках |
| `/lsp-simulate` | Тестировать изменения в памяти, не касаясь файла |
| `/lsp-edit-symbol` | Редактировать именованный символ, не зная его файла или позиции |
| `/lsp-edit-export` | Безопасное редактирование экспортируемых символов, сначала находит всех вызывающих |
| `/lsp-rename` | Предохранитель `prepare_rename`, предпросмотр всех мест, подтверждение, атомарное применение |

**Начало работы**

| Навык | Назначение |
|-------|---------|
| `/lsp-onboard` | Онбординг проекта в первой сессии: определить языки, составить карту пакетов, найти точки входа и «горячие точки», проверить диагностику |

**Понимание незнакомого кода**

| Навык | Назначение |
|-------|---------|
| `/lsp-explore` | «Расскажи мне об этом символе»: наведение + реализации + иерархия вызовов + ссылки за один проход |
| `/lsp-understand` | Углублённая карта кода для символа или файла: информация о типах, иерархия вызовов, ссылки, исходный код |
| `/lsp-docs` | Трёхуровневая документация: наведение → офлайн-тулчейн → исходный код |
| `/lsp-cross-repo` | Найти все использования символа библиотеки в репозиториях-потребителях |
| `/lsp-local-symbols` | Список символов в рамках файла, поиск использований и информация о типах |

**После редактирования**

| Навык | Назначение |
|-------|---------|
| `/lsp-verify` | Диагностика + сборка + тесты после каждой правки |
| `/lsp-fix-all` | Применить быстрые исправления для всех диагностик в файле |
| `/lsp-test-correlation` | Найти и запустить только те тесты, которые покрывают отредактированный файл |
| `/lsp-format-code` | Отформатировать файл или выделение через форматтер языкового сервера |

**Генерация кода**

| Навык | Назначение |
|-------|---------|
| `/lsp-generate` | Запустить генерацию кода на стороне сервера (заглушки интерфейсов, скелеты тестов, моки) |
| `/lsp-extract-function` | Извлечь блок кода в именованную функцию через действия над кодом |

**Полный рабочий процесс**

| Навык | Назначение |
|-------|---------|
| `/lsp-refactor` | Сквозной рефакторинг: радиус влияния → предпросмотр → применение → проверка → тест |
| `/lsp-inspect` | Полный аудит качества кода (12 проверок): мёртвые символы, покрытие тестами, обработка ошибок, дрейф документации, безопасность конкурентности |
| `/lsp-concurrency-audit` | Аудит безопасности конкурентности на уровне полей для типа: прослеживает конкурентный доступ, помечает несинхронизированные поля |

## Docker

**Режим Stdio** (MCP-клиент порождает контейнер напрямую):

```bash
# Go
docker run --rm -i -v /your/project:/workspace ghcr.io/blackwell-systems/agent-lsp:go go:gopls

# TypeScript
docker run --rm -i -v /your/project:/workspace ghcr.io/blackwell-systems/agent-lsp:typescript typescript:typescript-language-server,--stdio

# Python
docker run --rm -i -v /your/project:/workspace ghcr.io/blackwell-systems/agent-lsp:python python:pyright-langserver,--stdio
```

**Режим HTTP** (постоянная служба, удалённые клиенты подключаются по HTTP+SSE):

```bash
docker run --rm \
  -p 8080:8080 \
  -v /your/project:/workspace \
  -e AGENT_LSP_TOKEN=your-secret-token \
  ghcr.io/blackwell-systems/agent-lsp:go \
  --http --port 8080 go:gopls
```

Образы по умолчанию запускаются от имени пользователя без прав root (uid 65532). Устанавливайте `AGENT_LSP_TOKEN` через переменную окружения, никогда через `--token` в командной строке. Образы также зеркалируются на Docker Hub (`blackwellsystems/agent-lsp`). Полный список тегов, настройку режима HTTP и параметры усиления безопасности см. в [DOCKER.md](../../DOCKER.md).

## Настройка

### Шаг 1: Установите agent-lsp

```bash
curl -fsSL https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.sh | sh
```

<details>
<summary>Альтернативные методы установки</summary>

**macOS / Linux**

```bash
brew install blackwell-systems/tap/agent-lsp
```

**Windows**

```powershell
# PowerShell (no admin required)
iwr -useb https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.ps1 | iex

# Scoop
scoop bucket add blackwell-systems https://github.com/blackwell-systems/agent-lsp
scoop install blackwell-systems/agent-lsp

# Winget
winget install BlackwellSystems.agent-lsp
```

**Все платформы**

```bash
# pip
pip install agent-lsp

# npm
npm install -g @blackwell-systems/agent-lsp

# Go install
go install github.com/blackwell-systems/agent-lsp/cmd/agent-lsp@latest
```

</details>

### Шаг 2: Установите языковые серверы

Установите серверы для вашего стека. Распространённые:

| Язык | Сервер | Установка |
|----------|--------|---------|
| TypeScript / JavaScript | `typescript-language-server` | `npm i -g typescript-language-server typescript` |
| Python | `pyright-langserver` | `npm i -g pyright` |
| Go | `gopls` | `go install golang.org/x/tools/gopls@latest` |
| Rust | `rust-analyzer` | `rustup component add rust-analyzer` |
| C / C++ | `clangd` | `apt install clangd` / `brew install llvm` |
| Ruby | `solargraph` | `gem install solargraph` |

Полный список из 32 поддерживаемых языков в [docs/reference/language-support.md](../../docs/reference/language-support.md).

### Шаг 3: Проверьте настройку

```bash
agent-lsp doctor
```

Проверяет каждый настроенный языковой сервер и сообщает о его возможностях. Устраните любые сбои перед продолжением. Команды установки и особенности конкретных серверов см. в [поддержке языков](../../docs/reference/language-support.md).

### Шаг 4: Настройте ваш AI-инструмент

```bash
agent-lsp init
```

Обнаруживает языковые серверы в вашем PATH, спрашивает, какой AI-инструмент вы используете, записывает правильную конфигурацию MCP и устанавливает правила осведомлённости о навыках для вашего AI-провайдера (CLAUDE.md для Claude Code, `.cursor/rules/` для Cursor, `.clinerules` для Cline, `.windsurfrules` для Windsurf, `GEMINI.md` для Gemini CLI). Для CI или скриптового использования: `agent-lsp init --non-interactive`.

Сгенерированная конфигурация выглядит так:

```json
{
  "mcpServers": {
    "lsp": {
      "type": "stdio",
      "command": "agent-lsp",
      "args": [
        "go:gopls",
        "typescript:typescript-language-server,--stdio",
        "python:pyright-langserver,--stdio"
      ]
    }
  }
}
```

Каждый аргумент имеет вид `language:server-binary` (аргументы сервера разделяются запятыми).

### Шаг 5: Установите навыки

```bash
git clone https://github.com/blackwell-systems/agent-lsp.git /tmp/agent-lsp-skills
cd /tmp/agent-lsp-skills/skills && ./install.sh --copy
```

Навыки — это файлы промптов, копируемые в конфигурацию вашего AI-инструмента. `--copy` означает, что клон затем можно безопасно удалить.

Навыки также доступны как **MCP-промпты**: любой MCP-клиент может обнаружить их через `prompts/list` и получить полные инструкции рабочего процесса через `prompts/get`, без ручной установки. Путь `install.sh` предназначен для клиентов, совместимых с AgentSkills (слэш-команды Claude Code).

### Шаг 6: Разрешите права инструментов (Claude Code)

Для Claude Code добавьте `mcp__lsp__*` в свой список разрешений, чтобы все 65 инструментов были доступны без запросов на подтверждение по каждому инструменту:

```json
// ~/.claude/settings.json
{
  "permissions": {
    "allow": ["mcp__lsp__*"]
  }
}
```

Без этого Claude Code будет запрашивать разрешение при каждом вызове инструмента. Другие MCP-клиенты обрабатывают разрешения иначе; сверьтесь с документацией вашего клиента.

Навыки — это многоинструментальные рабочие процессы, кодирующие надёжные процедуры: проверка радиуса влияния перед правкой, спекулятивный предпросмотр перед записью, запуск тестов после изменения. Полный список см. в [docs/guide/skills.md](../../docs/guide/skills.md).

### Шаг 7: Начните работать

Ваш AI-агент вызывает инструменты автоматически. Первый вызов инициализирует рабочее пространство:

```
start_lsp(root_dir="/your/project")
```

Это то, что делает агент, а не то, что вы вводите. Затем используйте любой из 65 инструментов. Сессия остаётся прогретой; при переключении файлов перезапуск не нужен.

## Что уникально в agent-lsp

| Возможность | Детали |
|------------|---------|
| Инструменты | **65** |
| Языки (проверенные в CI) | **32**, сквозные интеграционные тесты при каждом push |
| Рабочие процессы агентов (навыки) | **24**, именованные многошаговые процедуры, обнаруживаемые через MCP `prompts/list` |
| Спекулятивное выполнение | **8 инструментов**, симуляция изменений перед записью на диск |
| Принуждение к фазам | **4 навыка**, среда выполнения блокирует внеочередные вызовы инструментов с руководством по восстановлению |
| Модель соединения | **постоянная**, прогретый индекс между файлами и проектами |
| Иерархия вызовов | **✓**, единый инструмент, параметр направления |
| Иерархия типов | **✓**, проверено в CI |
| Межрепозиторные ссылки | **✓**, многокорневое рабочее пространство |
| Автослежение | **✓**, всегда включено, отслеживание файлов с антидребезгом |
| Транспорт HTTP+SSE | **✓**, аутентификация по bearer token, Docker без root |
| Распространение | **единый бинарный файл Go**, 10 каналов установки |

## Сценарии использования

- **Мультипроектные сессии**: направьте свой AI на `~/code/`, работайте в любом проекте без переконфигурации
- **Полиглотная разработка**: бэкенд на Go + фронтенд на TypeScript + скрипты на Python в одной сессии
- **Большие монорепозитории**: один сервер обрабатывает все языки, маршрутизирует по расширению файла
- **Миграция кода**: рефакторинг между репозиториями с полным отслеживанием межрепозиторных ссылок
- **CI-конвейеры**: проверка против реального поведения языкового сервера
- **Нишевые языковые стеки**: Gleam, Elixir, Prisma, Zig, Clojure, Nix, Dart, Scala, MongoDB — всё проверено в CI

## Поддержка нескольких языков

32 языка, сквозная проверка в CI против реальных языковых серверов при каждом запуске CI. Ни одна другая реализация MCP-LSP не тестирует в CI ни одного языка.

Go, Python, TypeScript, Rust, Java, C, C++, C#, Ruby, PHP, Kotlin, Swift, Scala, Zig, Lua, Elixir, Gleam, Clojure, Dart, Terraform, Nix, Prisma, SQL, MongoDB, JavaScript, YAML, JSON, Dockerfile, CSS, HTML, MQL.

Полную матрицу покрытия см. в [docs/reference/language-support.md](../../docs/reference/language-support.md).

## Инструменты

65 инструментов, охватывающих навигацию, анализ, рефакторинг, редактирование символов, композитное исследование, безопасное редактирование, спекулятивное выполнение и жизненный цикл сессии. Всё проверено в CI.

Полный справочник с параметрами и примерами см. в [docs/reference/tools.md](../../docs/reference/tools.md).

## Дополнительное чтение

### Документация

- [Справочник по инструментам](../../docs/reference/tools.md): полный справочник по инструментам с параметрами и примерами
- [Справочник по навыкам](../../docs/guide/skills.md): справочник по навыкам, рабочие процессы, сценарии использования и композиция
- [Поддержка языков](../../docs/reference/language-support.md): матрица покрытия языков
- [Архитектура](../../docs/architecture/architecture.md): системный дизайн и внутреннее устройство
- [Спекулятивное выполнение](../../docs/guide/speculative-execution.md): рабочие процессы «симулируй, потом применяй»
- [Соответствие LSP](../../docs/reference/lsp-conformance.md): покрытие спецификации LSP 3.17
- [Docker](../../DOCKER.md): теги Docker, compose и кэширование томов

### Участие в разработке

- [Заметки по CI](../../docs/architecture/ci-notes.md): особенности CI и детали тестовой оснастки
- [Распространение](../../docs/architecture/distribution.md): каналы установки и конвейер релизов

## Разработка

```bash
git clone https://github.com/blackwell-systems/agent-lsp.git
cd agent-lsp && go build ./...
go test ./...                   # unit tests
go test ./... -tags integration # integration tests (requires language servers)
```

## Использование как библиотеки

Пакеты `pkg/lsp`, `pkg/session` и `pkg/types` предоставляют стабильный Go API для непосредственного использования LSP-клиента agent-lsp без запуска MCP-сервера.

```go
import "github.com/blackwell-systems/agent-lsp/pkg/lsp"

client := lsp.NewLSPClient("gopls", []string{})
client.Initialize(ctx, "/path/to/workspace")
defer client.Shutdown(ctx)

locs, err := client.GetDefinition(ctx, fileURI, lsp.Position{Line: 10, Character: 4})
```

Полный API пакетов см. в [docs/architecture/architecture.md](../../docs/architecture/architecture.md).

## Лицензия

MIT