micro-models-agent 2.11.0 → 2.12.0

package/dist/modules/lsp/check-tool.js

@@ -1,11 +1,13 @@
+// lsp_check: сбор файлов для проверки и форматирование диагностик.
 import { readdir, stat } from "fs/promises";
 import { resolve, relative } from "path";
 import { getServerForFile } from "./config";
 import { toForwardSlash } from "../../tools/path-utils";
-/** lsp_check directory mode: walk depth and per-call file cap. */
+/** Режим каталога lsp_check: глубина обхода и кап файлов на вызов. */
 export const MAX_LSP_CHECK_FILES = 15;
 const MAX_LSP_WALK_DEPTH = 4;
 const SKIP_DIRS = new Set(["node_modules", ".git", ".mma", "dist"]);
+/** Подписи severity диагностик. */
 export const severityLabels = {
     1: "error",
     2: "warning",
@@ -13,10 +15,9 @@ export const severityLabels = {
     4: "hint",
 };
 /**
- * Resolve the target to a file (single check) or a bounded list of source
- * files (directory check, capped at MAX_LSP_CHECK_FILES). Only files with a
- * configured LSP server are collected, so unsupported extensions are simply
- * not checked rather than producing noise.
+ * Резолв цели: файл (точечная проверка) или ограниченный список исходников
+ * (проверка каталога, кап MAX_LSP_CHECK_FILES). Собираются только файлы с
+ * настроенным LSP-сервером — неподдерживаемые расширения молча не проверяются.
  */
 export async function collectCheckFiles(resolved, config) {
     const info = await stat(resolved).catch(() => null);
@@ -45,6 +46,7 @@ async function walkDir(dir, depth, out, config) {
         }
     }
 }
+/** Форматировать диагностики списком `файл(стр,кол): severity: текст` (первые 40). */
 export function formatCheckDiagnostics(items, baseDir) {
     return items
         .slice(0, 40)

package/dist/modules/lsp/client.js

@@ -1,3 +1,4 @@
+// LSP-клиент: spawn сервера, JSON-RPC поверх stdio, диагностики, tree-kill при shutdown.
 import { spawn, execSync } from "child_process";
 import { resolve } from "path";
 import { platform } from "os";
@@ -5,11 +6,11 @@ import { resolveSpawnCommand, buildWinCommandLine } from "./command";
 import { killTree } from "../processes/registry";
 import { toForwardSlash } from "../../tools/path-utils";
 import { errMsg } from "../../utils";
+import { LSP_DEFAULT_TIMEOUT_MS as DEFAULT_TIMEOUT } from "../../config/timeouts";
 /**
- * Logger adapter that writes LSP diagnostics to app.jsonl only — never to
- * console/terminal. LSP warnings are noisy (timeout on first run, npx
- * install) and should be diagnosable from session files without polluting
- * the user's chat.
+ * Логгер-адаптер: LSP-диагностику только в app.jsonl, никогда в консоль/терминал.
+ * LSP-предупреждения шумные (таймаут на первом запуске, установка npx) и должны
+ * диагностироваться из файлов сессии, не мусор в чате пользователя.
  */
 export class FileOnlyLogger {
     logger;
@@ -29,9 +30,10 @@ export class FileOnlyLogger {
         this.logger.logSilent("error", msg, meta);
     }
 }
-const DEFAULT_TIMEOUT = 15000;
+/** LSP-клиент: checkFile/probe поверх spawn + initialize + shutdown. */
 export class LspClient {
     logger = null;
+    /** Назначить логгер (null — молчать). */
     setLogger(logger) {
         this.logger = logger;
     }
@@ -44,6 +46,7 @@ export class LspClient {
     diagnosticsResolve = null;
     diagnosticsTimer = null;
     initialized = false;
+    /** Проверить файл: открыть в сервере, дождаться publishDiagnostics, вернуть их. */
     async checkFile(filePath, baseDir, config, projectRoot = baseDir) {
         const timeout = config.timeout ?? DEFAULT_TIMEOUT;
         try {
@@ -71,7 +74,7 @@ export class LspClient {
             return await diagPromise;
         }
         catch (e) {
-            // Re-throw so the LspModule can surface failures instead of hiding them.
+            // Пробросить наружу, чтобы LspModule показал падение, а не спрятал.
             throw e instanceof Error ? e : new Error(String(e));
         }
         finally {
@@ -79,10 +82,9 @@ export class LspClient {
         }
     }
     /**
-     * Lightweight "does the server actually start" probe: spawn + initialize +
-     * shutdown. Used by the REPL banner to surface a dead server (npx
-     * auto-install failure, wrong package name, missing binary) up front instead
-     * of the first write_file timing out.
+     * Лёгкая проба «сервер реально стартует»: spawn + initialize + shutdown.
+     * Для баннера REPL — мёртвый сервер (упавшая npx-автоустановка, неверное имя
+     * пакета, нет бинарника) виден заранее, а не таймаутом первого write_file.
      */
     async probe(config, projectRoot, timeout) {
         try {
@@ -110,7 +112,7 @@ export class LspClient {
                 command: config.command,
                 projectRoot,
             });
-            // npx auto-install can blow past the initialize timeout on first run — retry once.
+            // npx-автоустановка может вылететь за таймаут initialize на первом запуске — один ретрай.
             if (!(e instanceof Error) || !e.message.includes("initialize"))
                 throw e;
             await this.shutdown();
@@ -138,9 +140,9 @@ export class LspClient {
                 throw new Error(`${config.command} not found in PATH`);
             }
         }
-        // When the command is npx, try to find the actual binary globally first.
-        // npx downloads packages on every invocation (slow on Windows, ~8-15s),
-        // even when the binary is already installed globally.
+        // Команда npx — сначала ищем реальный бинарник глобально.
+        // npx качает пакеты на каждый вызов (на Windows медленно, ~8-15с),
+        // даже если бинарник уже стоит глобально.
         let effectiveCommand = config.command;
         let effectiveArgs = config.args ?? [];
         if (config.command === "npx" && effectiveArgs.length > 0) {
@@ -149,13 +151,13 @@ export class LspClient {
                 const whichCmd = platform() === "win32" ? `where ${binaryName}` : `which ${binaryName}`;
                 try {
                     execSync(whichCmd, { stdio: "pipe", timeout: 3000 });
-                    // Binary found globally — use it directly, skip npx.
+                    // Бинарник есть глобально — напрямую, без npx.
                     effectiveCommand = binaryName;
                     effectiveArgs = effectiveArgs.filter((a) => a !== "--yes" && a !== "--package" && a !== binaryName && !this.isPackageVersion(a));
                     this.logger?.debug(`LSP: using globally installed ${binaryName} (skipped npx)`);
                 }
                 catch {
-                    // Not found globally — fall back to npx (will auto-install).
+                    // Глобально нет — фолбэк на npx (самоустановится).
                     this.logger?.debug(`LSP: ${binaryName} not found globally, falling back to npx`);
                 }
             }
@@ -169,14 +171,13 @@ export class LspClient {
                 stdio: ["pipe", "pipe", "pipe"],
                 env: { ...process.env, ...config.env },
                 cwd: projectRoot,
-                // POSIX: make the child a process-group leader so killTree()'s
-                // `kill(-pid)` reaches the whole chain (npx → node → tsserver).
-                // Without it the group kill fails with ESRCH and grandchildren
-                // survive as orphans. Windows relies on taskkill /T instead.
+                // POSIX: потомок — лидер группы, чтобы `kill(-pid)` killTree() доставал
+                // всю цепочку (npx → node → tsserver). Без этого групповой kill падает
+                // с ESRCH, а внуки выживают сиротами. Windows — taskkill /T.
                 detached: !isWin,
             };
             if (isWin) {
-                // A `.cmd` shim can't be spawned directly under Node (`spawn npx EINVAL`) — run via cmd.exe.
+                // `.cmd`-шим напрямую под Node не спавнится (`spawn npx EINVAL`) — через cmd.exe.
                 spawnCommand = buildWinCommandLine(spawnCommand, args);
                 spawnArgs = [];
                 spawnOpts.shell = true;
@@ -210,7 +211,7 @@ export class LspClient {
                 const headerEnd = this.buffer.indexOf("\r\n\r\n");
                 if (headerEnd === -1)
                     return;
-                // Headers are ASCII — decode just the header slice.
+                // Заголовки — ASCII: декодим только срез заголовка.
                 const header = this.buffer.subarray(0, headerEnd).toString("utf8");
                 const match = header.match(/Content-Length: (\d+)/i);
                 if (!match) {
@@ -218,7 +219,7 @@ export class LspClient {
                     continue;
                 }
                 this.contentLength = parseInt(match[1], 10);
-                // Guard against malicious/buggy servers sending absurd Content-Length
+                // Защита от злонамеренных/битых серверов с абсурдным Content-Length
                 if (this.contentLength > 10 * 1024 * 1024) {
                     this.buffer = this.buffer.subarray(headerEnd + 4);
                     this.contentLength = -1;
@@ -226,9 +227,9 @@ export class LspClient {
                 }
                 this.buffer = this.buffer.subarray(headerEnd + 4);
             }
-            // Content-Length counts BYTES, not JS characters. Slicing a decoded
-            // string by character count corrupts frames containing multi-byte
-            // UTF-8 (e.g. Cyrillic diagnostics) — keep the remainder as raw bytes.
+            // Content-Length считает БАЙТЫ, не JS-символы. Нарезка декодированной
+            // строки по числу символов портит фреймы с многобайтным UTF-8
+            // (напр. кириллические диагностики) — остаток держим сырыми байтами.
             if (this.buffer.length < this.contentLength)
                 return;
             const body = this.buffer.subarray(0, this.contentLength).toString("utf8");
@@ -306,10 +307,9 @@ export class LspClient {
     async shutdown() {
         try {
             if (this.process && this.initialized && this.process.stdin?.writable) {
-                // Await the shutdown response (with timeout) so the server has time to
-                // acknowledge before we send exit and kill the process.  The old code
-                // fired shutdown as fire-and-forget, then killed immediately — the
-                // server never had a chance to reply, producing spurious timeout warnings.
+                // Ответ shutdown ждём (с таймаутом), чтобы сервер успел подтвердить до
+                // exit и kill. Старый код слал shutdown fire-and-forget и тут же убивал —
+                // сервер ответить не успевал, сыпались ложные timeout-предупреждения.
                 try {
                     await this.sendRequest("shutdown", null, 3000);
                 }
@@ -325,9 +325,9 @@ export class LspClient {
         }
         finally {
             if (this.process) {
-                // The direct child on win32 is the cmd.exe wrapper; killing it alone
-                // orphans the npx → node → tsserver tree (observed as leaked node
-                // processes after every check). Tree-kill so the whole chain dies.
+                // Прямой потомок на win32 — cmd.exe-обёртка; её убийство в одиночку
+                // сиротит дерево npx → node → tsserver (наблюдались текущие node после
+                // каждого чека). Tree-kill — умирает вся цепочка.
                 try {
                     killTree(this.process);
                 }
@@ -374,11 +374,11 @@ export class LspClient {
         return map[ext ?? ""] ?? "plaintext";
     }
     /**
-     * Extract the actual binary name from npx args — only for the strict layout
-     * `[--yes] [--package X]... <binary> --stdio`. Servers with trailing server
-     * arguments (e.g. angular's `ngserver --stdio --tsProbeLocations …`) return
-     * null and always run through npx, so their flags are never mistaken for the
-     * binary or stripped.
+     * Имя реального бинарника из npx-args — только строгий layout
+     * `[--yes] [--package X]... <binary> --stdio`. Серверы с хвостовыми
+     * серверными аргументами (напр. angular `ngserver --stdio --tsProbeLocations …`)
+     * дают null и всегда идут через npx — их флаги не принять за бинарник
+     * и не вырезать.
      */
     extractBinaryFromNpxArgs(args) {
         const stdioIdx = args.lastIndexOf("--stdio");
@@ -399,7 +399,7 @@ export class LspClient {
         }
         return binary;
     }
-    /** Check if a string looks like a package version specifier (e.g. "typescript@5"). */
+    /** Похоже ли на спецификатор версии пакета (напр. "typescript@5"). */
     isPackageVersion(s) {
         return /^[\w-]+@[\d.+*-]/.test(s);
     }

package/dist/modules/lsp/command.js

@@ -1,23 +1,20 @@
+// Запуск LSP-серверов на Windows: резолв shim (.cmd/.bat) и строка для cmd.exe.
 import { delimiter, join } from "path";
 import { existsSync } from "fs";
 import { platform } from "os";
 const WIN_EXTS = [".cmd", ".bat", ".exe", ".com"];
 /**
- * Resolve the command string passed to `child_process.spawn` on Windows.
- *
- * Node's `spawn` cannot execute `.cmd`/`.bat` shims directly without a shell,
- * and a bare `npx` fails with `spawn npx ENOENT` because on Windows the
- * real executable is `npx.cmd`. This returns the first existing shim
- * (`npx.cmd`, `npx.bat`, `npx.exe`, ...) found on PATH, or the bare command
- * when nothing exists (the spawn will then fail with a meaningful ENOENT).
- *
- * Non-Windows platforms and commands that already carry an extension or a
- * path separator are returned unchanged.
+ * Резолв команды для `child_process.spawn` на Windows.
+ * Node-`spawn` не исполняет `.cmd`/`.bat`-шимы напрямую без shell, а голый
+ * `npx` падает с `spawn npx ENOENT` — на Windows реальный бинарник это
+ * `npx.cmd`. Возвращает первый найденный на PATH шим (`npx.cmd`, `npx.bat`,
+ * `npx.exe`, …), а если ничего нет — голую команду (spawn упадёт с понятным
+ * ENOENT). Не-Windows и команды с расширением/сепаратором — как есть.
  */
 export function resolveSpawnCommand(command, platformName = platform(), pathEnv = process.env.PATH ?? "") {
     if (platformName !== "win32")
         return command;
-    // Already a path or has an extension — pass through.
+    // Уже путь или с расширением — пропустить как есть.
     if (command.includes("/") ||
         command.includes("\\") ||
         WIN_EXTS.some((ext) => command.toLowerCase().endsWith(ext))) {
@@ -34,19 +31,15 @@ export function resolveSpawnCommand(command, platformName = platform(), pathEnv
     return command;
 }
 /**
- * Join a resolved command and its args into a single cmd.exe command line.
- *
- * Under Node on Windows, `spawn` of a `.cmd`/`.bat` shim WITHOUT a shell throws
- * `spawn EINVAL` (CreateProcess cannot run batch files directly). Resolving
- * `npx` → `npx.cmd` fixes the old `ENOENT` but not the `EINVAL` — the spawn
- * still has no shell. The reliable fix is to run the whole command line through
- * `cmd.exe /d /s /c` (i.e. `spawn(line, { shell: true })`). This helper builds
- * that line, quoting any argument that contains cmd.exe metacharacters so the
- * package names and flags in LSP configs (`typescript-language-server --stdio`,
- * `pyright --stdio`) survive the round-trip.
- *
- * Non-Windows platforms never call this (they spawn the resolved command +
- * args directly, no shell).
+ * Склейка резолвленной команды и args в одну строку для cmd.exe.
+ * Под Node на Windows `spawn` `.cmd`/`.bat`-шима БЕЗ shell бросает
+ * `spawn EINVAL` (CreateProcess не запускает батники напрямую). Резолв
+ * `npx` → `npx.cmd` чинит старый `ENOENT`, но не `EINVAL` — shell'а всё равно
+ * нет. Надёжный фикс — гнать всю строку через `cmd.exe /d /s /c`
+ * (т.е. `spawn(line, { shell: true })`). Хелпер строит строку, квотируя
+ * аргументы с cmd-метасимволами, чтобы имена пакетов и флаги LSP-конфигов
+ * (`typescript-language-server --stdio`, `pyright --stdio`) пережили round-trip.
+ * Не-Windows сюда не ходят (спавнят команду + args напрямую, без shell).
  */
 export function buildWinCommandLine(command, args) {
     const quote = (part) => {

package/dist/modules/lsp/config.js

@@ -1,11 +1,11 @@
+// Дефолтные LSP-серверы и выбор сервера по файлу (язык, Angular-исключение).
 import { existsSync } from "fs";
 import { dirname, join } from "path";
 /**
- * LSP server defaults.
- *
- * Strategy: prefer `npx` (auto-downloads) over globally installed binaries.
- * Servers using system tools (rust-analyzer, gopls) have `autoInstall: false`
- * and are skipped silently when not found.
+ * Дефолты LSP-серверов.
+ * Стратегия: предпочитать `npx` (самодокачка) глобальным бинарникам.
+ * Серверы на системных тулах (rust-analyzer, gopls) — `autoInstall: false`,
+ * при отсутствии молча скипаются.
  */
 export const DEFAULT_LSP_CONFIG = {
     enabled: true,
@@ -141,7 +141,7 @@ const LANGUAGE_MAP = {
     css: "css",
     scss: "css",
 };
-/** Language id for a file extension (via LANGUAGE_MAP), or null when unsupported. */
+/** Id языка по расширению файла (через LANGUAGE_MAP), неподдерживаемое — null. */
 export function getLanguageForFile(filePath) {
     const ext = filePath.split(".").pop()?.toLowerCase();
     if (!ext)
@@ -151,8 +151,8 @@ export function getLanguageForFile(filePath) {
 const ANGULAR_MARKER = "angular.json";
 const ANGULAR_LOOKUP_DEPTH = 10;
 /**
- * True when the file lives inside an Angular workspace (an `angular.json`
- * marker exists in one of its ancestor directories, bounded lookup).
+ * Лежит ли файл внутри Angular-workspace (маркер `angular.json` в одном из
+ * предков, поиск ограничен глубиной).
  */
 function isAngularProject(filePath) {
     let dir = dirname(filePath);
@@ -167,9 +167,9 @@ function isAngularProject(filePath) {
     return false;
 }
 /**
- * Config key of the LSP server for a file. `.html` routes to the `angular`
- * server inside Angular workspaces (templates with bindings need the Angular
- * language service) and to the generic `html` server everywhere else.
+ * Ключ конфига LSP-сервера для файла. `.html` идёт на сервер `angular` внутри
+ * Angular-workspace (шаблонам с биндингами нужен Angular language service),
+ * везде иначе — на generic `html`.
  */
 export function getServerKeyForFile(filePath, config) {
     const lang = getLanguageForFile(filePath);
@@ -180,6 +180,7 @@ export function getServerKeyForFile(filePath, config) {
     }
     return lang;
 }
+/** Конфиг LSP-сервера для файла (null — не поддерживается). */
 export function getServerForFile(filePath, config) {
     const key = getServerKeyForFile(filePath, config);
     if (!key)

package/dist/modules/lsp/index.js

@@ -1,3 +1,4 @@
+// Публичный фасад модуля LSP: модуль, клиент, конфиг, типы.
 export { LspModule } from "./module";
 export { LspClient, FileOnlyLogger } from "./client";
 export { getServerForFile, DEFAULT_LSP_CONFIG } from "./config";

package/dist/modules/lsp/module.js

@@ -12,23 +12,22 @@ import { severityLabels, collectCheckFiles, formatCheckDiagnostics } from "./che
 import { errMsg } from "../../utils";
 import { join } from "path";
 /**
- * Consecutive LSP failures before a server is disabled for the session. A dead
- * server (not installed, npx auto-install failed, path missing) otherwise
- * spams `[LSP check failed]` on EVERY write, teaching the model to ignore the
- * signal entirely (observed: ses_mst2r0r5 had LSP dead all session and the
- * model never reacted). After the threshold we say so once and stop the noise
- * for that server — a CSS timeout must not take TypeScript checks down too.
+ * Подряд идущих падений LSP до отключения сервера на сессию. Мёртвый сервер
+ * (не стоит, упала npx-автоустановка, нет пути) иначе спамит `[LSP check failed]`
+ * на КАЖДУЮ запись, приучая модель игнорировать сигнал целиком (наблюдалось:
+ * ses_mst2r0r5 — LSP мёртв всю сессию, модель не реагировала). После порога —
+ * одно громкое сообщение и тишина по этому серверу: таймаут CSS не должен
+ * ронять проверки TypeScript.
  */
 const MAX_CONSECUTIVE_LSP_FAILURES = 3;
 /**
- * Module-resolution diagnostics that are meaningless without a type
- * environment. In a bare directory (no tsconfig.json / node_modules) the
- * TypeScript server reports `Cannot find module 'fs'` and
- * `Cannot find name '__dirname'` for perfectly valid Node code — the model
- * then abandons a working approach because of phantom errors (observed
- * ses_mtho2oab: LSP "errors" pushed the model off a planned .ts file to .js
- * and into a plan-drift spiral). Suppressed with an explicit inconclusive
- * note when no type env exists near the project root.
+ * Диагностики резолва модулей, бессмысленные без type-окружения. В голом
+ * каталоге (без tsconfig.json / node_modules) TS-сервер рапортует
+ * `Cannot find module 'fs'` и `Cannot find name '__dirname'` на валидный
+ * Node-код — модель бросает рабочий подход из-за фантомных ошибок (наблюдалось
+ * ses_mtho2oab: LSP-"ошибки" столкнули модель с планового .ts на .js и в
+ * спираль plan-drift). Душатся с явной пометкой inconclusive, если рядом с
+ * корнем проекта нет type-окружения.
  */
 const TYPE_ENV_DIAG_PATTERN = /Cannot find module ['"][^'"]+['"] or its corresponding type declarations|Cannot find name '(__dirname|__filename|require|process|Buffer|console)'|Do you need to install type definitions/;
 function hasTypeEnvironment(projectRoot) {
@@ -36,6 +35,7 @@ function hasTypeEnvironment(projectRoot) {
         existsSync(join(projectRoot, "jsconfig.json")) ||
         existsSync(join(projectRoot, "node_modules")));
 }
+/** Модуль LSP: пост-проверки записи, тул lsp_check, учёт мёртвых серверов. */
 export class LspModule {
     name = "lsp";
     config;
@@ -49,43 +49,42 @@ export class LspModule {
         this.logger = logger ?? null;
         this.client.setLogger(this.logger);
     }
-    /** Update the logger (e.g., after session switch). */
+    /** Обновить логгер (напр. после смены сессии). */
     setLogger(logger) {
         this.logger = logger;
         this.client.setLogger(logger);
     }
-    /** Reset disabled servers (e.g., after /lsp restart). */
+    /** Сбросить отключённые серверы (напр. после /lsp restart). */
     resetDisabledServers() {
         this.failuresByServer.clear();
         this.disabledServers.clear();
     }
-    /** Get list of disabled server keys. */
+    /** Список отключённых ключей серверов. */
     getDisabledServers() {
         return Array.from(this.disabledServers);
     }
-    /** Get failure counts per server. */
+    /** Счётчики падений по серверам. */
     getFailureCounts() {
         return new Map(this.failuresByServer);
     }
-    /** Test hook: has the module disabled any LSP server for the session? */
+    /** Тест-хук: отключал ли модуль какой-то LSP-сервер на сессии. */
     isLspDisabled() {
         return this.disabledServers.size > 0;
     }
-    /** Test hook: is the given server (config-derived key) disabled? */
+    /** Тест-хук: отключён ли сервер (ключ из конфига). */
     isServerDisabled(key) {
         return this.disabledServers.has(key);
     }
-    /** Stable server identity derived from the config. */
+    /** Стабильная идентичность сервера из конфига. */
     serverKey(server) {
         return `${server.command}:${(server.args ?? []).join(" ")}`;
     }
     getPlugin() {
-        const self = this;
         return {
             name: "lsp-check",
             priority: 15,
             onAfterTool: async (_ctx, call, result) => {
-                if (!self.config.enabled)
+                if (!this.config.enabled)
                     return;
                 if (call.name !== "write_file" && call.name !== "edit_file")
                     return;
@@ -97,16 +96,16 @@ export class LspModule {
                 const fullPath = resolve(_ctx.baseDir, filePath);
                 if (!existsSync(fullPath))
                     return;
-                const serverConfig = getServerForFile(fullPath, self.config);
+                const serverConfig = getServerForFile(fullPath, this.config);
                 if (!serverConfig)
                     return;
-                const key = self.serverKey(serverConfig);
-                if (self.disabledServers.has(key))
+                const key = this.serverKey(serverConfig);
+                if (this.disabledServers.has(key))
                     return;
                 const projectRoot = findProjectRoot(fullPath, _ctx.baseDir, serverConfig.workspaceMarkers ?? []);
                 try {
-                    const diagnostics = await self.client.checkFile(fullPath, _ctx.baseDir, serverConfig, projectRoot);
-                    self.failuresByServer.set(key, 0);
+                    const diagnostics = await this.client.checkFile(fullPath, _ctx.baseDir, serverConfig, projectRoot);
+                    this.failuresByServer.set(key, 0);
                     const errors = diagnostics.filter((d) => d.severity === 1);
                     const warnings = diagnostics.filter((d) => d.severity === 2);
                     if (errors.length > 0) {
@@ -119,20 +118,22 @@ export class LspModule {
                     }
                 }
                 catch (e) {
-                    // Surface failures instead of silently returning [] — a dead LSP
-                    // previously produced ZERO diagnostics across whole sessions and the
-                    // model only found type errors reactively via `bun run build`.
+                    // Падения — наружу, а не молчаливый []: мёртвый LSP раньше давал
+                    // НОЛЬ диагностик целыми сессиями, и модель находила ошибки типов
+                    // лишь реактивно через `bun run build`.
                     const msg = errMsg(e);
-                    const failures = (self.failuresByServer.get(key) ?? 0) + 1;
-                    self.failuresByServer.set(key, failures);
+                    const failures = (this.failuresByServer.get(key) ?? 0) + 1;
+                    this.failuresByServer.set(key, failures);
                     try {
                         _ctx.logger?.warn(`LSP check failed for ${filePath}: ${msg}`);
                     }
-                    catch { }
+                    catch {
+                        // Падающий логгер не должен ломать путь проверки.
+                    }
                     if (failures >= MAX_CONSECUTIVE_LSP_FAILURES) {
-                        // One loud, actionable message, then stop the per-write noise for
-                        // the rest of the session. The model must not learn to ignore LSP.
-                        self.disabledServers.add(key);
+                        // Одно громкое actionable-сообщение, дальше — без шума на каждую
+                        // запись до конца сессии. Модель не должна учиться игнорить LSP.
+                        this.disabledServers.add(key);
                         result.output += `\n\n[LSP disabled: ${t("lsp.unavailable")}]`;
                     }
                     else {
@@ -143,15 +144,14 @@ export class LspModule {
         };
     }
     /**
-     * On-demand diagnostics tool. LSP checks only ran after write/edit (the
-     * plugin above), so a read-only "check this project for errors" task got
-     * ZERO compiler feedback — the model scanned files with read_file and never
-     * learned whether the code compiled (observed: ses_msvuao0h — a "проверь на
-     * ошибки" task ran no build, no lsp, and declared success). `lsp_check`
-     * gives the model a way to ask for static diagnostics on demand.
+     * Тул диагностики по требованию. Проверки LSP шли только после write/edit
+     * (плагин выше), и read-only задача «проверь проект на ошибки» получала
+     * НОЛЬ фидбэка от компилятора — модель сканировала файлы через read_file и
+     * не узнавала, компилируется ли код (наблюдалось: ses_msvuao0h — задача
+     * "проверь на ошибки" без build, без lsp, с декларацией успеха). `lsp_check`
+     * даёт модели способ спросить статические диагностики по требованию.
      */
     getToolDefinitions() {
-        const self = this;
         return [
             {
                 name: "lsp_check",
@@ -171,7 +171,7 @@ export class LspModule {
                     },
                     required: ["path"],
                 },
-                handler: async (ctx, args) => self.runCheck(ctx, args),
+                handler: async (ctx, args) => this.runCheck(ctx, args),
             },
         ];
     }
@@ -240,7 +240,9 @@ export class LspModule {
                 try {
                     ctx.logger?.warn(`LSP check failed for ${file}: ${msg}`);
                 }
-                catch { }
+                catch {
+                    // Падающий логгер не должен ломать путь проверки.
+                }
                 if (failures >= MAX_CONSECUTIVE_LSP_FAILURES) {
                     this.disabledServers.add(key);
                     notes.push(`[LSP disabled: ${t("lsp.unavailable")}]`);

package/dist/modules/lsp/probe.js

@@ -3,13 +3,12 @@ import { getServerKeyForFile } from "./config";
 import { collectCheckFiles } from "./check-tool";
 import { findProjectRoot } from "./project-root";
 import { errMsg } from "../../utils";
-const DEFAULT_PROBE_TIMEOUT_MS = 30_000;
-const DEFAULT_PROBE_DEADLINE_MS = 60_000;
+import { LSP_PROBE_TIMEOUT_MS as DEFAULT_PROBE_TIMEOUT_MS, LSP_PROBE_DEADLINE_MS as DEFAULT_PROBE_DEADLINE_MS, } from "../../config/timeouts";
 const DEFAULT_MAX_PARALLEL = 3;
 /**
- * Check which LSP servers apply to the project (via the same bounded file
- * walk as lsp_check) and probe each one: spawn + initialize + shutdown.
- * Used by the REPL banner so a dead server is visible before the first write.
+ * Выяснить, какие LSP-серверы применимы к проекту (тот же ограниченный обход,
+ * что в lsp_check), и пробить каждый: spawn + initialize + shutdown.
+ * Для баннера REPL — мёртвый сервер виден до первой записи.
  */
 export async function probeLspServers(config, baseDir, deps = {}) {
     if (!config.enabled)
@@ -33,15 +32,15 @@ export async function probeLspServers(config, baseDir, deps = {}) {
     }
     if (servers.length === 0)
         return { ok: [], failed: [], noneApplicable: true };
-    // Probe in bounded waves. Probing everything in parallel on a cold npx cache
-    // makes the servers fight over the shared cache lock — observed as `LSP
-    // request timeout: initialize` for half the servers. Fully sequential probing
-    // avoids that but doubles the REPL banner wait (each server ~2s). A wave of
-    // `maxParallel` keeps the banner fast on a warm cache while capping cold-cache
-    // contention; each server in a wave gets its own LspClient (the client is
-    // stateful — process, request ids, response buffer — so concurrent probes on
-    // a shared instance would cross-talk). When a client is injected (tests), it
-    // is reused for every server.
+    // Проба ограниченными волнами. Параллельная проба всего на холодном
+    // npx-кеше заставляет серверы драться за общий лок кеша — наблюдалось как
+    // `LSP request timeout: initialize` у половины серверов. Чисто
+    // последовательная проба убирает драку, но удваивает ожидание баннера REPL
+    // (сервер ~2с). Волна `maxParallel` держит баннер быстрым на тёплом кеше и
+    // режет конкуренцию на холодном; у каждого сервера в волне свой LspClient
+    // (клиент stateful — процесс, id запросов, буфер ответов, — конкурентные
+    // пробы на общем инстансе кросс-токали бы). Инжектированный клиент (тесты)
+    // переиспользуется на все серверы.
     const ok = [];
     const failed = [];
     const deadline = Date.now() + deadlineMs;