micro-models-agent 0.19.0 → 0.19.2

package/dist/modules/execution/auditor.js

@@ -1,72 +0,0 @@
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { resolve, join } from 'path';
-import { t } from '../../i18n/index';
-export class Auditor {
-    baseDir;
-    constructor(baseDir) {
-        this.baseDir = baseDir;
-    }
-    async audit(plan) {
-        const allStepText = plan.steps.map(s => s.description).join(' ');
-        const fileMatches = allStepText.match(/\b[\w./-]+\.[a-z]+/gi) || [];
-        const uniqueFiles = [...new Set(fileMatches)];
-        const missingFiles = [];
-        const existingFiles = [];
-        for (const filePath of uniqueFiles) {
-            const resolved = resolve(this.baseDir, filePath);
-            if (existsSync(resolved)) {
-                existingFiles.push(filePath);
-            }
-            else {
-                missingFiles.push(filePath);
-            }
-        }
-        const doneSteps = plan.steps.filter(s => s.status === 'done').length;
-        const totalSteps = plan.steps.length;
-        const typeCheckError = await this.runProjectTypeCheck();
-        const passed = missingFiles.length === 0 && !typeCheckError;
-        let summary;
-        if (passed) {
-            summary = t('exec.audit_pass', { done: doneSteps, total: totalSteps, files: existingFiles.length });
-        }
-        else {
-            const missingCount = missingFiles.length;
-            if (typeCheckError) {
-                summary = t('exec.audit_fail_typecheck', { done: doneSteps, total: totalSteps, missing: missingCount, typeError: typeCheckError });
-            }
-            else {
-                summary = t('exec.audit_fail', { done: doneSteps, total: totalSteps, files: missingCount });
-            }
-        }
-        return {
-            passed,
-            missingFiles,
-            createdFiles: existingFiles,
-            modifiedFiles: [],
-            summary,
-            typeCheckError,
-        };
-    }
-    async runProjectTypeCheck() {
-        const tsconfigPath = join(this.baseDir, 'tsconfig.json');
-        if (!existsSync(tsconfigPath)) {
-            return null;
-        }
-        try {
-            execSync(`npx tsc --noEmit --skipLibCheck`, { cwd: this.baseDir, stdio: 'pipe', timeout: 30000 });
-            return null;
-        }
-        catch (err) {
-            if (err.status === 127 || err.message.includes('not found') || err.message.includes('ENOENT')) {
-                return null;
-            }
-            const stderr = err.stderr?.toString() || err.stdout?.toString() || '';
-            if (stderr.includes('error TS')) {
-                const firstError = stderr.split('\n').find((line) => line.includes('error TS')) || 'TypeScript type error';
-                return firstError.trim();
-            }
-            return null;
-        }
-    }
-}

package/dist/modules/execution/index.js

@@ -1,6 +0,0 @@
-export { ExecutionModule } from './module';
-export { PlanCreator } from './planner';
-export { PlanTracker } from './tracker';
-export { StepVerifier } from './verifier';
-export { StuckDetector } from './stuck-detector';
-export { Auditor } from './auditor';

package/dist/modules/execution/module.js

@@ -1,337 +0,0 @@
-import { t } from "../../i18n/index";
-import { PlanCreator } from "./planner";
-import { PlanTracker } from "./tracker";
-import { StepVerifier } from "./verifier";
-import { StuckDetector } from "./stuck-detector";
-import { Auditor } from "./auditor";
-import { existsSync } from "fs";
-import { resolve } from "path";
-const STUCK_RECOVERY_COOLDOWN = 5;
-export class ExecutionModule {
-    name = "execution";
-    tracker = null;
-    verifier;
-    stuckDetector;
-    auditor;
-    baseDir;
-    lastRecoveryIteration = -STUCK_RECOVERY_COOLDOWN;
-    constructor(baseDir, stuckThreshold = 8) {
-        this.baseDir = baseDir;
-        this.verifier = new StepVerifier(baseDir);
-        this.stuckDetector = new StuckDetector(stuckThreshold);
-        this.auditor = new Auditor(baseDir);
-    }
-    setPlan(plan) {
-        this.tracker = new PlanTracker(plan);
-    }
-    getTracker() {
-        return this.tracker;
-    }
-    getStuckDetector() {
-        return this.stuckDetector;
-    }
-    /**
-     * Final audit before the agent may declare the task done. Returns null when
-     * no plan is active; otherwise checks plan completion + artifact existence.
-     */
-    async runFinalAudit() {
-        if (!this.tracker)
-            return null;
-        const plan = this.tracker.getPlan();
-        const audit = await this.auditor.audit(plan);
-        const pendingSteps = plan.steps
-            .filter((s) => s.status !== "done" && s.status !== "skipped")
-            .map((s) => `${s.id}. ${s.description}`);
-        const done = plan.steps.filter((s) => s.status === "done").length;
-        const passed = audit.passed && pendingSteps.length === 0;
-        return {
-            passed,
-            done,
-            total: plan.steps.length,
-            pendingSteps,
-            missingFiles: audit.missingFiles,
-            summary: audit.summary,
-        };
-    }
-    getSystemPromptBlock() {
-        if (!this.tracker)
-            return null;
-        return {
-            content: this.tracker.toPromptBlock(),
-            priority: "critical",
-            essential: true,
-            estimatedTokens: 200,
-        };
-    }
-    getToolDefinitions() {
-        return [
-            {
-                name: "plan",
-                description: 'Create, update, show, or abort a multi-step plan. Use "create" at the start of complex tasks. Use "update" after completing each step to track progress. Use "show" to re-print the current plan checklist.',
-                parameters: {
-                    type: "object",
-                    properties: {
-                        action: {
-                            type: "string",
-                            enum: ["create", "update", "show", "abort"],
-                        },
-                        title: { type: "string" },
-                        steps: { type: "array", items: { type: "string" } },
-                        step: { type: "number" },
-                        status: { type: "string", enum: ["done", "failed", "skipped"] },
-                        note: { type: "string" },
-                    },
-                    required: ["action"],
-                },
-                handler: async (_ctx, args) => {
-                    const action = String(args.action);
-                    if (action === "create") {
-                        const title = String(args.title || "Task Plan");
-                        const steps = Array.isArray(args.steps)
-                            ? args.steps.map(String)
-                            : [];
-                        if (steps.length === 0) {
-                            return { success: false, output: t("plan.no_steps") };
-                        }
-                        const plan = PlanCreator.createPlan(title, steps);
-                        this.setPlan(plan);
-                        const display = PlanCreator.toPromptBlock(plan, 0);
-                        return {
-                            success: true,
-                            output: t("plan.created", { title, steps: String(steps.length) }),
-                            display,
-                        };
-                    }
-                    if (action === "show") {
-                        if (!this.tracker) {
-                            return { success: false, output: t("plan.no_active") };
-                        }
-                        const display = this.tracker.toPromptBlock();
-                        return {
-                            success: true,
-                            output: `${t("plan.show_header")}\n${display}`,
-                            display,
-                        };
-                    }
-                    if (action === "update" && args.step && this.tracker) {
-                        this.tracker.updateStepStatus(Number(args.step), args.status || "done");
-                        if (args.note)
-                            this.tracker.addNote(Number(args.step), String(args.note));
-                        const progress = this.tracker.getProgressString();
-                        const display = this.tracker.toPromptBlock();
-                        return {
-                            success: true,
-                            output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}\n${progress}`,
-                            display,
-                        };
-                    }
-                    if (action === "abort") {
-                        this.tracker = null;
-                        return { success: true, output: t("plan.aborted") };
-                    }
-                    if (!this.tracker) {
-                        return { success: false, output: t("plan.no_active") };
-                    }
-                    return {
-                        success: false,
-                        output: t("plan.unknown_action", { action }),
-                    };
-                },
-            },
-            {
-                name: "todo",
-                description: "Manage sub-tasks within current plan step. Use to break down complex steps into smaller tasks.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        action: { type: "string", enum: ["add", "done", "list"] },
-                        items: { type: "array", items: { type: "string" } },
-                    },
-                    required: ["action"],
-                },
-                handler: async (_ctx, args) => {
-                    if (!this.tracker) {
-                        return { success: false, output: t("plan.no_active") };
-                    }
-                    const action = String(args.action);
-                    const currentStep = this.tracker.getCurrentStep();
-                    if (!currentStep) {
-                        return { success: false, output: t("plan.step_not_found") };
-                    }
-                    if (action === "add" && Array.isArray(args.items)) {
-                        const items = args.items.map(String);
-                        currentStep.note = currentStep.note
-                            ? `${currentStep.note}; ${items.join(", ")}`
-                            : items.join(", ");
-                        return {
-                            success: true,
-                            output: t("todo.added", {
-                                count: String(items.length),
-                                items: items.join(", "),
-                            }),
-                        };
-                    }
-                    if (action === "done") {
-                        return {
-                            success: true,
-                            output: t("todo.marked_done", { count: "1" }),
-                        };
-                    }
-                    if (action === "list") {
-                        const note = currentStep.note || "(no sub-tasks)";
-                        return {
-                            success: true,
-                            output: `Step ${currentStep.id}: ${currentStep.description}\nSub-tasks: ${note}`,
-                        };
-                    }
-                    return {
-                        success: false,
-                        output: t("todo.unknown_action", { action }),
-                    };
-                },
-            },
-            {
-                name: "verify",
-                description: "Run verification for the current step. Checks files mentioned in the step description.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        step: { type: "number", description: "Step number to verify" },
-                    },
-                },
-                handler: async (_ctx, args) => {
-                    if (!this.tracker)
-                        return { success: false, output: t("plan.no_active") };
-                    const step = args.step
-                        ? this.tracker.getStep(Number(args.step))
-                        : this.tracker.getCurrentStep();
-                    if (!step)
-                        return { success: false, output: t("plan.step_not_found") };
-                    const result = await this.verifier.verifyStep(step.description);
-                    return {
-                        success: result.passed,
-                        output: result.passed
-                            ? t("verify.passed")
-                            : t("verify.failed", {
-                                details: result.failed.map((f) => f.message).join("; "),
-                            }),
-                    };
-                },
-            },
-        ];
-    }
-    getPlugin() {
-        return {
-            name: "execution",
-            onBeforeThink: (ctx) => {
-                const step = this.tracker?.getCurrentStep();
-                if (this.tracker && step) {
-                    this.stuckDetector.setCurrentStep(step.id, step.description);
-                    this.stuckDetector.recordIteration(step.id);
-                }
-                else {
-                    this.stuckDetector.reset();
-                }
-                const stuckReason = this.stuckDetector.getStuckReason();
-                if (stuckReason) {
-                    ctx.logger?.warn(stuckReason);
-                }
-                if (this.stuckDetector.isStuck() ||
-                    this.stuckDetector.hasRepetitiveToolCalls()) {
-                    const currentIter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
-                    if (currentIter - this.lastRecoveryIteration >=
-                        STUCK_RECOVERY_COOLDOWN) {
-                        const recovery = this.stuckDetector.getRecoveryMessage();
-                        if (recovery && ctx.contextManager) {
-                            ctx.contextManager.addMessage({
-                                role: "user",
-                                content: `<system-summary>${recovery}</system-summary>`,
-                            });
-                        }
-                        this.lastRecoveryIteration = currentIter;
-                    }
-                }
-            },
-            onBeforeTool: (ctx, call) => {
-                const warning = this.checkPlanAlignment(call);
-                if (warning && ctx.contextManager) {
-                    ctx.contextManager.addMessage({
-                        role: "user",
-                        content: `<system-summary>${warning}</system-summary>`,
-                    });
-                }
-                return true;
-            },
-            onToolCall: (ctx) => {
-                const toolName = ctx?.toolName;
-                const args = ctx?.args;
-                if (toolName && args) {
-                    this.stuckDetector.recordToolCall(toolName, args);
-                }
-            },
-            onAfterTool: (ctx, call, result) => {
-                if (!result.success) {
-                    this.stuckDetector.recordToolError(call.name);
-                }
-                else {
-                    this.stuckDetector.recordToolSuccess();
-                }
-                if (this.tracker &&
-                    result.success &&
-                    (call.name === "write_file" || call.name === "edit_file")) {
-                    this.advancePlanIfStepComplete();
-                }
-            },
-        };
-    }
-    checkPlanAlignment(call) {
-        if (!this.tracker)
-            return null;
-        const step = this.tracker.getCurrentStep();
-        if (!step)
-            return null;
-        const allowedAlways = [
-            "plan",
-            "todo",
-            "verify",
-            "list_dir",
-            "read_file",
-            "glob",
-            "grep",
-            "file_info",
-            "load_skill",
-            "question",
-            "approve",
-        ];
-        if (allowedAlways.includes(call.name))
-            return null;
-        const stepPaths = (step.description.match(/\b[\w./\\-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
-        if (stepPaths.length === 0)
-            return null;
-        const argStr = JSON.stringify(call.arguments).toLowerCase();
-        const callPaths = (argStr.match(/\b[\w./\\-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
-        if (callPaths.length === 0)
-            return null;
-        const offPath = callPaths.some((p) => !stepPaths.some((s) => p.includes(s) || s.includes(p)));
-        if (!offPath)
-            return null;
-        return t("exec.plan_warning", {
-            step: String(step.id),
-            description: step.description,
-            tool: call.name,
-        });
-    }
-    advancePlanIfStepComplete() {
-        const step = this.tracker?.getCurrentStep();
-        if (!step)
-            return;
-        const stepPaths = step.description.match(/\b[\w./\\-]+\.[a-z]+/gi) || [];
-        if (stepPaths.length === 0)
-            return;
-        const allExist = stepPaths.every((p) => existsSync(resolve(this.baseDir, p)));
-        if (allExist) {
-            this.tracker?.updateStepStatus(step.id, "done");
-            this.tracker?.advance();
-        }
-    }
-}

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

@@ -1,209 +0,0 @@
-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;
-    }
-}