@technicalshree/auto-fix 1.1.0

package/dist/config/defaults.js

@@ -0,0 +1,44 @@
+export const defaultConfig = {
+    version: 1,
+    ports: {
+        default: [3000, 5173, 8000, 8080],
+        extra: [9229],
+    },
+    node: {
+        package_manager: "auto",
+        deep_cleanup: {
+            remove_node_modules: true,
+            remove_lockfile: false,
+        },
+        caches: {
+            next: true,
+            vite: true,
+            directories: [".turbo", ".cache"],
+        },
+    },
+    python: {
+        venv_path: ".venv",
+        install: {
+            prefer: "uv",
+        },
+        tools: {
+            format: ["ruff format", "black ."],
+            lint: ["ruff check ."],
+            test: ["pytest -q"],
+        },
+    },
+    docker: {
+        compose_file: "auto",
+        safe_down: true,
+        rebuild: true,
+        prune: false,
+    },
+    checks: {
+        default: ["lint", "format", "test"],
+    },
+    output: {
+        report_dir: ".autofix/reports",
+        snapshot_dir: ".autofix/snapshots",
+        verbosity: "normal",
+    },
+};

package/dist/config/loadConfig.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { parse } from "yaml";
+import { defaultConfig } from "./defaults.js";
+import { fileExists } from "../utils/fs.js";
+function mergeDeep(target, source) {
+    const output = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        if (Array.isArray(value)) {
+            output[key] = value;
+            continue;
+        }
+        if (value && typeof value === "object") {
+            const current = output[key];
+            output[key] = mergeDeep((current ?? {}), value);
+            continue;
+        }
+        output[key] = value;
+    }
+    return output;
+}
+async function findConfigPath(cwd) {
+    let current = cwd;
+    while (true) {
+        const candidate = path.join(current, ".autofix.yml");
+        if (await fileExists(candidate))
+            return candidate;
+        const gitDir = path.join(current, ".git");
+        if (await fileExists(gitDir))
+            return null;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export async function loadConfig(cwd) {
+    const cfgPath = await findConfigPath(cwd);
+    if (!cfgPath)
+        return { config: defaultConfig, path: null };
+    const raw = await readFile(cfgPath, "utf8");
+    const user = parse(raw);
+    return { config: mergeDeep(defaultConfig, user), path: cfgPath };
+}

package/dist/core/detectEnvironment.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { parse as parseYaml } from "yaml";
+import { fileExists } from "../utils/fs.js";
+async function detectPackageManager(cwd) {
+    if (await fileExists(path.join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (await fileExists(path.join(cwd, "yarn.lock")))
+        return "yarn";
+    if (await fileExists(path.join(cwd, "package-lock.json")))
+        return "npm";
+    return "unknown";
+}
+async function detectLockfileCorruption(cwd) {
+    const pkgLock = path.join(cwd, "package-lock.json");
+    if (await fileExists(pkgLock)) {
+        try {
+            JSON.parse(await readFile(pkgLock, "utf8"));
+        }
+        catch {
+            return true;
+        }
+    }
+    const pnpmLock = path.join(cwd, "pnpm-lock.yaml");
+    if (await fileExists(pnpmLock)) {
+        try {
+            parseYaml(await readFile(pnpmLock, "utf8"));
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+}
+export async function detectEnvironment(cwd, config) {
+    const packageJsonPath = path.join(cwd, "package.json");
+    const hasPackage = await fileExists(packageJsonPath);
+    let scripts = [];
+    let hasNext = false;
+    let hasVite = false;
+    if (hasPackage) {
+        try {
+            const parsed = JSON.parse(await readFile(packageJsonPath, "utf8"));
+            scripts = Object.keys(parsed.scripts ?? {});
+            const deps = { ...(parsed.dependencies ?? {}), ...(parsed.devDependencies ?? {}) };
+            hasNext = Boolean(deps.next) || scripts.some((s) => s.toLowerCase().includes("next"));
+            hasVite = Boolean(deps.vite) || scripts.some((s) => s.toLowerCase().includes("vite"));
+        }
+        catch {
+            // Ignore malformed package file in detection phase.
+        }
+    }
+    const requirements = (await fileExists(path.join(cwd, "requirements.txt"))) ||
+        (await fileExists(path.join(cwd, "requirements-dev.txt")));
+    const hasPyproject = await fileExists(path.join(cwd, "pyproject.toml"));
+    const venvPath = path.join(cwd, config.python.venv_path);
+    const venvExists = await fileExists(venvPath);
+    const composeCandidates = ["docker-compose.yml", "compose.yml", "docker-compose.yaml", "compose.yaml"];
+    const composeFile = (await Promise.all(composeCandidates.map(async (name) => ((await fileExists(path.join(cwd, name))) ? name : null)))).find((v) => Boolean(v)) ?? undefined;
+    const lockfileCandidates = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"];
+    const lockfiles = (await Promise.all(lockfileCandidates.map(async (name) => ((await fileExists(path.join(cwd, name))) ? name : null)))).filter((v) => Boolean(v));
+    const lockfileCorrupted = await detectLockfileCorruption(cwd);
+    const issues = [];
+    if (hasPackage && !(await fileExists(path.join(cwd, "node_modules"))))
+        issues.push("node_modules directory missing");
+    if ((hasPyproject || requirements) && !venvExists)
+        issues.push("python virtual environment missing");
+    if (composeFile)
+        issues.push("docker compose project detected (state may require refresh)");
+    if (lockfileCorrupted)
+        issues.push("lockfile appears corrupted; frozen installs likely to fail");
+    return {
+        node: {
+            detected: hasPackage,
+            packageManager: await detectPackageManager(cwd),
+            hasNodeModules: await fileExists(path.join(cwd, "node_modules")),
+            hasNext,
+            hasVite,
+            lockfiles,
+            lockfileCorrupted,
+            packageScripts: scripts,
+        },
+        python: {
+            detected: hasPyproject || requirements,
+            hasPyproject,
+            hasRequirements: requirements,
+            venvPath: config.python.venv_path,
+            venvExists,
+        },
+        docker: { detected: Boolean(composeFile), composeFile },
+        issues,
+    };
+}

package/dist/core/executor.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import readline from "node:readline/promises";
+import { setTimeout as sleep } from "node:timers/promises";
+import { runShellCommand } from "../utils/process.js";
+import { canAutoRunDestructive, shouldPromptForDestructive } from "./safety.js";
+import { snapshotPathsForStep } from "./snapshots.js";
+async function askConfirmation(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = (await rl.question(`${question} [y/N]: `)).trim().toLowerCase();
+    rl.close();
+    return answer === "y" || answer === "yes";
+}
+function snapshotCandidates(step) {
+    if (step.id.includes("lockfiles"))
+        return ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"];
+    return [];
+}
+async function verifyPortsReleased(cwd, commands) {
+    const ports = commands
+        .map((c) => c.match(/:(\d+)/)?.[1])
+        .filter((v) => Boolean(v));
+    const maxMs = 2000;
+    const intervalMs = 100;
+    let elapsed = 0;
+    while (elapsed <= maxMs) {
+        const checks = await Promise.all(ports.map((p) => runShellCommand(`lsof -ti :${p}`, cwd)));
+        const busy = checks
+            .map((result, idx) => ({ port: ports[idx], pids: result.stdout.trim().split(/\s+/).filter(Boolean) }))
+            .filter((x) => x.pids.length > 0);
+        if (busy.length === 0) {
+            await sleep(150);
+            return { ok: true, details: "ports confirmed free" };
+        }
+        await sleep(intervalMs);
+        elapsed += intervalMs;
+    }
+    const remaining = await Promise.all(ports.map((p) => runShellCommand(`lsof -ti :${p}`, cwd)));
+    const detail = remaining
+        .map((r, i) => `${ports[i]}: ${r.stdout.trim() || "none"}`)
+        .join(", ");
+    return { ok: false, details: `remaining pid(s) -> ${detail}. Try: lsof -ti :<port> | xargs kill -9` };
+}
+export async function executeSteps(ctx, steps, snapshotDir, hooks) {
+    const output = [];
+    const confirmFn = hooks?.onConfirm ?? askConfirmation;
+    for (const step of steps) {
+        const current = { ...step };
+        if (ctx.flags.verbose)
+            console.log(`[phase:${step.phase}] ${step.title}`);
+        if (ctx.command === "doctor" || ctx.command === "plan" || ctx.flags.dryRun) {
+            current.status = step.status === "proposed" ? "proposed" : "planned";
+            output.push(current);
+            continue;
+        }
+        if (step.destructive && !canAutoRunDestructive(ctx)) {
+            if (shouldPromptForDestructive(ctx, step)) {
+                const ok = await confirmFn(`Run destructive step: ${step.title}?`);
+                if (!ok) {
+                    current.status = "proposed";
+                    current.proposedReason = "Needs explicit approval";
+                    hooks?.onStepEnd(current);
+                    output.push(current);
+                    continue;
+                }
+            }
+            else {
+                current.status = "proposed";
+                current.proposedReason = ctx.interactive
+                    ? "Needs --deep or --approve"
+                    : "Non-interactive mode: destructive step skipped";
+                hooks?.onStepEnd(current);
+                output.push(current);
+                continue;
+            }
+        }
+        current.status = "running";
+        hooks?.onStepStart(current);
+        if (step.destructive) {
+            const snaps = await snapshotPathsForStep(ctx.cwd, path.join(snapshotDir, ctx.runId), step.id, snapshotCandidates(step));
+            current.snapshotPaths = snaps;
+        }
+        let failed = false;
+        const commandOutputs = [];
+        for (const command of step.commands) {
+            if (ctx.flags.verbose)
+                console.log(`  \u25B8 ${command}`);
+            const result = await runShellCommand(command, ctx.cwd);
+            commandOutputs.push(`$ ${command}\n${result.stdout}${result.stderr}`.trim());
+            if (ctx.flags.verbose) {
+                if (result.stdout)
+                    console.log(result.stdout.trimEnd());
+                if (result.stderr)
+                    console.error(result.stderr.trimEnd());
+            }
+            if (!result.success) {
+                failed = true;
+                break;
+            }
+        }
+        if (!failed && step.id === "ports-cleanup") {
+            const portCheck = await verifyPortsReleased(ctx.cwd, step.commands);
+            if (!portCheck.ok) {
+                current.status = "failed";
+                current.error = portCheck.details;
+                current.output = commandOutputs.join("\n\n");
+                hooks?.onStepEnd(current);
+                output.push(current);
+                continue;
+            }
+            commandOutputs.push(portCheck.details);
+        }
+        current.output = commandOutputs.join("\n\n");
+        if (failed) {
+            current.status = "failed";
+            current.error = "One or more commands failed";
+        }
+        else {
+            current.status = "success";
+        }
+        hooks?.onStepEnd(current);
+        output.push(current);
+    }
+    return output;
+}

package/dist/core/planBuilder.js

@@ -0,0 +1,45 @@
+import { buildNodeSteps } from "../subsystems/node.js";
+import { buildPythonSteps } from "../subsystems/python.js";
+import { buildDockerSteps } from "../subsystems/docker.js";
+import { buildCheckSteps } from "../subsystems/checks.js";
+export function buildPortSteps(flags, config) {
+    if (!flags.killPorts)
+        return [];
+    const ports = flags.killPorts.length > 0 ? flags.killPorts : [...config.ports.default, ...config.ports.extra];
+    if (ports.length === 0)
+        return [];
+    return [
+        {
+            id: "ports-cleanup",
+            title: "Kill processes using configured ports",
+            subsystem: "meta",
+            phase: "ports",
+            rationale: "Port conflict cleanup before subsystem repair.",
+            commands: ports.map((port) => `lsof -ti :${port} | xargs kill -9`),
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        },
+    ];
+}
+export function buildPlan(detection, config, flags) {
+    const steps = [];
+    // strict order: ports -> docker -> node -> python -> checks(format, lint, test)
+    steps.push(...buildPortSteps(flags, config));
+    if (flags.focus === "all" || flags.focus === "docker")
+        steps.push(...buildDockerSteps(detection, config, flags));
+    if (flags.focus === "all" || flags.focus === "node")
+        steps.push(...buildNodeSteps(detection, config, flags));
+    if (flags.focus === "all" || flags.focus === "python")
+        steps.push(...buildPythonSteps(detection, config, flags));
+    const checks = [];
+    if (flags.focus === "all" || flags.focus === "node")
+        checks.push(...buildCheckSteps(detection, config, flags, "node"));
+    if (flags.focus === "all" || flags.focus === "python")
+        checks.push(...buildCheckSteps(detection, config, flags, "python"));
+    const order = { format: 1, lint: 2, test: 3 };
+    checks.sort((a, b) => (order[a.checkKind ?? "test"] - order[b.checkKind ?? "test"]));
+    steps.push(...checks);
+    return steps;
+}

package/dist/core/run.js

@@ -0,0 +1,125 @@
+import path from "node:path";
+import readline from "node:readline/promises";
+import { tmpdir } from "node:os";
+import { detectEnvironment } from "./detectEnvironment.js";
+import { buildPlan } from "./planBuilder.js";
+import { executeSteps } from "./executor.js";
+import { ensureAutofixInGitignore, ensureWritableDir } from "../utils/fs.js";
+function suggestNextAction(detection) {
+    if (detection.node.detected)
+        return "npm run dev";
+    if (detection.python.detected)
+        return "python -m pytest -q";
+    if (detection.docker.detected)
+        return "docker compose ps";
+    return "Review project setup and rerun auto-fix doctor";
+}
+function summarizeDetection(detection) {
+    const out = [];
+    if (detection.node.detected)
+        out.push("Node");
+    if (detection.python.detected)
+        out.push("Python");
+    if (detection.docker.detected)
+        out.push("Docker Compose");
+    if (out.length === 0)
+        out.push("No supported project type detected");
+    return out;
+}
+async function maybeConfirmPolyglot(ctx, detection) {
+    const count = [detection.node.detected, detection.python.detected, detection.docker.detected].filter(Boolean).length;
+    if (ctx.flags.focus !== "all" || count < 2)
+        return true;
+    if (ctx.flags.approve)
+        return true;
+    if (!ctx.interactive)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = (await rl.question("Detected Node + Python + Docker scope. Run all subsystems? (Y/n): ")).trim().toLowerCase();
+    rl.close();
+    return !(answer === "n" || answer === "no");
+}
+function applyPolyglotGuard(ctx, detection, steps) {
+    const warnings = [];
+    const count = [detection.node.detected, detection.python.detected, detection.docker.detected].filter(Boolean).length;
+    if (count < 2 || ctx.flags.focus !== "all")
+        return { steps, warnings };
+    if (!ctx.interactive && !ctx.flags.approve) {
+        warnings.push("Non-interactive polyglot run defaulted to safe minimal set (ports + caches only)");
+        const filtered = steps.filter((s) => s.phase === "ports" || s.id.includes("clean-cache") || s.id.includes("next-cache") || s.id.includes("vite-cache"));
+        return { steps: filtered, warnings };
+    }
+    if (!ctx.flags.approve) {
+        const heavy = steps.filter((s) => s.phase === "docker" || s.id.includes("install-deps") || s.id.includes("reset-venv") || s.id.includes("remove-node-modules"));
+        if (heavy.length > 2)
+            warnings.push("Heavy polyglot plan detected. Use --approve for full deep multi-ecosystem cleanup.");
+    }
+    return { steps, warnings };
+}
+function computeSummary(steps, detection, warnings) {
+    const succeeded = steps.filter((s) => s.status === "success").length;
+    const failed = steps.filter((s) => s.status === "failed" || s.status === "partial").length;
+    const skipped = steps.filter((s) => s.status === "skipped" || s.status === "proposed" || s.status === "planned").length;
+    const irreversibleStepIds = steps.filter((s) => s.irreversible && (s.status === "success" || s.status === "proposed" || s.status === "planned")).map((s) => s.id);
+    return {
+        detectedEnvironment: summarizeDetection(detection),
+        actions: steps.map((s) => `${s.status}: ${s.title}`),
+        succeeded,
+        failed,
+        skipped,
+        nextBestAction: suggestNextAction(detection),
+        undoCoverage: irreversibleStepIds.length > 0 ? "partial" : "full",
+        irreversibleStepIds,
+        warnings,
+    };
+}
+export async function runAutoFix(ctx, config, reportDir, callbacks) {
+    const detection = await detectEnvironment(ctx.cwd, config);
+    callbacks?.onDetection?.(detection);
+    const runAll = await maybeConfirmPolyglot(ctx, detection);
+    if (!runAll) {
+        ctx.flags.focus = "node";
+    }
+    const plan = buildPlan(detection, config, ctx.flags);
+    const guarded = applyPolyglotGuard(ctx, detection, plan);
+    callbacks?.onPlanReady?.(guarded.steps);
+    const desiredSnapshotDir = path.resolve(ctx.cwd, config.output.snapshot_dir);
+    const writable = await ensureWritableDir(desiredSnapshotDir);
+    const snapshotDir = writable ? desiredSnapshotDir : path.join(tmpdir(), "autofix", ctx.runId);
+    if (!writable)
+        await ensureWritableDir(snapshotDir);
+    const executed = await executeSteps(ctx, guarded.steps, snapshotDir, callbacks?.stepHooks);
+    const gitignoreUpdated = await ensureAutofixInGitignore(ctx.cwd);
+    if (gitignoreUpdated)
+        guarded.warnings.push("Added .autofix/ to .gitignore");
+    if (!writable)
+        guarded.warnings.push(`.autofix not writable; using temp snapshot dir: ${snapshotDir}`);
+    const report = {
+        runId: ctx.runId,
+        command: ctx.command,
+        cwd: ctx.cwd,
+        startedAt: new Date().toISOString(),
+        finishedAt: new Date().toISOString(),
+        flags: ctx.flags,
+        detection,
+        steps: executed,
+        summary: computeSummary(executed, detection, guarded.warnings),
+        undo: executed
+            .filter((s) => s.snapshotPaths && s.snapshotPaths.length > 0)
+            .map((s) => ({
+            stepId: s.id,
+            snapshotPaths: s.snapshotPaths ?? [],
+            restored: [],
+            skipped: [],
+            missingSnapshot: [],
+            failed: [],
+            nextBestAction: s.undoHints?.[0]?.command,
+        })),
+        storage: {
+            reportDir,
+            snapshotDir,
+            fallbackToTemp: !writable,
+        },
+    };
+    return { report, gitignoreUpdated };
+}

package/dist/core/safety.js

@@ -0,0 +1,9 @@
+export function needsApproval(step) {
+    return step.destructive;
+}
+export function canAutoRunDestructive(ctx) {
+    return ctx.flags.deep || ctx.flags.approve;
+}
+export function shouldPromptForDestructive(ctx, step) {
+    return needsApproval(step) && !canAutoRunDestructive(ctx) && ctx.interactive;
+}

package/dist/core/snapshots.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { cp } from "node:fs/promises";
+import { ensureDir, fileExists } from "../utils/fs.js";
+export async function snapshotPathsForStep(cwd, snapshotRoot, stepId, candidates) {
+    const created = [];
+    for (const candidate of candidates) {
+        if (candidate === "node_modules")
+            continue;
+        const source = path.join(cwd, candidate);
+        if (!(await fileExists(source)))
+            continue;
+        const dest = path.join(snapshotRoot, stepId, candidate.replace(/[\\/:]/g, "_"));
+        await ensureDir(path.dirname(dest));
+        await cp(source, dest, { recursive: true, force: true });
+        created.push(dest);
+    }
+    return created;
+}

package/dist/core/undo.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { cp } from "node:fs/promises";
+import { fileExists, readJsonFile } from "../utils/fs.js";
+export async function undoLatest(reportPath, cwd) {
+    const report = await readJsonFile(reportPath);
+    if (!report)
+        return { report: null, entries: [] };
+    const entries = [];
+    for (const step of report.steps) {
+        const restored = [];
+        const failed = [];
+        const skipped = [];
+        const missingSnapshot = [];
+        if (!step.undoable || !step.snapshotPaths || step.snapshotPaths.length === 0) {
+            skipped.push("not undoable or no snapshot");
+            entries.push({
+                stepId: step.id,
+                snapshotPaths: step.snapshotPaths ?? [],
+                restored,
+                skipped,
+                missingSnapshot,
+                failed,
+                nextBestAction: step.undoHints?.[0]?.command,
+            });
+            continue;
+        }
+        for (const snap of step.snapshotPaths) {
+            if (!(await fileExists(snap))) {
+                missingSnapshot.push(snap);
+                continue;
+            }
+            const base = path.basename(snap);
+            const target = path.join(cwd, base.replace(/_/g, "/"));
+            try {
+                await cp(snap, target, { recursive: true, force: true });
+                restored.push(target);
+            }
+            catch {
+                failed.push(target);
+            }
+        }
+        entries.push({
+            stepId: step.id,
+            snapshotPaths: step.snapshotPaths,
+            restored,
+            skipped,
+            missingSnapshot,
+            failed,
+            nextBestAction: step.undoHints?.[0]?.command,
+        });
+    }
+    return { report, entries };
+}

package/dist/report/renderSummary.js

@@ -0,0 +1,73 @@
+import { style } from "../utils/colors.js";
+function modeBanner(command, flags, useColor) {
+    const c = style(useColor);
+    const tags = [];
+    if (flags.dryRun && command !== "plan")
+        tags.push("dry-run");
+    if (flags.deep)
+        tags.push("deep");
+    if (flags.approve)
+        tags.push("approve");
+    if (flags.forceFresh)
+        tags.push("force-fresh");
+    if (flags.focus !== "all")
+        tags.push(`focus:${flags.focus}`);
+    if (flags.killPorts)
+        tags.push("kill-ports");
+    if (flags.verbose)
+        tags.push("verbose");
+    if (flags.quiet)
+        tags.push("quiet");
+    const tagStr = tags.length > 0 ? ` ${c.dim(`[${tags.join(", ")}]`)}` : "";
+    return c.strong(`auto-fix · ${command}`) + tagStr;
+}
+export function renderSummary(report, useColor) {
+    const c = style(useColor);
+    const lines = [];
+    lines.push(modeBanner(report.command, report.flags, useColor));
+    lines.push("");
+    lines.push(c.title("Detected environment"));
+    lines.push(`- ${report.summary.detectedEnvironment.join(", ") || "None"}`);
+    lines.push(c.title("Plan/Actions"));
+    if (report.steps.length === 0) {
+        lines.push("- No actions were planned.");
+    }
+    else {
+        for (const step of report.steps) {
+            const tags = [];
+            if (step.irreversible)
+                tags.push("IRREVERSIBLE");
+            const extra = step.proposedReason ? ` (${step.proposedReason})` : "";
+            lines.push(`- [${step.status}] ${step.id} ${step.title}${tags.length ? ` [${tags.join(",")}]` : ""}${extra}`);
+            if (step.irreversible && step.irreversibleReason) {
+                lines.push(`  reason: ${step.irreversibleReason} | This will NOT be covered by undo.`);
+            }
+        }
+    }
+    lines.push(c.title("Results"));
+    lines.push(`- Success: ${report.summary.succeeded}, Failed: ${report.summary.failed}, Skipped/Proposed: ${report.summary.skipped}`);
+    if (report.summary.irreversibleStepIds.length > 0) {
+        lines.push(`- Undo coverage: partial (some actions irreversible)`);
+        lines.push(`- Irreversible steps: ${report.summary.irreversibleStepIds.join(", ")}`);
+    }
+    for (const warning of report.summary.warnings) {
+        lines.push(`- Warning: ${warning}`);
+    }
+    lines.push(c.title("Next best action"));
+    lines.push(`- ${report.summary.nextBestAction}`);
+    return lines.join("\n");
+}
+export function renderQuietSummary(report, useColor) {
+    const c = style(useColor);
+    const lines = [];
+    lines.push(modeBanner(report.command, report.flags, useColor));
+    lines.push("");
+    lines.push(c.title("Results"));
+    lines.push(`- Success: ${report.summary.succeeded}, Failed: ${report.summary.failed}, Skipped/Proposed: ${report.summary.skipped}`);
+    if (report.summary.irreversibleStepIds.length > 0) {
+        lines.push(`- Undo coverage: partial (some actions irreversible)`);
+    }
+    lines.push(c.title("Next best action"));
+    lines.push(`- ${report.summary.nextBestAction}`);
+    return lines.join("\n");
+}

package/dist/report/writeReport.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+import { writeJsonFile } from "../utils/fs.js";
+export async function writeRunReport(report, reportDir) {
+    const runReportPath = path.join(reportDir, `${report.runId}.json`);
+    const latestPath = path.join(reportDir, "latest.json");
+    await writeJsonFile(runReportPath, report);
+    await writeJsonFile(latestPath, report);
+    return { runReportPath, latestPath };
+}