@samaksh/git-worker 0.0.0-stage → 0.1.0

package/src/stages/plan.ts

@@ -0,0 +1,362 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps, BranchPlan, 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: Stage<RunContext, AppDeps> = 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: BranchPlan[] = [];
+  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<string, string>();
+      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<string, string>();
+    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: string | undefined) => {
+              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 as string);
+          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/src/stages/push.ts

@@ -0,0 +1,120 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps, PushResult, ok, err } from "../core/types.js";
+import { workspaceError, inputCancelledError } from "../core/errors.js";
+import { clack, sectionHeader, statusLine, sym } from "../utils/ui.js";
+import chalk from "chalk";
+
+export const pushChangesStage: Stage<RunContext, AppDeps> = 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: PushResult[] = [];
+
+  // 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<string>({
+      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/src/stages/report.ts

@@ -0,0 +1,126 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps, ok } from "../core/types.js";
+import { sectionHeader, statusLine, divider, sym, renderBranchTable } from "../utils/ui.js";
+import { saveJson, saveMarkdown, RunReport } from "../services/report/index.js";
+import chalk from "chalk";
+
+export const reportResultsStage: Stage<RunContext, AppDeps> = 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: RunReport = {
+      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);
+};