micro-models-agent 0.61.0 → 0.62.0

package/dist/modules/lsp/module.js

@@ -0,0 +1,260 @@
+import { existsSync } from "fs";
+import { relative, resolve } from "path";
+import { LspClient } from "./client";
+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 { safeResolvePath } from "../../tools/path-utils";
+import { t } from "../../i18n/index";
+import { severityLabels, collectCheckFiles, formatCheckDiagnostics } from "./check-tool";
+/**
+ * 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.
+ */
+const MAX_CONSECUTIVE_LSP_FAILURES = 3;
+export class LspModule {
+    name = "lsp";
+    config;
+    client;
+    failuresByServer = new Map();
+    disabledServers = new Set();
+    logger = null;
+    constructor(config, client, logger) {
+        this.config = { ...DEFAULT_LSP_CONFIG, ...config };
+        this.client = client ?? new LspClient();
+        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). */
+    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? */
+    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)
+                    return;
+                if (call.name !== "write_file" && call.name !== "edit_file")
+                    return;
+                if (!result.success)
+                    return;
+                const filePath = String(call.arguments.path ?? "");
+                if (!filePath)
+                    return;
+                const fullPath = resolve(_ctx.baseDir, filePath);
+                if (!existsSync(fullPath))
+                    return;
+                const serverConfig = getServerForFile(fullPath, self.config);
+                if (!serverConfig)
+                    return;
+                const key = self.serverKey(serverConfig);
+                if (self.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 errors = diagnostics.filter((d) => d.severity === 1);
+                    const warnings = diagnostics.filter((d) => d.severity === 2);
+                    if (errors.length > 0) {
+                        const items = formatDiagnostics(errors, fullPath);
+                        result.output += `\n\n[LSP errors]:\n${items}`;
+                    }
+                    if (warnings.length > 0) {
+                        const items = formatDiagnostics(warnings, fullPath);
+                        result.output += `\n\n[LSP warnings]:\n${items}`;
+                    }
+                }
+                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`.
+                    const msg = e instanceof Error ? e.message : String(e);
+                    const failures = (self.failuresByServer.get(key) ?? 0) + 1;
+                    self.failuresByServer.set(key, failures);
+                    try {
+                        _ctx.logger?.warn(`LSP check failed for ${filePath}: ${msg}`);
+                    }
+                    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);
+                        result.output += `\n\n[LSP disabled: ${t("lsp.unavailable")}]`;
+                    }
+                    else {
+                        result.output += `\n\n[LSP check failed]: ${msg}`;
+                    }
+                }
+            },
+        };
+    }
+    /**
+     * 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.
+     */
+    getToolDefinitions() {
+        const self = this;
+        return [
+            {
+                name: "lsp_check",
+                icon: "🩺",
+                description: 'Run static checks (LSP diagnostics) on a file or directory. For "check for errors" tasks: pass a file to check it, or a directory to check its source files (capped at 15). Returns [LSP errors] / [LSP warnings] for files with a configured LSP server.',
+                tags: ["code", "check"],
+                alwaysOn: true,
+                boundedOutput: true,
+                timeoutMs: 90000,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "File or directory to check",
+                        },
+                    },
+                    required: ["path"],
+                },
+                handler: async (ctx, args) => self.runCheck(ctx, args),
+            },
+        ];
+    }
+    async runCheck(ctx, args) {
+        if (!this.config.enabled) {
+            return { success: false, output: t("lsp.check_disabled") };
+        }
+        const path = String(args.path ?? "");
+        if (!path)
+            return { success: false, output: t("lsp.check_no_path") };
+        const resolved = safeResolvePath(ctx.baseDir, path);
+        const securityPaths = ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths;
+        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, securityPaths);
+        if (!scopeCheck.allowed) {
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            return { success: false, output: t("lsp.check_notfound", { path }) };
+        }
+        const files = await collectCheckFiles(resolved, this.config);
+        const errors = [];
+        const warnings = [];
+        const notes = [];
+        const checkedFiles = [];
+        let checked = 0;
+        for (const file of files) {
+            const serverConfig = getServerForFile(file, this.config);
+            if (!serverConfig)
+                continue;
+            const key = this.serverKey(serverConfig);
+            if (this.disabledServers.has(key))
+                continue;
+            const projectRoot = findProjectRoot(file, ctx.baseDir, serverConfig.workspaceMarkers ?? []);
+            try {
+                const diags = await this.client.checkFile(file, ctx.baseDir, serverConfig, projectRoot);
+                this.failuresByServer.set(key, 0);
+                checked++;
+                checkedFiles.push(relative(ctx.baseDir, file).replace(/\\/g, "/"));
+                for (const d of diags) {
+                    if (d.severity === 1)
+                        errors.push({ file, diag: d });
+                    else if (d.severity === 2)
+                        warnings.push({ file, diag: d });
+                }
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                const failures = (this.failuresByServer.get(key) ?? 0) + 1;
+                this.failuresByServer.set(key, failures);
+                try {
+                    ctx.logger?.warn(`LSP check failed for ${file}: ${msg}`);
+                }
+                catch { }
+                if (failures >= MAX_CONSECUTIVE_LSP_FAILURES) {
+                    this.disabledServers.add(key);
+                    notes.push(`[LSP disabled: ${t("lsp.unavailable")}]`);
+                }
+                else {
+                    notes.push(`[LSP check failed for ${file}: ${msg}]`);
+                }
+            }
+        }
+        const lines = [];
+        if (checked > 0) {
+            lines.push(t("lsp.checked_files", { count: String(checked) }));
+            lines.push(...checkedFiles.map((f) => `  ${f}`));
+        }
+        if (errors.length > 0) {
+            lines.push(`[LSP errors] (${errors.length}):`);
+            lines.push(formatCheckDiagnostics(errors, ctx.baseDir));
+        }
+        if (warnings.length > 0) {
+            lines.push(`[LSP warnings] (${warnings.length}):`);
+            lines.push(formatCheckDiagnostics(warnings, ctx.baseDir));
+        }
+        if (checked > 0 && errors.length === 0 && warnings.length === 0) {
+            lines.push(t("lsp.check_clean", { count: String(checked) }));
+        }
+        lines.push(...notes);
+        if (lines.length === 0) {
+            return {
+                success: true,
+                output: t("lsp.check_clean", { count: String(checked) }),
+            };
+        }
+        return { success: errors.length === 0, output: lines.join("\n") };
+    }
+}
+function formatDiagnostics(diagnostics, filePath) {
+    const filename = filePath.replace(/\\/g, "/").split("/").pop() ?? filePath;
+    return diagnostics
+        .slice(0, 5)
+        .map((d) => {
+        const line = d.range.start.line + 1;
+        const col = d.range.start.character + 1;
+        const sev = severityLabels[d.severity] ?? "unknown";
+        return `  ${filename}(${line},${col}): ${sev}: ${d.message}`;
+    })
+        .join("\n");
+}

package/dist/modules/lsp/probe.js

@@ -0,0 +1,86 @@
+import { LspClient } from "./client";
+import { getLanguageForFile } from "./config";
+import { collectCheckFiles } from "./check-tool";
+import { findProjectRoot } from "./project-root";
+const DEFAULT_PROBE_TIMEOUT_MS = 30_000;
+const DEFAULT_PROBE_DEADLINE_MS = 60_000;
+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.
+ */
+export async function probeLspServers(config, baseDir, deps = {}) {
+    if (!config.enabled)
+        return { ok: [], failed: [], noneApplicable: true };
+    const timeoutCap = deps.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+    const deadlineMs = deps.deadlineMs ?? DEFAULT_PROBE_DEADLINE_MS;
+    const maxParallel = deps.maxParallel ?? DEFAULT_MAX_PARALLEL;
+    const collect = deps.collectFiles ?? collectCheckFiles;
+    const files = await collect(baseDir, config);
+    const seen = new Set();
+    const servers = [];
+    for (const file of files) {
+        const language = getLanguageForFile(file);
+        if (!language)
+            continue;
+        const server = config.servers[language];
+        if (!server || seen.has(language))
+            continue;
+        seen.add(language);
+        servers.push({ language, config: server });
+    }
+    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.
+    const ok = [];
+    const failed = [];
+    const deadline = Date.now() + deadlineMs;
+    const probeOne = async (language, server) => {
+        const projectRoot = findProjectRoot(baseDir, baseDir, server.workspaceMarkers ?? []);
+        const serverTimeout = Math.min(server.timeout ?? timeoutCap, timeoutCap);
+        const started = Date.now();
+        const probeClient = deps.client ?? new LspClient();
+        if (!deps.client)
+            probeClient.setLogger(deps.logger ?? null);
+        try {
+            await probeClient.probe(server, projectRoot, serverTimeout);
+            ok.push({ language, ok: true, durationMs: Date.now() - started });
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            deps.logger?.warn(`LSP probe failed for ${language}: ${errorMsg}`, {
+                command: server.command,
+                timeout: serverTimeout,
+                durationMs: Date.now() - started,
+            });
+            failed.push({
+                language,
+                ok: false,
+                error: errorMsg,
+                durationMs: Date.now() - started,
+            });
+        }
+    };
+    for (let i = 0; i < servers.length; i += maxParallel) {
+        if (Date.now() >= deadline) {
+            const remaining = servers.slice(i).map((s) => s.language);
+            deps.logger?.warn(`LSP probe deadline reached, skipping: ${remaining.join(", ")}`);
+            for (const { language } of servers.slice(i)) {
+                failed.push({ language, ok: false, error: "timeout", durationMs: 0 });
+            }
+            break;
+        }
+        const wave = servers.slice(i, i + maxParallel);
+        await Promise.all(wave.map(({ language, config: server }) => probeOne(language, server)));
+    }
+    return { ok, failed, noneApplicable: false };
+}

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

@@ -0,0 +1,32 @@
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+/**
+ * Resolve the LSP workspace root for an edited file.
+ *
+ * The workspace root must be the nearest project of the *edited file*, not the
+ * agent baseDir — tsserver resolves `typescript` relative to the workspace
+ * root, so for a file in `bicycle-shop/src/x.ts` under baseDir `mma_tests` the
+ * root must be `bicycle-shop` (observed: "Could not find a valid TypeScript
+ * installation" on every write/edit because baseDir had no node_modules).
+ *
+ * Which files mark a project root is language-specific and is declared in the
+ * LSP server config (`LspServerConfig.workspaceMarkers`) — this function takes
+ * the markers as a parameter and performs no language detection itself.
+ */
+export function findProjectRoot(filePath, baseDir, markers) {
+    if (!markers || markers.length === 0)
+        return baseDir;
+    let dir = dirname(filePath);
+    const root = baseDir.replace(/[\\/]+$/, "");
+    while (true) {
+        if (markers.some((m) => existsSync(join(dir, m)))) {
+            return dir;
+        }
+        if (dir === root)
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return root;
+        dir = parent;
+    }
+}

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

@@ -0,0 +1,144 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { spawn } from "child_process";
+import { t } from "../../i18n/index";
+import { LspClient } from "./client";
+import { collectCheckFiles } from "./check-tool";
+import { getServerForFile } from "./config";
+import { findProjectRoot } from "./project-root";
+/** 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. */
+const STARTUP_CHECK_TIMEOUT_MS = 60_000;
+/** Cap of tsc error lines surfaced in the prompt block. */
+const STARTUP_CHECK_ERROR_CAP = 20;
+/**
+ * Scan the project at session start for errors that already exist, so the
+ * model knows the baseline BEFORE it starts working. Addresses interrupted
+ * sessions: code left half-broken by a previous run is surfaced up front
+ * instead of being discovered (or missed) reactively.
+ *
+ * Strategy:
+ * - If the project has a tsconfig.json → one `tsc --noEmit --skipLibCheck`
+ *   invocation (single process, covers the whole project).
+ * - Otherwise → bounded LSP diagnostics on up to STARTUP_CHECK_FILE_CAP files
+ *   (handles CSS/JSON/plain-JS projects with no TS).
+ *
+ * Always fail-open: on any error/timeout/clean result → returns null, so the
+ * check can never slow down or break session startup.
+ */
+export async function runStartupHealthCheck(config, baseDir, deps = {}) {
+    if (!config.enabled)
+        return null;
+    try {
+        const result = await Promise.race([
+            runCheck(config, baseDir, deps),
+            new Promise((resolve) => setTimeout(() => resolve(null), STARTUP_CHECK_TIMEOUT_MS)),
+        ]);
+        if (!result || result.lines.length === 0)
+            return null;
+        const content = `${t("lsp.startup_header")}\n${result.lines.join("\n")}`;
+        return {
+            content,
+            priority: "high",
+            essential: false,
+            estimatedTokens: Math.ceil(content.length / 4),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function runCheck(config, baseDir, deps) {
+    const projectRoot = findProjectRoot(baseDir, baseDir, ["tsconfig.json", "package.json"]);
+    if (existsSync(join(projectRoot, "tsconfig.json"))) {
+        const runTsc = deps.runTsc ?? runTscDefault;
+        const errors = await runTsc(projectRoot, STARTUP_CHECK_TIMEOUT_MS);
+        if (errors.length === 0)
+            return null;
+        return { lines: errors.slice(0, STARTUP_CHECK_ERROR_CAP) };
+    }
+    const client = deps.client ?? new LspClient();
+    if (!deps.client)
+        client.setLogger(deps.logger ?? null);
+    const files = await collectCheckFiles(baseDir, config);
+    const lines = [];
+    let checked = 0;
+    for (const file of files.slice(0, STARTUP_CHECK_FILE_CAP)) {
+        const serverConfig = getServerForFile(file, config);
+        if (!serverConfig)
+            continue;
+        const fileRoot = findProjectRoot(file, baseDir, serverConfig.workspaceMarkers ?? []);
+        try {
+            const diags = await client.checkFile(file, baseDir, serverConfig, fileRoot);
+            checked++;
+            for (const d of diags) {
+                if (d.severity === 1) {
+                    lines.push(formatStartupError(file, baseDir, d));
+                }
+            }
+        }
+        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)}`);
+        }
+    }
+    if (checked === 0 || lines.length === 0)
+        return null;
+    return { lines: lines.slice(0, STARTUP_CHECK_ERROR_CAP) };
+}
+async function runTscDefault(projectRoot, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn("npx", ["tsc", "--noEmit", "--skipLibCheck"], {
+            cwd: projectRoot,
+            shell: true,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let out = "";
+        child.stdout?.on("data", (d) => {
+            out += d.toString();
+        });
+        child.stderr?.on("data", (d) => {
+            out += d.toString();
+        });
+        const timer = setTimeout(() => {
+            child.kill();
+            resolve([]);
+        }, timeoutMs);
+        child.on("error", () => {
+            clearTimeout(timer);
+            resolve([]);
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            resolve(parseTscErrors(out));
+        });
+    });
+}
+export function parseTscErrors(output) {
+    const lines = [];
+    for (const raw of output.split("\n")) {
+        const line = raw.replace(/^[a-zA-Z]:/, "").trim();
+        if (line.includes("error TS"))
+            lines.push(line);
+    }
+    return dedupe(lines);
+}
+function formatStartupError(file, baseDir, d) {
+    const rel = file.replace(baseDir.replace(/[\\/]$/, ""), "").replace(/^[\\/]/, "");
+    const line = d.range.start.line + 1;
+    const col = d.range.start.character + 1;
+    return `  ${rel || file}(${line},${col}): error: ${d.message}`;
+}
+function dedupe(lines) {
+    const seen = new Set();
+    const out = [];
+    for (const line of lines) {
+        if (!seen.has(line)) {
+            seen.add(line);
+            out.push(line);
+        }
+    }
+    return out;
+}

package/dist/modules/lsp/types.js

@@ -0,0 +1 @@
+export {};