micro-models-agent 0.44.0 → 0.45.0

package/dist/modules/execution/planner.js

@@ -1,85 +0,0 @@
-function generatePlanId() {
-    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-    let id = "";
-    for (let i = 0; i < 6; i++) {
-        id += chars[Math.floor(Math.random() * chars.length)];
-    }
-    return `plan_${id}`;
-}
-export class PlanCreator {
-    static isMultiStep(task) {
-        const fileCount = (task.match(/\b[\w./-]+\.[a-z]+\b/gi) || []).length;
-        if (fileCount > 1)
-            return true;
-        const actionWords = [
-            "implement",
-            "create",
-            "add",
-            "build",
-            "setup",
-            "configure",
-            "write",
-            "make",
-            "develop",
-        ];
-        const words = task.split(/\s+/);
-        const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
-        return hasActionWord && words.length > 8;
-    }
-    static createPlan(title, stepDescriptions, baseDir) {
-        const stepCount = stepDescriptions.length;
-        return {
-            id: generatePlanId(),
-            title: `[${stepCount}] ${title}`,
-            steps: stepDescriptions.map((desc, i) => ({
-                id: i + 1,
-                description: desc,
-                status: "pending",
-            })),
-            createdAt: new Date().toISOString(),
-            baseDir,
-        };
-    }
-    static replan(plan, newSteps, title) {
-        const kept = plan.steps.filter((s) => s.status === "done" || s.status === "skipped");
-        const baseTitle = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
-        const newTitle = title || baseTitle;
-        const totalSteps = kept.length + newSteps.length;
-        const added = newSteps.map((desc, i) => ({
-            id: kept.length + i + 1,
-            description: desc,
-            status: "pending",
-        }));
-        return {
-            id: plan.id,
-            title: `[${totalSteps}] ${newTitle}`,
-            steps: [...kept, ...added],
-            createdAt: plan.createdAt,
-            baseDir: plan.baseDir,
-            name: plan.name,
-        };
-    }
-    static toPromptBlock(plan, currentStepIndex) {
-        const date = plan.createdAt.slice(0, 10);
-        const lines = [
-            `[${plan.id}] ${plan.title}`,
-            `Dir: ${plan.baseDir}`,
-            `Created: ${date} | Progress: ${plan.steps.filter((s) => s.status === "done").length}/${plan.steps.length} done, current: step ${currentStepIndex + 1}`,
-            ``,
-        ];
-        for (const step of plan.steps) {
-            const icon = step.status === "done"
-                ? "[x]"
-                : step.status === "in_progress"
-                    ? "[*]"
-                    : step.status === "failed"
-                        ? "[!]"
-                        : step.status === "skipped"
-                            ? "[-]"
-                            : "[ ]";
-            const note = step.note ? ` — ${step.note}` : "";
-            lines.push(`${icon} ${step.id}. ${step.description}${note}`);
-        }
-        return lines.join("\n");
-    }
-}

package/dist/modules/execution/stuck-detector.js

@@ -1,347 +0,0 @@
-import { t } from "../../i18n/index";
-const TRANSIENT_PATTERNS = [
-    /timeout/i,
-    /timed out/i,
-    /ECONNREFUSED/i,
-    /ETIMEDOUT/i,
-    /ECONNRESET/i,
-    /killed/i,
-    /SIGTERM/i,
-    /SIGKILL/i,
-    /rate limit/i,
-    /429/i,
-    /503/i,
-    /502/i,
-];
-const BLOCKING_PATTERNS = [
-    /EACCES/i,
-    /permission denied/i,
-    /EPERM/i,
-    /ENOENT.*node_modules/i,
-    /ENOTDIR/i,
-    /invalid.*token/i,
-    /unauthorized/i,
-    /401/i,
-    /403/i,
-];
-export function classifyError(output) {
-    for (const p of TRANSIENT_PATTERNS) {
-        if (p.test(output))
-            return "transient";
-    }
-    for (const p of BLOCKING_PATTERNS) {
-        if (p.test(output))
-            return "blocking";
-    }
-    return "systematic";
-}
-export class StuckDetector {
-    threshold;
-    errorThreshold;
-    iterationsOnCurrentStep = 0;
-    currentStepId = null;
-    toolErrors = new Map();
-    currentStepDescription = "";
-    recentToolCalls = [];
-    maxRecentCalls = 10;
-    repetitionThreshold = 3;
-    consecutiveFailures = 0;
-    lastFailedTool = "";
-    lastErrorOutput = "";
-    escalationCount = 0;
-    escalationThreshold = 3;
-    fileRewriteCount = new Map();
-    fileRewriteThreshold = 3;
-    constructor(threshold = 6, errorThreshold = 3) {
-        this.threshold = threshold;
-        this.errorThreshold = errorThreshold;
-    }
-    recordIteration(stepId) {
-        if (stepId === this.currentStepId) {
-            this.iterationsOnCurrentStep++;
-        }
-        else {
-            this.resetStepState(stepId);
-        }
-    }
-    recordToolCall(name, args) {
-        const argsKey = JSON.stringify(args);
-        this.recentToolCalls.push({ name, argsKey });
-        if (this.recentToolCalls.length > this.maxRecentCalls) {
-            this.recentToolCalls.shift();
-        }
-    }
-    recordToolError(toolName, output) {
-        this.toolErrors.set(toolName, (this.toolErrors.get(toolName) || 0) + 1);
-        this.consecutiveFailures++;
-        this.lastFailedTool = toolName;
-        if (output)
-            this.lastErrorOutput = output;
-    }
-    getLastErrorOutput() {
-        return this.lastErrorOutput;
-    }
-    getLastFailedTool() {
-        return this.lastFailedTool;
-    }
-    getIterationsOnCurrentStep() {
-        return this.iterationsOnCurrentStep;
-    }
-    recordToolSuccess() {
-        this.consecutiveFailures = 0;
-        this.lastFailedTool = "";
-        this.escalationCount = 0;
-    }
-    setCurrentStep(stepId, description) {
-        if (stepId !== this.currentStepId) {
-            this.resetStepState(stepId);
-        }
-        this.currentStepDescription = description;
-    }
-    isStuck() {
-        return this.iterationsOnCurrentStep > this.threshold;
-    }
-    hasRepetitiveErrors(toolName) {
-        if (toolName) {
-            return (this.toolErrors.get(toolName) || 0) >= this.errorThreshold;
-        }
-        return Array.from(this.toolErrors.values()).some((c) => c >= this.errorThreshold);
-    }
-    hasRepetitiveToolCalls() {
-        if (this.recentToolCalls.length < this.repetitionThreshold)
-            return false;
-        const last = this.recentToolCalls[this.recentToolCalls.length - 1];
-        // Check consecutive identical calls (original logic)
-        let consecutiveCount = 1;
-        for (let i = this.recentToolCalls.length - 2; i >= 0; i--) {
-            if (this.recentToolCalls[i].name === last.name &&
-                this.recentToolCalls[i].argsKey === last.argsKey) {
-                consecutiveCount++;
-            }
-            else {
-                break;
-            }
-        }
-        if (consecutiveCount >= this.repetitionThreshold)
-            return true;
-        // Also detect interleaved patterns (A, B, A, B, A) — count any single
-        // tool+args combo in the window and flag if it appears >= threshold times
-        const counts = new Map();
-        for (const call of this.recentToolCalls) {
-            const key = `${call.name}::${call.argsKey}`;
-            counts.set(key, (counts.get(key) || 0) + 1);
-        }
-        for (const count of counts.values()) {
-            if (count >= this.repetitionThreshold)
-                return true;
-        }
-        return false;
-    }
-    hasConsecutiveFailures() {
-        return this.consecutiveFailures >= this.errorThreshold;
-    }
-    getConsecutiveFailuresCount() {
-        return this.consecutiveFailures;
-    }
-    recordEscalation() {
-        this.escalationCount++;
-    }
-    shouldEscalate() {
-        return this.escalationCount >= this.escalationThreshold;
-    }
-    resetEscalation() {
-        this.escalationCount = 0;
-    }
-    getEscalationCount() {
-        return this.escalationCount;
-    }
-    getHints() {
-        const hints = [];
-        const desc = this.currentStepDescription.toLowerCase();
-        if (desc.includes("install") ||
-            desc.includes("npm") ||
-            desc.includes("pip")) {
-            hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
-        }
-        if (desc.includes("test") || desc.includes("spec")) {
-            hints.push("Make sure the source files exist and have real code before running tests.");
-        }
-        if (desc.includes("build") || desc.includes("compile")) {
-            hints.push("Check that all dependencies are installed and source files are not empty.");
-        }
-        if (desc.includes("deploy") || desc.includes("publish")) {
-            hints.push("Verify credentials and network access before deploying.");
-        }
-        if (this.hasRepetitiveToolCalls()) {
-            hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
-        }
-        if (this.hasConsecutiveFailures()) {
-            hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
-        }
-        return hints;
-    }
-    getActionableHints() {
-        const hints = [];
-        const error = this.lastErrorOutput;
-        if (!error)
-            return hints;
-        // Runtime incompatibility — tool/module crashes on this Node version
-        if (/Cannot read properties of undefined|is not a function|is not a constructor/i.test(error)) {
-            if (/node_modules/.test(error)) {
-                hints.push("A dependency is incompatible with your Node.js version. Check if there is an alternative package or use a different runtime.");
-            }
-        }
-        // TypeScript syntax errors — model generated invalid code
-        if (/TS1005|TS1003|TS1109|TS1128|TS1434/i.test(error)) {
-            hints.push("TypeScript syntax error. Read the error message carefully — it tells you the exact line and column. Fix the syntax before retrying.");
-        }
-        // TypeScript type errors — model doesn't understand the types
-        if (/TS2322|TS2345|TS2769|TS7006|TS7016/i.test(error)) {
-            hints.push("TypeScript type mismatch. Check the type signature of the function/API you are using. If a package lacks type declarations, install @types/<package> or use skipLibCheck.");
-        }
-        // Module not found — missing dependency or wrong import
-        if (/Cannot find module|Module not found|ERR_MODULE_NOT_FOUND/i.test(error)) {
-            hints.push("Module not found. Run npm install or check if the import path is correct.");
-        }
-        // Permission / access errors
-        if (/EACCES|EPERM|permission denied/i.test(error)) {
-            hints.push("Permission denied. Check file permissions or run with appropriate privileges.");
-        }
-        // Network errors
-        if (/ECONNREFUSED|ETIMEDOUT|ENOTFOUND|fetch failed/i.test(error)) {
-            hints.push("Network error. Check if the server is running and accessible.");
-        }
-        // Command not found
-        if (/is not recognized|command not found|not found in path/i.test(error)) {
-            hints.push("Command not found. Check if the tool is installed and in PATH.");
-        }
-        // File rewrite loop — same file keeps failing
-        if (this.hasExcessiveRewrites()) {
-            const file = this.getExcessiveRewriteFile();
-            hints.push(`File ${file} has been rewritten ${this.getFileRewriteCount(file)} times without success. Stop rewriting and try a fundamentally different approach.`);
-        }
-        return hints;
-    }
-    getToolAlternative() {
-        const tool = this.lastFailedTool;
-        const error = this.lastErrorOutput;
-        if (!tool)
-            return null;
-        // If a tool fails with a runtime crash, suggest alternatives
-        if (/Cannot read properties of undefined|is not a function|TypeError|ReferenceError/i.test(error)) {
-            // Map of tools to their common alternatives
-            const alternatives = {
-                "ts-node": "tsx",
-                jest: "vitest",
-                mocha: "vitest",
-                webpack: "vite",
-                rollup: "vite",
-                parcel: "vite",
-                babel: "tsc",
-                eslint: "biome",
-                prettier: "biome",
-            };
-            for (const [failed, alt] of Object.entries(alternatives)) {
-                if (tool.includes(failed) || error.includes(failed)) {
-                    return alt;
-                }
-            }
-        }
-        return null;
-    }
-    recordFileRewrite(filePath) {
-        const count = (this.fileRewriteCount.get(filePath) || 0) + 1;
-        this.fileRewriteCount.set(filePath, count);
-    }
-    getFileRewriteCount(filePath) {
-        return this.fileRewriteCount.get(filePath) || 0;
-    }
-    hasExcessiveRewrites() {
-        return Array.from(this.fileRewriteCount.values()).some((c) => c >= this.fileRewriteThreshold);
-    }
-    getExcessiveRewriteFile() {
-        for (const [file, count] of this.fileRewriteCount) {
-            if (count >= this.fileRewriteThreshold)
-                return file;
-        }
-        return null;
-    }
-    getRepetitiveToolMessage() {
-        if (!this.hasRepetitiveToolCalls())
-            return "";
-        const last = this.recentToolCalls[this.recentToolCalls.length - 1];
-        return t("exec.repetitive_tool", {
-            tool: last.name,
-            count: this.repetitionThreshold,
-        });
-    }
-    getStuckReason() {
-        if (this.isStuck()) {
-            return t("exec.stuck", {
-                stepId: String(this.currentStepId ?? "?"),
-                description: this.currentStepDescription,
-                iterations: this.iterationsOnCurrentStep,
-            });
-        }
-        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
-        if (errorTool) {
-            return t("exec.tool_errors", { tool: errorTool[0], count: errorTool[1] });
-        }
-        return "";
-    }
-    getRecoveryMessage() {
-        if (this.isStuck()) {
-            return t("exec.stuck_recovery", {
-                iterations: this.iterationsOnCurrentStep,
-                stepId: String(this.currentStepId ?? "?"),
-                description: this.currentStepDescription,
-            });
-        }
-        // Per-tool error recovery (more specific — e.g., "bash failed 3 times")
-        const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
-        if (errorTool) {
-            return t("exec.tool_errors_recovery", {
-                tool: errorTool[0],
-                count: errorTool[1],
-            });
-        }
-        // Consecutive failures from different tools (generic — e.g., "5 consecutive failures")
-        if (this.hasConsecutiveFailures()) {
-            return t("exec.consecutive_failures_recovery", {
-                count: this.consecutiveFailures,
-            });
-        }
-        if (this.hasRepetitiveToolCalls()) {
-            return this.getRepetitiveToolMessage();
-        }
-        return "";
-    }
-    reset() {
-        this.currentStepId = null;
-        this.iterationsOnCurrentStep = 0;
-        this.toolErrors.clear();
-        this.consecutiveFailures = 0;
-        this.lastFailedTool = "";
-        this.lastErrorOutput = "";
-        this.recentToolCalls = [];
-        this.fileRewriteCount.clear();
-        this.escalationCount = 0;
-    }
-    /**
-     * Reset all per-step state when moving to a new step. Prevents errors and
-     * tool repetitions from one step leaking into the next (false-positive
-     * stuck/recovery on the first iteration of the new step).
-     */
-    resetStepState(stepId) {
-        this.currentStepId = stepId;
-        this.iterationsOnCurrentStep = 1;
-        this.toolErrors.clear();
-        this.consecutiveFailures = 0;
-        this.lastFailedTool = "";
-        this.lastErrorOutput = "";
-        this.recentToolCalls = [];
-        this.fileRewriteCount.clear();
-        // Preserve escalationCount — prevents agent from "gaming" stuck detection
-        // by marking a step done and moving to the next one
-    }
-}

package/dist/modules/execution/tracker.js

@@ -1,67 +0,0 @@
-import { PlanCreator } 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 done = this.plan.steps.filter((s) => s.status === "done").length;
-        const total = this.plan.steps.length;
-        const pct = total > 0 ? Math.round((done / total) * 100) : 0;
-        const barWidth = 10;
-        const filled = Math.round((done / total) * barWidth);
-        const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
-        return `[${this.plan.id}] ${this.plan.title}  ${done}/${total}  ${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,178 +0,0 @@
-import { existsSync } from 'fs';
-import { resolve, extname } from 'path';
-import { spawn } from 'child_process';
-import { t } from '../../i18n/index';
-import { validateExpertConfig } from '../../config/experts';
-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)}` };
-        }
-    }
-    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) {
-        const fileMatches = stepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || [];
-        const results = [];
-        let syntaxValid = true;
-        for (const filePath of fileMatches) {
-            const result = await this.checkFileExists(filePath);
-            results.push(result);
-            if (result.passed) {
-                const fullPath = resolve(this.baseDir, filePath);
-                if (!(await this.validateSyntax(fullPath))) {
-                    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),
-        };
-    }
-    async validateSyntax(filePath) {
-        const ext = extname(filePath);
-        if (ext === '.ts' || ext === '.tsx') {
-            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') {
-            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);
-                }
-            });
-        });
-    }
-}