@samaksh/git-worker 0.0.0-stage → 0.2.0

package/dist/stages/eligibility.js

@@ -0,0 +1,68 @@
+import { ok, err } from "../core/types.js";
+import { workspaceError } from "../core/errors.js";
+import { clack, sectionHeader, statusLine } from "../utils/ui.js";
+export const checkEligibilityStage = async (context, deps) => {
+    if (!context.selectedBranches || !context.target || !context.project) {
+        return err(workspaceError("Prerequisites missing for eligibility check"));
+    }
+    sectionHeader("Eligibility Check");
+    const eligible = [];
+    const ineligible = [];
+    const isEnvTarget = context.target.path === ".env" || context.target.path.startsWith(".env.");
+    const total = context.selectedBranches.length;
+    const isBatchMode = total > 8;
+    const s = clack.spinner();
+    if (isBatchMode) {
+        s.start(`Checking eligibility for ${total} branches…`);
+    }
+    // Concurrent execution pool (up to 16 workers in parallel)
+    const concurrency = Math.min(16, total);
+    let completed = 0;
+    let currentIndex = 0;
+    const workers = Array.from({ length: concurrency }, async () => {
+        while (currentIndex < total) {
+            const idx = currentIndex++;
+            const branch = context.selectedBranches[idx];
+            // 1. Check if the target file exists in the branch
+            const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, context.target.path);
+            const targetFound = targetRead.ok;
+            // 2. If target is a non-.env file, check if .env is available as variable source
+            let envNote = "";
+            if (!isEnvTarget) {
+                const envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
+                if (envRead.ok) {
+                    envNote = " • .env present";
+                }
+                else {
+                    envNote = " • .env missing (variables will require fallbacks)";
+                }
+            }
+            const fileStatus = targetFound ? "target file found" : "target file will be created";
+            eligible.push(branch);
+            completed++;
+            if (isBatchMode) {
+                s.message(`Checking eligibility (${completed}/${total})…`);
+            }
+            else {
+                statusLine(targetFound ? "ok" : "info", branch.name, `${branch.sha.slice(0, 8)} — ${fileStatus}${envNote}`);
+            }
+        }
+    });
+    await Promise.all(workers);
+    if (isBatchMode) {
+        s.stop(`Checked ${total} branches (${eligible.length} eligible)`);
+    }
+    if (ineligible.length > 0) {
+        console.log("");
+        clack.log.warn(`${ineligible.length} branch(es) ineligible:`);
+        for (const { branch, reason } of ineligible) {
+            statusLine("warn", branch.name, reason);
+        }
+    }
+    if (eligible.length === 0) {
+        clack.log.error("No eligible branches found.");
+        return err(workspaceError("No eligible branches"));
+    }
+    statusLine("ok", `${eligible.length} eligible branch(es) ready`);
+    return ok({ ...context, eligible });
+};

package/dist/stages/load-template.d.ts

@@ -0,0 +1,3 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+export declare const loadTemplateStage: Stage<RunContext, AppDeps>;

package/dist/stages/load-template.js

@@ -0,0 +1,168 @@
+import { ok, err } from "../core/types.js";
+import { workspaceError } from "../core/errors.js";
+import { parseEnvTemplate, synthesizeTemplate } from "../services/template/env.js";
+import { extractTemplateVariables } from "../services/template/interpolator.js";
+import { sectionHeader, statusLine } from "../utils/ui.js";
+export const loadTemplateStage = async (context, deps) => {
+    if (!context.project || !context.target) {
+        return err(workspaceError("Prerequisites missing for template load"));
+    }
+    sectionHeader("Template");
+    const targetPath = context.target.path;
+    const isEnvTarget = targetPath === ".env" || targetPath.startsWith(".env.");
+    // 1. Try to load saved template from ~/.git-worker state
+    const stateResult = await deps.services.state.loadTemplate(context.project.stateDir, targetPath);
+    if (stateResult.ok && stateResult.value) {
+        const state = stateResult.value;
+        statusLine("ok", "Loaded saved template", `last updated ${state.updatedAt}`);
+        if (state.lastRunSummary) {
+            const s = state.lastRunSummary;
+            statusLine("info", `Last run: ${s.committed} committed, ${s.failed} failed, ${s.skipped} skipped of ${s.total}`);
+        }
+        if (isEnvTarget) {
+            const parseResult = parseEnvTemplate(state.template);
+            if (parseResult.ok) {
+                const activeTemplate = {
+                    path: targetPath,
+                    engine: "env-reconcile",
+                    raw: state.template,
+                    parsedEnv: parseResult.value,
+                };
+                return ok({
+                    ...context,
+                    template: parseResult.value,
+                    activeTemplate,
+                    templates: [activeTemplate],
+                });
+            }
+        }
+        else {
+            const activeTemplate = {
+                path: targetPath,
+                engine: "source-of-truth",
+                raw: state.template,
+                variables: extractTemplateVariables(state.template),
+            };
+            return ok({
+                ...context,
+                template: {
+                    raw: state.template,
+                    assignments: [],
+                    placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
+                },
+                activeTemplate,
+                templates: [activeTemplate],
+            });
+        }
+        statusLine("warn", "Saved template was invalid — synthesizing a new one");
+    }
+    else {
+        statusLine("info", "No saved template — synthesizing first-run draft");
+    }
+    // 2. First run: synthesize from existing branch content
+    if (context.eligible && context.eligible.length > 0 && context.project) {
+        if (isEnvTarget) {
+            const contents = [];
+            for (const branch of context.eligible.slice(0, 5)) {
+                const readResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
+                if (readResult.ok) {
+                    contents.push({ branchName: branch.name, content: readResult.value });
+                }
+            }
+            const synthesized = synthesizeTemplate(contents);
+            const parseResult = parseEnvTemplate(synthesized);
+            if (parseResult.ok) {
+                statusLine("ok", "Synthesized .env template from branch content");
+                const activeTemplate = {
+                    path: targetPath,
+                    engine: "env-reconcile",
+                    raw: synthesized,
+                    parsedEnv: parseResult.value,
+                };
+                return ok({
+                    ...context,
+                    template: parseResult.value,
+                    activeTemplate,
+                    templates: [activeTemplate],
+                });
+            }
+        }
+        else {
+            // Source-of-truth: read sample from first branch that has the file
+            for (const branch of context.eligible) {
+                const readResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
+                if (readResult.ok) {
+                    statusLine("ok", `Loaded draft template from branch '${branch.name}'`);
+                    const activeTemplate = {
+                        path: targetPath,
+                        engine: "source-of-truth",
+                        raw: readResult.value,
+                        variables: extractTemplateVariables(readResult.value),
+                    };
+                    return ok({
+                        ...context,
+                        template: {
+                            raw: readResult.value,
+                            assignments: [],
+                            placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
+                        },
+                        activeTemplate,
+                        templates: [activeTemplate],
+                    });
+                }
+            }
+        }
+    }
+    // 3. Fallback starters for new files
+    let starterContent = "";
+    if (isEnvTarget) {
+        starterContent =
+            "# Git Worker Template\n# Use KEY=value for static values enforced on all branches\n# Use KEY={KEY} to read existing value from each branch\n";
+        const parseResult = parseEnvTemplate(starterContent);
+        if (!parseResult.ok)
+            return parseResult;
+        const activeTemplate = {
+            path: targetPath,
+            engine: "env-reconcile",
+            raw: starterContent,
+            parsedEnv: parseResult.value,
+        };
+        statusLine("info", "Using starter template for .env");
+        return ok({
+            ...context,
+            template: parseResult.value,
+            activeTemplate,
+            templates: [activeTemplate],
+        });
+    }
+    else if (targetPath.endsWith(".json")) {
+        starterContent = `{\n  "name": "\${BRANCH_SLUG}",\n  "version": "1.0.0"\n}\n`;
+    }
+    else if (targetPath.endsWith(".yaml") || targetPath.endsWith(".yml")) {
+        starterContent = `# Git Worker YAML Template\nname: "\${BRANCH_SLUG}"\nservice:\n  port: \${PORT:-8080}\n`;
+    }
+    else if (targetPath.toLowerCase().includes("dockerfile")) {
+        starterContent = `# Git Worker Dockerfile Template\nFROM node:20-alpine\nENV SERVICE=\${BRANCH_SLUG}\nEXPOSE \${PORT:-8080}\n`;
+    }
+    else {
+        starterContent = `# Git Worker Template for ${targetPath}\n`;
+    }
+    statusLine("info", `Using starter template for ${targetPath}`);
+    const activeTemplate = {
+        path: targetPath,
+        engine: "source-of-truth",
+        raw: starterContent,
+        variables: extractTemplateVariables(starterContent),
+        isNewFile: true,
+    };
+    return ok({
+        ...context,
+        template: {
+            raw: starterContent,
+            assignments: [],
+            placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
+        },
+        activeTemplate,
+        templates: [activeTemplate],
+    });
+};

package/dist/stages/plan.d.ts

@@ -0,0 +1,3 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+export declare const planChangesStage: Stage<RunContext, AppDeps>;

package/dist/stages/plan.js

@@ -0,0 +1,270 @@
+import { ok, err } from "../core/types.js";
+import { workspaceError } from "../core/errors.js";
+import { parseEnvFile } from "../services/template/env.js";
+import { transformEnv } from "../services/template/transform.js";
+import { interpolateTemplate } from "../services/template/interpolator.js";
+import { sha256, planHash as computePlanHash } from "../utils/hash.js";
+import { computeDiff } from "../services/review/index.js";
+import { clack, sectionHeader, statusLine, sym } from "../utils/ui.js";
+import chalk from "chalk";
+export const planChangesStage = async (context, deps) => {
+    if ((!context.template && !context.activeTemplate) ||
+        !context.eligible ||
+        !context.target ||
+        !context.project) {
+        return err(workspaceError("Prerequisites missing for planning"));
+    }
+    sectionHeader("Planning Changes");
+    const plans = [];
+    const isCi = context.input.ci ?? false;
+    const targetPath = context.target.path;
+    const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
+    const engine = context.activeTemplate?.engine ?? (isEnv ? "env-reconcile" : "source-of-truth");
+    const templateRaw = context.activeTemplate?.raw ?? context.template?.raw ?? "";
+    for (const branch of context.eligible) {
+        const s = clack.spinner();
+        s.start(`Planning ${branch.name}…`);
+        // ─────────────────────────────────────────────────────────────────
+        // 1. SOURCE-OF-TRUTH ENGINE (for Dockerfile, JSON, YAML, scripts)
+        // ─────────────────────────────────────────────────────────────────
+        if (engine === "source-of-truth") {
+            // A. Read the branch's .env to extract variables
+            const envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
+            const envMap = new Map();
+            if (envRead.ok) {
+                const parsedEnv = parseEnvFile(envRead.value);
+                if (parsedEnv.ok) {
+                    for (const [key, entry] of parsedEnv.value.map) {
+                        envMap.set(key, entry.value);
+                    }
+                }
+            }
+            // B. Read existing target file from branch (if present)
+            const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
+            const isNewFile = !targetRead.ok;
+            const beforeContent = targetRead.ok ? targetRead.value : "";
+            const beforeContentHash = sha256(beforeContent);
+            // C. Interpolate template with branch's .env vars and built-ins
+            const interpolated = interpolateTemplate(templateRaw, envMap, {
+                branchName: branch.name,
+                repoName: context.project.id,
+                commitSha: branch.sha,
+            });
+            if (!interpolated.ok) {
+                s.stop(chalk.red(`${branch.name} — interpolation error`));
+                plans.push({
+                    branch,
+                    baseCommitSha: branch.sha,
+                    path: targetPath,
+                    beforeContent,
+                    beforeContentHash,
+                    afterContent: beforeContent,
+                    afterContentHash: beforeContentHash,
+                    diff: "",
+                    planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                    status: "error",
+                    reason: interpolated.error.message,
+                    addedKeys: [],
+                    updatedKeys: [],
+                    isNewFile,
+                });
+                continue;
+            }
+            const { content: afterContent, missingVars } = interpolated.value;
+            // D. Handle missing variables without fallback
+            if (missingVars.length > 0) {
+                const errorReason = `Missing required variable(s) from .env: ${missingVars.join(", ")}`;
+                s.stop(chalk.red(`${branch.name} — ${errorReason}`));
+                plans.push({
+                    branch,
+                    baseCommitSha: branch.sha,
+                    path: targetPath,
+                    beforeContent,
+                    beforeContentHash,
+                    afterContent: beforeContent,
+                    afterContentHash: beforeContentHash,
+                    diff: "",
+                    planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                    status: "error",
+                    reason: errorReason,
+                    addedKeys: [],
+                    updatedKeys: [],
+                    missingVars,
+                    isNewFile,
+                });
+                continue;
+            }
+            // E. Diff & Plan Hash
+            const afterContentHash = sha256(afterContent);
+            const changed = afterContent !== beforeContent;
+            const diff = computeDiff(beforeContent, afterContent, targetPath);
+            const hash = computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, afterContentHash);
+            if (changed) {
+                s.stop(chalk.green(`${branch.name} — ${isNewFile ? "new file created" : "file updated"}`));
+            }
+            else {
+                s.stop(chalk.gray(`${branch.name} — no changes`));
+            }
+            plans.push({
+                branch,
+                baseCommitSha: branch.sha,
+                path: targetPath,
+                beforeContent,
+                beforeContentHash,
+                afterContent,
+                afterContentHash,
+                diff,
+                planHash: hash,
+                status: changed ? "changed" : "unchanged",
+                addedKeys: isNewFile ? [targetPath] : [],
+                updatedKeys: !isNewFile && changed ? [targetPath] : [],
+                isNewFile,
+            });
+            continue;
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // 2. ENV RECONCILE ENGINE (for .env files)
+        // ─────────────────────────────────────────────────────────────────
+        const readResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
+        const beforeContent = readResult.ok ? readResult.value : "";
+        const beforeContentHash = sha256(beforeContent);
+        // Parse existing file to find which keys exist
+        const existingParse = parseEnvFile(beforeContent);
+        if (!existingParse.ok) {
+            s.stop(chalk.red(`${branch.name} — file parse error`));
+            plans.push({
+                branch,
+                baseCommitSha: branch.sha,
+                path: targetPath,
+                beforeContent,
+                beforeContentHash,
+                afterContent: beforeContent,
+                afterContentHash: beforeContentHash,
+                diff: "",
+                planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                status: "error",
+                reason: existingParse.error.message,
+                addedKeys: [],
+                updatedKeys: [],
+            });
+            continue;
+        }
+        const existingMap = existingParse.value.map;
+        const branchValues = new Map();
+        let hadError = false;
+        let errorReason = "";
+        const envTemplate = context.activeTemplate?.parsedEnv ?? context.template;
+        if (envTemplate) {
+            for (const assignment of envTemplate.assignments) {
+                if (!assignment.isPlaceholder || !assignment.placeholderName)
+                    continue;
+                if (existingMap.has(assignment.key)) {
+                    branchValues.set(assignment.key, existingMap.get(assignment.key).value);
+                }
+                else {
+                    if (isCi) {
+                        hadError = true;
+                        errorReason = `Missing value for '${assignment.key}' in CI mode`;
+                        break;
+                    }
+                    s.stop(`${branch.name} — needs input`);
+                    console.log("");
+                    console.log(chalk.bold(`  ${sym.branch} Branch: ${chalk.cyan(branch.name)}`));
+                    console.log(chalk.yellow(`  Missing key: ${chalk.bold(assignment.key)}`));
+                    const value = await clack.text({
+                        message: `Value for ${chalk.bold(assignment.key)} in ${chalk.cyan(branch.name)}:`,
+                        placeholder: `enter value for ${assignment.key}`,
+                        validate: (v) => {
+                            if (!v || v.trim() === "")
+                                return `Value cannot be empty`;
+                        },
+                    });
+                    if (clack.isCancel(value)) {
+                        hadError = true;
+                        errorReason = "User cancelled value input";
+                        s.stop(chalk.yellow(`${branch.name} — skipped`));
+                        break;
+                    }
+                    branchValues.set(assignment.key, value);
+                    s.start(`Planning ${branch.name}…`);
+                }
+            }
+        }
+        if (hadError) {
+            s.stop(chalk.red(`${branch.name} — ${errorReason}`));
+            plans.push({
+                branch,
+                baseCommitSha: branch.sha,
+                path: targetPath,
+                beforeContent,
+                beforeContentHash,
+                afterContent: beforeContent,
+                afterContentHash: beforeContentHash,
+                diff: "",
+                planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                status: "error",
+                reason: errorReason,
+                addedKeys: [],
+                updatedKeys: [],
+            });
+            continue;
+        }
+        // Transform
+        const transformResult = transformEnv(beforeContent, envTemplate, branchValues);
+        if (!transformResult.ok) {
+            s.stop(chalk.red(`${branch.name} — transform error`));
+            plans.push({
+                branch,
+                baseCommitSha: branch.sha,
+                path: targetPath,
+                beforeContent,
+                beforeContentHash,
+                afterContent: beforeContent,
+                afterContentHash: beforeContentHash,
+                diff: "",
+                planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                status: "error",
+                reason: transformResult.error.message,
+                addedKeys: [],
+                updatedKeys: [],
+            });
+            continue;
+        }
+        const { content: afterContent, changed, addedKeys, updatedKeys } = transformResult.value;
+        const afterContentHash = sha256(afterContent);
+        const diff = computeDiff(beforeContent, afterContent, targetPath);
+        const hash = computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, afterContentHash);
+        if (changed) {
+            const summary = [
+                updatedKeys.length > 0 ? `${updatedKeys.length} updated` : "",
+                addedKeys.length > 0 ? `${addedKeys.length} added` : "",
+            ]
+                .filter(Boolean)
+                .join(", ");
+            s.stop(chalk.green(`${branch.name} — ${summary || "changed"}`));
+        }
+        else {
+            s.stop(chalk.gray(`${branch.name} — no changes`));
+        }
+        plans.push({
+            branch,
+            baseCommitSha: branch.sha,
+            path: targetPath,
+            beforeContent,
+            beforeContentHash,
+            afterContent,
+            afterContentHash,
+            diff,
+            planHash: hash,
+            status: changed ? "changed" : "unchanged",
+            addedKeys,
+            updatedKeys,
+        });
+    }
+    const changed = plans.filter((p) => p.status === "changed").length;
+    const unchanged = plans.filter((p) => p.status === "unchanged").length;
+    const errors = plans.filter((p) => p.status === "error").length;
+    console.log("");
+    statusLine("ok", `Planning complete — ${changed} changed, ${unchanged} unchanged, ${errors} error(s)`);
+    return ok({ ...context, plans });
+};

package/dist/stages/push.d.ts

@@ -0,0 +1,3 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+export declare const pushChangesStage: Stage<RunContext, AppDeps>;

package/dist/stages/push.js

@@ -0,0 +1,99 @@
+import { ok, err } from "../core/types.js";
+import { workspaceError } from "../core/errors.js";
+import { clack, sectionHeader, statusLine } from "../utils/ui.js";
+import chalk from "chalk";
+export const pushChangesStage = async (context, deps) => {
+    if (!context.results || !context.project) {
+        return err(workspaceError("Prerequisites missing for push"));
+    }
+    const pushPolicy = context.input.push || deps.config.git.pushPolicy;
+    const remote = context.input.remote || deps.config.git.remote;
+    const committedBranches = context.results.filter((r) => r.status === "committed");
+    const pushResults = [];
+    // Skipped non-committed branches
+    for (const result of context.results) {
+        if (result.status !== "committed") {
+            pushResults.push({ branch: result.branch, status: "skipped", reason: "Not committed" });
+        }
+    }
+    if (committedBranches.length === 0) {
+        return ok({ ...context, pushResults });
+    }
+    sectionHeader("Push");
+    if (pushPolicy === "never") {
+        for (const r of committedBranches) {
+            pushResults.push({ branch: r.branch, status: "skipped", reason: "Push policy: never" });
+            statusLine("skip", r.branch.name, "push skipped (policy: never)");
+        }
+        return ok({ ...context, pushResults });
+    }
+    if (pushPolicy === "prompt" && context.input.ci) {
+        for (const r of committedBranches) {
+            pushResults.push({
+                branch: r.branch,
+                status: "skipped",
+                reason: "Cannot prompt in CI mode (use --push always to push in CI)",
+            });
+            statusLine("skip", r.branch.name, "push skipped (CI mode without --push always)");
+        }
+        return ok({ ...context, pushResults });
+    }
+    if (pushPolicy === "prompt" && !context.input.ci) {
+        // Ask per branch or batch
+        const batchChoice = await clack.select({
+            message: `Push ${committedBranches.length} committed branch(es) to '${remote}'?`,
+            options: [
+                { value: "all", label: `Push all ${committedBranches.length} branches`, hint: "recommended" },
+                { value: "per-branch", label: "Choose per branch" },
+                { value: "none", label: "Skip push (commit only)" },
+            ],
+        });
+        if (clack.isCancel(batchChoice) || batchChoice === "none") {
+            for (const r of committedBranches) {
+                pushResults.push({ branch: r.branch, status: "skipped", reason: "User declined" });
+            }
+            statusLine("skip", "Push skipped");
+            return ok({ ...context, pushResults });
+        }
+        if (batchChoice === "per-branch") {
+            for (const result of committedBranches) {
+                const confirm = await clack.confirm({
+                    message: `Push ${result.branch.name} → ${remote}?`,
+                    initialValue: true,
+                });
+                if (clack.isCancel(confirm) || !confirm) {
+                    pushResults.push({ branch: result.branch, status: "skipped", reason: "User declined" });
+                    statusLine("skip", result.branch.name, "push skipped");
+                    continue;
+                }
+                const s = clack.spinner();
+                s.start(`Pushing ${result.branch.name} → ${remote}…`);
+                const pushResult = await deps.services.gitOps.push(context.project.managedRepoPath, remote, result.branch.name);
+                if (!pushResult.ok) {
+                    s.stop(chalk.red(`${result.branch.name} — push failed`));
+                    pushResults.push({ branch: result.branch, status: "failed", reason: pushResult.error.message });
+                }
+                else {
+                    s.stop(chalk.green(`${result.branch.name} — pushed`));
+                    pushResults.push({ branch: result.branch, status: "pushed" });
+                }
+            }
+            return ok({ ...context, pushResults });
+        }
+    }
+    // Push all (policy === "always" or batchChoice === "all")
+    for (const result of committedBranches) {
+        const s = clack.spinner();
+        s.start(`Pushing ${result.branch.name} → ${remote}…`);
+        const pushResult = await deps.services.gitOps.push(context.project.managedRepoPath, remote, result.branch.name);
+        if (!pushResult.ok) {
+            s.stop(chalk.red(`${result.branch.name} — push failed`));
+            pushResults.push({ branch: result.branch, status: "failed", reason: pushResult.error.message });
+        }
+        else {
+            s.stop(chalk.green(`${result.branch.name} — pushed`));
+            pushResults.push({ branch: result.branch, status: "pushed" });
+        }
+    }
+    return ok({ ...context, pushResults });
+};

package/dist/stages/report.d.ts

@@ -0,0 +1,3 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+export declare const reportResultsStage: Stage<RunContext, AppDeps>;