micro-models-agent 0.61.0 → 0.61.1

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

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

@@ -0,0 +1,94 @@
+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");
+    }
+}