micro-models-agent 0.40.1 → 0.41.2

package/dist/modules/indexer/project-profile.js

@@ -0,0 +1,183 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { t } from "../../i18n/index";
+const MANIFEST_ORDER = [
+    "package.json",
+    "pyproject.toml",
+    "Cargo.toml",
+    "go.mod",
+    "requirements.txt",
+];
+const MAX_DEPS = 5;
+const MAX_DEV_DEPS = 3;
+const MAX_SCRIPTS = 3;
+/**
+ * Find the first existing manifest in priority order (best-effort, root only).
+ */
+export function detectManifest(baseDir) {
+    for (const manifest of MANIFEST_ORDER) {
+        if (existsSync(join(baseDir, manifest)))
+            return manifest;
+    }
+    return null;
+}
+/** Strip version specifiers from a manifest dependency entry. */
+function cleanDependency(entry) {
+    let name = entry.trim();
+    const eq = name.indexOf("=");
+    if (eq > 0)
+        name = name.slice(0, eq);
+    const ineq = name.search(/[<>=!~^]/);
+    if (ineq > 0)
+        name = name.slice(0, ineq);
+    return name.replace(/["',]/g, "").trim();
+}
+function readPackageJson(baseDir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(baseDir, "package.json"), "utf-8"));
+        if (!raw || typeof raw !== "object")
+            return null;
+        const profile = {
+            runtime: "node",
+            deps: Object.keys(raw.dependencies || {}),
+            devDeps: Object.keys(raw.devDependencies || {}),
+            scripts: {},
+        };
+        if (typeof raw.name === "string" && raw.name)
+            profile.name = raw.name;
+        if (raw.scripts && typeof raw.scripts === "object") {
+            for (const [key, val] of Object.entries(raw.scripts)) {
+                if (typeof val === "string" && val)
+                    profile.scripts[key] = val;
+            }
+        }
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+function readPyproject(baseDir) {
+    try {
+        const content = readFileSync(join(baseDir, "pyproject.toml"), "utf-8");
+        const profile = { runtime: "python", deps: [], devDeps: [], scripts: {} };
+        const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+        if (nameMatch)
+            profile.name = nameMatch[1];
+        const depsBlock = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+        if (depsBlock) {
+            profile.deps = [...depsBlock[1].matchAll(/"([^"]+)"/g)]
+                .map((m) => cleanDependency(m[1]))
+                .filter(Boolean);
+        }
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+function readCargo(baseDir) {
+    try {
+        const content = readFileSync(join(baseDir, "Cargo.toml"), "utf-8");
+        const profile = { runtime: "rust", deps: [], devDeps: [], scripts: {} };
+        const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+        if (nameMatch)
+            profile.name = nameMatch[1];
+        let inDeps = false;
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (/^\[.*\]$/.test(trimmed)) {
+                inDeps = trimmed === "[dependencies]";
+                continue;
+            }
+            if (inDeps && /^[A-Za-z0-9_-]+\s*=/.test(trimmed)) {
+                profile.deps.push(trimmed.split("=")[0].trim());
+            }
+        }
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+function readGoMod(baseDir) {
+    try {
+        const content = readFileSync(join(baseDir, "go.mod"), "utf-8");
+        const profile = { runtime: "go", deps: [], devDeps: [], scripts: {} };
+        const moduleMatch = content.match(/^module\s+(\S+)/m);
+        if (moduleMatch)
+            profile.name = moduleMatch[1];
+        for (const line of content.split("\n")) {
+            const m = line.match(/^\s*(\S+)\s+v[\d.]+/);
+            if (m && !line.startsWith("//"))
+                profile.deps.push(m[1]);
+        }
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+function readRequirements(baseDir) {
+    try {
+        const content = readFileSync(join(baseDir, "requirements.txt"), "utf-8");
+        const profile = { runtime: "python", deps: [], devDeps: [], scripts: {} };
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-"))
+                continue;
+            profile.deps.push(cleanDependency(trimmed));
+        }
+        return profile;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read a compact project profile from the workspace manifest (best-effort).
+ * Returns null when no readable manifest is present.
+ */
+export function readProjectProfile(baseDir) {
+    const manifest = detectManifest(baseDir);
+    if (!manifest)
+        return null;
+    switch (manifest) {
+        case "package.json":
+            return readPackageJson(baseDir);
+        case "pyproject.toml":
+            return readPyproject(baseDir);
+        case "Cargo.toml":
+            return readCargo(baseDir);
+        case "go.mod":
+            return readGoMod(baseDir);
+        case "requirements.txt":
+            return readRequirements(baseDir);
+        default:
+            return null;
+    }
+}
+/** One-line stack-neutral summary of the project profile. */
+export function formatProjectProfile(profile) {
+    const parts = [];
+    if (profile.deps.length > 0) {
+        parts.push(`${t("indexer.stack_deps")}: ${profile.deps.slice(0, MAX_DEPS).join(", ")}`);
+    }
+    if (profile.devDeps.length > 0) {
+        parts.push(`${t("indexer.stack_dev")}: ${profile.devDeps.slice(0, MAX_DEV_DEPS).join(", ")}`);
+    }
+    const scripts = Object.entries(profile.scripts).slice(0, MAX_SCRIPTS);
+    if (scripts.length > 0) {
+        parts.push(`${t("indexer.stack_scripts")}: ${scripts.map(([k, v]) => `${k}=${v}`).join(", ")}`);
+    }
+    const name = profile.name ? ` ${profile.name}` : "";
+    return `[Stack: ${profile.runtime}${name} — ${parts.join(" | ")}]`;
+}
+/**
+ * Convenience: detect + read + format in one call. Returns null when the
+ * workspace has no readable manifest.
+ */
+export function buildProjectProfileLine(baseDir) {
+    const profile = readProjectProfile(baseDir);
+    return profile ? formatProjectProfile(profile) : null;
+}

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/check-tool.js

@@ -0,0 +1,58 @@
+import { readdir, stat } from "fs/promises";
+import { resolve, relative } from "path";
+import { getServerForFile } from "./config";
+/** lsp_check directory mode: walk depth and per-call file cap. */
+export const MAX_LSP_CHECK_FILES = 15;
+const MAX_LSP_WALK_DEPTH = 4;
+const SKIP_DIRS = new Set(["node_modules", ".git", ".mma", "dist"]);
+export const severityLabels = {
+    1: "error",
+    2: "warning",
+    3: "info",
+    4: "hint",
+};
+/**
+ * Resolve the target to a file (single check) or a bounded list of source
+ * files (directory check, capped at MAX_LSP_CHECK_FILES). Only files with a
+ * configured LSP server are collected, so unsupported extensions are simply
+ * not checked rather than producing noise.
+ */
+export async function collectCheckFiles(resolved, config) {
+    const info = await stat(resolved).catch(() => null);
+    if (!info)
+        return [];
+    if (info.isFile())
+        return [resolved];
+    const out = [];
+    await walkDir(resolved, 0, out, config);
+    return out;
+}
+async function walkDir(dir, depth, out, config) {
+    if (depth > MAX_LSP_WALK_DEPTH || out.length >= MAX_LSP_CHECK_FILES)
+        return;
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (out.length >= MAX_LSP_CHECK_FILES)
+            break;
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            await walkDir(resolve(dir, entry.name), depth + 1, out, config);
+        }
+        else if (entry.isFile() && getServerForFile(resolve(dir, entry.name), config)) {
+            out.push(resolve(dir, entry.name));
+        }
+    }
+}
+export function formatCheckDiagnostics(items, baseDir) {
+    return items
+        .slice(0, 40)
+        .map(({ file, diag }) => {
+        const rel = relative(baseDir, file).replace(/\\/g, "/");
+        const line = diag.range.start.line + 1;
+        const col = diag.range.start.character + 1;
+        const sev = severityLabels[diag.severity] ?? "unknown";
+        return `  ${rel}(${line},${col}): ${sev}: ${diag.message}`;
+    })
+        .join("\n");
+}

package/dist/modules/lsp/client.js

@@ -1,5 +1,8 @@
 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;
@@ -11,18 +14,10 @@ export class LspClient {
     diagnosticsResolve = null;
     diagnosticsTimer = null;
     initialized = false;
-    async checkFile(filePath, baseDir, config) {
+    async checkFile(filePath, baseDir, config, projectRoot = baseDir) {
         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;
+            await this.initialize(config, projectRoot, timeout);
             this.sendNotification("initialized", {});
             const uri = this.pathToUri(resolve(filePath));
             const fs = await import("fs");
@@ -31,10 +26,8 @@ export class LspClient {
                 this.diagnosticsResolve = resolve;
                 this.diagnostics = [];
                 this.diagnosticsTimer = setTimeout(() => {
-                    if (this.diagnosticsResolve) {
-                        this.diagnosticsResolve([]);
-                        this.diagnosticsResolve = null;
-                    }
+                    this.diagnosticsResolve?.([]);
+                    this.diagnosticsResolve = null;
                 }, timeout);
             });
             this.sendNotification("textDocument/didOpen", {
@@ -47,14 +40,51 @@ export class LspClient {
             });
             return await diagPromise;
         }
-        catch {
-            return [];
+        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();
         }
     }
-    async startServer(config, baseDir) {
+    /**
+     * 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) {
+            // 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) {
         if (config.autoInstall === false) {
             try {
                 execSync(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
@@ -65,11 +95,21 @@ export class LspClient {
         }
         return new Promise((resolve, reject) => {
             const args = config.args ?? [];
-            const proc = spawn(config.command, args, {
+            const isWin = platform() === "win32";
+            let spawnCommand = resolveSpawnCommand(config.command);
+            let spawnArgs = args;
+            const spawnOpts = {
                 stdio: ["pipe", "pipe", "pipe"],
                 env: { ...process.env, ...config.env },
-                cwd: baseDir,
-            });
+                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);
@@ -80,9 +120,8 @@ 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);
         });
     }
@@ -133,10 +172,8 @@ export class LspClient {
                     clearTimeout(this.diagnosticsTimer);
                     this.diagnosticsTimer = null;
                 }
-                if (this.diagnosticsResolve) {
-                    this.diagnosticsResolve(this.diagnostics);
-                    this.diagnosticsResolve = null;
-                }
+                this.diagnosticsResolve?.(this.diagnostics);
+                this.diagnosticsResolve = null;
             }
             return;
         }
@@ -192,13 +229,18 @@ 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 {
-                    this.process.kill();
+                    killTree(this.process);
                 }
                 catch { }
                 this.process = null;
             }
             this.initialized = false;
+            this.buffer = "";
+            this.contentLength = -1;
             if (this.diagnosticsTimer) {
                 clearTimeout(this.diagnosticsTimer);
                 this.diagnosticsTimer = null;
@@ -207,18 +249,19 @@ export class LspClient {
     }
     pathToUri(filePath) {
         const normalized = filePath.replace(/\\/g, "/");
-        if (/^[a-zA-Z]:/.test(normalized)) {
-            return `file:///${normalized}`;
-        }
-        return `file://${normalized}`;
+        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",

package/dist/modules/lsp/command.js

@@ -0,0 +1,60 @@
+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(" ");
+}