micro-models-agent 0.41.2 → 0.43.0

package/dist/modules/indexer/walker.js

@@ -1,19 +1,19 @@
-import { readdirSync, readFileSync, statSync, existsSync, watch } from "fs";
-import { join, relative, extname } from "path";
+import { readdirSync, readFileSync, statSync, existsSync, watch } from 'fs';
+import { join, relative, extname } from 'path';
 const LANGUAGES = {
-    ".ts": "typescript",
-    ".tsx": "typescript-react",
-    ".js": "javascript",
-    ".jsx": "javascript-react",
-    ".json": "json",
-    ".md": "markdown",
-    ".yaml": "yaml",
-    ".yml": "yaml",
-    ".py": "python",
-    ".rs": "rust",
-    ".go": "go",
+    '.ts': 'typescript',
+    '.tsx': 'typescript-react',
+    '.js': 'javascript',
+    '.jsx': 'javascript-react',
+    '.json': 'json',
+    '.md': 'markdown',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.py': 'python',
+    '.rs': 'rust',
+    '.go': 'go',
 };
-const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", ".mma", "coverage"]);
+const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.mma', 'coverage']);
 export class Indexer {
     baseDir;
     MAX_FILES = 1000;
@@ -63,7 +63,7 @@ export class Indexer {
                     const ext = extname(entry).toLowerCase();
                     const language = LANGUAGES[ext];
                     if (language) {
-                        const content = readFileSync(fullPath, "utf-8");
+                        const content = readFileSync(fullPath, 'utf-8');
                         const exports = this.extractExports(content, language);
                         files.push({ path: relPath, language, exports, size: stat.size });
                         totalSize += stat.size;
@@ -76,7 +76,7 @@ export class Indexer {
         return { files, totalSize };
     }
     extractExports(content, language) {
-        if (language === "typescript" || language === "javascript") {
+        if (language === 'typescript' || language === 'javascript') {
             const exports = [];
             const exportRegex = /export\s+(?:const|function|class|interface|type|enum|default\s+(?:class|function))\s+(\w+)/g;
             let match;
@@ -95,7 +95,7 @@ export class Indexer {
         const langs = Object.entries(byLang)
             .sort((a, b) => b[1] - a[1])
             .map(([lang, count]) => `${lang}:${count}`)
-            .join(", ");
+            .join(', ');
         return `[Index: ${result.files.length} files, ${(result.totalSize / 1024).toFixed(1)}KB (${langs})]`;
     }
 }

package/dist/modules/lsp/client.js

@@ -1,8 +1,5 @@
 import { spawn, execSync } from "child_process";
 import { resolve } from "path";
-import { platform } from "os";
-import { resolveSpawnCommand, buildWinCommandLine } from "./command";
-import { killTree } from "../processes/registry";
 const DEFAULT_TIMEOUT = 15000;
 export class LspClient {
     process = null;
@@ -14,10 +11,18 @@ export class LspClient {
     diagnosticsResolve = null;
     diagnosticsTimer = null;
     initialized = false;
-    async checkFile(filePath, baseDir, config, projectRoot = baseDir) {
+    async checkFile(filePath, baseDir, config) {
         const timeout = config.timeout ?? DEFAULT_TIMEOUT;
         try {
-            await this.initialize(config, projectRoot, timeout);
+            await this.startServer(config, baseDir);
+            const rootUri = this.pathToUri(resolve(baseDir));
+            const initResult = await this.sendRequest("initialize", {
+                processId: process.pid,
+                rootUri,
+                workspaceFolders: [{ uri: rootUri, name: "workspace" }],
+                capabilities: { textDocument: { publishDiagnostics: {} } },
+            }, timeout);
+            this.initialized = true;
             this.sendNotification("initialized", {});
             const uri = this.pathToUri(resolve(filePath));
             const fs = await import("fs");
@@ -26,8 +31,10 @@ export class LspClient {
                 this.diagnosticsResolve = resolve;
                 this.diagnostics = [];
                 this.diagnosticsTimer = setTimeout(() => {
-                    this.diagnosticsResolve?.([]);
-                    this.diagnosticsResolve = null;
+                    if (this.diagnosticsResolve) {
+                        this.diagnosticsResolve([]);
+                        this.diagnosticsResolve = null;
+                    }
                 }, timeout);
             });
             this.sendNotification("textDocument/didOpen", {
@@ -40,51 +47,14 @@ export class LspClient {
             });
             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);
+        catch {
+            return [];
         }
         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) {
-            // 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);
-            await this.sendRequest("initialize", initParams, timeout);
-        }
-        this.initialized = true;
-    }
-    async startServer(config, projectRoot) {
+    async startServer(config, baseDir) {
         if (config.autoInstall === false) {
             try {
                 execSync(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
@@ -95,21 +65,11 @@ export class LspClient {
         }
         return new Promise((resolve, reject) => {
             const args = config.args ?? [];
-            const isWin = platform() === "win32";
-            let spawnCommand = resolveSpawnCommand(config.command);
-            let spawnArgs = args;
-            const spawnOpts = {
+            const proc = spawn(config.command, args, {
                 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);
+                cwd: baseDir,
+            });
             proc.on("error", reject);
             proc.stdout.on("data", (chunk) => {
                 this.handleData(chunk);
@@ -120,8 +80,9 @@ export class LspClient {
             });
             this.process = proc;
             setTimeout(() => {
-                if (!this.initialized && this.process)
+                if (!this.initialized && this.process) {
                     reject(new Error("LSP server start timeout"));
+                }
             }, config.timeout ?? 10000);
         });
     }
@@ -172,8 +133,10 @@ export class LspClient {
                     clearTimeout(this.diagnosticsTimer);
                     this.diagnosticsTimer = null;
                 }
-                this.diagnosticsResolve?.(this.diagnostics);
-                this.diagnosticsResolve = null;
+                if (this.diagnosticsResolve) {
+                    this.diagnosticsResolve(this.diagnostics);
+                    this.diagnosticsResolve = null;
+                }
             }
             return;
         }
@@ -229,18 +192,13 @@ export class LspClient {
         }
         finally {
             if (this.process) {
-                // The direct child on win32 is the cmd.exe wrapper; killing it alone
-                // orphans the npx → node → tsserver tree (observed as leaked node
-                // processes after every check). Tree-kill so the whole chain dies.
                 try {
-                    killTree(this.process);
+                    this.process.kill();
                 }
                 catch { }
                 this.process = null;
             }
             this.initialized = false;
-            this.buffer = "";
-            this.contentLength = -1;
             if (this.diagnosticsTimer) {
                 clearTimeout(this.diagnosticsTimer);
                 this.diagnosticsTimer = null;
@@ -249,19 +207,18 @@ export class LspClient {
     }
     pathToUri(filePath) {
         const normalized = filePath.replace(/\\/g, "/");
-        return /^[a-zA-Z]:/.test(normalized) ? `file:///${normalized}` : `file://${normalized}`;
+        if (/^[a-zA-Z]:/.test(normalized)) {
+            return `file:///${normalized}`;
+        }
+        return `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",

package/dist/modules/lsp/config.js

@@ -10,125 +10,71 @@ export const DEFAULT_LSP_CONFIG = {
     timeout: 15000,
     servers: {
         typescript: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "typescript-language-server",
-                "--package",
-                "typescript@5",
-                "typescript-language-server",
-                "--stdio",
-            ],
-            timeout: 30000,
+            command: 'npx',
+            args: ['typescript-language-server', '--stdio'],
+            timeout: 20000,
             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,
+            command: 'npx',
+            args: ['typescript-language-server', '--stdio'],
+            timeout: 15000,
             autoInstall: true,
-            workspaceMarkers: ["package.json", "tsconfig.json"],
         },
         python: {
-            command: "npx",
-            args: ["pyright", "--stdio"],
+            command: 'npx',
+            args: ['pyright', '--stdio'],
             timeout: 15000,
             autoInstall: true,
-            workspaceMarkers: ["pyproject.toml", "setup.py", "requirements.txt"],
         },
         rust: {
-            command: "rust-analyzer",
+            command: 'rust-analyzer',
             timeout: 15000,
             autoInstall: false,
-            workspaceMarkers: ["Cargo.toml"],
         },
         go: {
-            command: "gopls",
+            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,
+            command: 'npx',
+            args: ['vscode-json-languageserver', '--stdio'],
+            timeout: 10000,
             autoInstall: true,
-            workspaceMarkers: ["package.json"],
         },
         html: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "vscode-langservers-extracted",
-                "--package",
-                "typescript@5",
-                "vscode-html-language-server",
-                "--stdio",
-            ],
-            timeout: 60000,
+            command: 'npx',
+            args: ['vscode-html-languageserver', '--stdio'],
+            timeout: 10000,
             autoInstall: true,
-            workspaceMarkers: ["package.json"],
         },
         css: {
-            command: "npx",
-            args: [
-                "--yes",
-                "--package",
-                "vscode-langservers-extracted",
-                "--package",
-                "typescript@5",
-                "vscode-css-language-server",
-                "--stdio",
-            ],
-            timeout: 60000,
+            command: 'npx',
+            args: ['vscode-css-languageserver', '--stdio'],
+            timeout: 10000,
             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",
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: '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();
+export function getServerForFile(filePath, config) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
     if (!ext)
         return null;
-    return LANGUAGE_MAP[ext] ?? null;
-}
-export function getServerForFile(filePath, config) {
-    const lang = getLanguageForFile(filePath);
+    const lang = LANGUAGE_MAP[ext];
     if (!lang)
         return null;
     return config.servers[lang] ?? null;

package/dist/modules/lsp/index.js

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

package/dist/modules/lsp/module.js

@@ -1,57 +1,33 @@
-import { existsSync } from "fs";
-import { 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;
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { LspClient } from './client';
+import { getServerForFile, DEFAULT_LSP_CONFIG } from './config';
+const severityLabels = {
+    1: 'error',
+    2: 'warning',
+    3: 'info',
+    4: 'hint',
+};
 export class LspModule {
-    name = "lsp";
+    name = 'lsp';
     config;
-    client;
-    failuresByServer = new Map();
-    disabledServers = new Set();
-    constructor(config, client) {
+    client = new LspClient();
+    constructor(config) {
         this.config = { ...DEFAULT_LSP_CONFIG, ...config };
-        this.client = client ?? new LspClient();
-    }
-    /** 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",
+            name: 'lsp-check',
             priority: 15,
             onAfterTool: async (_ctx, call, result) => {
                 if (!self.config.enabled)
                     return;
-                if (call.name !== "write_file" && call.name !== "edit_file")
+                if (call.name !== 'write_file' && call.name !== 'edit_file')
                     return;
                 if (!result.success)
                     return;
-                const filePath = String(call.arguments.path ?? "");
+                const filePath = String(call.arguments.path ?? '');
                 if (!filePath)
                     return;
                 const fullPath = resolve(_ctx.baseDir, filePath);
@@ -60,13 +36,8 @@ export class LspModule {
                 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 diagnostics = await self.client.checkFile(fullPath, _ctx.baseDir, serverConfig);
                     const errors = diagnostics.filter((d) => d.severity === 1);
                     const warnings = diagnostics.filter((d) => d.severity === 2);
                     if (errors.length > 0) {
@@ -78,155 +49,20 @@ export class LspModule {
                         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}`;
-                    }
-                }
+                catch { }
             },
         };
     }
-    /**
-     * 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",
-                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 = [];
-        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++;
-                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 (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;
+    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";
+        const sev = severityLabels[d.severity] ?? 'unknown';
         return `  ${filename}(${line},${col}): ${sev}: ${d.message}`;
     })
-        .join("\n");
+        .join('\n');
 }