micro-models-agent 0.19.0 → 0.19.2

package/dist/modules/execution/plan-validator.js

@@ -1,153 +0,0 @@
-export function validatePlan(plan, config) {
-    const errors = [];
-    const warnings = [];
-    const autoFixes = [];
-    if (!plan.subtasks || plan.subtasks.length === 0) {
-        return { valid: false, errors: ['Plan has no subtasks'], warnings: [], autoFixes: [] };
-    }
-    errors.push(...expertTagsExist(plan.subtasks, config));
-    errors.push(...hasCycle(plan.subtasks));
-    const overlapErrors = hasAllowedFilesOverlap(plan.subtasks);
-    errors.push(...overlapErrors);
-    const readOverlaps = deleteReadOverlap(plan.subtasks);
-    for (const overlap of readOverlaps) {
-        if (overlap.canAutoFix) {
-            autoFixes.push({ subtaskId: overlap.subtaskId, fix: `Add depends_on: ${overlap.dependsOn}` });
-        }
-        else if (overlap.error) {
-            errors.push(overlap.error);
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-        autoFixes,
-    };
-}
-export function expertTagsExist(subtasks, config) {
-    const errors = [];
-    const knownExperts = new Set(Object.keys(config.experts || {}));
-    for (const subtask of subtasks) {
-        if (!knownExperts.has(subtask.expert_tag)) {
-            errors.push(`Subtask "${subtask.id}" references unknown expert_tag "${subtask.expert_tag}". Known experts: ${Array.from(knownExperts).join(', ')}`);
-        }
-    }
-    return errors;
-}
-export function hasCycle(subtasks) {
-    const edges = new Map();
-    for (const s of subtasks) {
-        edges.set(s.id, s.depends_on || []);
-    }
-    const visited = new Set();
-    const inStack = new Set();
-    function dfs(node) {
-        if (inStack.has(node))
-            return true;
-        if (visited.has(node))
-            return false;
-        visited.add(node);
-        inStack.add(node);
-        const deps = edges.get(node) || [];
-        for (const dep of deps) {
-            if (edges.has(dep) && dfs(dep))
-                return true;
-        }
-        inStack.delete(node);
-        return false;
-    }
-    const errors = [];
-    for (const s of subtasks) {
-        visited.clear();
-        inStack.clear();
-        if (dfs(s.id)) {
-            errors.push(`Cycle detected involving subtask "${s.id}"`);
-            break;
-        }
-    }
-    return errors;
-}
-export function hasAllowedFilesOverlap(subtasks) {
-    const errors = [];
-    const writeFiles = new Map();
-    for (const s of subtasks) {
-        for (const f of s.allowed_files || []) {
-            if (!writeFiles.has(f)) {
-                writeFiles.set(f, []);
-            }
-            writeFiles.get(f).push(s.id);
-        }
-    }
-    for (const [file, writers] of writeFiles) {
-        if (writers.length > 1) {
-            const noDep = writers.filter(w => {
-                const sub = subtasks.find(s => s.id === w);
-                return sub && !sub.depends_on?.some(d => writers.includes(d));
-            });
-            if (noDep.length > 1) {
-                errors.push(`Write-write overlap on "${file}" between subtasks: ${writers.join(', ')} without dependency chain`);
-            }
-        }
-    }
-    return errors;
-}
-export function deleteReadOverlap(subtasks) {
-    const results = [];
-    for (let i = 0; i < subtasks.length; i++) {
-        for (let j = 0; j < subtasks.length; j++) {
-            if (i === j)
-                continue;
-            const writer = subtasks[i];
-            const reader = subtasks[j];
-            if (!writer.allowed_files || !reader.read_only_files)
-                continue;
-            const readFiles = new Set(reader.read_only_files);
-            const writeFiles = writer.allowed_files;
-            const overlapping = writeFiles.filter(f => {
-                for (const rf of readFiles) {
-                    if (f.startsWith(rf) || rf.startsWith(f))
-                        return true;
-                }
-                return false;
-            });
-            if (overlapping.length > 0 && !reader.depends_on?.includes(writer.id)) {
-                const canAutoFix = !reader.depends_on || reader.depends_on.length === 0;
-                if (canAutoFix) {
-                    results.push({
-                        subtaskId: reader.id,
-                        dependsOn: writer.id,
-                        canAutoFix: true,
-                    });
-                }
-                else {
-                    results.push({
-                        subtaskId: reader.id,
-                        dependsOn: writer.id,
-                        canAutoFix: false,
-                        error: `Read-after-write overlap between "${writer.id}" (writer) and "${reader.id}" (reader) on "${overlapping.join(', ')}" — add depends_on: [${writer.id}]`,
-                    });
-                }
-            }
-        }
-    }
-    return results;
-}
-export function applyAutoFixes(plan, autoFixes) {
-    const fixed = { ...plan, subtasks: plan.subtasks.map(s => ({ ...s })) };
-    for (const fix of autoFixes) {
-        const sub = fixed.subtasks.find(s => s.id === fix.subtaskId);
-        if (!sub)
-            continue;
-        const dependsOnMatch = fix.fix.match(/depends_on:\s*(\S+)/);
-        if (dependsOnMatch) {
-            const dep = dependsOnMatch[1];
-            if (!sub.depends_on)
-                sub.depends_on = [];
-            if (!sub.depends_on.includes(dep)) {
-                sub.depends_on.push(dep);
-            }
-        }
-    }
-    return fixed;
-}

package/dist/modules/execution/planner.js

@@ -1,35 +0,0 @@
-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) {
-        return {
-            title,
-            steps: stepDescriptions.map((desc, i) => ({
-                id: i + 1,
-                description: desc,
-                status: 'pending',
-            })),
-            createdAt: new Date().toISOString(),
-        };
-    }
-    static toPromptBlock(plan, currentStepIndex) {
-        const lines = [`[Plan: ${plan.title}] (steps: ${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,134 +0,0 @@
-import { t } from '../../i18n/index';
-export class StuckDetector {
-    threshold;
-    errorThreshold;
-    iterationsOnCurrentStep = 0;
-    currentStepId = null;
-    toolErrors = new Map();
-    currentStepDescription = '';
-    recentToolCalls = [];
-    maxRecentCalls = 10;
-    repetitionThreshold = 3;
-    consecutiveFailures = 0;
-    lastFailedTool = '';
-    constructor(threshold = 8, errorThreshold = 3) {
-        this.threshold = threshold;
-        this.errorThreshold = errorThreshold;
-    }
-    recordIteration(stepId) {
-        if (stepId === this.currentStepId) {
-            this.iterationsOnCurrentStep++;
-        }
-        else {
-            this.currentStepId = stepId;
-            this.iterationsOnCurrentStep = 1;
-        }
-    }
-    recordToolCall(name, args) {
-        const argsKey = JSON.stringify(args);
-        this.recentToolCalls.push({ name, argsKey });
-        if (this.recentToolCalls.length > this.maxRecentCalls) {
-            this.recentToolCalls.shift();
-        }
-    }
-    recordToolError(toolName) {
-        this.toolErrors.set(toolName, (this.toolErrors.get(toolName) || 0) + 1);
-        this.consecutiveFailures++;
-        this.lastFailedTool = toolName;
-    }
-    recordToolSuccess() {
-        this.consecutiveFailures = 0;
-        this.lastFailedTool = '';
-    }
-    setCurrentStep(stepId, description) {
-        if (stepId !== this.currentStepId) {
-            this.currentStepId = stepId;
-            this.iterationsOnCurrentStep = 1;
-        }
-        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];
-        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) {
-                count++;
-            }
-            else {
-                break;
-            }
-        }
-        return count >= this.repetitionThreshold;
-    }
-    hasConsecutiveFailures() {
-        return this.consecutiveFailures >= this.errorThreshold;
-    }
-    getConsecutiveFailuresCount() {
-        return this.consecutiveFailures;
-    }
-    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 });
-        }
-        // 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 '';
-    }
-    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.iterationsOnCurrentStep = 0;
-        this.toolErrors.clear();
-        this.consecutiveFailures = 0;
-        this.lastFailedTool = '';
-    }
-}

package/dist/modules/execution/tracker.js

@@ -1,53 +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;
-    }
-    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 `[Plan: ${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,149 +0,0 @@
-import { existsSync } from 'fs';
-import { resolve, extname } from 'path';
-import { execSync } 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 {
-            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) {
-            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 {
-            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) {
-            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 (!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),
-        };
-    }
-    validateSyntax(filePath) {
-        const ext = extname(filePath);
-        if (ext === '.ts' || ext === '.tsx') {
-            try {
-                execSync(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: 'pipe', timeout: 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 {
-                execSync(`node --check ${filePath}`, { stdio: 'pipe', timeout: 5000 });
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        return true;
-    }
-}

package/dist/modules/hallucination/confidence.js

@@ -1,59 +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", 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",
-                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",
-                    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",
-                    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,66 +0,0 @@
-import { t } from "../../i18n/index";
-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);
-    }
-    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" };
-    }
-}

package/dist/modules/hallucination/detector.js

@@ -1,33 +0,0 @@
-import { ConsistencyCheck } from "./consistency";
-import { ConfidenceCheck } from "./confidence";
-export class HallucinationDetector {
-    consistency;
-    confidence;
-    constructor() {
-        this.consistency = new ConsistencyCheck();
-        this.confidence = new ConfidenceCheck();
-    }
-    getConsistencyCheck() {
-        return this.consistency;
-    }
-    getConfidenceCheck() {
-        return this.confidence;
-    }
-    validate(response) {
-        const confidenceResult = this.confidence.validate(response);
-        if (confidenceResult.status === "retry" ||
-            confidenceResult.status === "block") {
-            return confidenceResult;
-        }
-        const consistencyResult = this.consistency.validate(response);
-        const warnings = [];
-        if (consistencyResult.status === "warn")
-            warnings.push(consistencyResult.reason || "");
-        if (confidenceResult.status === "warn")
-            warnings.push(confidenceResult.reason || "");
-        if (warnings.length > 0) {
-            return { status: "warn", reason: warnings.join("; ") };
-        }
-        return { status: "pass" };
-    }
-}