micro-models-agent 0.39.0 → 0.40.0

package/dist/modules/lsp/client.js

@@ -0,0 +1,235 @@
+import { spawn, execSync } from "child_process";
+import { resolve } from "path";
+const DEFAULT_TIMEOUT = 15000;
+export class LspClient {
+    process = null;
+    requestId = 0;
+    pending = new Map();
+    buffer = "";
+    contentLength = -1;
+    diagnostics = [];
+    diagnosticsResolve = null;
+    diagnosticsTimer = null;
+    initialized = false;
+    async checkFile(filePath, baseDir, config) {
+        const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        try {
+            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");
+            const content = fs.readFileSync(filePath, "utf-8");
+            const diagPromise = new Promise((resolve) => {
+                this.diagnosticsResolve = resolve;
+                this.diagnostics = [];
+                this.diagnosticsTimer = setTimeout(() => {
+                    if (this.diagnosticsResolve) {
+                        this.diagnosticsResolve([]);
+                        this.diagnosticsResolve = null;
+                    }
+                }, timeout);
+            });
+            this.sendNotification("textDocument/didOpen", {
+                textDocument: {
+                    uri,
+                    languageId: this.languageFromPath(filePath),
+                    version: 1,
+                    text: content,
+                },
+            });
+            return await diagPromise;
+        }
+        catch {
+            return [];
+        }
+        finally {
+            await this.shutdown();
+        }
+    }
+    async startServer(config, baseDir) {
+        if (config.autoInstall === false) {
+            try {
+                execSync(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
+            }
+            catch {
+                throw new Error(`${config.command} not found in PATH`);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const args = config.args ?? [];
+            const proc = spawn(config.command, args, {
+                stdio: ["pipe", "pipe", "pipe"],
+                env: { ...process.env, ...config.env },
+                cwd: baseDir,
+            });
+            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) {
+                    reject(new Error("LSP server start timeout"));
+                }
+            }, 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 { }
+        }
+    }
+    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;
+                }
+                if (this.diagnosticsResolve) {
+                    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);
+                    reject(new Error(`LSP request timeout: ${method}`));
+                }
+            }, timeout);
+        });
+    }
+    sendNotification(method, params) {
+        const message = JSON.stringify({ jsonrpc: "2.0", method, params });
+        this.write(message);
+    }
+    write(message) {
+        if (!this.process?.stdin?.writable)
+            return;
+        const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
+        try {
+            this.process.stdin.write(header + message);
+        }
+        catch { }
+    }
+    async shutdown() {
+        try {
+            if (this.process && this.initialized && this.process.stdin?.writable) {
+                this.sendRequest("shutdown", null, 3000).catch(() => { });
+                this.sendNotification("exit", null);
+                await new Promise((r) => setTimeout(r, 200));
+            }
+        }
+        catch {
+        }
+        finally {
+            if (this.process) {
+                try {
+                    this.process.kill();
+                }
+                catch { }
+                this.process = null;
+            }
+            this.initialized = false;
+            if (this.diagnosticsTimer) {
+                clearTimeout(this.diagnosticsTimer);
+                this.diagnosticsTimer = null;
+            }
+        }
+    }
+    pathToUri(filePath) {
+        const normalized = filePath.replace(/\\/g, "/");
+        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",
+            js: "javascript",
+            jsx: "javascriptreact",
+            py: "python",
+            go: "go",
+            rs: "rust",
+            json: "json",
+            html: "html",
+            css: "css",
+            scss: "scss",
+            md: "markdown",
+            yaml: "yaml",
+            yml: "yaml",
+        };
+        return map[ext ?? ""] ?? "plaintext";
+    }
+}

package/dist/modules/lsp/config.js

@@ -0,0 +1,81 @@
+/**
+ * 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: ['typescript-language-server', '--stdio'],
+            timeout: 20000,
+            autoInstall: true,
+        },
+        javascript: {
+            command: 'npx',
+            args: ['typescript-language-server', '--stdio'],
+            timeout: 15000,
+            autoInstall: true,
+        },
+        python: {
+            command: 'npx',
+            args: ['pyright', '--stdio'],
+            timeout: 15000,
+            autoInstall: true,
+        },
+        rust: {
+            command: 'rust-analyzer',
+            timeout: 15000,
+            autoInstall: false,
+        },
+        go: {
+            command: 'gopls',
+            timeout: 15000,
+            autoInstall: false,
+        },
+        json: {
+            command: 'npx',
+            args: ['vscode-json-languageserver', '--stdio'],
+            timeout: 10000,
+            autoInstall: true,
+        },
+        html: {
+            command: 'npx',
+            args: ['vscode-html-languageserver', '--stdio'],
+            timeout: 10000,
+            autoInstall: true,
+        },
+        css: {
+            command: 'npx',
+            args: ['vscode-css-languageserver', '--stdio'],
+            timeout: 10000,
+            autoInstall: true,
+        },
+    },
+};
+const LANGUAGE_MAP = {
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    rs: 'rust',
+    go: 'go',
+    json: 'json',
+    html: 'html',
+    css: 'css',
+    scss: 'css',
+};
+export function getServerForFile(filePath, config) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (!ext)
+        return null;
+    const lang = LANGUAGE_MAP[ext];
+    if (!lang)
+        return null;
+    return config.servers[lang] ?? null;
+}

package/dist/modules/lsp/index.js

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

package/dist/modules/lsp/module.js

@@ -0,0 +1,68 @@
+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';
+    config;
+    client = new LspClient();
+    constructor(config) {
+        this.config = { ...DEFAULT_LSP_CONFIG, ...config };
+    }
+    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;
+                try {
+                    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) {
+                        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 { }
+            },
+        };
+    }
+}
+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/types.js

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

package/dist/modules/mcp/client.js

@@ -112,19 +112,25 @@ export class MCPClient {
                 env: { ...process.env, ...this.config.env },
                 stdio: ["pipe", "pipe", "pipe"],
             });
+            let _resolved = false;
             child.on("error", (err) => {
                 this._connected = false;
-                reject(err);
+                if (!_resolved) {
+                    _resolved = true;
+                    reject(err);
+                }
             });
             child.on("exit", (code) => {
                 this._connected = false;
-                if (code !== 0) {
+                if (code !== 0 && !_resolved) {
+                    _resolved = true;
                     reject(new Error(`MCP server exited with code ${code}`));
                 }
             });
             child.on("spawn", () => {
                 this._connected = true;
                 this.process = child;
+                _resolved = true;
                 resolve();
             });
         });

package/dist/modules/memory/store.js

@@ -62,4 +62,8 @@ export class MemoryStore {
         writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
         return true;
     }
+    appendRule(category, pattern, cause, solution) {
+        const entry = `**pattern:** ${pattern}\n  **cause:** ${cause}\n  **solution:** ${solution}`;
+        this.append(category, entry);
+    }
 }