micro-models-agent 0.28.17 → 0.29.0

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

@@ -1,38 +1,28 @@
-import { getExpertConfig } from "../../config/experts";
-import { filterToolsByTags } from "../../tools/filter-tools";
-import { StuckDetector } from "./stuck-detector";
-import { t } from "../../i18n/index";
+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",
+    '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));
+    return TRANSIENT_ERROR_PATTERNS.some(p => error.includes(p));
 }
 function sleep(ms) {
-    return new Promise((r) => setTimeout(r, 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]));
+    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));
+            const depsSatisfied = (sub.depends_on || []).every(d => !remaining.has(d));
             if (depsSatisfied) {
                 ready.push(sub);
             }
@@ -55,19 +45,19 @@ async function executeSubtask(subtask, deps, _sharedContext) {
             subtaskId: subtask.id,
             success: false,
             summary: `Unknown expert_tag: ${subtask.expert_tag}`,
-            result: "",
+            result: '',
             error: `No expert config found for tag "${subtask.expert_tag}"`,
             durationMs: Date.now() - startTime,
         };
     }
-    const subagentTool = deps.toolRegistry.get("subagent");
+    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",
+            summary: 'Subagent tool not registered',
+            result: '',
+            error: 'Subagent tool not found in registry',
             durationMs: Date.now() - startTime,
         };
     }
@@ -77,25 +67,23 @@ async function executeSubtask(subtask, deps, _sharedContext) {
         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",
+            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 lastError = '';
     let lastResult = null;
-    const stuckDetector = new StuckDetector(maxAttempts * 2, maxAttempts);
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        stuckDetector.recordIteration(1);
         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}`;
+                ? `\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,
@@ -120,83 +108,45 @@ async function executeSubtask(subtask, deps, _sharedContext) {
             }
             lastError = result.output;
             lastResult = result;
-            stuckDetector.recordToolError("subagent", result.output);
-            // Inject actionable hints into the next retry's prompt
-            if (attempt < maxAttempts) {
-                const hints = stuckDetector.getActionableHints();
-                const recovery = stuckDetector.getRecoveryMessage();
-                if (hints.length > 0) {
-                    deps.logger.debug(`Hint for subtask "${subtask.id}" retry: ${hints.join("; ")}`);
-                }
-                if (recovery) {
-                    deps.logger.debug(`Recovery for subtask "${subtask.id}": ${recovery}`);
-                }
-            }
             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;
             }
-            // Non-transient failure — build detailed error with hints
-            const hints = stuckDetector.getActionableHints();
-            let errorDetail = result.output;
-            if (hints.length > 0) {
-                errorDetail += `\n\n${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join("\n") })}`;
-            }
-            if (lastError) {
-                errorDetail +=
-                    "\n\nIf relevant skills are available, consider loading one with load_skill for expert guidance.";
-            }
             return {
                 subtaskId: subtask.id,
                 success: false,
                 summary: `Failed: ${subtask.id}`,
                 result: result.output,
-                error: errorDetail,
+                error: result.output,
                 durationMs: Date.now() - startTime,
             };
         }
         catch (e) {
             lastError = e.message;
-            stuckDetector.recordToolError("subagent", 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;
             }
-            const hints = stuckDetector.getActionableHints();
-            let errorDetail = e.message;
-            if (hints.length > 0) {
-                errorDetail += `\n\n${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join("\n") })}`;
-            }
-            if (lastError) {
-                errorDetail +=
-                    "\n\nIf relevant skills are available, consider loading one with load_skill for expert guidance.";
-            }
             return {
                 subtaskId: subtask.id,
                 success: false,
                 summary: `Error: ${subtask.id}`,
-                result: "",
-                error: errorDetail,
+                result: '',
+                error: e.message,
                 durationMs: Date.now() - startTime,
             };
         }
     }
-    // Exhausted retries — build detailed failure
-    const stuckReason = stuckDetector.getStuckReason();
-    let finalError = lastError;
-    if (stuckReason) {
-        finalError += `\n${stuckReason}`;
-    }
     return {
         subtaskId: subtask.id,
         success: false,
         summary: `Failed after ${maxAttempts} attempts: ${subtask.id}`,
-        result: "",
-        error: finalError,
+        result: '',
+        error: lastError,
         durationMs: Date.now() - startTime,
     };
 }
@@ -211,41 +161,34 @@ export class MoEExecutor {
         const warnings = [];
         const waves = topologicalSort(plan.subtasks);
         if (waves.length === 0) {
-            return {
-                success: false,
-                results: [],
-                errors: ["Failed to topologically sort subtasks (possible cycle)"],
-                warnings: [],
-            };
+            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);
+                .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)`,
-                ],
+                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) => {
+            const wavePromises = wave.map(subtask => executeSubtask(subtask, this.deps, plan.shared_context)
+                .then(result => {
                 results.push(result);
                 return result;
             })
-                .catch((e) => {
+                .catch(e => {
                 const errResult = {
                     subtaskId: subtask.id,
                     success: false,
                     summary: `Unhandled error: ${subtask.id}`,
-                    result: "",
+                    result: '',
                     error: e.message,
                     durationMs: 0,
                 };
@@ -254,9 +197,9 @@ export class MoEExecutor {
             }));
             await Promise.all(wavePromises);
         }
-        const failed = results.filter((r) => !r.success);
+        const failed = results.filter(r => !r.success);
         if (failed.length > 0) {
-            errors.push(...failed.map((f) => `[${f.subtaskId}] ${f.error || f.summary}`));
+            errors.push(...failed.map(f => `[${f.subtaskId}] ${f.error || f.summary}`));
         }
         return { success: failed.length === 0, results, errors, warnings };
     }

package/dist/modules/execution/planner.js

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