micro-models-agent 0.58.2 → 0.60.0

package/dist/modules/lsp/client.js

@@ -1,389 +0,0 @@
-import { spawn, execSync } from "child_process";
-import { resolve } from "path";
-import { platform } from "os";
-import { resolveSpawnCommand, buildWinCommandLine } from "./command";
-import { killTree } from "../processes/registry";
-/**
- * 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.
- */
-export class FileOnlyLogger {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    debug(msg, meta) {
-        this.logger.logSilent("debug", msg, meta);
-    }
-    info(msg, meta) {
-        this.logger.logSilent("info", msg, meta);
-    }
-    warn(msg, meta) {
-        this.logger.logSilent("warn", msg, meta);
-    }
-    error(msg, meta) {
-        this.logger.logSilent("error", msg, meta);
-    }
-}
-const DEFAULT_TIMEOUT = 15000;
-export class LspClient {
-    logger = null;
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    process = null;
-    requestId = 0;
-    pending = new Map();
-    buffer = "";
-    contentLength = -1;
-    diagnostics = [];
-    diagnosticsResolve = null;
-    diagnosticsTimer = null;
-    initialized = false;
-    async checkFile(filePath, baseDir, config, projectRoot = baseDir) {
-        const timeout = config.timeout ?? DEFAULT_TIMEOUT;
-        try {
-            await this.initialize(config, projectRoot, timeout);
-            this.sendNotification("initialized", {});
-            const uri = this.pathToUri(resolve(filePath));
-            const fs = await import("fs");
-            const content = fs.readFileSync(filePath, "utf-8");
-            const diagPromise = new Promise((resolve) => {
-                this.diagnosticsResolve = resolve;
-                this.diagnostics = [];
-                this.diagnosticsTimer = setTimeout(() => {
-                    this.diagnosticsResolve?.([]);
-                    this.diagnosticsResolve = null;
-                }, timeout);
-            });
-            this.sendNotification("textDocument/didOpen", {
-                textDocument: {
-                    uri,
-                    languageId: this.languageFromPath(filePath),
-                    version: 1,
-                    text: content,
-                },
-            });
-            return await diagPromise;
-        }
-        catch (e) {
-            // Re-throw so the LspModule can surface failures instead of hiding them.
-            throw e instanceof Error ? e : new Error(String(e));
-        }
-        finally {
-            await this.shutdown();
-        }
-    }
-    /**
-     * 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.
-     */
-    async probe(config, projectRoot, timeout) {
-        try {
-            await this.initialize(config, projectRoot, timeout);
-        }
-        finally {
-            await this.shutdown();
-        }
-    }
-    async initialize(config, projectRoot, timeout) {
-        await this.startServer(config, projectRoot);
-        const rootUri = this.pathToUri(projectRoot);
-        const initParams = {
-            processId: process.pid,
-            rootUri,
-            workspaceFolders: [{ uri: rootUri, name: "workspace" }],
-            capabilities: { textDocument: { publishDiagnostics: {} } },
-        };
-        try {
-            await this.sendRequest("initialize", initParams, timeout);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            this.logger?.warn(`LSP initialize failed (attempt 1): ${msg}`, {
-                command: config.command,
-                projectRoot,
-            });
-            // npx auto-install can blow past the initialize timeout on first run — retry once.
-            if (!(e instanceof Error) || !e.message.includes("initialize"))
-                throw e;
-            await this.shutdown();
-            await this.startServer(config, projectRoot);
-            try {
-                await this.sendRequest("initialize", initParams, timeout);
-            }
-            catch (retryErr) {
-                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                this.logger?.error(`LSP initialize failed (attempt 2, giving up): ${retryMsg}`, {
-                    command: config.command,
-                    projectRoot,
-                });
-                throw retryErr;
-            }
-        }
-        this.initialized = true;
-    }
-    async startServer(config, projectRoot) {
-        if (config.autoInstall === false) {
-            try {
-                execSync(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
-            }
-            catch {
-                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.
-        let effectiveCommand = config.command;
-        let effectiveArgs = config.args ?? [];
-        if (config.command === "npx" && effectiveArgs.length > 0) {
-            const binaryName = this.extractBinaryFromNpxArgs(effectiveArgs);
-            if (binaryName) {
-                const whichCmd = platform() === "win32" ? `where ${binaryName}` : `which ${binaryName}`;
-                try {
-                    execSync(whichCmd, { stdio: "pipe", timeout: 3000 });
-                    // Binary found globally — use it directly, skip 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).
-                    this.logger?.debug(`LSP: ${binaryName} not found globally, falling back to npx`);
-                }
-            }
-        }
-        return new Promise((resolve, reject) => {
-            const args = effectiveArgs;
-            const isWin = platform() === "win32";
-            let spawnCommand = resolveSpawnCommand(effectiveCommand);
-            let spawnArgs = args;
-            const spawnOpts = {
-                stdio: ["pipe", "pipe", "pipe"],
-                env: { ...process.env, ...config.env },
-                cwd: projectRoot,
-            };
-            if (isWin) {
-                // A `.cmd` shim can't be spawned directly under Node (`spawn npx EINVAL`) — run via cmd.exe.
-                spawnCommand = buildWinCommandLine(spawnCommand, args);
-                spawnArgs = [];
-                spawnOpts.shell = true;
-            }
-            const proc = spawn(spawnCommand, spawnArgs, spawnOpts);
-            proc.on("error", reject);
-            proc.stdout.on("data", (chunk) => {
-                this.handleData(chunk);
-            });
-            proc.stderr.on("data", () => { });
-            proc.once("spawn", () => {
-                resolve();
-            });
-            this.process = proc;
-            setTimeout(() => {
-                if (!this.initialized && this.process) {
-                    const msg = "LSP server start timeout";
-                    this.logger?.error(msg, { command: config.command, projectRoot, timeout: config.timeout ?? 10000 });
-                    reject(new Error(msg));
-                }
-            }, config.timeout ?? 10000);
-        });
-    }
-    handleData(chunk) {
-        this.buffer += chunk.toString();
-        this.parseMessages();
-    }
-    parseMessages() {
-        while (true) {
-            if (this.contentLength === -1) {
-                const headerEnd = this.buffer.indexOf("\r\n\r\n");
-                if (headerEnd === -1)
-                    return;
-                const header = this.buffer.slice(0, headerEnd);
-                const match = header.match(/Content-Length: (\d+)/i);
-                if (!match) {
-                    this.buffer = this.buffer.slice(headerEnd + 4);
-                    this.contentLength = -1;
-                    continue;
-                }
-                this.contentLength = parseInt(match[1], 10);
-                // Guard against malicious/buggy servers sending absurd Content-Length
-                if (this.contentLength > 10 * 1024 * 1024) {
-                    this.buffer = this.buffer.slice(headerEnd + 4);
-                    this.contentLength = -1;
-                    continue;
-                }
-                this.buffer = this.buffer.slice(headerEnd + 4);
-            }
-            if (this.buffer.length < this.contentLength)
-                return;
-            const body = this.buffer.slice(0, this.contentLength);
-            this.buffer = this.buffer.slice(this.contentLength);
-            this.contentLength = -1;
-            try {
-                const msg = JSON.parse(body);
-                this.handleMessage(msg);
-            }
-            catch (e) {
-                this.logger?.debug(`LSP JSON parse error: ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-    }
-    handleMessage(msg) {
-        if (msg.method === "textDocument/publishDiagnostics") {
-            const params = msg.params;
-            if (params?.diagnostics) {
-                this.diagnostics = params.diagnostics;
-                if (this.diagnosticsTimer) {
-                    clearTimeout(this.diagnosticsTimer);
-                    this.diagnosticsTimer = null;
-                }
-                this.diagnosticsResolve?.(this.diagnostics);
-                this.diagnosticsResolve = null;
-            }
-            return;
-        }
-        if (msg.id !== undefined && msg.id !== null) {
-            const pending = this.pending.get(msg.id);
-            if (pending) {
-                this.pending.delete(msg.id);
-                if (msg.error) {
-                    pending.reject(new Error(String(msg.error.message ?? "LSP error")));
-                }
-                else {
-                    pending.resolve(msg.result);
-                }
-            }
-        }
-    }
-    sendRequest(method, params, timeout) {
-        return new Promise((resolve, reject) => {
-            const id = ++this.requestId;
-            this.pending.set(id, { resolve, reject });
-            const message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
-            this.write(message);
-            setTimeout(() => {
-                if (this.pending.has(id)) {
-                    this.pending.delete(id);
-                    const msg = `LSP request timeout: ${method}`;
-                    this.logger?.warn(msg, { method, timeout });
-                    reject(new Error(msg));
-                }
-            }, timeout);
-        });
-    }
-    sendNotification(method, params) {
-        const message = JSON.stringify({ jsonrpc: "2.0", method, params });
-        this.write(message);
-    }
-    write(message) {
-        if (!this.process?.stdin?.writable) {
-            this.logger?.debug("LSP write failed: process stdin not writable");
-            return;
-        }
-        const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
-        try {
-            this.process.stdin.write(header + message);
-        }
-        catch (e) {
-            this.logger?.debug(`LSP write error: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    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.
-                try {
-                    await this.sendRequest("shutdown", null, 3000);
-                }
-                catch (e) {
-                    this.logger?.debug(`LSP shutdown request failed: ${e instanceof Error ? e.message : String(e)}`);
-                }
-                this.sendNotification("exit", null);
-                await new Promise((r) => setTimeout(r, 200));
-            }
-        }
-        catch (e) {
-            this.logger?.debug(`LSP shutdown error: ${e instanceof Error ? e.message : String(e)}`);
-        }
-        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.
-                try {
-                    killTree(this.process);
-                }
-                catch (e) {
-                    this.logger?.debug(`LSP killTree error: ${e instanceof Error ? e.message : String(e)}`);
-                }
-                this.process = null;
-            }
-            this.initialized = false;
-            this.buffer = "";
-            this.contentLength = -1;
-            if (this.diagnosticsTimer) {
-                clearTimeout(this.diagnosticsTimer);
-                this.diagnosticsTimer = null;
-            }
-        }
-    }
-    pathToUri(filePath) {
-        const normalized = filePath.replace(/\\/g, "/");
-        return /^[a-zA-Z]:/.test(normalized) ? `file:///${normalized}` : `file://${normalized}`;
-    }
-    languageFromPath(filePath) {
-        const ext = filePath.split(".").pop()?.toLowerCase();
-        const map = {
-            ts: "typescript",
-            tsx: "typescriptreact",
-            mts: "typescript",
-            cts: "typescript",
-            js: "javascript",
-            jsx: "javascriptreact",
-            mjs: "javascript",
-            cjs: "javascript",
-            py: "python",
-            go: "go",
-            rs: "rust",
-            json: "json",
-            html: "html",
-            css: "css",
-            scss: "scss",
-            md: "markdown",
-            yaml: "yaml",
-            yml: "yaml",
-        };
-        return map[ext ?? ""] ?? "plaintext";
-    }
-    /**
-     * Extract the actual binary name from npx args.
-     * For `npx --yes --package typescript-language-server --package typescript@5 typescript-language-server --stdio`
-     * returns `typescript-language-server` (the last non-flag arg before `--stdio`).
-     */
-    extractBinaryFromNpxArgs(args) {
-        // Find the binary: last arg that doesn't start with -- and isn't a package version
-        for (let i = args.length - 1; i >= 0; i--) {
-            const arg = args[i];
-            if (arg === "--stdio")
-                continue;
-            if (arg.startsWith("--"))
-                return null; // unexpected format
-            if (this.isPackageVersion(arg))
-                continue;
-            return arg;
-        }
-        return null;
-    }
-    /** Check if a string looks like a package version specifier (e.g. "typescript@5"). */
-    isPackageVersion(s) {
-        return /^[\w-]+@[\d.+*-]/.test(s);
-    }
-}

package/dist/modules/lsp/command.js

@@ -1,60 +0,0 @@
-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.
- */
-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))) {
-        return command;
-    }
-    const dirs = pathEnv.split(delimiter).filter(Boolean);
-    for (const dir of dirs) {
-        for (const ext of WIN_EXTS) {
-            const candidate = join(dir, `${command}${ext}`);
-            if (existsSync(candidate))
-                return `${command}${ext}`;
-        }
-    }
-    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).
- */
-export function buildWinCommandLine(command, args) {
-    const quote = (part) => {
-        if (part === "")
-            return '""';
-        if (!/[\s"&|^<>()%!]/.test(part))
-            return part;
-        return `"${part.replace(/"/g, '\\"')}"`;
-    };
-    return [command, ...args].map(quote).join(" ");
-}

package/dist/modules/lsp/config.js

@@ -1,135 +0,0 @@
-/**
- * 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.
- */
-export const DEFAULT_LSP_CONFIG = {
-    enabled: true,
-    timeout: 15000,
-    servers: {
-        typescript: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "typescript-language-server",
-                "--package",
-                "typescript@5",
-                "typescript-language-server",
-                "--stdio",
-            ],
-            timeout: 30000,
-            autoInstall: true,
-            workspaceMarkers: ["package.json", "tsconfig.json"],
-        },
-        javascript: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "typescript-language-server",
-                "--package",
-                "typescript@5",
-                "typescript-language-server",
-                "--stdio",
-            ],
-            timeout: 30000,
-            autoInstall: true,
-            workspaceMarkers: ["package.json", "tsconfig.json"],
-        },
-        python: {
-            command: "npx",
-            args: ["pyright", "--stdio"],
-            timeout: 15000,
-            autoInstall: true,
-            workspaceMarkers: ["pyproject.toml", "setup.py", "requirements.txt"],
-        },
-        rust: {
-            command: "rust-analyzer",
-            timeout: 15000,
-            autoInstall: false,
-            workspaceMarkers: ["Cargo.toml"],
-        },
-        go: {
-            command: "gopls",
-            timeout: 15000,
-            autoInstall: false,
-            workspaceMarkers: ["go.mod"],
-        },
-        json: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "vscode-langservers-extracted",
-                "vscode-json-language-server",
-                "--stdio",
-            ],
-            timeout: 30000,
-            autoInstall: true,
-            workspaceMarkers: ["package.json"],
-        },
-        html: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "vscode-langservers-extracted",
-                "--package",
-                "typescript@5",
-                "vscode-html-language-server",
-                "--stdio",
-            ],
-            timeout: 60000,
-            autoInstall: true,
-            workspaceMarkers: ["package.json"],
-        },
-        css: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "vscode-langservers-extracted",
-                "--package",
-                "typescript@5",
-                "vscode-css-language-server",
-                "--stdio",
-            ],
-            timeout: 60000,
-            autoInstall: true,
-            workspaceMarkers: ["package.json"],
-        },
-    },
-};
-const LANGUAGE_MAP = {
-    ts: "typescript",
-    tsx: "typescript",
-    mts: "typescript",
-    cts: "typescript",
-    js: "javascript",
-    jsx: "javascript",
-    mjs: "javascript",
-    cjs: "javascript",
-    py: "python",
-    rs: "rust",
-    go: "go",
-    json: "json",
-    html: "html",
-    css: "css",
-    scss: "css",
-};
-/** Language id for a file extension (via LANGUAGE_MAP), or null when unsupported. */
-export function getLanguageForFile(filePath) {
-    const ext = filePath.split(".").pop()?.toLowerCase();
-    if (!ext)
-        return null;
-    return LANGUAGE_MAP[ext] ?? null;
-}
-export function getServerForFile(filePath, config) {
-    const lang = getLanguageForFile(filePath);
-    if (!lang)
-        return null;
-    return config.servers[lang] ?? null;
-}

package/dist/modules/lsp/index.js

@@ -1,3 +0,0 @@
-export { LspModule } from "./module";
-export { LspClient, FileOnlyLogger } from "./client";
-export { getServerForFile, DEFAULT_LSP_CONFIG } from "./config";