micro-models-agent 0.47.1 → 0.48.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

@@ -0,0 +1,101 @@
+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",
+};
+const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", ".mma", "coverage"]);
+export class Indexer {
+    baseDir;
+    MAX_FILES = 1000;
+    watcher = null;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    watch(callback) {
+        this.watcher = watch(this.baseDir, { recursive: true }, (event, filename) => {
+            if (filename && !Array.from(IGNORE_DIRS).some((dir) => filename.includes(dir))) {
+                callback(event, filename);
+            }
+        });
+    }
+    unwatch() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    async walk() {
+        const files = [];
+        let totalSize = 0;
+        let count = 0;
+        const walkDir = (dir) => {
+            if (!existsSync(dir))
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir);
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (count >= this.MAX_FILES)
+                    return;
+                const fullPath = join(dir, entry);
+                const relPath = relative(this.baseDir, fullPath);
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (!IGNORE_DIRS.has(entry)) {
+                        walkDir(fullPath);
+                    }
+                }
+                else if (stat.isFile()) {
+                    const ext = extname(entry).toLowerCase();
+                    const language = LANGUAGES[ext];
+                    if (language) {
+                        const content = readFileSync(fullPath, "utf-8");
+                        const exports = this.extractExports(content, language);
+                        files.push({ path: relPath, language, exports, size: stat.size });
+                        totalSize += stat.size;
+                        count++;
+                    }
+                }
+            }
+        };
+        walkDir(this.baseDir);
+        return { files, totalSize };
+    }
+    extractExports(content, language) {
+        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;
+            while ((match = exportRegex.exec(content)) !== null) {
+                exports.push(match[1]);
+            }
+            return exports;
+        }
+        return [];
+    }
+    summarize(result) {
+        const byLang = {};
+        for (const f of result.files) {
+            byLang[f.language] = (byLang[f.language] || 0) + 1;
+        }
+        const langs = Object.entries(byLang)
+            .sort((a, b) => b[1] - a[1])
+            .map(([lang, count]) => `${lang}:${count}`)
+            .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

@@ -0,0 +1,278 @@
+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;
+    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) {
+            // 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 });
+            }
+            catch {
+                throw new Error(`${config.command} not found in PATH`);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const args = config.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: 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)
+                    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;
+                }
+                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) {
+                // 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 { }
+                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";
+    }
+}

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(" ");
+}