micro-models-agent 0.39.1 → 0.40.0

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

@@ -1,17 +1,58 @@
-import { t } from '../../i18n/index';
+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 = '';
+    currentStepDescription = "";
     recentToolCalls = [];
     maxRecentCalls = 10;
     repetitionThreshold = 3;
     consecutiveFailures = 0;
-    lastFailedTool = '';
-    constructor(threshold = 8, errorThreshold = 3) {
+    lastFailedTool = "";
+    lastErrorOutput = "";
+    escalationCount = 0;
+    escalationThreshold = 3;
+    fileRewriteCount = new Map();
+    fileRewriteThreshold = 3;
+    constructor(threshold = 6, errorThreshold = 3) {
         this.threshold = threshold;
         this.errorThreshold = errorThreshold;
     }
@@ -20,8 +61,7 @@ export class StuckDetector {
             this.iterationsOnCurrentStep++;
         }
         else {
-            this.currentStepId = stepId;
-            this.iterationsOnCurrentStep = 1;
+            this.resetStepState(stepId);
         }
     }
     recordToolCall(name, args) {
@@ -31,19 +71,30 @@ export class StuckDetector {
             this.recentToolCalls.shift();
         }
     }
-    recordToolError(toolName) {
+    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.lastFailedTool = "";
+        this.escalationCount = 0;
     }
     setCurrentStep(stepId, description) {
         if (stepId !== this.currentStepId) {
-            this.currentStepId = stepId;
-            this.iterationsOnCurrentStep = 1;
+            this.resetStepState(stepId);
         }
         this.currentStepDescription = description;
     }
@@ -54,22 +105,37 @@ export class StuckDetector {
         if (toolName) {
             return (this.toolErrors.get(toolName) || 0) >= this.errorThreshold;
         }
-        return Array.from(this.toolErrors.values()).some(c => c >= 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];
-        let count = 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) {
-                count++;
+            if (this.recentToolCalls[i].name === last.name &&
+                this.recentToolCalls[i].argsKey === last.argsKey) {
+                consecutiveCount++;
             }
             else {
                 break;
             }
         }
-        return count >= this.repetitionThreshold;
+        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;
@@ -77,58 +143,205 @@ export class StuckDetector {
     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 '';
+            return "";
         const last = this.recentToolCalls[this.recentToolCalls.length - 1];
-        return t('exec.repetitive_tool', { tool: last.name, count: this.repetitionThreshold });
+        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 });
+            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 t("exec.tool_errors", { tool: errorTool[0], count: errorTool[1] });
         }
-        return '';
+        return "";
     }
     getRecoveryMessage() {
         if (this.isStuck()) {
-            return t('exec.stuck_recovery', { iterations: this.iterationsOnCurrentStep });
+            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] });
+            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 });
+            return t("exec.consecutive_failures_recovery", {
+                count: this.consecutiveFailures,
+            });
         }
         if (this.hasRepetitiveToolCalls()) {
             return this.getRepetitiveToolMessage();
         }
-        return '';
-    }
-    checkOffTrack(toolName, call) {
-        if (!this.currentStepDescription)
-            return null;
-        const toolArgStr = JSON.stringify(call.arguments).toLowerCase();
-        const pathInStep = (this.currentStepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || [])
-            .map(p => p.toLowerCase());
-        const pathInCall = (toolArgStr.match(/\b[\w./-]+\.[a-z]+/gi) || [])
-            .map(p => p.toLowerCase());
-        const overlaps = pathInCall.some(p => pathInStep.some(s => p.includes(s) || s.includes(p)));
-        if (!overlaps && pathInStep.length > 0 && pathInCall.length > 0) {
-            return t('exec.off_track', { stepId: String(this.currentStepId), description: this.currentStepDescription, tool: toolName });
-        }
-        return null;
+        return "";
     }
     reset() {
+        this.currentStepId = null;
         this.iterationsOnCurrentStep = 0;
         this.toolErrors.clear();
         this.consecutiveFailures = 0;
-        this.lastFailedTool = '';
+        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,4 +1,4 @@
-import { PlanCreator } from './planner';
+import { PlanCreator } from "./planner";
 export class PlanTracker {
     plan;
     currentStepIndex = 0;
@@ -15,7 +15,7 @@ export class PlanTracker {
         return this.plan.steps[this.currentStepIndex];
     }
     getStep(id) {
-        return this.plan.steps.find(s => s.id === id);
+        return this.plan.steps.find((s) => s.id === id);
     }
     updateStepStatus(id, status) {
         const step = this.getStep(id);
@@ -30,22 +30,36 @@ export class PlanTracker {
     advance() {
         if (this.currentStepIndex < this.plan.steps.length - 1) {
             this.currentStepIndex++;
-            this.plan.steps[this.currentStepIndex].status = 'in_progress';
+            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');
+        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 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 `[Plan: ${this.plan.title}]  ${done}/${total}  ${bar}  ${pct}%`;
+        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/verifier.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'fs';
 import { resolve, extname } from 'path';
-import { execSync } from 'child_process';
+import { spawn } from 'child_process';
 import { t } from '../../i18n/index';
 import { validateExpertConfig } from '../../config/experts';
 export class StepVerifier {
@@ -18,12 +18,7 @@ export class StepVerifier {
     }
     async runScript(scriptName) {
         try {
-            execSync(`bun run ${scriptName}`, {
-                cwd: this.baseDir,
-                encoding: 'utf-8',
-                timeout: 60_000,
-                stdio: 'pipe',
-            });
+            await this.runAsync(`bun run ${scriptName}`, this.baseDir, 60_000);
             return { passed: true, message: t('verify.script_passed', { script: scriptName }) };
         }
         catch (e) {
@@ -36,12 +31,7 @@ export class StepVerifier {
             return { passed: true, message: 'No tsconfig.json found — skipping type check' };
         }
         try {
-            execSync('npx tsc --noEmit', {
-                cwd: this.baseDir,
-                encoding: 'utf-8',
-                timeout: 60_000,
-                stdio: 'pipe',
-            });
+            await this.runAsync('npx tsc --noEmit', this.baseDir, 60_000);
             return { passed: true, message: 'TypeScript type check passed' };
         }
         catch (e) {
@@ -105,7 +95,7 @@ export class StepVerifier {
             results.push(result);
             if (result.passed) {
                 const fullPath = resolve(this.baseDir, filePath);
-                if (!this.validateSyntax(fullPath)) {
+                if (!(await this.validateSyntax(fullPath))) {
                     syntaxValid = false;
                     results.push({ passed: false, message: t('verify.syntax_error', { path: filePath }) });
                 }
@@ -117,11 +107,11 @@ export class StepVerifier {
             failed: results.filter(r => !r.passed),
         };
     }
-    validateSyntax(filePath) {
+    async validateSyntax(filePath) {
         const ext = extname(filePath);
         if (ext === '.ts' || ext === '.tsx') {
             try {
-                execSync(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: 'pipe', timeout: 10000 });
+                await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 10000);
                 return true;
             }
             catch (err) {
@@ -137,7 +127,7 @@ export class StepVerifier {
         }
         if (ext === '.js' || ext === '.jsx') {
             try {
-                execSync(`node --check ${filePath}`, { stdio: 'pipe', timeout: 5000 });
+                await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
                 return true;
             }
             catch {
@@ -146,4 +136,43 @@ export class StepVerifier {
         }
         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/hallucination/confidence.js

@@ -30,14 +30,19 @@ export class ConfidenceCheck {
             }
         }
         // Language-agnostic: very low word diversity (same words repeated)
-        const words = response.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+        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",
-                    reason: t("hall.repetitive", { pct: Math.round((1 - diversity) * 100) }),
+                    reason: t("hall.repetitive", {
+                        pct: Math.round((1 - diversity) * 100),
+                    }),
                 };
             }
         }

package/dist/modules/hallucination/consistency.js

@@ -1,4 +1,3 @@
-import { t } from '../../i18n/index';
 export class ConsistencyCheck {
     decisions = [];
     createdFiles = new Set();
@@ -15,46 +14,13 @@ export class ConsistencyCheck {
     getCreatedFiles() {
         return Array.from(this.createdFiles);
     }
-    validate(response) {
-        const lower = response.toLowerCase();
-        for (const d of this.decisions) {
-            const decisionWords = d.decision.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-            const contradicts = decisionWords.some(word => {
-                // English patterns
-                if (lower.includes(`instead of ${word}`))
-                    return true;
-                if (lower.includes(`not ${word}`))
-                    return true;
-                if (lower.includes(`replacing ${word} with`))
-                    return true;
-                if (lower.includes(`switching to`))
-                    return true;
-                if (lower.includes(`changing from ${word}`))
-                    return true;
-                if (lower.includes(`abandoning ${word}`))
-                    return true;
-                // Russian patterns
-                if (lower.includes(`вместо ${word}`))
-                    return true;
-                if (lower.includes(`заменяя ${word}`))
-                    return true;
-                if (lower.includes(`заменяем ${word}`))
-                    return true;
-                if (lower.includes(`переключаемся на`))
-                    return true;
-                if (lower.includes(`от ${word} к`))
-                    return true;
-                if (lower.includes(`отказываемся от ${word}`))
-                    return true;
-                return false;
-            });
-            if (contradicts) {
-                return {
-                    status: 'warn',
-                    reason: t('hall.contradiction', { decision: d.decision, location: d.location }),
-                };
-            }
-        }
-        return { status: 'pass' };
+    getDeletedFiles() {
+        return Array.from(this.deletedFiles);
+    }
+    getDecisions() {
+        return this.decisions;
+    }
+    hasDecisions() {
+        return this.decisions.length > 0;
     }
 }