micro-models-agent 0.51.1 → 0.51.2

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

@@ -1,183 +0,0 @@
-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,101 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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,278 +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";
-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

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