micro-models-agent 0.58.2 → 0.60.0

package/dist/modules/lsp/module.js

@@ -1,260 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

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