pan-stack-cli 0.1.2 → 0.1.5

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

@@ -0,0 +1,320 @@
+#!/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 {
+  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(
+    `${mode} ${ref} thất bại — ${files.length} file conflict`
+  );
+  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(`    … và ${files.length - 8} file khác`));
+  }
+}
+
+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 = "repo không tồn tại hoặc chưa clone";
+    return result;
+  }
+
+  const branch = getCurrentBranch(destination);
+  result.branch = branch || "(detached HEAD)";
+  if (!branch) {
+    result.message = "đang detached HEAD — bỏ qua";
+    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 = `đang dở ${inProgress} — cần resolve trước`;
+    printEarlyConflict({ name, branch, ref, files, mode: inProgress });
+    return result;
+  }
+
+  const dirtyCount = countDirtyFiles(destination);
+  if (dirtyCount > 0) {
+    console.log(
+      `${ICON.warn} ${colors.yellow(`[warn] ${name}: working tree có ${dirtyCount} thay đổi chưa commit`)}`
+    );
+  }
+
+  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 || "git fetch origin thất bại";
+    console.log(`${ICON.warn} ${colors.yellow(`[warn] ${name}: ${result.message}`)}`);
+    return result;
+  }
+
+  if (!refExists(destination, ref)) {
+    result.status = "error";
+    result.message = `không tìm thấy ref ${ref} (chạy fetch trước?)`;
+    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 : ["(xem git status)"];
+    result.message = `${result.mode} conflict`;
+    printEarlyConflict({
+      name,
+      branch,
+      ref,
+      files: result.conflictFiles,
+      mode: result.mode,
+    });
+    return result;
+  }
+
+  result.status = "ok";
+  result.message = "đã cập nhật";
+  console.log(`${ICON.ok} ${colors.green(`[ok] ${name}: ${branch} đã sync ${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("─── sync-main summary ───"));
+  console.log(
+    `${ICON.info} ref: ${ref} · mode: ${rebase ? "rebase" : "merge"} · repos: ${results.length}`
+  );
+  console.log(
+    `  ${ICON.ok} ok: ${ok.length} · ${ICON.conflict} conflict: ${conflicts.length} · ${ICON.warn} error: ${errors.length} · ${ICON.skip} skip: ${skipped.length}`
+  );
+
+  if (conflicts.length > 0) {
+    console.log("");
+    console.log(colors.bold(colors.red(`${ICON.conflict} CONFLICT — cần xử lý thủ công`)));
+    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"
+        ? "git add <file>… && git rebase --continue   (hoặc git rebase --abort)"
+        : "git add <file>… && git commit";
+      console.log(colors.dim(`  → ${hint}`));
+    }
+  }
+
+  if (errors.length > 0) {
+    console.log("");
+    console.log(colors.bold(colors.yellow(`${ICON.warn} LỖI`)));
+    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} Kết thúc với conflict — resolve từng repo ở trên rồi commit/rebase --continue`
+        )
+      )
+    );
+  } else if (errors.length > 0) {
+    console.log("");
+    console.log(
+      colors.bold(colors.yellow(`${ICON.warn} Kết thúc với lỗi — xem chi tiết ở trên`))
+    );
+  } else if (ok.length > 0) {
+    console.log("");
+    console.log(colors.green(`${ICON.ok} Tất cả repo đã chọn đã sync ${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} sync-main: ${targets.length} repo · ${args.rebase ? "rebase" : "merge"} ← ${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/cli.js

@@ -72,7 +72,7 @@ function resolveProjectWorkspace({
     if (!found) {
       const label = manifestPath || ".project.yaml";
       throw new Error(
-        `Manifest not found: ${label} (đã tìm từ ${startDir} lên thư mục cha)`
+        `Manifest not found: ${label} (walked up from ${startDir})`
       );
     }
     resolvedManifest = found;
@@ -140,12 +140,13 @@ function printCommonOptions() {
 
 options:
   -h, --help           show this help message and exit
-  --base-dir BASE_DIR  Base directory for relative repo paths. Default: thư mục chứa .project.yaml (walk-up từ cwd nếu cần).
+  --base-dir BASE_DIR  Base directory for relative repo paths. Default: directory containing .project.yaml (walk-up from cwd when needed).
   --dry-run            Print commands only`;
 }
 
 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

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { spawnSync } = require("child_process");
+const { spawnOptions } = require("../../platform");
 
 function isGitRepo(directory) {
   return fs.existsSync(path.join(directory, ".git"));
@@ -14,7 +15,7 @@ function runGit(gitArgs, { cwd, dryRun, action, name }) {
   }
 
   console.log(`[${action}] ${name}: ${cwd}`);
-  const result = spawnSync(command[0], command.slice(1), { stdio: "inherit", cwd });
+  const result = spawnSync(command[0], command.slice(1), spawnOptions({ stdio: "inherit", cwd }));
   return result.status ?? 1;
 }
 
@@ -31,10 +32,10 @@ function ensureRepoExists({ name, destination }) {
 }
 
 function listRemotesVerbose(directory) {
-  const result = spawnSync("git", ["remote", "-v"], {
+  const result = spawnSync("git", ["remote", "-v"], spawnOptions({
     cwd: directory,
     encoding: "utf8",
-  });
+  }));
   if (result.status !== 0) {
     return [];
   }
@@ -45,16 +46,90 @@ function listRemotesVerbose(directory) {
 }
 
 function runGitStatus(directory, gitArgs = []) {
-  const result = spawnSync("git", ["status", ...gitArgs], {
+  const result = spawnSync("git", ["status", ...gitArgs], spawnOptions({
     cwd: directory,
     stdio: "inherit",
-  });
+  }));
   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,

package/lib/git/helpers/repo-select.js

@@ -0,0 +1,97 @@
+const readline = require("readline");
+const { isGitRepo } = require("./git");
+
+function buildTargets({ repos, workspaceRoot, includeWorkspace }) {
+  const targets = [];
+  if (includeWorkspace && isGitRepo(workspaceRoot)) {
+    targets.push({
+      name: "workspace",
+      destination: workspaceRoot,
+      label: "workspace (stack root)",
+    });
+  }
+  for (const repo of repos) {
+    targets.push({
+      name: repo.name,
+      destination: repo.destination,
+      label: repo.name,
+    });
+  }
+  return targets;
+}
+
+function findTargetByName(targets, name) {
+  const needle = String(name || "").trim();
+  if (!needle) {
+    return [];
+  }
+  return targets.filter((target) => target.name === needle);
+}
+
+function promptRepoChoice(targets) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log("");
+    console.log("Chọn repo để sync-main:");
+    console.log(`  1. all (${targets.length} repo)`);
+    targets.forEach((target, index) => {
+      console.log(`  ${index + 2}. ${target.label}`);
+      console.log(`     ${target.destination}`);
+    });
+    console.log("");
+
+    rl.question("Nhập số (1 = all): ", (answer) => {
+      rl.close();
+      const choice = Number.parseInt(String(answer).trim(), 10);
+      if (!Number.isFinite(choice) || choice < 1 || choice > targets.length + 1) {
+        reject(new Error("Lựa chọn không hợp lệ."));
+        return;
+      }
+      if (choice === 1) {
+        resolve(targets);
+        return;
+      }
+      resolve([targets[choice - 2]]);
+    });
+  });
+}
+
+async function resolveTargets({
+  repos,
+  workspaceRoot,
+  includeWorkspace,
+  selection,
+}) {
+  const targets = buildTargets({ repos, workspaceRoot, includeWorkspace });
+  if (targets.length === 0) {
+    throw new Error("Không có repo git nào để sync-main.");
+  }
+
+  const picked = String(selection || "").trim();
+  if (picked === "all") {
+    return targets;
+  }
+  if (picked) {
+    const matches = findTargetByName(targets, picked);
+    if (matches.length === 0) {
+      const names = targets.map((target) => target.name).join(", ");
+      throw new Error(`Repo '${picked}' không có trong manifest. Có: ${names}`);
+    }
+    return matches;
+  }
+
+  if (process.stdin.isTTY) {
+    return promptRepoChoice(targets);
+  }
+
+  return targets;
+}
+
+module.exports = {
+  buildTargets,
+  resolveTargets,
+};

package/lib/manifest.js

@@ -323,7 +323,7 @@ function getCommandDefinition(source, commandName, subArg) {
     const target = def.targets[targetName];
     if (!target) {
       const valid = Object.keys(def.targets).join(" | ");
-      throw new Error(`Target hợp lệ cho '${commandName}': ${valid}`);
+      throw new Error(`Valid targets for '${commandName}': ${valid}`);
     }
     return {
       ...target,