micro-models-agent 0.44.0 → 0.45.0

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

@@ -1,266 +0,0 @@
-import { getExpertConfig } from "../../config/experts";
-import { filterToolsByTags } from "../../tools/filter-tools";
-import { StuckDetector } from "./stuck-detector";
-import { t } from "../../i18n/index";
-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;
-    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,
-            };
-            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;
-            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];
-            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-coverage.js

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

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

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

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;
-}