@samaksh/git-worker 0.0.0-stage → 0.1.0

package/src/stages/select.ts

@@ -0,0 +1,302 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps, BranchRef, 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";
+
+/**
+ * Matches a branch name against a pattern.
+ * Supports:
+ * - Regex: /uat.*\/, /^release\//, /pattern/i
+ * - Glob: uat/*, *orders, uat*
+ * - Exact name: main, develop
+ * - Trailing slash prefix: uat/
+ * - Substring fallback: orders
+ */
+export function matchesBranchPattern(name: string, pattern: string): boolean {
+  const trimmed = pattern.trim();
+  if (!trimmed) return false;
+
+  // 1. Regex pattern: /regex/ or /regex/flags
+  const regexMatch = trimmed.match(/^\/(.+)\/([a-z]*)$/i);
+  if (regexMatch) {
+    try {
+      return new RegExp(regexMatch[1], regexMatch[2]).test(name);
+    } catch {
+      return false;
+    }
+  }
+
+  // 2. Glob pattern with * or ?
+  if (trimmed.includes("*") || trimmed.includes("?")) {
+    const escaped = trimmed
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+      .replace(/\*/g, ".*")
+      .replace(/\?/g, ".");
+    try {
+      return new RegExp(`^${escaped}$`).test(name);
+    } catch {
+      return false;
+    }
+  }
+
+  // 3. Exact match
+  if (name === trimmed) {
+    return true;
+  }
+
+  // 4. Prefix match if pattern ends with '/'
+  if (trimmed.endsWith("/") && name.startsWith(trimmed)) {
+    return true;
+  }
+
+  // 5. Fallback substring match
+  return name.includes(trimmed);
+}
+
+export const selectTargetsStage: Stage<RunContext, AppDeps> = async (context, deps) => {
+  if (!context.project) {
+    return err(workspaceError("Project not resolved"));
+  }
+
+  sectionHeader("Branch & Target Selection");
+
+  const s = clack.spinner();
+  s.start("Listing branches…");
+
+  const result = await deps.services.git.listBranches(
+    context.project.managedRepoPath,
+    deps.config.git.remote
+  );
+
+  if (!result.ok) {
+    s.stop(chalk.red("Failed to list branches"));
+    return result;
+  }
+
+  s.stop(`Found ${result.value.length} branches`);
+
+  let branches = result.value;
+
+  // De-duplicate by name (prefer remote over local)
+  const seen = new Map<string, BranchRef>();
+  for (const b of branches) {
+    if (!seen.has(b.name) || b.isRemote) {
+      seen.set(b.name, b);
+    }
+  }
+  branches = Array.from(seen.values());
+
+  // Filter by pattern if supplied via CLI
+  if (context.input.branch) {
+    const pattern = context.input.branch;
+    const invert = Boolean(context.input.invertBranch);
+    branches = branches.filter((b) => {
+      const matched = matchesBranchPattern(b.name, pattern);
+      return invert ? !matched : matched;
+    });
+    statusLine(
+      "info",
+      `Pattern '${pattern}'${invert ? " (inverted)" : ""} matched ${branches.length} branch(es)`
+    );
+  }
+
+  // Interactive branch selection (non-CI when no --branch provided)
+  if (!context.input.ci && !context.input.branch) {
+    if (branches.length === 0) {
+      clack.log.warn("No branches found in this repository.");
+      return err(inputCancelledError("No branches available"));
+    }
+
+    const allBranches = branches;
+    let selectedNames = new Set<string>();
+
+    while (true) {
+      const selectedCount = selectedNames.size;
+      const totalCount = allBranches.length;
+
+      type BranchAction = "confirm" | "pattern" | "all" | "invert" | "list";
+
+      const options: { value: BranchAction; label: string; hint?: string }[] = [];
+
+      if (selectedCount > 0) {
+        options.push({
+          value: "confirm",
+          label: `➜ Confirm and proceed with ${selectedCount} branch(es)`,
+          hint: "proceed to target file selection",
+        });
+        options.push({
+          value: "invert",
+          label: `🔄 Invert selection (select the other ${totalCount - selectedCount} branches)`,
+          hint: "flip current selection",
+        });
+        options.push({
+          value: "pattern",
+          label: "🔍 Filter by pattern or regex",
+          hint: "glob (uat/*) or regex (/uat.*/)",
+        });
+        options.push({
+          value: "list",
+          label: "📋 Customize selection from list",
+          hint: "toggle individual checkboxes",
+        });
+        options.push({
+          value: "all",
+          label: `🌟 Select ALL branches (${totalCount} branches)`,
+        });
+      } else {
+        options.push({
+          value: "pattern",
+          label: "🔍 Filter by pattern or regex",
+          hint: "glob (uat/*) or regex (/uat.*/)",
+        });
+        options.push({
+          value: "all",
+          label: `🌟 Select ALL branches (${totalCount} branches)`,
+          hint: "select every branch in repository",
+        });
+        options.push({
+          value: "list",
+          label: "📋 Choose individually from list",
+          hint: "select branches with checkboxes",
+        });
+        options.push({
+          value: "invert",
+          label: `🔄 Invert selection (select all ${totalCount} branches)`,
+        });
+      }
+
+      const previewText =
+        selectedCount > 0
+          ? `${selectedCount} of ${totalCount} selected: ${chalk.cyan(
+              Array.from(selectedNames).slice(0, 3).join(", ") +
+                (selectedCount > 3 ? `, +${selectedCount - 3} more` : "")
+            )}`
+          : `0 of ${totalCount} branches selected`;
+
+      const choice = await clack.select<BranchAction>({
+        message: `Branch selection (${previewText}):`,
+        options,
+      });
+
+      if (clack.isCancel(choice)) {
+        return err(inputCancelledError("Branch selection cancelled"));
+      }
+
+      if (choice === "confirm") {
+        if (selectedNames.size === 0) {
+          clack.log.warn("Please select at least one branch before proceeding.");
+          continue;
+        }
+        break;
+      }
+
+      if (choice === "all") {
+        selectedNames = new Set(allBranches.map((b) => b.name));
+        statusLine("ok", `Selected all ${totalCount} branch(es)`);
+        continue;
+      }
+
+      if (choice === "invert") {
+        const inverted = allBranches.filter((b) => !selectedNames.has(b.name));
+        selectedNames = new Set(inverted.map((b) => b.name));
+        statusLine(
+          "ok",
+          `Inverted selection: ${selectedNames.size} of ${totalCount} branch(es) selected`
+        );
+        continue;
+      }
+
+      if (choice === "pattern") {
+        const patternInput = await clack.text({
+          message: "Enter glob pattern (e.g. uat/*) or regex (e.g. /uat.*/):",
+          placeholder: "/uat.*/ or uat/*",
+          validate: (v) => {
+            if (!v || v.trim().length === 0) {
+              return "Please enter a pattern or regex";
+            }
+          },
+        });
+
+        if (clack.isCancel(patternInput)) {
+          continue;
+        }
+
+        const pattern = (patternInput as string).trim();
+        const matched = allBranches.filter((b) => matchesBranchPattern(b.name, pattern));
+
+        if (matched.length === 0) {
+          clack.log.warn(`Pattern '${pattern}' matched 0 of ${totalCount} branches.`);
+          continue;
+        }
+
+        selectedNames = new Set(matched.map((b) => b.name));
+        statusLine(
+          "ok",
+          `Pattern '${pattern}' matched ${matched.length} branch(es):`
+        );
+        for (const b of matched.slice(0, 5)) {
+          console.log(chalk.gray(`    • ${b.name}`));
+        }
+        if (matched.length > 5) {
+          console.log(chalk.gray(`    ... and ${matched.length - 5} more`));
+        }
+        continue;
+      }
+
+      if (choice === "list") {
+        const picked = await clack.multiselect<string>({
+          message: "Select branches to process (Space to toggle, Enter to confirm):",
+          options: allBranches.map((b) => ({
+            value: b.name,
+            label: `${sym.branch} ${b.name}`,
+            hint: b.isRemote
+              ? `remote/${b.remote}  ${b.sha.slice(0, 8)}`
+              : `local  ${b.sha.slice(0, 8)}`,
+          })),
+          initialValues: Array.from(selectedNames),
+          required: false,
+        });
+
+        if (clack.isCancel(picked)) {
+          continue;
+        }
+
+        selectedNames = new Set(picked as string[]);
+        statusLine("ok", `Selection updated: ${selectedNames.size} branch(es) selected`);
+        continue;
+      }
+    }
+
+    branches = allBranches.filter((b) => selectedNames.has(b.name));
+  }
+
+  if (branches.length === 0) {
+    clack.log.warn("No branches selected.");
+    return err(inputCancelledError("No branches selected"));
+  }
+
+  // Target file selection
+  let targetPath = context.input.file;
+  if (!targetPath && !context.input.ci) {
+    const fileInput = await clack.text({
+      message: "Target file path:",
+      placeholder: ".env",
+      defaultValue: ".env",
+    });
+    if (clack.isCancel(fileInput)) {
+      return err(inputCancelledError("File selection cancelled"));
+    }
+    targetPath = (fileInput as string) || ".env";
+  } else if (!targetPath) {
+    targetPath = ".env";
+  }
+
+  statusLine("ok", `Selected ${branches.length} branch(es) → ${targetPath}`);
+
+  return ok({
+    ...context,
+    selectedBranches: branches,
+    target: { path: targetPath },
+  });
+};

package/src/stages/sync.ts

@@ -0,0 +1,63 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps, ok, err } from "../core/types.js";
+import { workspaceError } from "../core/errors.js";
+import { clack, statusLine } from "../utils/ui.js";
+import chalk from "chalk";
+
+export const syncRepositoryStage: Stage<RunContext, AppDeps> = async (context, deps) => {
+  if (!context.project) {
+    return err(workspaceError("Project not resolved"));
+  }
+
+  const s = clack.spinner();
+  s.start(
+    context.project.isCached
+      ? "Syncing cached repository with remote…"
+      : "Cloning repository into managed workspace…"
+  );
+
+  const cloneResult = await deps.services.workspace.ensureManagedClone(context.project);
+  if (!cloneResult.ok) {
+    s.stop(chalk.red("Clone failed"));
+    return cloneResult;
+  }
+
+  if (cloneResult.value.isCached) {
+    s.message("Using cached repository — fetching latest branches…");
+  }
+
+  // Acquire workspace lock
+  const lockResult = await deps.services.workspace.acquireLock(
+    context.project,
+    deps.config.workspace.lockTimeoutMs
+  );
+  if (!lockResult.ok) {
+    s.stop(chalk.red("Could not acquire workspace lock"));
+    return lockResult;
+  }
+
+  // Register lock release on process exit
+  const releaseLock = lockResult.value;
+  process.on("exit", () => { releaseLock(); });
+  process.on("SIGINT", () => { releaseLock(); process.exit(130); });
+  process.on("SIGTERM", () => { releaseLock(); process.exit(143); });
+
+  // Fetch latest from remote
+  if (context.project.remoteUrl) {
+    const fetchResult = await deps.services.git.fetch(
+      context.project.managedRepoPath,
+      deps.config.git.remote,
+      deps.config.git.fetchPrune
+    );
+    if (!fetchResult.ok) {
+      s.stop(chalk.yellow("Fetch warning — continuing with cached refs"));
+      statusLine("warn", fetchResult.error.message);
+    } else {
+      s.stop(chalk.green("Repository synced"));
+    }
+  } else {
+    s.stop(chalk.green("Checkout ready (no remote to fetch)"));
+  }
+
+  return ok(context);
+};

package/src/utils/hash.ts

@@ -0,0 +1,15 @@
+import { createHash } from "crypto";
+
+export function sha256(content: string): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+export function planHash(
+  branchName: string,
+  baseCommitSha: string,
+  targetPath: string,
+  beforeContentHash: string,
+  afterContentHash: string
+): string {
+  return sha256(`${branchName}|${baseCommitSha}|${targetPath}|${beforeContentHash}|${afterContentHash}`);
+}

package/src/utils/ui.ts

@@ -0,0 +1,137 @@
+/**
+ * Terminal UI utilities using chalk for color and @clack/prompts for interactive prompts.
+ * All UX-facing output goes through this module.
+ */
+import chalk from "chalk";
+import * as clack from "@clack/prompts";
+
+export { clack };
+
+// ── Symbols ────────────────────────────────────────────────────────────────
+
+export const sym = {
+  check: chalk.green("✓"),
+  cross: chalk.red("✗"),
+  skip: chalk.gray("–"),
+  dot: chalk.gray("•"),
+  warn: chalk.yellow("⚠"),
+  arrow: chalk.cyan("→"),
+  branch: chalk.cyan("⎇"),
+};
+
+// ── Box / header ───────────────────────────────────────────────────────────
+
+export function banner(): void {
+  console.log("");
+  console.log(chalk.bold.cyan("  ◆ git-worker"));
+  console.log(chalk.gray("  Safe multi-branch file sync"));
+  console.log("");
+}
+
+export function sectionHeader(title: string): void {
+  console.log("");
+  console.log(chalk.bold(`  ${title}`));
+  console.log(chalk.gray("  " + "─".repeat(Math.max(title.length, 40))));
+}
+
+export function divider(): void {
+  console.log(chalk.gray("  " + "─".repeat(60)));
+}
+
+// ── Status lines ──────────────────────────────────────────────────────────
+
+export function statusLine(
+  status: "ok" | "fail" | "warn" | "skip" | "info",
+  message: string,
+  detail?: string
+): void {
+  const icon =
+    status === "ok" ? sym.check :
+    status === "fail" ? sym.cross :
+    status === "warn" ? sym.warn :
+    status === "skip" ? sym.skip :
+    sym.dot;
+
+  const color =
+    status === "ok" ? chalk.green :
+    status === "fail" ? chalk.red :
+    status === "warn" ? chalk.yellow :
+    status === "skip" ? chalk.gray :
+    chalk.white;
+
+  console.log(`  ${icon} ${color(message)}`);
+  if (detail) console.log(chalk.gray(`    ${detail}`));
+}
+
+// ── Diff rendering ────────────────────────────────────────────────────────
+
+export function renderDiff(diff: string, redact = false): void {
+  if (!diff) {
+    console.log(chalk.gray("    (no changes)"));
+    return;
+  }
+
+  const lines = diff.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      console.log(chalk.gray(`    ${line}`));
+    } else if (line.startsWith("@@")) {
+      console.log(chalk.cyan(`    ${line}`));
+    } else if (line.startsWith("+")) {
+      const display = redact ? redactLine(line) : line;
+      console.log(chalk.green(`    ${display}`));
+    } else if (line.startsWith("-")) {
+      const display = redact ? redactLine(line) : line;
+      console.log(chalk.red(`    ${display}`));
+    } else {
+      console.log(chalk.gray(`    ${line}`));
+    }
+  }
+}
+
+function redactLine(line: string): string {
+  // Redact value portion: +KEY=value → +KEY=[REDACTED]
+  return line.replace(/^([+-][A-Za-z_][A-Za-z0-9_]*)=.+$/, "$1=[REDACTED]");
+}
+
+// ── Branch status table ───────────────────────────────────────────────────
+
+export function renderBranchTable(
+  rows: Array<{
+    name: string;
+    status: string;
+    detail?: string;
+  }>
+): void {
+  const maxName = Math.max(...rows.map((r) => r.name.length), 10);
+  for (const row of rows) {
+    const name = row.name.padEnd(maxName);
+    let statusStr: string;
+    switch (row.status) {
+      case "committed":
+        statusStr = chalk.green("committed");
+        break;
+      case "failed":
+        statusStr = chalk.red("failed   ");
+        break;
+      case "rejected":
+        statusStr = chalk.yellow("rejected ");
+        break;
+      case "unchanged":
+        statusStr = chalk.gray("unchanged");
+        break;
+      case "skipped":
+        statusStr = chalk.gray("skipped  ");
+        break;
+      case "changed":
+        statusStr = chalk.cyan("changed  ");
+        break;
+      case "error":
+        statusStr = chalk.red("error    ");
+        break;
+      default:
+        statusStr = chalk.gray(row.status.padEnd(9));
+    }
+    console.log(`  ${sym.branch} ${chalk.white(name)}  ${statusStr}  ${chalk.gray(row.detail ?? "")}`);
+  }
+}

package/src/utils/which.ts

@@ -0,0 +1,18 @@
+import { existsSync } from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Find the full path of an executable on PATH.
+ * Returns null if not found.
+ */
+export async function which(name: string): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(`which ${name}`);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "types": ["node"],
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}