pan-stack-cli 0.1.4 → 0.2.1

package/lib/git/git-sync-main.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+/*
+ * Sync origin/main (or --ref) into the current branch for selected PAN Stack repos.
+ *
+ * Fetches first, then merge (default) or rebase (--rebase). Interactive repo picker
+ * when TTY; pass repo name or "all" as first positional argument.
+ */
+
+const {
+  looksLikeManifest,
+  loadManifestRepos,
+  printCommonOptions,
+} = require("./helpers/cli");
+const colors = require("./helpers/colors");
+const { resolveTargets } = require("./helpers/repo-select");
+const { t } = require("../i18n");
+const {
+  ensureRepoExists,
+  runGit,
+  runGitCapture,
+  getCurrentBranch,
+  refExists,
+  listConflictedFiles,
+  isMergeOrRebaseInProgress,
+  countDirtyFiles,
+} = require("./helpers/git");
+
+const ICON = {
+  ok: "✅",
+  warn: "⚠️",
+  conflict: "⛔",
+  skip: "⏭️",
+  info: "ℹ️",
+};
+
+function printHelp() {
+  console.log(`usage: pan sync-main [repo|all] [options]   (alias: pan sm)
+
+Fetch remote main (or --ref) and merge into the current branch for workspace and/or child repos.
+
+positional:
+  repo|all           Repo name from .project.yaml, or "all". Interactive picker if omitted (TTY).
+
+${printCommonOptions()}
+  --ref REF            Remote-tracking ref to merge (default: origin/main)
+  --rebase             Use git rebase instead of merge
+  --no-workspace       Only manifest child repos (skip workspace stack root)`);
+}
+
+function parseSyncMainArgs(argv) {
+  const args = {
+    help: false,
+    manifest: "",
+    baseDir: ".",
+    dryRun: false,
+    ref: "origin/main",
+    rebase: false,
+    noWorkspace: false,
+    selection: "",
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      args.help = true;
+    } else if (arg === "--base-dir") {
+      args.baseDir = argv[++index] || ".";
+    } else if (arg === "--dry-run") {
+      args.dryRun = true;
+    } else if (arg === "--ref") {
+      args.ref = argv[++index] || "origin/main";
+    } else if (arg === "--rebase") {
+      args.rebase = true;
+    } else if (arg === "--no-workspace") {
+      args.noWorkspace = true;
+    } else if (!arg.startsWith("-")) {
+      if (looksLikeManifest(arg) && !args.manifest) {
+        args.manifest = arg;
+      } else if (!args.selection) {
+        args.selection = arg;
+      } else {
+        throw new Error(`Unexpected argument: ${arg}`);
+      }
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  return args;
+}
+
+function printEarlyConflict({ name, branch, ref, files, mode }) {
+  const headline = colors.bold(
+    colors.red(`${ICON.conflict} [conflict] ${name} (${branch})`)
+  );
+  const detail = colors.yellow(
+    t("SYNCMAIN_CONFLICT_SHORT__MODE_REF_N", { mode, ref, n: files.length })
+  );
+  console.log(`${headline} — ${detail}`);
+  for (const file of files.slice(0, 8)) {
+    console.log(colors.dim(`    • ${file}`));
+  }
+  if (files.length > 8) {
+    console.log(
+      colors.dim(`    ${t("SYNCMAIN_MORE_FILES__N", { n: files.length - 8 })}`)
+    );
+  }
+}
+
+function syncMainRepo({
+  name,
+  destination,
+  dryRun,
+  ref,
+  rebase,
+}) {
+  const result = {
+    name,
+    destination,
+    branch: "",
+    status: "skipped",
+    message: "",
+    conflictFiles: [],
+    mode: rebase ? "rebase" : "merge",
+  };
+
+  if (!ensureRepoExists({ name, destination })) {
+    result.message = t("SYNCMAIN_MSG_NOT_CLONED");
+    return result;
+  }
+
+  const branch = getCurrentBranch(destination);
+  result.branch = branch || t("SYNCMAIN_DETACHED_LABEL");
+  if (!branch) {
+    result.message = t("SYNCMAIN_MSG_DETACHED");
+    console.log(`${ICON.skip} [skip] ${name}: ${result.message}`);
+    return result;
+  }
+
+  const inProgress = isMergeOrRebaseInProgress(destination);
+  if (inProgress) {
+    const files = listConflictedFiles(destination);
+    result.status = "conflict";
+    result.conflictFiles = files;
+    result.message = t("SYNCMAIN_MSG_IN_PROGRESS__MODE", { mode: inProgress });
+    printEarlyConflict({ name, branch, ref, files, mode: inProgress });
+    return result;
+  }
+
+  const dirtyCount = countDirtyFiles(destination);
+  if (dirtyCount > 0) {
+    console.log(
+      `${ICON.warn} ${colors.yellow(t("SYNCMAIN_MSG_DIRTY__NAME_N", { name, n: dirtyCount }))}`
+    );
+  }
+
+  if (dryRun) {
+    console.log(
+      `[dry-run] (in ${destination}) git fetch origin && git ${rebase ? "rebase" : "merge"} ${ref}`
+    );
+    result.status = "dry-run";
+    result.message = "dry-run";
+    return result;
+  }
+
+  console.log(`[fetch] ${name}: ${destination}`);
+  const fetch = runGitCapture(["fetch", "origin"], { cwd: destination });
+  if (fetch.status !== 0) {
+    result.status = "error";
+    result.message = fetch.stderr || t("SYNCMAIN_MSG_FETCH_FAILED");
+    console.log(`${ICON.warn} ${colors.yellow(`[warn] ${name}: ${result.message}`)}`);
+    return result;
+  }
+
+  if (!refExists(destination, ref)) {
+    result.status = "error";
+    result.message = t("SYNCMAIN_MSG_REF_MISSING__REF", { ref });
+    console.log(`${ICON.warn} ${colors.yellow(`[warn] ${name}: ${result.message}`)}`);
+    return result;
+  }
+
+  const gitArgs = rebase ? ["rebase", ref] : ["merge", "--no-edit", ref];
+  console.log(`[${result.mode}] ${name} (${branch}) ← ${ref}`);
+  const action = runGit(gitArgs, {
+    cwd: destination,
+    dryRun: false,
+    action: result.mode,
+    name,
+  });
+
+  const conflictFiles = listConflictedFiles(destination);
+  if (conflictFiles.length > 0 || action !== 0) {
+    result.status = "conflict";
+    result.conflictFiles =
+      conflictFiles.length > 0 ? conflictFiles : [t("SYNCMAIN_MSG_SEE_STATUS")];
+    result.message = t("SYNCMAIN_MSG_CONFLICT__MODE", { mode: result.mode });
+    printEarlyConflict({
+      name,
+      branch,
+      ref,
+      files: result.conflictFiles,
+      mode: result.mode,
+    });
+    return result;
+  }
+
+  result.status = "ok";
+  result.message = t("SYNCMAIN_MSG_UPDATED");
+  console.log(
+    `${ICON.ok} ${colors.green(t("SYNCMAIN_MSG_SYNCED__NAME_BRANCH_REF", { name, branch, ref }))}`
+  );
+  return result;
+}
+
+function printSummary(results, { ref, rebase }) {
+  const ok = results.filter((item) => item.status === "ok");
+  const conflicts = results.filter((item) => item.status === "conflict");
+  const errors = results.filter((item) => item.status === "error");
+  const skipped = results.filter(
+    (item) => item.status === "skipped" || item.status === "dry-run"
+  );
+
+  console.log("");
+  console.log(colors.bold(t("SYNCMAIN_HEADER")));
+  console.log(
+    `${ICON.info} ${t("SYNCMAIN_INFO__REF_MODE_REPOS", {
+      ref, mode: rebase ? "rebase" : "merge", repos: results.length,
+    })}`
+  );
+  console.log(
+    t("SYNCMAIN_COUNTS__OK_CONFLICT_ERR_SKIP", {
+      ok: ok.length, conflict: conflicts.length, err: errors.length, skip: skipped.length,
+    })
+  );
+
+  if (conflicts.length > 0) {
+    console.log("");
+    console.log(
+      colors.bold(colors.red(`${ICON.conflict} ${t("SYNCMAIN_CONFLICT_HEADER")}`))
+    );
+    for (const item of conflicts) {
+      console.log(colors.yellow(`\n  ${item.name} (${item.branch})`));
+      console.log(colors.dim(`  ${item.destination}`));
+      for (const file of item.conflictFiles) {
+        console.log(`    • ${file}`);
+      }
+      const hint = item.mode === "rebase"
+        ? t("SYNCMAIN_HINT_REBASE")
+        : t("SYNCMAIN_HINT_MERGE");
+      console.log(colors.dim(`  → ${hint}`));
+    }
+  }
+
+  if (errors.length > 0) {
+    console.log("");
+    console.log(colors.bold(colors.yellow(`${ICON.warn} ${t("SYNCMAIN_ERRORS_HEADER")}`)));
+    for (const item of errors) {
+      console.log(`  • ${item.name}: ${item.message}`);
+    }
+  }
+
+  if (conflicts.length > 0) {
+    console.log("");
+    console.log(
+      colors.bold(colors.red(`${ICON.conflict} ${t("SYNCMAIN_END_CONFLICT")}`))
+    );
+  } else if (errors.length > 0) {
+    console.log("");
+    console.log(
+      colors.bold(colors.yellow(`${ICON.warn} ${t("SYNCMAIN_END_ERROR")}`))
+    );
+  } else if (ok.length > 0) {
+    console.log("");
+    console.log(
+      colors.green(`${ICON.ok} ${t("SYNCMAIN_END_ALL_SYNCED__REF", { ref })}`)
+    );
+  }
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const args = parseSyncMainArgs(argv);
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const { repos, workspaceRoot } = loadManifestRepos({
+    manifestPath: args.manifest,
+    baseDir: args.baseDir,
+  });
+
+  const targets = await resolveTargets({
+    repos,
+    workspaceRoot,
+    includeWorkspace: !args.noWorkspace,
+    selection: args.selection,
+  });
+
+  console.log(
+    `${ICON.info} ${t("SYNCMAIN_INTRO__COUNT_MODE_REF", {
+      count: targets.length,
+      mode: args.rebase ? "rebase" : "merge",
+      ref: args.ref,
+    })}`
+  );
+
+  const results = [];
+  for (const target of targets) {
+    results.push(
+      syncMainRepo({
+        name: target.name,
+        destination: target.destination,
+        dryRun: args.dryRun,
+        ref: args.ref,
+        rebase: args.rebase,
+      })
+    );
+    console.log("");
+  }
+
+  printSummary(results, { ref: args.ref, rebase: args.rebase });
+
+  const hasConflict = results.some((item) => item.status === "conflict");
+  const hasError = results.some((item) => item.status === "error");
+  if (hasConflict || hasError) {
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/lib/git/helpers/bulk-report.js

@@ -0,0 +1,202 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { spawnOptions } = require("../../platform");
+const colors = require("./colors");
+const { runGitCapture, getCurrentBranch, listConflictedFiles } = require("./git");
+const { t } = require("../../i18n");
+
+const ICON = { ok: "✅", fail: "❌", warn: "⚠️", skip: "⏭️", info: "ℹ️", up: "↑", down: "↓" };
+
+// ───────── shared helpers ─────────
+
+/** Chạy git im lặng, capture stdout/stderr; trả { status, stdout, stderr }. */
+function runGitSilent(gitArgs, cwd) {
+  const result = spawnSync("git", gitArgs, spawnOptions({ cwd, encoding: "utf8" }));
+  return {
+    status: result.status ?? 1,
+    stdout: (result.stdout || "").trim(),
+    stderr: (result.stderr || "").trim(),
+  };
+}
+
+/** ahead/behind so với upstream. Trả null nếu không có upstream. */
+function aheadBehind(cwd) {
+  const upstream = runGitCapture(["rev-parse", "--abbrev-ref", "@{u}"], { cwd });
+  if (upstream.status !== 0 || !upstream.stdout) return null;
+  const rl = runGitCapture(["rev-list", "--left-right", "--count", "HEAD...@{u}"], { cwd });
+  if (rl.status !== 0) return null;
+  const [ahead, behind] = rl.stdout.split(/\s+/).map((n) => parseInt(n, 10) || 0);
+  return { ahead, behind, upstream: upstream.stdout };
+}
+
+/**
+ * Tổng line change của các commit sắp push (@{u}..HEAD).
+ * Cộng theo từng commit (`git log --numstat`), không dùng net-diff.
+ * Trả { insertions, deletions, filesChanged } — filesChanged = số path unique.
+ */
+function aheadLineStats(cwd, { range } = {}) {
+  const empty = { insertions: 0, deletions: 0, filesChanged: 0 };
+  let revRange = range;
+  if (!revRange) {
+    const ab = aheadBehind(cwd);
+    if (!ab || ab.ahead === 0) return empty;
+    revRange = "@{u}..HEAD";
+  }
+  const res = runGitCapture(
+    ["log", "--numstat", "--pretty=tformat:", "--no-merges", revRange],
+    { cwd }
+  );
+  if (res.status !== 0) return empty;
+  let insertions = 0;
+  let deletions = 0;
+  const files = new Set();
+  for (const line of (res.stdout || "").split(/\r?\n/)) {
+    if (!line) continue;
+    // numstat: "<add>\t<del>\t<path>" — binary: "-\t-\t<path>"
+    const parts = line.split("\t");
+    if (parts.length < 3) continue;
+    const add = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+    const del = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+    insertions += add;
+    deletions += del;
+    files.add(parts.slice(2).join("\t"));
+  }
+  return { insertions, deletions, filesChanged: files.size };
+}
+
+// ───────── output parsers ─────────
+
+/** Parse `git pull` output. */
+function parsePullOutput(stdout, stderr) {
+  const text = `${stdout}\n${stderr}`;
+  const out = { mode: "unknown", filesChanged: 0, insertions: 0, deletions: 0, conflict: false, upToDate: false };
+  if (/Already up to date|Already up-to-date/i.test(text)) out.upToDate = true;
+  if (/Fast-forward/i.test(text)) out.mode = "fast-forward";
+  else if (/Merge made by/i.test(text)) out.mode = "merge";
+  else if (/Successfully rebased/i.test(text)) out.mode = "rebase";
+  else if (/CONFLICT/i.test(text)) { out.mode = "conflict"; out.conflict = true; }
+  // shortstat line: " 12 files changed, 234 insertions(+), 56 deletions(-)"
+  const stat = text.match(/(\d+)\s+files?\s+changed(?:,\s*(\d+)\s+insertions?\(\+\))?(?:,\s*(\d+)\s+deletions?\(-\))?/);
+  if (stat) {
+    out.filesChanged = parseInt(stat[1], 10);
+    out.insertions = parseInt(stat[2] || "0", 10);
+    out.deletions = parseInt(stat[3] || "0", 10);
+  }
+  return out;
+}
+
+/** Parse `git push` output. GitLab/GitHub in gợi ý URL MR/PR ở stderr. */
+function parsePushOutput(stdout, stderr) {
+  const text = `${stdout}\n${stderr}`;
+  const out = { pushed: false, upToDate: false, rejected: false, mrLink: "", refs: [] };
+  if (/Everything up-to-date|up to date/i.test(text)) out.upToDate = true;
+  if (/\[rejected\]|! \[remote rejected\]|failed to push some refs/i.test(text)) out.rejected = true;
+  // URL merge_requests hoặc pull/new
+  const url =
+    text.match(/https?:\/\/\S*merge_requests\/new\S*/) ||
+    text.match(/https?:\/\/\S*\/merge_requests\/\d+/) ||
+    text.match(/https?:\/\/\S*\/-\/merge_requests\S*/) ||
+    text.match(/https?:\/\/\S*\/pull\/new\/\S+/) ||
+    text.match(/https?:\/\/\S*\/pull\/\d+/);
+  if (url) out.mrLink = url[0].replace(/[.,)]+$/, "");
+  // refs pushed: "abcdef..123456  main -> main"
+  const refRe = /([0-9a-f]{7,}\.\.[0-9a-f]{7,})\s+(\S+)\s+->\s+(\S+)/g;
+  let m;
+  while ((m = refRe.exec(text)) !== null) {
+    out.refs.push({ range: m[1], local: m[2], remote: m[3] });
+    out.pushed = true;
+  }
+  // "* [new branch]"
+  if (/\*\s+\[new branch\]/.test(text)) out.pushed = true;
+  return out;
+}
+
+/** Parse `git fetch --all` output — số dòng update ref. */
+function parseFetchOutput(stdout, stderr) {
+  const text = `${stdout}\n${stderr}`;
+  const out = { newBranches: 0, updatedBranches: 0, newTags: 0, prunedRefs: 0 };
+  out.newBranches = (text.match(/\*\s+\[new branch\]/g) || []).length;
+  out.updatedBranches = (text.match(/^\s*[0-9a-f]{6,}\.\.[0-9a-f]{6,}\s+/gm) || []).length;
+  out.newTags = (text.match(/\*\s+\[new tag\]/g) || []).length;
+  out.prunedRefs = (text.match(/\[deleted\]/g) || []).length;
+  return out;
+}
+
+// ───────── table renderer ─────────
+
+/**
+ * @param {Array<{key:string,label:string,align?:'l'|'r'}>} columns
+ * @param {Array<Object>} rows
+ */
+function renderTable(columns, rows) {
+  // strip ANSI để đo width thật
+  const strip = (s) => String(s ?? "").replace(/\x1b\[[0-9;]*m/g, "");
+  const visLen = (s) => strip(s).length;
+  const widths = columns.map((c) => Math.max(c.label.length, ...rows.map((r) => visLen(r[c.key]))));
+
+  const pad = (s, w, align) => {
+    const len = visLen(s);
+    const spaces = " ".repeat(Math.max(0, w - len));
+    return align === "r" ? spaces + s : s + spaces;
+  };
+
+  const header = columns.map((c, i) => colors.bold(pad(c.label, widths[i], c.align))).join("  ");
+  const sep = columns.map((_, i) => colors.dim("─".repeat(widths[i]))).join("  ");
+  const body = rows.map((r) =>
+    columns.map((c, i) => pad(String(r[c.key] ?? ""), widths[i], c.align)).join("  ")
+  );
+  return [header, sep, ...body].join("\n");
+}
+
+function statusBadge(kind, text) {
+  if (kind === "ok") return colors.green(`${ICON.ok} ${text}`);
+  if (kind === "warn") return colors.yellow(`${ICON.warn} ${text}`);
+  if (kind === "fail") return colors.red(`${ICON.fail} ${text}`);
+  if (kind === "skip") return colors.dim(`${ICON.skip} ${text}`);
+  return text;
+}
+
+function printSummary({ title, rows, columns, footerLines = [] }) {
+  console.log("");
+  console.log(colors.bold(`─── ${title} ───`));
+  if (rows.length === 0) {
+    console.log(colors.dim("(no data)"));
+    return;
+  }
+  console.log(renderTable(columns, rows));
+  for (const line of footerLines) console.log(line);
+}
+
+/** Helper: cột bảng có label theo i18n. */
+function bulkColumns(specs) {
+  return specs.map((s) => ({ key: s.key, label: t(s.labelKey), align: s.align }));
+}
+
+/** Dịch mode pull (fast-forward/merge/rebase/conflict) qua i18n. */
+function pullModeLabel(mode) {
+  switch (mode) {
+    case "fast-forward": return t("BULK_MODE_FAST_FORWARD");
+    case "merge": return t("BULK_MODE_MERGE");
+    case "rebase": return t("BULK_MODE_REBASE");
+    case "conflict": return t("BULK_STATUS_CONFLICT");
+    default: return mode;
+  }
+}
+
+module.exports = {
+  ICON,
+  runGitSilent,
+  aheadBehind,
+  aheadLineStats,
+  parsePullOutput,
+  parsePushOutput,
+  parseFetchOutput,
+  renderTable,
+  statusBadge,
+  printSummary,
+  bulkColumns,
+  pullModeLabel,
+  listConflictedFiles,
+  getCurrentBranch,
+};

package/lib/git/helpers/cli.js

@@ -1,7 +1,8 @@
 const path = require("path");
 const fs = require("fs");
-const { findNearestProjectManifest } = require("../../discover");
-const { parseManifest, manifestRepos, validateRepo } = require("./manifest");
+const { findNearestProjectManifest, discoverGitRepos } = require("../../discover");
+const { parseManifestWithLocal, manifestRepos, validateRepo } = require("./manifest");
+const { t } = require("../../i18n");
 
 function parseCommonArgs(argv, extraFlags = {}) {
   const args = {
@@ -96,12 +97,46 @@ function resolveProjectWorkspace({
   };
 }
 
-function loadManifestRepos({ manifestPath, baseDir, startDir = process.cwd() }) {
-  const workspace = resolveProjectWorkspace({ manifestPath, baseDir, startDir });
+/**
+ * Fallback khi không có `.project.yaml`: coi `startDir` (nơi gõ lệnh) là gốc dự
+ * án, quét git repo con bên trong (giống `pan stats`) — dùng cho các lệnh git
+ * thuần (pull/push/fetch/checkout/sync-main/mr/grv/gst), KHÔNG áp dụng cho
+ * `clone` (cần url khai báo trong manifest, không tự suy ra được).
+ */
+function fallbackReposFromScan(startDir) {
+  const found = discoverGitRepos(startDir);
+  if (!found.length) {
+    throw new Error(
+      t("MANIFEST_NOT_FOUND_NO_GIT_FALLBACK__DIR", { dir: startDir })
+    );
+  }
+  console.log(t("MANIFEST_NOT_FOUND_FALLBACK_SCAN__DIR", { dir: startDir }));
+  return found.map((repo) => ({
+    name: repo.name,
+    url: null,
+    repoPath: path.relative(startDir, repo.dir) || ".",
+    destination: repo.dir,
+  }));
+}
+
+function loadManifestRepos({ manifestPath, baseDir, startDir = process.cwd(), allowFallback = true }) {
+  let workspace;
+  try {
+    workspace = resolveProjectWorkspace({ manifestPath, baseDir, startDir });
+  } catch (error) {
+    if (!allowFallback) throw error;
+    return {
+      repos: fallbackReposFromScan(startDir),
+      manifestPath: "",
+      baseDir: startDir,
+      workspaceRoot: startDir,
+    };
+  }
+
   const { manifestPath: resolvedManifest, baseDir: resolvedBaseDir, workspaceRoot } =
     workspace;
 
-  const data = parseManifest(resolvedManifest);
+  const data = parseManifestWithLocal(resolvedManifest);
   const repos = manifestRepos(data);
   if (repos.length === 0) {
     throw new Error("No repositories found in manifest.");
@@ -146,6 +181,7 @@ options:
 
 module.exports = {
   parseCommonArgs,
+  looksLikeManifest,
   resolveProjectWorkspace,
   loadManifestRepos,
   printCommonOptions,

package/lib/git/helpers/colors.js

@@ -0,0 +1,19 @@
+const supportsColor =
+  Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && process.env.FORCE_COLOR !== "0";
+
+function wrap(code, text) {
+  if (!supportsColor || text == null) {
+    return String(text ?? "");
+  }
+  return `\u001b[${code}m${text}\u001b[0m`;
+}
+
+module.exports = {
+  supportsColor,
+  bold: (text) => wrap("1", text),
+  red: (text) => wrap("31", text),
+  green: (text) => wrap("32", text),
+  yellow: (text) => wrap("33", text),
+  cyan: (text) => wrap("36", text),
+  dim: (text) => wrap("2", text),
+};

package/lib/git/helpers/git.js

@@ -53,9 +53,83 @@ function runGitStatus(directory, gitArgs = []) {
   return result.status ?? 1;
 }
 
+function runGitCapture(gitArgs, { cwd } = {}) {
+  const result = spawnSync("git", gitArgs, spawnOptions({
+    cwd,
+    encoding: "utf8",
+  }));
+  return {
+    status: result.status ?? 1,
+    stdout: (result.stdout || "").trim(),
+    stderr: (result.stderr || "").trim(),
+  };
+}
+
+function getCurrentBranch(directory) {
+  const branch = runGitCapture(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: directory });
+  if (branch.status !== 0) {
+    return "";
+  }
+  if (branch.stdout === "HEAD") {
+    return "";
+  }
+  return branch.stdout;
+}
+
+function refExists(directory, ref) {
+  const result = runGitCapture(["rev-parse", "--verify", ref], { cwd: directory });
+  return result.status === 0;
+}
+
+function listConflictedFiles(directory) {
+  const result = runGitCapture(
+    ["diff", "--name-only", "--diff-filter=U"],
+    { cwd: directory }
+  );
+  if (result.status !== 0) {
+    return [];
+  }
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function isMergeOrRebaseInProgress(directory) {
+  const merge = runGitCapture(["rev-parse", "-q", "--verify", "MERGE_HEAD"], {
+    cwd: directory,
+  });
+  if (merge.status === 0) {
+    return "merge";
+  }
+  const rebaseMerge = fs.existsSync(path.join(directory, ".git", "rebase-merge"));
+  const rebaseApply = fs.existsSync(path.join(directory, ".git", "rebase-apply"));
+  if (rebaseMerge || rebaseApply) {
+    return "rebase";
+  }
+  return "";
+}
+
+function countDirtyFiles(directory) {
+  const result = runGitCapture(["status", "--porcelain"], { cwd: directory });
+  if (result.status !== 0) {
+    return 0;
+  }
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean).length;
+}
+
 module.exports = {
   isGitRepo,
   runGit,
+  runGitCapture,
+  getCurrentBranch,
+  refExists,
+  listConflictedFiles,
+  isMergeOrRebaseInProgress,
+  countDirtyFiles,
   ensureRepoExists,
   listRemotesVerbose,
   runGitStatus,