micro-models-agent 0.59.0 → 0.60.1

package/dist/modules/execution/tracker.js

@@ -1,69 +0,0 @@
-import { PlanCreator, getPlanProgress } from "./planner";
-export class PlanTracker {
-    plan;
-    currentStepIndex = 0;
-    constructor(plan) {
-        this.plan = plan;
-    }
-    getPlan() {
-        return this.plan;
-    }
-    getCurrentStepIndex() {
-        return this.currentStepIndex;
-    }
-    getCurrentStep() {
-        return this.plan.steps[this.currentStepIndex];
-    }
-    getStep(id) {
-        return this.plan.steps.find((s) => s.id === id);
-    }
-    updateStepStatus(id, status) {
-        const step = this.getStep(id);
-        if (step)
-            step.status = status;
-    }
-    addNote(id, note) {
-        const step = this.getStep(id);
-        if (step)
-            step.note = note;
-    }
-    advance() {
-        if (this.currentStepIndex < this.plan.steps.length - 1) {
-            this.currentStepIndex++;
-            this.plan.steps[this.currentStepIndex].status = "in_progress";
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Advance the pointer past any done/skipped steps without mutating their
-     * status. Keeps currentStepIndex in sync when the model marks steps done via
-     * the `plan update` tool (which never calls advance()). Without this,
-     * getCurrentStep() stays on the first step forever and the stuck detector
-     * accumulates false-positive "no progress" warnings.
-     */
-    syncCurrentStep() {
-        while (this.currentStepIndex < this.plan.steps.length - 1 &&
-            (this.plan.steps[this.currentStepIndex].status === "done" ||
-                this.plan.steps[this.currentStepIndex].status === "skipped")) {
-            this.currentStepIndex++;
-        }
-    }
-    isComplete() {
-        return this.plan.steps.every((s) => s.status === "done" || s.status === "skipped");
-    }
-    getProgressString() {
-        const p = getPlanProgress(this.plan);
-        const total = p.total;
-        const settled = p.settled;
-        const pct = total > 0 ? Math.round((settled / total) * 100) : 0;
-        const barWidth = 10;
-        const filled = Math.round((settled / total) * barWidth);
-        const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
-        const skippedPart = p.skipped > 0 ? ` (${p.skipped} skipped)` : "";
-        return `[${this.plan.id}] ${this.plan.title}  ${settled}/${total}${skippedPart}  ${bar}  ${pct}%`;
-    }
-    toPromptBlock() {
-        return PlanCreator.toPromptBlock(this.plan, this.currentStepIndex);
-    }
-}

package/dist/modules/execution/types.js

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

package/dist/modules/execution/verifier.js

@@ -1,235 +0,0 @@
-import { existsSync } from "fs";
-import { resolve, extname, join } from "path";
-import { spawn } from "child_process";
-import { t } from "../../i18n/index";
-import { validateExpertConfig } from "../../config/experts";
-import { findProjectRoot } from "../lsp/project-root";
-import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
-import { findExistingFile } from "./auditor";
-export class StepVerifier {
-    baseDir;
-    constructor(baseDir) {
-        this.baseDir = baseDir;
-    }
-    async checkFileExists(path) {
-        const resolved = resolve(this.baseDir, path);
-        const exists = existsSync(resolved);
-        return {
-            passed: exists,
-            message: exists ? t("verify.file_exists", { path }) : t("verify.file_not_found", { path }),
-        };
-    }
-    async runScript(scriptName) {
-        try {
-            await this.runAsync(`bun run ${scriptName}`, this.baseDir, 60_000);
-            return { passed: true, message: t("verify.script_passed", { script: scriptName }) };
-        }
-        catch (e) {
-            return {
-                passed: false,
-                message: t("verify.script_failed", { script: scriptName, message: e.message }),
-            };
-        }
-    }
-    async runTypeCheck() {
-        const tsconfigPath = resolve(this.baseDir, "tsconfig.json");
-        if (!existsSync(tsconfigPath)) {
-            return { passed: true, message: "No tsconfig.json found — skipping type check" };
-        }
-        try {
-            await this.runAsync("npx tsc --noEmit", this.baseDir, 60_000);
-            return { passed: true, message: "TypeScript type check passed" };
-        }
-        catch (e) {
-            const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
-            return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
-        }
-    }
-    /**
-     * Type-check a specific file, resolving the project root from the FILE's
-     * location (not the agent baseDir). For nested layouts (`baseDir/proj/` with
-     * its own tsconfig.json) the old baseDir-based check silently skipped every
-     * type error (observed in ses_mst2r0r5: zero type feedback for the whole
-     * session). Markers mirror the TypeScript LSP server config.
-     */
-    async runTypeCheckForFile(filePath) {
-        const projectRoot = findProjectRoot(filePath, this.baseDir, ["tsconfig.json", "package.json"]);
-        const tsconfigPath = join(projectRoot, "tsconfig.json");
-        if (!existsSync(tsconfigPath)) {
-            return { passed: true, message: "No tsconfig.json found — skipping type check" };
-        }
-        try {
-            await this.runAsync("npx tsc --noEmit --skipLibCheck", projectRoot, 60_000);
-            return { passed: true, message: "TypeScript type check passed" };
-        }
-        catch (e) {
-            const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
-            return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
-        }
-    }
-    async runTests() {
-        const pkgPath = resolve(this.baseDir, "package.json");
-        if (!existsSync(pkgPath)) {
-            return { passed: true, message: "No package.json found — skipping tests" };
-        }
-        try {
-            const pkg = JSON.parse(require("fs").readFileSync(pkgPath, "utf-8"));
-            if (!pkg.scripts?.test) {
-                return { passed: true, message: "No test script defined — skipping tests" };
-            }
-        }
-        catch {
-            /* fall through — attempt to run */
-        }
-        return this.runScript("test");
-    }
-    async verifyArtifactFiles(files) {
-        return Promise.all(files.map((f) => this.checkFileExists(f)));
-    }
-    async verifyMoEManifest(plan, config, allToolTags) {
-        const errors = [];
-        const warnings = [];
-        const details = [];
-        const expertErrors = validateExpertConfig(config, allToolTags);
-        for (const err of expertErrors) {
-            errors.push(err);
-            details.push({ passed: false, message: err });
-        }
-        const tscResult = await this.runTypeCheck();
-        details.push(tscResult);
-        if (!tscResult.passed) {
-            errors.push(tscResult.message);
-        }
-        for (const sub of plan.subtasks) {
-            const fileChecks = await this.verifyArtifactFiles(sub.allowed_files || []);
-            for (const check of fileChecks) {
-                details.push(check);
-                if (!check.passed) {
-                    errors.push(check.message);
-                }
-            }
-        }
-        return {
-            success: errors.length === 0,
-            errors,
-            warnings,
-            details,
-        };
-    }
-    async verifyStep(stepDescription, kind) {
-        const fileMatches = extractFileLikeTokens(stripUrls(stepDescription));
-        // No named files — this step cannot be verified by file existence. Do NOT
-        // trivially pass (empty every() = true); signal noFiles so the tool guides
-        // the model to run a real check instead.
-        if (fileMatches.length === 0) {
-            return { passed: false, syntaxValid: true, failed: [], noFiles: true };
-        }
-        const results = [];
-        let syntaxValid = true;
-        for (const filePath of fileMatches) {
-            const resolved = findExistingFile(this.baseDir, filePath);
-            const exists = !!resolved;
-            if (kind === "delete") {
-                // For delete steps: file NOT existing is a pass
-                results.push({
-                    passed: !exists,
-                    message: exists
-                        ? t("verify.file_still_exists", { path: filePath })
-                        : t("verify.file_not_found", { path: filePath }),
-                });
-                // Don't syntax-check a deleted file
-                continue;
-            }
-            // Create steps: file must exist + valid syntax
-            if (!exists) {
-                results.push({ passed: false, message: t("verify.file_not_found", { path: filePath }) });
-                continue;
-            }
-            results.push({ passed: true, message: t("verify.file_exists", { path: filePath }) });
-            if (!(await this.validateSyntax(resolved))) {
-                syntaxValid = false;
-                results.push({ passed: false, message: t("verify.syntax_error", { path: filePath }) });
-            }
-        }
-        return {
-            passed: results.every((r) => r.passed),
-            syntaxValid,
-            failed: results.filter((r) => !r.passed),
-            noFiles: false,
-        };
-    }
-    async validateSyntax(filePath) {
-        const ext = extname(filePath);
-        if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
-            try {
-                await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 10000);
-                return true;
-            }
-            catch (err) {
-                if (err.status === 127 ||
-                    err.message.includes("not found") ||
-                    err.message.includes("ENOENT")) {
-                    return true;
-                }
-                const stderr = err.stderr?.toString() || "";
-                if (stderr.includes("error TS") && !stderr.includes("Cannot find module")) {
-                    return false;
-                }
-                return true;
-            }
-        }
-        if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
-            try {
-                await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Run a command asynchronously (non-blocking event loop) and resolve when it
-     * exits. Rejects with the captured stderr/stdout on non-zero exit or timeout.
-     */
-    runAsync(command, cwd, timeoutMs) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(command, {
-                cwd,
-                shell: true,
-                windowsHide: true,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            let stdout = "";
-            let stderr = "";
-            child.stdout?.on("data", (d) => {
-                stdout += d.toString();
-            });
-            child.stderr?.on("data", (d) => {
-                stderr += d.toString();
-            });
-            const timer = setTimeout(() => {
-                child.kill();
-                reject(new Error(`Command timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            child.on("error", (err) => {
-                clearTimeout(timer);
-                reject(err);
-            });
-            child.on("close", (code) => {
-                clearTimeout(timer);
-                if (code === 0) {
-                    resolve({ stdout, stderr });
-                }
-                else {
-                    const err = new Error(`Command failed with exit code ${code}`);
-                    err.stdout = stdout;
-                    err.stderr = stderr;
-                    err.status = code;
-                    reject(err);
-                }
-            });
-        });
-    }
-}

package/dist/modules/execution/windows-commands.js

@@ -1,41 +0,0 @@
-/**
- * Unix commands that do not exist (or have incompatible semantics) in Windows
- * cmd.exe. The 9B model keeps reaching for grep/sed/ls/find via the bash tool;
- * each failure returns a hint, but the model retries.
- *
- * This is a session-level, module-side companion to the bash tool's own
- * per-command hard-stop (`UNIX_TO_WIN_HINTS` / `FAILING_FIRST_WORDS` /
- * `HARD_BLOCK_THRESHOLD` in src/tools/bash.ts). That mechanism injects
- * "STOP using X" INTO the tool output, which a 9B model tends to ignore; this
- * one, gated to win32 like bash.ts, queues a <system-summary> that lands
- * before the next model call. Keep the two command lists consistent.
- *
- * This is a command allow/deny list (like the security module's command
- * blacklist), NOT task classification (rule #10).
- */
-const FORBIDDEN_COMMANDS = new Set([
-    "grep",
-    "sed",
-    "ls",
-    "find",
-    "rm",
-    "touch",
-    "which",
-    "diff",
-    "cp",
-    "mv",
-]);
-function firstWord(command) {
-    const segs = command.trim().split(/[\s;|&]+/);
-    return (segs[0] || "").replace(/[^\w-]/g, "").toLowerCase();
-}
-/** The forbidden command name if `command` starts with one (handles `cd x && …`). */
-export function forbiddenWindowsCommand(command) {
-    const m = command.match(/^\s*cd\s+\S+\s*&&\s*(\S+)/);
-    if (m)
-        return forbiddenWindowsCommand(m[1]);
-    const word = firstWord(command);
-    if (word && FORBIDDEN_COMMANDS.has(word))
-        return word;
-    return null;
-}

package/dist/modules/hallucination/confidence.js

@@ -1,66 +0,0 @@
-import { t } from "../../i18n/index";
-const MIN_CHARS = 1;
-const MIN_WORDS = 5;
-export class ConfidenceCheck {
-    previousResponse = "";
-    setPreviousResponse(response) {
-        this.previousResponse = response;
-    }
-    validate(response) {
-        if (!response || response.length < MIN_CHARS) {
-            return {
-                status: "retry",
-                kind: "short",
-                reason: t("hall.short_response"),
-            };
-        }
-        // Language-agnostic: very short response with no structured content
-        const wordCount = response.split(/\s+/).filter(Boolean).length;
-        const hasStructure = /```|^\s*[-*]\s|^\s*\d+\.\s|<[^>]+>/m.test(response);
-        if (wordCount < MIN_WORDS && !hasStructure) {
-            return {
-                status: "warn",
-                kind: "short",
-                reason: t("hall.short_response"),
-            };
-        }
-        // Language-agnostic: repetition detection via word overlap
-        if (this.previousResponse) {
-            const overlap = this.calculateOverlap(response, this.previousResponse);
-            if (overlap > 0.5) {
-                return {
-                    status: "retry",
-                    kind: "repetition",
-                    reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
-                };
-            }
-        }
-        // Language-agnostic: very low word diversity (same words repeated)
-        const words = response
-            .toLowerCase()
-            .split(/\s+/)
-            .filter((w) => w.length > 2);
-        if (words.length >= 10) {
-            const unique = new Set(words);
-            const diversity = unique.size / words.length;
-            if (diversity < 0.25) {
-                return {
-                    status: "warn",
-                    kind: "diversity",
-                    reason: t("hall.repetitive", {
-                        pct: Math.round((1 - diversity) * 100),
-                    }),
-                };
-            }
-        }
-        return { status: "pass" };
-    }
-    calculateOverlap(a, b) {
-        const wordsA = new Set(a.toLowerCase().split(/\s+/));
-        const wordsB = b.toLowerCase().split(/\s+/);
-        if (wordsB.length === 0)
-            return 0;
-        const matches = wordsB.filter((w) => wordsA.has(w));
-        return matches.length / wordsB.length;
-    }
-}

package/dist/modules/hallucination/consistency.js

@@ -1,26 +0,0 @@
-export class ConsistencyCheck {
-    decisions = [];
-    createdFiles = new Set();
-    deletedFiles = new Set();
-    trackDecision(decision, location) {
-        this.decisions.push({ decision, location });
-    }
-    trackCreatedFile(path) {
-        this.createdFiles.add(path);
-    }
-    trackDeletedFile(path) {
-        this.deletedFiles.add(path);
-    }
-    getCreatedFiles() {
-        return Array.from(this.createdFiles);
-    }
-    getDeletedFiles() {
-        return Array.from(this.deletedFiles);
-    }
-    getDecisions() {
-        return this.decisions;
-    }
-    hasDecisions() {
-        return this.decisions.length > 0;
-    }
-}

package/dist/modules/hallucination/detector.js

@@ -1,47 +0,0 @@
-import { ConsistencyCheck } from "./consistency";
-import { ConfidenceCheck } from "./confidence";
-import { FactualCheck } from "./factual";
-import { LLMJudge } from "./llm-judge";
-export class HallucinationDetector {
-    consistency;
-    confidence;
-    factual;
-    judge;
-    constructor(baseDir, llmProvider) {
-        this.consistency = new ConsistencyCheck();
-        this.confidence = new ConfidenceCheck();
-        this.factual = baseDir ? new FactualCheck(baseDir) : null;
-        this.judge = llmProvider ? new LLMJudge(llmProvider) : null;
-    }
-    getConsistencyCheck() {
-        return this.consistency;
-    }
-    getConfidenceCheck() {
-        return this.confidence;
-    }
-    /** Add files known from compaction summaries to the factual checker. */
-    addKnownFiles(files) {
-        this.factual?.addKnownFiles(files);
-    }
-    async validate(response) {
-        const confidenceResult = this.confidence.validate(response);
-        if (confidenceResult.status === "retry" || confidenceResult.status === "block") {
-            return confidenceResult;
-        }
-        const factualResult = this.factual?.validate(response);
-        if (factualResult && factualResult.status !== "pass") {
-            return factualResult;
-        }
-        // LLM-as-judge consistency: fast path (no decisions) skips any LLM call.
-        const judgeResult = this.judge ? await this.judge.validate(response, this.consistency) : null;
-        const warnings = [];
-        if (judgeResult && judgeResult.status === "warn")
-            warnings.push(judgeResult.reason || "");
-        if (confidenceResult.status === "warn")
-            warnings.push(confidenceResult.reason || "");
-        if (warnings.length > 0) {
-            return { status: "warn", reason: warnings.join("; ") };
-        }
-        return { status: "pass" };
-    }
-}

package/dist/modules/hallucination/factual.js

@@ -1,169 +0,0 @@
-import { existsSync, readdirSync } from "fs";
-import { resolve, isAbsolute, join } from "path";
-import { t } from "../../i18n/index";
-import { extractFileLikeTokens, stripUrls } from "./js-identifiers";
-/** Generated/cached dirs to skip when scanning for bare file names. */
-const IGNORED_DIRS = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "coverage",
-    ".mma",
-    "_testing",
-]);
-export class FactualCheck {
-    baseDir;
-    nameCache = null;
-    nameCacheTime = 0;
-    lastRescan = 0;
-    static NAME_CACHE_TTL_MS = 5_000;
-    static RESCAN_COOLDOWN_MS = 2_000;
-    static MAX_INDEXED_FILES = 20_000;
-    /** Files known from compaction summaries — survive context resets. */
-    knownFiles = new Set();
-    constructor(baseDir) {
-        this.baseDir = baseDir;
-    }
-    /** Add file paths known from compaction summaries. These are checked
-     *  before the filesystem scan so bare filenames from compacted turns
-     *  are recognized even when the directory is in IGNORED_DIRS. */
-    addKnownFiles(files) {
-        for (const f of files)
-            this.knownFiles.add(f);
-    }
-    validate(response) {
-        const filePaths = this.extractFilePaths(response);
-        if (filePaths.length === 0)
-            return { status: "pass" };
-        const nonExistent = [];
-        for (const fp of filePaths) {
-            if (!this.pathExists(fp)) {
-                nonExistent.push(fp);
-            }
-        }
-        if (nonExistent.length > 0) {
-            return {
-                status: "warn",
-                reason: t("hall.unknown_paths", {
-                    paths: nonExistent.slice(0, 5).join(", "),
-                }),
-            };
-        }
-        return { status: "pass" };
-    }
-    /**
-     * Bare filenames ("bikes.json") and relative paths ("src/data/bikes.json")
-     * both land on the project tree. Absolute paths are checked as-is.
-     */
-    pathExists(fp) {
-        if (isAbsolute(fp))
-            return existsSync(fp);
-        // Check known files from compaction summaries first
-        if (this.knownFiles.has(fp))
-            return true;
-        for (const cand of this.dotfileVariants(fp)) {
-            if (this.knownFiles.has(cand))
-                return true;
-            if (existsSync(resolve(this.baseDir, cand)))
-                return true;
-        }
-        // "foo.json" has no directory part — treat it as a bare name that may
-        // live anywhere under baseDir (e.g. src/data/bikes.json). Resolving it
-        // against the workspace root alone produced false "unknown file" warnings.
-        if (!fp.includes("/") && !fp.includes("\\")) {
-            return this.bareNameExists(fp);
-        }
-        return false;
-    }
-    /**
-     * The token regex cannot anchor a leading dot (`\b` never matches between a
-     * non-word char and `.`), so dotfiles (.prettierrc.json, .env, …) are
-     * extracted as "prettierrc.json". Try the dot-prefixed basename too before
-     * declaring the file missing. "src/config.json" also yields
-     * "src/.config.json".
-     */
-    dotfileVariants(fp) {
-        const idx = Math.max(fp.lastIndexOf("/"), fp.lastIndexOf("\\"));
-        const base = idx >= 0 ? fp.slice(idx + 1) : fp;
-        if (base.startsWith("."))
-            return [fp];
-        return idx >= 0 ? [fp, `${fp.slice(0, idx + 1)}.${base}`] : [fp, `.${fp}`];
-    }
-    bareNameExists(name) {
-        for (const cand of this.dotfileVariants(name)) {
-            if (existsSync(resolve(this.baseDir, cand)))
-                return true;
-            if (this.indexHas(cand))
-                return true;
-            // Check known files — a bare name may match a full path from compaction
-            for (const known of this.knownFiles) {
-                if (known.endsWith(`/${cand}`) || known.endsWith(`\\${cand}`) || known === cand) {
-                    return true;
-                }
-            }
-        }
-        // A write_file from this session may have created the file after the
-        // index was built. Do a one-off rescan (rate-limited) before warning.
-        const now = Date.now();
-        if (now - this.lastRescan < FactualCheck.RESCAN_COOLDOWN_MS)
-            return false;
-        this.lastRescan = now;
-        this.nameCache = null;
-        this.nameCacheTime = 0;
-        return this.indexHas(name);
-    }
-    indexHas(name) {
-        return (this.getNameIndex().get(name)?.length ?? 0) > 0;
-    }
-    /**
-     * Basename → paths index, rebuilt every NAME_CACHE_TTL_MS so newly created
-     * files (write_file) are picked up without a full scan on every response.
-     */
-    getNameIndex() {
-        const now = Date.now();
-        if (this.nameCache && now - this.nameCacheTime < FactualCheck.NAME_CACHE_TTL_MS) {
-            return this.nameCache;
-        }
-        const index = new Map();
-        const scanned = this.scanDir(this.baseDir, index, 0);
-        if (scanned > 0 || index.size > 0) {
-            this.nameCache = index;
-            this.nameCacheTime = now;
-        }
-        return index;
-    }
-    scanDir(dir, index, count) {
-        if (count >= FactualCheck.MAX_INDEXED_FILES)
-            return count;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return count;
-        }
-        for (const entry of entries) {
-            if (count >= FactualCheck.MAX_INDEXED_FILES)
-                break;
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (!IGNORED_DIRS.has(entry.name)) {
-                    count = this.scanDir(full, index, count);
-                }
-            }
-            else if (entry.isFile()) {
-                const list = index.get(entry.name);
-                if (list)
-                    list.push(full);
-                else
-                    index.set(entry.name, [full]);
-                count++;
-            }
-        }
-        return count;
-    }
-    extractFilePaths(text) {
-        return extractFileLikeTokens(stripUrls(text));
-    }
-}

package/dist/modules/hallucination/index.js

@@ -1,5 +0,0 @@
-export { HallucinationDetector } from "./detector";
-export { ConsistencyCheck } from "./consistency";
-export { ConfidenceCheck } from "./confidence";
-export { FactualCheck } from "./factual";
-export { LLMJudge } from "./llm-judge";