micro-models-agent 0.63.3 → 1.1.0

package/dist/modules/lsp/module.js

@@ -5,9 +5,12 @@ import { getServerForFile, DEFAULT_LSP_CONFIG } from "./config";
 import { findProjectRoot } from "./project-root";
 import { isPathInScope } from "../security/path-validator";
 import { DEFAULT_SECURITY_CONFIG } from "../../config/security";
+import { toForwardSlash } from "../../tools/path-utils";
 import { safeResolvePath } from "../../tools/path-utils";
 import { t } from "../../i18n/index";
 import { severityLabels, collectCheckFiles, formatCheckDiagnostics } from "./check-tool";
+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
@@ -17,6 +20,22 @@ import { severityLabels, collectCheckFiles, formatCheckDiagnostics } from "./che
  * for that server — a CSS timeout must not take TypeScript checks down too.
  */
 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.
+ */
+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) {
+    return (existsSync(join(projectRoot, "tsconfig.json")) ||
+        existsSync(join(projectRoot, "jsconfig.json")) ||
+        existsSync(join(projectRoot, "node_modules")));
+}
 export class LspModule {
     name = "lsp";
     config;
@@ -103,7 +122,7 @@ export class LspModule {
                     // 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`.
-                    const msg = e instanceof Error ? e.message : String(e);
+                    const msg = errMsg(e);
                     const failures = (self.failuresByServer.get(key) ?? 0) + 1;
                     self.failuresByServer.set(key, failures);
                     try {
@@ -183,6 +202,7 @@ export class LspModule {
         const notes = [];
         const checkedFiles = [];
         let checked = 0;
+        let suppressedTypeEnvDiags = 0;
         for (const file of files) {
             const serverConfig = getServerForFile(file, this.config);
             if (!serverConfig)
@@ -192,10 +212,20 @@ export class LspModule {
                 continue;
             const projectRoot = findProjectRoot(file, ctx.baseDir, serverConfig.workspaceMarkers ?? []);
             try {
-                const diags = await this.client.checkFile(file, ctx.baseDir, serverConfig, projectRoot);
+                let diags = await this.client.checkFile(file, ctx.baseDir, serverConfig, projectRoot);
                 this.failuresByServer.set(key, 0);
                 checked++;
-                checkedFiles.push(relative(ctx.baseDir, file).replace(/\\/g, "/"));
+                checkedFiles.push(toForwardSlash(relative(ctx.baseDir, file)));
+                if (!hasTypeEnvironment(projectRoot)) {
+                    const kept = diags.filter((d) => {
+                        if (TYPE_ENV_DIAG_PATTERN.test(d.message)) {
+                            suppressedTypeEnvDiags++;
+                            return false;
+                        }
+                        return true;
+                    });
+                    diags = kept;
+                }
                 for (const d of diags) {
                     if (d.severity === 1)
                         errors.push({ file, diag: d });
@@ -204,7 +234,7 @@ export class LspModule {
                 }
             }
             catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
+                const msg = errMsg(e);
                 const failures = (this.failuresByServer.get(key) ?? 0) + 1;
                 this.failuresByServer.set(key, failures);
                 try {
@@ -236,6 +266,9 @@ export class LspModule {
         if (checked > 0 && errors.length === 0 && warnings.length === 0) {
             lines.push(t("lsp.check_clean", { count: String(checked) }));
         }
+        if (suppressedTypeEnvDiags > 0) {
+            lines.push(`[lsp_check inconclusive: no tsconfig.json / node_modules near project root — ${suppressedTypeEnvDiags} module-resolution diagnostic(s) suppressed. Initialize the project (package.json + types) for accurate TypeScript checks.]`);
+        }
         lines.push(...notes);
         if (lines.length === 0) {
             return {
@@ -247,7 +280,7 @@ export class LspModule {
     }
 }
 function formatDiagnostics(diagnostics, filePath) {
-    const filename = filePath.replace(/\\/g, "/").split("/").pop() ?? filePath;
+    const filename = toForwardSlash(filePath).split("/").pop() ?? filePath;
     return diagnostics
         .slice(0, 5)
         .map((d) => {

package/dist/modules/lsp/probe.js

@@ -1,7 +1,8 @@
 import { LspClient } from "./client";
-import { getLanguageForFile } from "./config";
+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;
 const DEFAULT_MAX_PARALLEL = 3;
@@ -21,7 +22,7 @@ export async function probeLspServers(config, baseDir, deps = {}) {
     const seen = new Set();
     const servers = [];
     for (const file of files) {
-        const language = getLanguageForFile(file);
+        const language = getServerKeyForFile(file, config);
         if (!language)
             continue;
         const server = config.servers[language];
@@ -56,7 +57,7 @@ export async function probeLspServers(config, baseDir, deps = {}) {
             ok.push({ language, ok: true, durationMs: Date.now() - started });
         }
         catch (e) {
-            const errorMsg = e instanceof Error ? e.message : String(e);
+            const errorMsg = errMsg(e);
             deps.logger?.warn(`LSP probe failed for ${language}: ${errorMsg}`, {
                 command: server.command,
                 timeout: serverTimeout,

package/dist/modules/lsp/project-root.js

@@ -1,5 +1,6 @@
 import { existsSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join, relative, isAbsolute } from "path";
+import { platform } from "os";
 /**
  * Resolve the LSP workspace root for an edited file.
  *
@@ -13,11 +14,50 @@ import { dirname, join } from "path";
  * LSP server config (`LspServerConfig.workspaceMarkers`) — this function takes
  * the markers as a parameter and performs no language detection itself.
  */
+/**
+ * Находит локальный компилятор TypeScript, поднимаясь от `startDir` вверх по
+ * `node_modules`. Возвращает готовую команду или null, если tsc не установлен.
+ *
+ * Почему не `npx`: обёртка npx тратит 5–13 секунд даже на локальный пакет
+ * (Windows), а без локального typescript пытается лезть в сеть. Прямой вызов
+ * локального tsc — доли секунды и честная деградация (null → пропускаем).
+ *
+ * Кросс-платформенность:
+ * - предпочитаем JS-энтрипоинт `typescript/bin/tsc` и запускаем его ТЕКУЩИМ
+ *   рантаймом (`process.execPath` — bun или node). Так не зависим от `node` в
+ *   PATH (актуально для систем только с Bun) и одинаково работает на
+ *   Windows/macOS/Linux;
+ * - если JS-файла нет, но есть `.bin`-стаб, берём его: на Windows `tsc.cmd`,
+ *   на macOS/Linux `tsc` (обёртка сама найдёт интерпретатор).
+ */
+export function resolveTscCommand(startDir, maxLevels = 8) {
+    const runtime = process.execPath;
+    let dir = startDir;
+    for (let i = 0; i < maxLevels; i++) {
+        const js = join(dir, "node_modules", "typescript", "bin", "tsc");
+        if (existsSync(js))
+            return `"${runtime}" "${js}"`;
+        const stub = join(dir, "node_modules", ".bin", platform() === "win32" ? "tsc.cmd" : "tsc");
+        if (existsSync(stub))
+            return `"${stub}"`;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 export function findProjectRoot(filePath, baseDir, markers) {
     if (!markers || markers.length === 0)
         return baseDir;
     let dir = dirname(filePath);
     const root = baseDir.replace(/[\\/]+$/, "");
+    // Clamp the walk to baseDir: callers that pass baseDir itself as filePath
+    // (probes) start at dirname(baseDir) — ABOVE the sandbox — and would pick up
+    // a marker directory from the parent (e.g. a package.json next to it).
+    const rel = relative(root, dir);
+    if ((rel && rel.startsWith("..")) || isAbsolute(rel))
+        dir = root;
     while (true) {
         if (markers.some((m) => existsSync(join(dir, m)))) {
             return dir;

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

@@ -5,7 +5,9 @@ import { t } from "../../i18n/index";
 import { LspClient } from "./client";
 import { collectCheckFiles } from "./check-tool";
 import { getServerForFile } from "./config";
-import { findProjectRoot } from "./project-root";
+import { findProjectRoot, resolveTscCommand } from "./project-root";
+import { estimateTokens } from "../../llm/token-counter";
+import { errMsg } from "../../utils";
 /** Startup check never examines more than this many files via LSP. */
 const STARTUP_CHECK_FILE_CAP = 5;
 /** Overall cap for the whole startup check — never block session start longer. */
@@ -42,7 +44,7 @@ export async function runStartupHealthCheck(config, baseDir, deps = {}) {
             content,
             priority: "high",
             essential: false,
-            estimatedTokens: Math.ceil(content.length / 4),
+            estimatedTokens: estimateTokens(content),
         };
     }
     catch {
@@ -80,7 +82,7 @@ async function runCheck(config, baseDir, deps) {
         }
         catch (e) {
             // Per-file LSP failure → log and skip (fail-open).
-            deps.logger?.debug(`Startup LSP check failed for ${file}: ${e instanceof Error ? e.message : String(e)}`);
+            deps.logger?.debug(`Startup LSP check failed for ${file}: ${errMsg(e)}`);
         }
     }
     if (checked === 0 || lines.length === 0)
@@ -88,8 +90,14 @@ async function runCheck(config, baseDir, deps) {
     return { lines: lines.slice(0, STARTUP_CHECK_ERROR_CAP) };
 }
 async function runTscDefault(projectRoot, timeoutMs) {
+    // Локальный tsc, а не `npx`: npx-обёртка (cmd → node npm-prefix) медленная и
+    // на Windows переживает выход процесса, оставляя открытым stdout-пайп —
+    // команда «виснет». Нет локального tsc — молча пропускаем проверку.
+    const tsc = resolveTscCommand(projectRoot);
+    if (!tsc)
+        return [];
     return new Promise((resolve) => {
-        const child = spawn("npx", ["tsc", "--noEmit", "--skipLibCheck"], {
+        const child = spawn(`${tsc} --noEmit --skipLibCheck`, {
             cwd: projectRoot,
             shell: true,
             windowsHide: true,

package/dist/modules/mcp/client.js

@@ -1,4 +1,12 @@
 import { spawn } from "child_process";
+import { defaultOutputBus } from "../../output";
+/** Default timeout for MCP HTTP requests (connect + tool calls). */
+const HTTP_TIMEOUT_MS = 10_000;
+/**
+ * Accept header required by the MCP Streamable HTTP transport — the server
+ * responds with 406 if the client doesn't accept both media types.
+ */
+const MCP_ACCEPT_HEADER = "application/json, text/event-stream";
 export class MCPClient {
     serverName;
     config;
@@ -31,22 +39,30 @@ export class MCPClient {
         if (!url)
             throw new Error("SSE transport requires a url");
         this.abortController = new AbortController();
-        const response = await fetch(url, {
-            method: "GET",
-            headers: {
-                Accept: "text/event-stream",
-                ...this.config.headers,
-            },
-            signal: this.abortController.signal,
-        });
-        if (!response.ok) {
-            throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+        const timeout = setTimeout(() => this.abortController?.abort(), this.config.timeout || HTTP_TIMEOUT_MS);
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Accept: "text/event-stream",
+                    ...this.config.headers,
+                },
+                signal: this.abortController.signal,
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+            }
+            this._connected = true;
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            this.readSSE(reader, decoder, buffer);
+        }
+        catch (err) {
+            clearTimeout(timeout);
+            throw err;
         }
-        this._connected = true;
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        this.readSSE(reader, decoder, buffer);
     }
     async readSSE(reader, decoder, buffer) {
         try {
@@ -87,6 +103,7 @@ export class MCPClient {
         try {
             const msg = JSON.parse(data);
             if (this.pendingResolve && msg.id) {
+                this.clearSseTimer();
                 if (msg.error) {
                     this.pendingReject?.(new Error(msg.error.message));
                 }
@@ -97,10 +114,15 @@ export class MCPClient {
                 this.pendingReject = null;
             }
         }
-        catch { }
+        catch (e) {
+            // Heartbeats/comments are not JSON — expected noise, but still logged
+            // so a genuinely broken stream is visible in diagnostics.
+            defaultOutputBus.log("error", "mcp", `[MCPClient] Unparseable SSE message: ${String(data).slice(0, 120)} ${e instanceof Error ? e.message : String(e)}`, { persist: true });
+        }
     }
     handleSSEError(err) {
         if (this.pendingReject) {
+            this.clearSseTimer();
             this.pendingReject(err);
             this.pendingResolve = null;
             this.pendingReject = null;
@@ -130,11 +152,102 @@ export class MCPClient {
             child.on("spawn", () => {
                 this._connected = true;
                 this.process = child;
-                _resolved = true;
-                resolve();
+                // MCP handshake: real servers require `initialize` before any
+                // tools/list or tools/call request.
+                this.stdioRequest("initialize", {
+                    protocolVersion: "2024-11-05",
+                    capabilities: {},
+                    clientInfo: { name: "mma", version: "1.0.0" },
+                }, 10000)
+                    .then(() => {
+                    child.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+                })
+                    .then(() => {
+                    _resolved = true;
+                    resolve();
+                })
+                    .catch((err) => {
+                    this._connected = false;
+                    if (!_resolved) {
+                        _resolved = true;
+                        reject(err);
+                    }
+                });
             });
         });
     }
+    /** Unparsed trailing bytes from stdio responses (partial line). */
+    stdioBuffer = "";
+    /**
+     * JSON-RPC request over stdio with timeout, exit handling and
+     * buffer-aware line parsing (notifications and stale responses between
+     * our request and its response no longer break matching).
+     */
+    stdioRequest(method, params, timeoutMs) {
+        const proc = this.process;
+        if (!proc || !proc.stdout || !proc.stdin) {
+            return Promise.reject(new Error("Not connected to MCP server"));
+        }
+        const stdout = proc.stdout;
+        const timeout = timeoutMs ?? this.config.timeout ?? 30000;
+        return new Promise((resolve, reject) => {
+            const request = {
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method,
+                ...(params !== undefined ? { params } : {}),
+            };
+            let timer;
+            let settled = false;
+            const finish = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                stdout.off("data", onData);
+                proc.off("exit", onExit);
+                fn();
+            };
+            const onData = (data) => {
+                this.stdioBuffer += data.toString();
+                let idx;
+                while ((idx = this.stdioBuffer.indexOf("\n")) !== -1 && !settled) {
+                    const line = this.stdioBuffer.slice(0, idx).trim();
+                    this.stdioBuffer = this.stdioBuffer.slice(idx + 1);
+                    if (!line)
+                        continue;
+                    let msg;
+                    try {
+                        msg = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (msg.id !== request.id)
+                        continue; // notification or foreign response
+                    finish(() => {
+                        if (msg.error) {
+                            reject(new Error(msg.error.message));
+                        }
+                        else {
+                            resolve(msg.result);
+                        }
+                    });
+                    return;
+                }
+            };
+            const onExit = () => {
+                finish(() => reject(new Error(`MCP server exited before responding to ${method}`)));
+            };
+            stdout.on("data", onData);
+            proc.once("exit", onExit);
+            timer = setTimeout(() => {
+                finish(() => reject(new Error(`MCP ${method} timeout`)));
+            }, timeout);
+            proc.stdin.write(JSON.stringify(request) + "\n");
+        });
+    }
     async listTools() {
         if (!this._connected) {
             await this.connect();
@@ -156,10 +269,12 @@ export class MCPClient {
         const response = await fetch(this.config.url, {
             method: "POST",
             headers: {
+                Accept: MCP_ACCEPT_HEADER,
                 "Content-Type": "application/json",
                 ...this.config.headers,
             },
             body: JSON.stringify(request),
+            signal: AbortSignal.timeout(this.config.timeout || HTTP_TIMEOUT_MS),
         });
         if (!response.ok) {
             const text = await response.text().catch(() => "");
@@ -180,6 +295,7 @@ export class MCPClient {
         const response = await fetch(this.config.url, {
             method: "POST",
             headers: {
+                Accept: MCP_ACCEPT_HEADER,
                 "Content-Type": "application/json",
                 ...this.config.headers,
             },
@@ -200,46 +316,8 @@ export class MCPClient {
         if (!this.process) {
             throw new Error("Not connected to MCP server");
         }
-        return new Promise((resolve, reject) => {
-            const request = {
-                jsonrpc: "2.0",
-                id: Date.now(),
-                method: "tools/list",
-            };
-            const requestStr = JSON.stringify(request) + "\n";
-            this.process.stdin.write(requestStr);
-            let responseData = "";
-            const onData = (data) => {
-                responseData += data.toString();
-                if (responseData.includes("\n")) {
-                    this.process.stdout.off("data", onData);
-                    try {
-                        const lines = responseData.split("\n").filter((l) => l.trim());
-                        for (const line of lines) {
-                            const response = JSON.parse(line);
-                            if (response.id === request.id) {
-                                if (response.error) {
-                                    reject(new Error(response.error.message));
-                                }
-                                else {
-                                    resolve(response.result?.tools || []);
-                                }
-                                return;
-                            }
-                        }
-                        reject(new Error("No matching response found"));
-                    }
-                    catch (e) {
-                        reject(new Error(`Parse error: ${e.message}`));
-                    }
-                }
-            };
-            this.process.stdout.on("data", onData);
-            setTimeout(() => {
-                this.process.stdout.off("data", onData);
-                reject(new Error("MCP listTools timeout"));
-            }, 30000);
-        });
+        const result = await this.stdioRequest("tools/list");
+        return result?.tools || [];
     }
     async disconnect() {
         if (this.config.transport === "http") {
@@ -281,10 +359,12 @@ export class MCPClient {
         const response = await fetch(this.config.url, {
             method: "POST",
             headers: {
+                Accept: MCP_ACCEPT_HEADER,
                 "Content-Type": "application/json",
                 ...this.config.headers,
             },
             body: JSON.stringify(request),
+            signal: AbortSignal.timeout(this.config.timeout || HTTP_TIMEOUT_MS),
         });
         if (!response.ok) {
             const text = await response.text().catch(() => "");
@@ -296,6 +376,8 @@ export class MCPClient {
         }
         return result.result || result;
     }
+    /** Timer of the in-flight SSE request — cleared when the reply arrives via the stream. */
+    sseTimer;
     async callToolSSE(toolName, args) {
         const request = {
             jsonrpc: "2.0",
@@ -310,7 +392,7 @@ export class MCPClient {
             this.pendingResolve = resolve;
             this.pendingReject = reject;
             const timeout = this.config.timeout || 30000;
-            const timer = setTimeout(() => {
+            this.sseTimer = setTimeout(() => {
                 this.pendingResolve = null;
                 this.pendingReject = null;
                 reject(new Error("MCP call timeout"));
@@ -318,6 +400,7 @@ export class MCPClient {
             fetch(this.config.url, {
                 method: "POST",
                 headers: {
+                    Accept: MCP_ACCEPT_HEADER,
                     "Content-Type": "application/json",
                     ...this.config.headers,
                 },
@@ -325,7 +408,7 @@ export class MCPClient {
                 signal: this.abortController?.signal,
             })
                 .then(async (response) => {
-                clearTimeout(timer);
+                this.clearSseTimer();
                 if (!response.ok) {
                     const text = await response.text().catch(() => "");
                     reject(new Error(`MCP POST failed: ${response.status} ${text}`));
@@ -340,60 +423,26 @@ export class MCPClient {
                 }
             })
                 .catch((err) => {
-                clearTimeout(timer);
+                this.clearSseTimer();
                 if (err.name !== "AbortError") {
                     reject(err);
                 }
             });
         });
     }
+    clearSseTimer() {
+        if (this.sseTimer !== undefined) {
+            clearTimeout(this.sseTimer);
+            this.sseTimer = undefined;
+        }
+    }
     callToolStdio(toolName, args) {
         if (!this.process) {
             throw new Error("Not connected to MCP server");
         }
-        return new Promise((resolve, reject) => {
-            const request = {
-                jsonrpc: "2.0",
-                id: Date.now(),
-                method: "tools/call",
-                params: {
-                    name: toolName,
-                    arguments: args,
-                },
-            };
-            const requestStr = JSON.stringify(request) + "\n";
-            this.process.stdin.write(requestStr);
-            let responseData = "";
-            const onData = (data) => {
-                responseData += data.toString();
-                if (responseData.includes("\n")) {
-                    this.process.stdout.off("data", onData);
-                    try {
-                        const lines = responseData.split("\n").filter((l) => l.trim());
-                        for (const line of lines) {
-                            const response = JSON.parse(line);
-                            if (response.id === request.id) {
-                                if (response.error) {
-                                    reject(new Error(response.error.message));
-                                }
-                                else {
-                                    resolve(response.result);
-                                }
-                                return;
-                            }
-                        }
-                        reject(new Error("No matching response found"));
-                    }
-                    catch (e) {
-                        reject(new Error(`Parse error: ${e.message}`));
-                    }
-                }
-            };
-            this.process.stdout.on("data", onData);
-            setTimeout(() => {
-                this.process.stdout.off("data", onData);
-                reject(new Error("MCP call timeout"));
-            }, 30000);
+        return this.stdioRequest("tools/call", {
+            name: toolName,
+            arguments: args,
         });
     }
 }