@samaksh/git-worker 0.0.0-stage → 0.1.0

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

package/dist/stages/report.js

@@ -0,0 +1,103 @@
+import { ok } from "../core/types.js";
+import { sectionHeader, statusLine, divider, renderBranchTable } from "../utils/ui.js";
+import { saveJson, saveMarkdown } from "../services/report/index.js";
+import chalk from "chalk";
+export const reportResultsStage = async (context, deps) => {
+    sectionHeader("Run Report");
+    const results = context.results ?? [];
+    const pushResults = context.pushResults ?? [];
+    // Per-branch status
+    renderBranchTable(results.map((r) => ({
+        name: r.branch.name,
+        status: r.status,
+        detail: r.commitSha
+            ? `commit ${r.commitSha.slice(0, 8)}`
+            : r.reason ?? "",
+    })));
+    // Push results (only non-skipped)
+    const activePushResults = pushResults.filter((p) => p.status !== "skipped");
+    if (activePushResults.length > 0) {
+        console.log("");
+        console.log(chalk.gray("  Push:"));
+        for (const pr of activePushResults) {
+            if (pr.status === "pushed") {
+                statusLine("ok", pr.branch.name, "pushed");
+            }
+            else {
+                statusLine("fail", pr.branch.name, pr.reason ?? "push failed");
+            }
+        }
+    }
+    // Aggregate summary
+    const committed = results.filter((r) => r.status === "committed").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const rejected = results.filter((r) => r.status === "rejected").length;
+    const unchanged = results.filter((r) => r.status === "unchanged").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const pushed = pushResults.filter((p) => p.status === "pushed").length;
+    divider();
+    console.log("");
+    console.log(`  ${chalk.bold("Total:")}  ` +
+        [
+            committed > 0 ? chalk.green(`${committed} committed`) : "",
+            pushed > 0 ? chalk.green(`${pushed} pushed`) : "",
+            failed > 0 ? chalk.red(`${failed} failed`) : "",
+            rejected > 0 ? chalk.yellow(`${rejected} rejected`) : "",
+            unchanged > 0 ? chalk.gray(`${unchanged} unchanged`) : "",
+            skipped > 0 ? chalk.gray(`${skipped} skipped`) : "",
+        ].filter(Boolean).join("  "));
+    console.log("");
+    // Save template state if any commits succeeded
+    const rawTemplate = context.activeTemplate?.raw ?? context.template?.raw;
+    if (committed > 0 && context.project && context.target && rawTemplate) {
+        const summary = {
+            committed,
+            failed,
+            skipped: skipped + rejected,
+            total: results.length,
+        };
+        const saveResult = await deps.services.state.saveTemplate(context.project.stateDir, context.target.path, rawTemplate, summary);
+        if (saveResult.ok) {
+            statusLine("ok", `Template saved for '${context.target.path}' (ready for next run)`);
+        }
+        else {
+            statusLine("warn", "Could not save template state", saveResult.error.message);
+        }
+    }
+    else if (committed === 0 && context.project && context.target && rawTemplate) {
+        // No commits but everything matches — offer to save reviewed template
+        const { clack } = await import("../utils/ui.js");
+        if (!context.input.ci) {
+            const save = await clack.confirm({
+                message: "No changes committed. Save current template for next run?",
+                initialValue: true,
+            });
+            if (!clack.isCancel(save) && save) {
+                await deps.services.state.saveTemplate(context.project.stateDir, context.target.path, rawTemplate);
+                statusLine("ok", `Template saved for '${context.target.path}'`);
+            }
+        }
+    }
+    // Write JSON/Markdown reports if configured
+    if (context.project && (deps.config.report.writeJson || deps.config.report.writeMarkdown)) {
+        const report = {
+            runId: context.runId,
+            targetPath: context.target?.path ?? "",
+            startedAt: new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            plans: context.plans ?? [],
+            results,
+            pushResults,
+        };
+        await saveJson(context.project.reportsDir, report, deps.config).catch(() => { });
+        await saveMarkdown(context.project.reportsDir, report, deps.config).catch(() => { });
+        if (deps.config.report.writeJson) {
+            statusLine("info", `JSON report: ${context.project.reportsDir}/${context.runId}.json`);
+        }
+        if (deps.config.report.writeMarkdown) {
+            statusLine("info", `Markdown report: ${context.project.reportsDir}/${context.runId}.md`);
+        }
+    }
+    console.log("");
+    return ok(context);
+};

package/dist/stages/resolve-project.d.ts

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