micro-models-agent 0.28.17 → 0.29.1

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

@@ -1,58 +1,17 @@
-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";
-}
+import { t } from '../../i18n/index';
 export class StuckDetector {
     threshold;
     errorThreshold;
     iterationsOnCurrentStep = 0;
     currentStepId = null;
     toolErrors = new Map();
-    currentStepDescription = "";
+    currentStepDescription = '';
     recentToolCalls = [];
     maxRecentCalls = 10;
     repetitionThreshold = 3;
     consecutiveFailures = 0;
-    lastFailedTool = "";
-    lastErrorOutput = "";
-    escalationCount = 0;
-    escalationThreshold = 3;
-    fileRewriteCount = new Map();
-    fileRewriteThreshold = 3;
-    constructor(threshold = 6, errorThreshold = 3) {
+    lastFailedTool = '';
+    constructor(threshold = 8, errorThreshold = 3) {
         this.threshold = threshold;
         this.errorThreshold = errorThreshold;
     }
@@ -61,7 +20,8 @@ export class StuckDetector {
             this.iterationsOnCurrentStep++;
         }
         else {
-            this.resetStepState(stepId);
+            this.currentStepId = stepId;
+            this.iterationsOnCurrentStep = 1;
         }
     }
     recordToolCall(name, args) {
@@ -71,30 +31,19 @@ export class StuckDetector {
             this.recentToolCalls.shift();
         }
     }
-    recordToolError(toolName, output) {
+    recordToolError(toolName) {
         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;
+        this.lastFailedTool = '';
     }
     setCurrentStep(stepId, description) {
         if (stepId !== this.currentStepId) {
-            this.resetStepState(stepId);
+            this.currentStepId = stepId;
+            this.iterationsOnCurrentStep = 1;
         }
         this.currentStepDescription = description;
     }
@@ -105,37 +54,22 @@ 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];
-        // Check consecutive identical calls (original logic)
-        let consecutiveCount = 1;
+        let count = 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++;
+            if (this.recentToolCalls[i].name === last.name && this.recentToolCalls[i].argsKey === last.argsKey) {
+                count++;
             }
             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;
+        return count >= this.repetitionThreshold;
     }
     hasConsecutiveFailures() {
         return this.consecutiveFailures >= this.errorThreshold;
@@ -143,205 +77,58 @@ 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,
-                stepId: String(this.currentStepId ?? "?"),
-                description: this.currentStepDescription,
-            });
+            return t('exec.stuck_recovery', { iterations: this.iterationsOnCurrentStep });
         }
         // 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 "";
+        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;
     }
     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
+        this.lastFailedTool = '';
     }
 }

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,36 +30,22 @@ 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 `[${this.plan.id}] ${this.plan.title}  ${done}/${total}  ${bar}  ${pct}%`;
+        const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+        return `[Plan: ${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 { spawn } from 'child_process';
+import { execSync } from 'child_process';
 import { t } from '../../i18n/index';
 import { validateExpertConfig } from '../../config/experts';
 export class StepVerifier {
@@ -18,7 +18,12 @@ export class StepVerifier {
     }
     async runScript(scriptName) {
         try {
-            await this.runAsync(`bun run ${scriptName}`, this.baseDir, 60_000);
+            execSync(`bun run ${scriptName}`, {
+                cwd: this.baseDir,
+                encoding: 'utf-8',
+                timeout: 60_000,
+                stdio: 'pipe',
+            });
             return { passed: true, message: t('verify.script_passed', { script: scriptName }) };
         }
         catch (e) {
@@ -31,7 +36,12 @@ export class StepVerifier {
             return { passed: true, message: 'No tsconfig.json found — skipping type check' };
         }
         try {
-            await this.runAsync('npx tsc --noEmit', this.baseDir, 60_000);
+            execSync('npx tsc --noEmit', {
+                cwd: this.baseDir,
+                encoding: 'utf-8',
+                timeout: 60_000,
+                stdio: 'pipe',
+            });
             return { passed: true, message: 'TypeScript type check passed' };
         }
         catch (e) {
@@ -95,7 +105,7 @@ export class StepVerifier {
             results.push(result);
             if (result.passed) {
                 const fullPath = resolve(this.baseDir, filePath);
-                if (!(await this.validateSyntax(fullPath))) {
+                if (!this.validateSyntax(fullPath)) {
                     syntaxValid = false;
                     results.push({ passed: false, message: t('verify.syntax_error', { path: filePath }) });
                 }
@@ -107,11 +117,11 @@ export class StepVerifier {
             failed: results.filter(r => !r.passed),
         };
     }
-    async validateSyntax(filePath) {
+    validateSyntax(filePath) {
         const ext = extname(filePath);
         if (ext === '.ts' || ext === '.tsx') {
             try {
-                await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 10000);
+                execSync(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: 'pipe', timeout: 10000 });
                 return true;
             }
             catch (err) {
@@ -127,7 +137,7 @@ export class StepVerifier {
         }
         if (ext === '.js' || ext === '.jsx') {
             try {
-                await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
+                execSync(`node --check ${filePath}`, { stdio: 'pipe', timeout: 5000 });
                 return true;
             }
             catch {
@@ -136,43 +146,4 @@ 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,19 +30,14 @@ 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,3 +1,4 @@
+import { t } from '../../i18n/index';
 export class ConsistencyCheck {
     decisions = [];
     createdFiles = new Set();
@@ -14,13 +15,46 @@ export class ConsistencyCheck {
     getCreatedFiles() {
         return Array.from(this.createdFiles);
     }
-    getDeletedFiles() {
-        return Array.from(this.deletedFiles);
-    }
-    getDecisions() {
-        return this.decisions;
-    }
-    hasDecisions() {
-        return this.decisions.length > 0;
+    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' };
     }
 }