micro-models-agent 0.54.1 → 0.55.1

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

package/dist/modules/execution/planner.js

@@ -1,94 +0,0 @@
-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}`;
-}
-/**
- * Single source of truth for plan progress counting (ses_mt4fn58c: `show`
- * said "6/7 done, complete" while `list` said "7/7" for the same plan —
- * one counted only "done", the other counted done+skipped). A skipped step
- * needs no further work, so it counts as settled everywhere.
- */
-export function getPlanProgress(plan) {
-    const done = plan.steps.filter((s) => s.status === "done").length;
-    const skipped = plan.steps.filter((s) => s.status === "skipped").length;
-    const total = plan.steps.length;
-    const settled = done + skipped;
-    return { done, skipped, total, settled, terminal: total > 0 && settled === total };
-}
-export class PlanCreator {
-    static createPlan(title, stepDescriptions, baseDir, kinds) {
-        const stepCount = stepDescriptions.length;
-        return {
-            id: generatePlanId(),
-            title: `[${stepCount}] ${title}`,
-            steps: stepDescriptions.map((desc, i) => ({
-                id: i + 1,
-                description: desc,
-                status: "pending",
-                kind: kinds?.[i] ?? "create",
-            })),
-            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) => ({
-            id: -1, // renumbered below
-            description: desc,
-            status: "pending",
-            kind: "create",
-        }));
-        // Renumber every step (kept + added) sequentially. Kept steps keep their
-        // status and kind but may collide with the added ids when the original
-        // plan skipped/pending steps in the middle (e.g. done 1, done 3 → kept
-        // [1,3], added [2…] collides with kept id 3).
-        const steps = [...kept, ...added].map((s, i) => ({ ...s, id: i + 1 }));
-        return {
-            id: plan.id,
-            title: `[${totalSteps}] ${newTitle}`,
-            steps,
-            createdAt: plan.createdAt,
-            baseDir: plan.baseDir,
-            name: plan.name,
-        };
-    }
-    static toPromptBlock(plan, currentStepIndex) {
-        const date = plan.createdAt.slice(0, 10);
-        const p = getPlanProgress(plan);
-        const skippedPart = p.skipped > 0 ? `, ${p.skipped} skipped` : "";
-        const progress = p.terminal
-            ? `${p.settled}/${p.total} done${skippedPart}, complete`
-            : `${p.settled}/${p.total} done${skippedPart}, current: step ${currentStepIndex + 1}`;
-        const lines = [
-            `[${plan.id}] ${plan.title}`,
-            `Dir: ${plan.baseDir}`,
-            `Created: ${date} | Progress: ${progress}`,
-            ``,
-        ];
-        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}`);
-            for (const sub of step.subtasks ?? []) {
-                lines.push(`    ${sub.done ? "[x]" : "[ ]"} ${sub.text}`);
-            }
-        }
-        return lines.join("\n");
-    }
-}