micro-models-agent 0.57.0 → 0.57.2

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

@@ -0,0 +1,304 @@
+import { getExpertConfig } from "../../config/experts";
+import { filterToolsByTags } from "../../tools/filter-tools";
+import { StuckDetector } from "./stuck-detector";
+import { t } from "../../i18n/index";
+import { ArtifactStore } from "../artifacts/store";
+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 = "";
+    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}`;
+            const subagentArgs = {
+                task: taskPrompt,
+                allowed_files: allowedFiles,
+                read_only_files: readOnlyFiles,
+                tool_tags: expertConfig.tool_tags,
+            };
+            if (deps.config.subagent?.resultMode === "file") {
+                subagentArgs.result_mode = "file";
+                subagentArgs.artifact_name = subtask.id;
+            }
+            const result = await subagentTool.handler({
+                config: deps.config,
+                baseDir: deps.baseDir,
+                logger: deps.logger,
+                llmProvider: deps.llmProvider,
+                toolExecutor: deps.toolExecutor,
+                sessionId: "moe",
+            }, subagentArgs);
+            if (result.success) {
+                if (deps.config.subagent?.resultMode === "file") {
+                    const pathMatch = result.output.match(/saved to artifact: (.+)/);
+                    const abs = pathMatch ? pathMatch[1].trim() : "";
+                    if (abs) {
+                        const store = new ArtifactStore({
+                            baseDir: deps.baseDir,
+                            sessionId: "moe",
+                        });
+                        const full = store.read(abs.split(/[\\/]/).pop() || ""); // file name only, scoped to root
+                        deps.logger.debug(`MoE subtask "${subtask.id}" attached artifact ${abs} (${full?.length ?? 0} chars) to Router`);
+                        return {
+                            subtaskId: subtask.id,
+                            success: true,
+                            summary: `Artifact: ${abs}`,
+                            result: full ?? result.output,
+                            durationMs: Date.now() - startTime,
+                        };
+                    }
+                }
+                return {
+                    subtaskId: subtask.id,
+                    success: true,
+                    summary: `Completed: ${subtask.id}`,
+                    result: result.output,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            lastError = result.output;
+            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,
+                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,
+                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,
+        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];
+            // Cap concurrent subtasks per wave (rateLimits.maxParallelTasks, default 5).
+            const maxParallel = this.deps.config?.security?.rateLimits?.maxParallelTasks ?? 5;
+            let active = 0;
+            const waiters = [];
+            const acquire = () => active < maxParallel
+                ? Promise.resolve(active++)
+                : new Promise((resolve) => waiters.push(() => resolve(active++)));
+            const release = () => {
+                active--;
+                const next = waiters.shift();
+                if (next)
+                    next();
+            };
+            const wavePromises = wave.map(async (subtask) => {
+                await acquire();
+                let result;
+                try {
+                    result = await executeSubtask(subtask, this.deps, plan.shared_context);
+                }
+                catch (e) {
+                    result = {
+                        subtaskId: subtask.id,
+                        success: false,
+                        summary: `Unhandled error: ${subtask.id}`,
+                        result: "",
+                        error: e instanceof Error ? e.message : String(e),
+                        durationMs: 0,
+                    };
+                }
+                finally {
+                    release();
+                }
+                results.push(result);
+                return result;
+            });
+            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 };
+    }
+}

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

@@ -0,0 +1,68 @@
+const FILE_PATH_RE = /\b[\w./\\-]+\.[a-z]+\b/gi;
+const IGNORED_EXT = new Set([
+    "tsx",
+    "jsx",
+    "json5",
+    "mdx",
+    "yml",
+    "yaml",
+    "toml",
+    "lock",
+    "svg",
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "ico",
+    "css",
+    "scss",
+    "less",
+    "html",
+]);
+/**
+ * Extract file paths (with extensions) mentioned in a task statement.
+ * Used to check whether a generated plan covers every file the task requires.
+ */
+export function extractFilePaths(text) {
+    if (!text)
+        return [];
+    const seen = new Set();
+    const result = [];
+    for (const m of text.matchAll(FILE_PATH_RE)) {
+        let p = m[0];
+        // Trim trailing punctuation that regex greedily keeps (e.g. "test.ts.")
+        p = p.replace(/[.,;:)\]>]+$/g, "");
+        const ext = p.split(".").pop()?.toLowerCase() ?? "";
+        if (!p || IGNORED_EXT.has(ext))
+            continue;
+        const key = p.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(p);
+    }
+    return result;
+}
+function basename(p) {
+    const parts = p.split(/[/\\]/);
+    return parts[parts.length - 1] ?? p;
+}
+/**
+ * Compare the file requirements in the task statement against the plan's step
+ * descriptions. A requirement is "covered" when its path (or its basename)
+ * appears in at least one step. Returns the missing paths.
+ */
+export function checkPlanCoverage(taskText, stepDescriptions) {
+    const taskPaths = extractFilePaths(taskText);
+    if (taskPaths.length === 0)
+        return { missing: [] };
+    const stepText = stepDescriptions.map((s) => s.toLowerCase()).join("\n");
+    const missing = taskPaths.filter((p) => {
+        const lower = p.toLowerCase();
+        const base = basename(lower);
+        // A step mentioning either the full relative path or its basename counts.
+        return !stepText.includes(lower) && !stepText.includes(base);
+    });
+    return { missing };
+}

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

@@ -0,0 +1,46 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+export class PlanPersister {
+    filePath;
+    constructor(baseDir) {
+        const mmaDir = join(baseDir, ".mma");
+        if (!existsSync(mmaDir)) {
+            mkdirSync(mmaDir, { recursive: true });
+        }
+        this.filePath = join(mmaDir, "plan.json");
+    }
+    save(plan) {
+        const file = {
+            id: plan.id,
+            title: plan.title,
+            steps: plan.steps,
+            createdAt: plan.createdAt,
+            updatedAt: new Date().toISOString(),
+            baseDir: plan.baseDir,
+        };
+        writeFileSync(this.filePath, JSON.stringify(file, null, 2), "utf-8");
+    }
+    load() {
+        if (!existsSync(this.filePath))
+            return null;
+        try {
+            const raw = readFileSync(this.filePath, "utf-8");
+            const file = JSON.parse(raw);
+            return {
+                id: file.id || "plan_legacy",
+                title: file.title,
+                steps: file.steps,
+                createdAt: file.createdAt,
+                baseDir: file.baseDir || process.cwd(),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    clear() {
+        if (existsSync(this.filePath)) {
+            writeFileSync(this.filePath, "", "utf-8");
+        }
+    }
+}

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

@@ -0,0 +1,196 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, rmSync } from "fs";
+import { join } from "path";
+const LEGACY_FILE = "plan.json";
+function readPlanFile(path, fallbackBaseDir) {
+    try {
+        const raw = readFileSync(path, "utf-8");
+        if (!raw.trim())
+            return null;
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.steps))
+            return null;
+        return {
+            id: parsed.id || "plan_legacy",
+            title: parsed.title || "Legacy plan",
+            steps: parsed.steps,
+            createdAt: parsed.createdAt || new Date().toISOString(),
+            baseDir: parsed.baseDir || fallbackBaseDir,
+            name: parsed.name,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writePlanFile(path, plan) {
+    writeFileSync(path, JSON.stringify(plan, null, 2), "utf-8");
+}
+function listDir(dir, baseDir) {
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    return files.map((f) => readPlanFile(join(dir, f), baseDir)).filter((p) => p !== null);
+}
+function toMeta(plan, status) {
+    return {
+        id: plan.id,
+        name: plan.name,
+        title: plan.title,
+        status,
+        createdAt: plan.createdAt,
+        stepCount: plan.steps.length,
+        doneCount: plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length,
+    };
+}
+export class PlanStore {
+    baseDir;
+    plansDir;
+    draftsDir;
+    archiveDir;
+    legacyPath;
+    constructor(baseDir) {
+        const mmaDir = join(baseDir, ".mma");
+        if (!existsSync(mmaDir))
+            mkdirSync(mmaDir, { recursive: true });
+        this.baseDir = baseDir;
+        this.plansDir = join(mmaDir, "plans");
+        this.draftsDir = join(this.plansDir, "drafts");
+        this.archiveDir = join(this.plansDir, "archive");
+        this.legacyPath = join(mmaDir, LEGACY_FILE);
+        for (const dir of [this.plansDir, this.draftsDir, this.archiveDir]) {
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+        }
+    }
+    activePath() {
+        return join(this.plansDir, "active.json");
+    }
+    // ---- Active plan ----
+    saveActive(plan) {
+        writePlanFile(this.activePath(), plan);
+    }
+    loadActive() {
+        const activePath = this.activePath();
+        if (existsSync(activePath)) {
+            const plan = readPlanFile(activePath, this.baseDir);
+            if (plan)
+                return plan;
+        }
+        // Legacy migration: read .mma/plan.json and move to active
+        if (existsSync(this.legacyPath)) {
+            const legacy = readPlanFile(this.legacyPath, this.baseDir);
+            if (legacy) {
+                this.saveActive(legacy);
+                try {
+                    rmSync(this.legacyPath, { force: true });
+                }
+                catch { }
+                return legacy;
+            }
+        }
+        return null;
+    }
+    clearActive() {
+        const p = this.activePath();
+        if (existsSync(p))
+            rmSync(p, { force: true });
+    }
+    // ---- Drafts (saved plans) ----
+    saveDraft(plan) {
+        writePlanFile(join(this.draftsDir, `${plan.id}.json`), plan);
+    }
+    loadDraft(id) {
+        const p = join(this.draftsDir, `${id}.json`);
+        return existsSync(p) ? readPlanFile(p, this.baseDir) : null;
+    }
+    removeDraft(id) {
+        const p = join(this.draftsDir, `${id}.json`);
+        if (existsSync(p))
+            rmSync(p, { force: true });
+    }
+    listDrafts() {
+        return listDir(this.draftsDir, this.baseDir);
+    }
+    // ---- Archive ----
+    archivePlan(plan) {
+        writePlanFile(join(this.archiveDir, `${plan.id}.json`), plan);
+        // Remove from drafts if present
+        this.removeDraft(plan.id);
+        // If archived plan was active, clear active
+        const active = this.loadActive();
+        if (active && active.id === plan.id) {
+            this.clearActive();
+        }
+    }
+    listArchived() {
+        return listDir(this.archiveDir, this.baseDir);
+    }
+    removeArchived(id) {
+        const p = join(this.archiveDir, `${id}.json`);
+        if (existsSync(p))
+            rmSync(p, { force: true });
+    }
+    // ---- Cross-status queries ----
+    listAll() {
+        const metas = [];
+        const active = this.loadActive();
+        if (active)
+            metas.push(toMeta(active, "active"));
+        for (const p of this.listDrafts())
+            metas.push(toMeta(p, "draft"));
+        for (const p of this.listArchived())
+            metas.push(toMeta(p, "archived"));
+        return metas;
+    }
+    find(id) {
+        const active = this.loadActive();
+        if (active && active.id === id)
+            return { plan: active, status: "active" };
+        const draft = this.loadDraft(id);
+        if (draft)
+            return { plan: draft, status: "draft" };
+        const archived = this.listArchived().find((p) => p.id === id);
+        if (archived)
+            return { plan: archived, status: "archived" };
+        return null;
+    }
+    // ---- Deletion (the user asked for plans to actually go away) ----
+    /** Permanently delete a plan wherever it lives. Returns its status, or null
+     *  when no plan with that id exists. */
+    deletePlan(id) {
+        const active = this.loadActive();
+        if (active && active.id === id) {
+            this.clearActive();
+            return "active";
+        }
+        const draftPath = join(this.draftsDir, `${id}.json`);
+        if (existsSync(draftPath)) {
+            rmSync(draftPath, { force: true });
+            return "draft";
+        }
+        const archivedPath = join(this.archiveDir, `${id}.json`);
+        if (existsSync(archivedPath)) {
+            rmSync(archivedPath, { force: true });
+            return "archived";
+        }
+        return null;
+    }
+    /** Delete every plan (active, drafts, archive). Returns the number removed. */
+    purgeAll() {
+        let n = 0;
+        const active = this.loadActive();
+        if (active) {
+            this.clearActive();
+            n++;
+        }
+        for (const p of this.listDrafts()) {
+            this.removeDraft(p.id);
+            n++;
+        }
+        for (const p of this.listArchived()) {
+            this.removeArchived(p.id);
+            n++;
+        }
+        return n;
+    }
+}