micro-models-agent 0.41.2 → 0.43.0

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

package/dist/modules/lsp/probe.js

@@ -1,76 +0,0 @@
-import { LspClient } from "./client";
-import { getLanguageForFile } from "./config";
-import { collectCheckFiles } from "./check-tool";
-import { findProjectRoot } from "./project-root";
-const DEFAULT_PROBE_TIMEOUT_MS = 30_000;
-const DEFAULT_PROBE_DEADLINE_MS = 60_000;
-const DEFAULT_MAX_PARALLEL = 3;
-/**
- * Check which LSP servers apply to the project (via the same bounded file
- * walk as lsp_check) and probe each one: spawn + initialize + shutdown.
- * Used by the REPL banner so a dead server is visible before the first write.
- */
-export async function probeLspServers(config, baseDir, deps = {}) {
-    if (!config.enabled)
-        return { ok: [], failed: [], noneApplicable: true };
-    const timeoutCap = deps.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
-    const deadlineMs = deps.deadlineMs ?? DEFAULT_PROBE_DEADLINE_MS;
-    const maxParallel = deps.maxParallel ?? DEFAULT_MAX_PARALLEL;
-    const collect = deps.collectFiles ?? collectCheckFiles;
-    const files = await collect(baseDir, config);
-    const seen = new Set();
-    const servers = [];
-    for (const file of files) {
-        const language = getLanguageForFile(file);
-        if (!language)
-            continue;
-        const server = config.servers[language];
-        if (!server || seen.has(language))
-            continue;
-        seen.add(language);
-        servers.push({ language, config: server });
-    }
-    if (servers.length === 0)
-        return { ok: [], failed: [], noneApplicable: true };
-    // Probe in bounded waves. Probing everything in parallel on a cold npx cache
-    // makes the servers fight over the shared cache lock — observed as `LSP
-    // request timeout: initialize` for half the servers. Fully sequential probing
-    // avoids that but doubles the REPL banner wait (each server ~2s). A wave of
-    // `maxParallel` keeps the banner fast on a warm cache while capping cold-cache
-    // contention; each server in a wave gets its own LspClient (the client is
-    // stateful — process, request ids, response buffer — so concurrent probes on
-    // a shared instance would cross-talk). When a client is injected (tests), it
-    // is reused for every server.
-    const ok = [];
-    const failed = [];
-    const deadline = Date.now() + deadlineMs;
-    const probeOne = async (language, server) => {
-        const projectRoot = findProjectRoot(baseDir, baseDir, server.workspaceMarkers ?? []);
-        const serverTimeout = Math.min(server.timeout ?? timeoutCap, timeoutCap);
-        const started = Date.now();
-        const probeClient = deps.client ?? new LspClient();
-        try {
-            await probeClient.probe(server, projectRoot, serverTimeout);
-            ok.push({ language, ok: true, durationMs: Date.now() - started });
-        }
-        catch (e) {
-            failed.push({
-                language,
-                ok: false,
-                error: e instanceof Error ? e.message : String(e),
-                durationMs: Date.now() - started,
-            });
-        }
-    };
-    for (let i = 0; i < servers.length; i += maxParallel) {
-        if (Date.now() >= deadline) {
-            for (const { language } of servers.slice(i)) {
-                failed.push({ language, ok: false, error: "timeout", durationMs: 0 });
-            }
-            break;
-        }
-        const wave = servers.slice(i, i + maxParallel);
-        await Promise.all(wave.map(({ language, config: server }) => probeOne(language, server)));
-    }
-    return { ok, failed, noneApplicable: false };
-}

package/dist/modules/lsp/project-root.js

@@ -1,32 +0,0 @@
-import { existsSync } from "fs";
-import { dirname, join } from "path";
-/**
- * Resolve the LSP workspace root for an edited file.
- *
- * The workspace root must be the nearest project of the *edited file*, not the
- * agent baseDir — tsserver resolves `typescript` relative to the workspace
- * root, so for a file in `bicycle-shop/src/x.ts` under baseDir `mma_tests` the
- * root must be `bicycle-shop` (observed: "Could not find a valid TypeScript
- * installation" on every write/edit because baseDir had no node_modules).
- *
- * Which files mark a project root is language-specific and is declared in the
- * LSP server config (`LspServerConfig.workspaceMarkers`) — this function takes
- * the markers as a parameter and performs no language detection itself.
- */
-export function findProjectRoot(filePath, baseDir, markers) {
-    if (!markers || markers.length === 0)
-        return baseDir;
-    let dir = dirname(filePath);
-    const root = baseDir.replace(/[\\/]+$/, "");
-    while (true) {
-        if (markers.some((m) => existsSync(join(dir, m)))) {
-            return dir;
-        }
-        if (dir === root)
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return root;
-        dir = parent;
-    }
-}

package/dist/modules/lsp/startup-check.js

@@ -1,141 +0,0 @@
-import { existsSync } from "fs";
-import { join } from "path";
-import { spawn } from "child_process";
-import { t } from "../../i18n/index";
-import { LspClient } from "./client";
-import { collectCheckFiles } from "./check-tool";
-import { getServerForFile } from "./config";
-import { findProjectRoot } from "./project-root";
-/** Startup check never examines more than this many files via LSP. */
-const STARTUP_CHECK_FILE_CAP = 5;
-/** Overall cap for the whole startup check — never block session start longer. */
-const STARTUP_CHECK_TIMEOUT_MS = 60_000;
-/** Cap of tsc error lines surfaced in the prompt block. */
-const STARTUP_CHECK_ERROR_CAP = 20;
-/**
- * Scan the project at session start for errors that already exist, so the
- * model knows the baseline BEFORE it starts working. Addresses interrupted
- * sessions: code left half-broken by a previous run is surfaced up front
- * instead of being discovered (or missed) reactively.
- *
- * Strategy:
- * - If the project has a tsconfig.json → one `tsc --noEmit --skipLibCheck`
- *   invocation (single process, covers the whole project).
- * - Otherwise → bounded LSP diagnostics on up to STARTUP_CHECK_FILE_CAP files
- *   (handles CSS/JSON/plain-JS projects with no TS).
- *
- * Always fail-open: on any error/timeout/clean result → returns null, so the
- * check can never slow down or break session startup.
- */
-export async function runStartupHealthCheck(config, baseDir, deps = {}) {
-    if (!config.enabled)
-        return null;
-    try {
-        const result = await Promise.race([
-            runCheck(config, baseDir, deps),
-            new Promise((resolve) => setTimeout(() => resolve(null), STARTUP_CHECK_TIMEOUT_MS)),
-        ]);
-        if (!result || result.lines.length === 0)
-            return null;
-        const content = `${t("lsp.startup_header")}\n${result.lines.join("\n")}`;
-        return {
-            content,
-            priority: "high",
-            essential: false,
-            estimatedTokens: Math.ceil(content.length / 4),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-async function runCheck(config, baseDir, deps) {
-    const projectRoot = findProjectRoot(baseDir, baseDir, ["tsconfig.json", "package.json"]);
-    if (existsSync(join(projectRoot, "tsconfig.json"))) {
-        const runTsc = deps.runTsc ?? runTscDefault;
-        const errors = await runTsc(projectRoot, STARTUP_CHECK_TIMEOUT_MS);
-        if (errors.length === 0)
-            return null;
-        return { lines: errors.slice(0, STARTUP_CHECK_ERROR_CAP) };
-    }
-    const client = deps.client ?? new LspClient();
-    const files = await collectCheckFiles(baseDir, config);
-    const lines = [];
-    let checked = 0;
-    for (const file of files.slice(0, STARTUP_CHECK_FILE_CAP)) {
-        const serverConfig = getServerForFile(file, config);
-        if (!serverConfig)
-            continue;
-        const fileRoot = findProjectRoot(file, baseDir, serverConfig.workspaceMarkers ?? []);
-        try {
-            const diags = await client.checkFile(file, baseDir, serverConfig, fileRoot);
-            checked++;
-            for (const d of diags) {
-                if (d.severity === 1) {
-                    lines.push(formatStartupError(file, baseDir, d));
-                }
-            }
-        }
-        catch {
-            // Per-file LSP failure → skip silently (fail-open).
-        }
-    }
-    if (checked === 0 || lines.length === 0)
-        return null;
-    return { lines: lines.slice(0, STARTUP_CHECK_ERROR_CAP) };
-}
-async function runTscDefault(projectRoot, timeoutMs) {
-    return new Promise((resolve) => {
-        const child = spawn("npx", ["tsc", "--noEmit", "--skipLibCheck"], {
-            cwd: projectRoot,
-            shell: true,
-            windowsHide: true,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let out = "";
-        child.stdout?.on("data", (d) => {
-            out += d.toString();
-        });
-        child.stderr?.on("data", (d) => {
-            out += d.toString();
-        });
-        const timer = setTimeout(() => {
-            child.kill();
-            resolve([]);
-        }, timeoutMs);
-        child.on("error", () => {
-            clearTimeout(timer);
-            resolve([]);
-        });
-        child.on("close", () => {
-            clearTimeout(timer);
-            resolve(parseTscErrors(out));
-        });
-    });
-}
-export function parseTscErrors(output) {
-    const lines = [];
-    for (const raw of output.split("\n")) {
-        const line = raw.replace(/^[a-zA-Z]:/, "").trim();
-        if (line.includes("error TS"))
-            lines.push(line);
-    }
-    return dedupe(lines);
-}
-function formatStartupError(file, baseDir, d) {
-    const rel = file.replace(baseDir.replace(/[\\/]$/, ""), "").replace(/^[\\/]/, "");
-    const line = d.range.start.line + 1;
-    const col = d.range.start.character + 1;
-    return `  ${rel || file}(${line},${col}): error: ${d.message}`;
-}
-function dedupe(lines) {
-    const seen = new Set();
-    const out = [];
-    for (const line of lines) {
-        if (!seen.has(line)) {
-            seen.add(line);
-            out.push(line);
-        }
-    }
-    return out;
-}

package/dist/modules/processes/detect.js

@@ -1,34 +0,0 @@
-/**
- * Heuristic detection of long-running (server/watch) commands.
- *
- * The explicit `background: true` bash parameter always wins; this list is a
- * convenience so dev servers don't block the agent. It only inspects the raw
- * shell command (a technical process-type decision, not task classification).
- */
-const LONG_RUNNING_PATTERNS = [
-    /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
-    /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
-    /(^|\s)--watch\b/i,
-    /(^|\s)-w\b/i,
-    /\bnodemon\b/i,
-    /\btsx watch\b/i,
-    /\b(ts-node|tsc)\s+.*--watch\b/i,
-    /\bvite(?!\s+(build|create))\b/i,
-    /\bwebpack(-dev-server|\s+serve)\b/i,
-    /\bastro dev\b/i,
-    /\bnext (dev|start)\b/i,
-    /\bnuxt (dev|start)\b/i,
-    /\bsvelte-kit (dev|preview)\b/i,
-    /\bgatsby develop\b/i,
-    /\bdocker(-compose)?\s+.*\bup\b/i,
-    /\buvicorn\b|\bgunicorn\b/i,
-    /\bpython\s+-m\s+http\.server\b/i,
-    /\bflask run\b/i,
-    /\bphp artisan serve\b/i,
-    /\brails (server|s)\b/i,
-    /\bvitest watch\b/i,
-    /\bjest --watch\b/i,
-];
-export function isLongRunningCommand(command) {
-    return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
-}

package/dist/modules/skills/matcher.js

@@ -1,27 +0,0 @@
-const MIN_WORD_LENGTH = 4;
-export class SkillsMatcher {
-    match(taskDescription, skills, maxResults = 3) {
-        const taskWords = taskDescription.toLowerCase().split(/\W+/).filter(w => w.length >= MIN_WORD_LENGTH);
-        const scored = skills.map(skill => {
-            const allKeywords = [
-                skill.name.toLowerCase(),
-                skill.description.toLowerCase(),
-                ...skill.keywords.map(k => k.toLowerCase()),
-            ];
-            let score = 0;
-            for (const word of taskWords) {
-                for (const kw of allKeywords) {
-                    if (kw === word || (kw.length >= MIN_WORD_LENGTH && kw.includes(word))) {
-                        score++;
-                    }
-                }
-            }
-            return { skill, score };
-        });
-        return scored
-            .filter(s => s.score > 0)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxResults)
-            .map(s => s.skill);
-    }
-}