micro-models-agent 0.28.9 → 0.29.0

package/dist/modules/execution/moe-executor.js

@@ -0,0 +1,209 @@
+import { getExpertConfig } from '../../config/experts';
+import { filterToolsByTags } from '../../tools/filter-tools';
+const TRANSIENT_ERROR_PATTERNS = [
+    'timeout', 'Timeout', 'TIMEOUT',
+    '5xx', '500', '502', '503',
+    'network', 'Network',
+    'ECONNREFUSED', 'ECONNRESET',
+    'fetch failed',
+    'abort', 'Abort',
+];
+function isTransientError(error) {
+    return TRANSIENT_ERROR_PATTERNS.some(p => error.includes(p));
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+export function topologicalSort(subtasks) {
+    const sorted = [];
+    const remaining = new Set(subtasks.map(s => s.id));
+    const subtaskMap = new Map(subtasks.map(s => [s.id, s]));
+    while (remaining.size > 0) {
+        const ready = [];
+        for (const id of remaining) {
+            const sub = subtaskMap.get(id);
+            const depsSatisfied = (sub.depends_on || []).every(d => !remaining.has(d));
+            if (depsSatisfied) {
+                ready.push(sub);
+            }
+        }
+        if (ready.length === 0) {
+            break;
+        }
+        sorted.push(ready);
+        for (const r of ready) {
+            remaining.delete(r.id);
+        }
+    }
+    return sorted;
+}
+async function executeSubtask(subtask, deps, _sharedContext) {
+    const startTime = Date.now();
+    const expertConfig = getExpertConfig(deps.config, subtask.expert_tag);
+    if (!expertConfig) {
+        return {
+            subtaskId: subtask.id,
+            success: false,
+            summary: `Unknown expert_tag: ${subtask.expert_tag}`,
+            result: '',
+            error: `No expert config found for tag "${subtask.expert_tag}"`,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    const subagentTool = deps.toolRegistry.get('subagent');
+    if (!subagentTool) {
+        return {
+            subtaskId: subtask.id,
+            success: false,
+            summary: 'Subagent tool not registered',
+            result: '',
+            error: 'Subagent tool not found in registry',
+            durationMs: Date.now() - startTime,
+        };
+    }
+    const allTools = deps.toolRegistry.getAll();
+    const filteredTools = filterToolsByTags(allTools, expertConfig.tool_tags);
+    if (filteredTools.length === 0) {
+        return {
+            subtaskId: subtask.id,
+            success: false,
+            summary: `No tools available for expert "${subtask.expert_tag}" (tags: ${expertConfig.tool_tags.join(', ')})`,
+            result: '',
+            error: 'No matching tools',
+            durationMs: Date.now() - startTime,
+        };
+    }
+    const maxAttempts = expertConfig.max_attempts || 3;
+    let lastError = '';
+    let lastResult = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const allowedFiles = subtask.allowed_files || [];
+            const readOnlyFiles = subtask.read_only_files || [];
+            const scopePrompt = allowedFiles.length > 0 || readOnlyFiles.length > 0
+                ? `\n\nAllowed files to write: ${allowedFiles.join(', ') || '(none)'}\nRead-only files: ${readOnlyFiles.join(', ') || '(none)'}`
+                : '';
+            const taskPrompt = `${subtask.description}\n\nExpected output: ${subtask.expected_output}\nSuccess criteria:\n${(subtask.success_criteria || []).map((c) => `- ${c}`).join('\n')}${scopePrompt}`;
+            const subagentArgs = {
+                task: taskPrompt,
+                allowed_files: allowedFiles,
+                read_only_files: readOnlyFiles,
+                tool_tags: expertConfig.tool_tags,
+            };
+            const result = await subagentTool.handler({
+                config: deps.config,
+                baseDir: deps.baseDir,
+                logger: deps.logger,
+                llmProvider: deps.llmProvider,
+                toolExecutor: deps.toolExecutor,
+            }, subagentArgs);
+            if (result.success) {
+                return {
+                    subtaskId: subtask.id,
+                    success: true,
+                    summary: `Completed: ${subtask.id}`,
+                    result: result.output,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            lastError = result.output;
+            lastResult = result;
+            if (isTransientError(lastError) && attempt < maxAttempts) {
+                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
+                deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: transient error`);
+                await sleep(delay);
+                continue;
+            }
+            return {
+                subtaskId: subtask.id,
+                success: false,
+                summary: `Failed: ${subtask.id}`,
+                result: result.output,
+                error: result.output,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            lastError = e.message;
+            if (isTransientError(lastError) && attempt < maxAttempts) {
+                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
+                deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: ${lastError}`);
+                await sleep(delay);
+                continue;
+            }
+            return {
+                subtaskId: subtask.id,
+                success: false,
+                summary: `Error: ${subtask.id}`,
+                result: '',
+                error: e.message,
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
+    return {
+        subtaskId: subtask.id,
+        success: false,
+        summary: `Failed after ${maxAttempts} attempts: ${subtask.id}`,
+        result: '',
+        error: lastError,
+        durationMs: Date.now() - startTime,
+    };
+}
+export class MoEExecutor {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async executePlan(plan) {
+        const results = [];
+        const errors = [];
+        const warnings = [];
+        const waves = topologicalSort(plan.subtasks);
+        if (waves.length === 0) {
+            return { success: false, results: [], errors: ['Failed to topologically sort subtasks (possible cycle)'], warnings: [] };
+        }
+        // Verify all subtasks are included — catch silent drops from unresolved dependencies
+        const sortedCount = waves.flat().length;
+        if (sortedCount < plan.subtasks.length) {
+            const missing = plan.subtasks
+                .filter(s => !waves.flat().some(w => w.id === s.id))
+                .map(s => s.id);
+            return {
+                success: false,
+                results: [],
+                errors: [`Missing subtasks after topological sort: ${missing.join(', ')} (dangling or invalid depends_on)`],
+                warnings: [],
+            };
+        }
+        for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
+            const wave = waves[waveIdx];
+            const wavePromises = wave.map(subtask => executeSubtask(subtask, this.deps, plan.shared_context)
+                .then(result => {
+                results.push(result);
+                return result;
+            })
+                .catch(e => {
+                const errResult = {
+                    subtaskId: subtask.id,
+                    success: false,
+                    summary: `Unhandled error: ${subtask.id}`,
+                    result: '',
+                    error: e.message,
+                    durationMs: 0,
+                };
+                results.push(errResult);
+                return errResult;
+            }));
+            await Promise.all(wavePromises);
+        }
+        const failed = results.filter(r => !r.success);
+        if (failed.length > 0) {
+            errors.push(...failed.map(f => `[${f.subtaskId}] ${f.error || f.summary}`));
+        }
+        return { success: failed.length === 0, results, errors, warnings };
+    }
+    getChainMaxAttempts() {
+        return 3;
+    }
+}

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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,53 @@
+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

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