micro-models-agent 2.16.1 → 2.17.1

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

@@ -1,197 +0,0 @@
-import { normalizeInputFrom } from "./input-from";
-/** Валидирует план: подзадачи, теги экспертов, циклы, пересечения, input_from. */
-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);
-        }
-    }
-    const inputRefErrors = validateInputFromRefs(plan.subtasks);
-    errors.push(...inputRefErrors.errors);
-    autoFixes.push(...inputRefErrors.autoFixes);
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-        autoFixes,
-    };
-}
-/**
- * Каждая ссылка input_from обязана указывать на существующую подзадачу и
- * подкрепляться ребром depends_on — иначе читатель стартует раньше продьюсера.
- */
-/** Валидирует ссылки input_from: неизвестные — ошибки, недостающие depends_on — автофиксы. */
-export function validateInputFromRefs(subtasks) {
-    const errors = [];
-    const autoFixes = [];
-    const ids = new Set(subtasks.map((s) => s.id));
-    for (const s of subtasks) {
-        for (const ref of normalizeInputFrom(s.input_from)) {
-            if (!ids.has(ref.subtaskId)) {
-                errors.push(`Subtask "${s.id}" input_from references unknown subtask "${ref.subtaskId}". Known subtasks: ${Array.from(ids).join(", ")}`);
-            }
-            else if (!s.depends_on?.includes(ref.subtaskId)) {
-                autoFixes.push({ subtaskId: s.id, fix: `Add depends_on: ${ref.subtaskId}` });
-            }
-        }
-    }
-    return { errors, autoFixes };
-}
-/** Проверяет, что все expert_tag подзадач известны из конфига. Возвращает ошибки. */
-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;
-}
-/** Ищет циклы в графе depends_on (DFS). Возвращает ошибки. */
-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;
-}
-/** Ищет write-write пересечения allowed_files без цепочки зависимостей. Возвращает ошибки. */
-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;
-}
-/** Два спека путей пересекаются, если равны или один — каталог-предок другого. */
-function pathsOverlap(a, b) {
-    const na = a.replace(/\\/g, "/").replace(/\/+$/, "");
-    const nb = b.replace(/\\/g, "/").replace(/\/+$/, "");
-    if (na === nb)
-        return true;
-    return na.startsWith(`${nb}/`) || nb.startsWith(`${na}/`);
-}
-/** Ищет read-after-write пересечения (писатель vs read_only читателя). Пустые depends_on — автофикс. */
-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;
-            // Точное совпадение или настоящий каталог-предок, НЕ строковый префикс:
-            // иначе сиблинги `src/main.ts` (писатель) vs `src/main.tsx` (читатель)
-            // ложно флаговались.
-            const overlapping = writeFiles.filter((f) => [...readFiles].some((rf) => pathsOverlap(f, rf)));
-            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;
-}
-/** Применяет автофиксы (добавление depends_on) к копии плана, оригинал не мутирует. */
-export function applyAutoFixes(plan, autoFixes) {
-    // Глубокое-ish клонирование: копируем каждый массив `depends_on`, чтобы пуши
-    // ниже не мутировали план вызывающего (поверхностный `{...s}` делил массив).
-    const fixed = {
-        ...plan,
-        subtasks: plan.subtasks.map((s) => ({
-            ...s,
-            depends_on: [...(s.depends_on ?? [])],
-        })),
-    };
-    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,103 +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}`;
-}
-/**
- * Единый источник правды подсчёта прогресса (ses_mt4fn58c: `show` говорил
- * "6/7 done, complete", а `list` — "7/7" для того же плана: один считал только
- * "done", другой done+skipped). Пропущенный шаг работы не требует, поэтому
- * везде считается settled.
- */
-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 };
-}
-/** Создатель планов: create, re-plan, промпт-блок. */
-export class PlanCreator {
-    /** Создаёт новый план из заголовка и описаний шагов. */
-    static createPlan(title, stepDescriptions, baseDir, kinds, checks) {
-        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",
-                ...(checks?.[i] ? { check: checks[i] } : {}),
-            })),
-            createdAt: new Date().toISOString(),
-            baseDir,
-        };
-    }
-    /** Re-plan: сохраняет done/skipped шаги, заменяет остальные новыми. */
-    static replan(plan, newSteps, title, newChecks) {
-        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, i) => ({
-            id: -1, // перенумеруется ниже
-            description: desc,
-            status: "pending",
-            kind: "create",
-            ...(newChecks?.[i] ? { check: newChecks[i] } : {}),
-        }));
-        // Перенумеровываем все шаги (сохранённые + новые) подряд. Сохранённые держат
-        // статус и kind, но их id могут коллизить с новыми, если исходный план
-        // пропускал/пендил шаги в середине (напр. done 1, done 3 → сохранённые
-        // [1,3], новые [2…] коллизят с сохранённым 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,
-        };
-    }
-    /** Рендерит план чеклистом для промпта (иконки статусов, checks, подзадачи). */
-    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}`);
-            if (step.check) {
-                lines.push(`    ↳ check: ${step.check}`);
-            }
-            for (const sub of step.subtasks ?? []) {
-                lines.push(`    [${sub.id}] ${sub.done ? "[x]" : "[ ]"} ${sub.text}`);
-            }
-        }
-        return lines.join("\n");
-    }
-}