pan-stack-cli 0.1.4 → 0.2.1

package/lib/git/helpers/manifest.js

@@ -1,6 +1,8 @@
 const fs = require("fs");
+const path = require("path");
 
 const PLACEHOLDER_VALUES = new Set(["", "repo_url_to_be_filled", "pan_stack_repo_url"]);
+const LOCAL_MANIFEST_FILE = ".project.local.yaml";
 
 function cleanValue(value) {
   let result = String(value || "").trim();
@@ -79,6 +81,92 @@ function parseManifest(manifestPath) {
   return data;
 }
 
+/**
+ * Parse `.project.yaml` rồi GỘP THÊM `repositories:` từ `.project.local.yaml` cùng thư mục
+ * (nếu có) — file cá nhân (gitignore), chỉ cần field `repositories:`. Mọi lệnh git built-in
+ * (clone/pull/push/fetch/grv/gst/sync-main/mr/checkout) đi qua `loadManifestRepos` (./cli.js) nên
+ * tự động thấy repo local — xem lib/manifest.js#parseManifestWithLocal (bản dùng cho .pan.yaml
+ * project commands) để biết thêm; 2 nơi khác parser (helpers riêng cho git built-in) nên duplicate
+ * logic merge ở đây, KHÔNG duplicate parser.
+ */
+function parseManifestWithLocal(manifestPath) {
+  const data = parseManifest(manifestPath);
+  const localPath = path.join(path.dirname(manifestPath), LOCAL_MANIFEST_FILE);
+  if (fs.existsSync(localPath)) {
+    const localData = parseManifest(localPath);
+    const localRepos = Array.isArray(localData.repositories) ? localData.repositories : [];
+    if (localRepos.length) {
+      data.repositories = [...(data.repositories || []), ...localRepos];
+      console.error(`ℹ️  +${localRepos.length} repo từ ${LOCAL_MANIFEST_FILE}`);
+    }
+  }
+  return data;
+}
+
+// Nhận diện 1 tham số CÓ PHẢI git URL hay không (để `pan clone <url>` phân biệt với
+// `pan clone` (không tham số = clone all) / `pan clone custom.project.yaml` (chỉ định manifest)).
+function looksLikeGitUrl(arg) {
+  if (!arg) return false;
+  if (/^(https?|ssh|git):\/\//i.test(arg)) return true;
+  if (/^[\w.-]+@[\w.-]+:.+/.test(arg)) return true; // scp-like: git@host:group/repo.git
+  if (/\.git$/i.test(arg)) return true;
+  return false;
+}
+
+// Tách tên dự án từ git URL — bỏ đuôi ".git", lấy phần cuối sau "/" (hoặc ":" kiểu scp-like).
+//   https://host/group/my-repo.git      -> my-repo
+//   git@github.com:user/my-repo.git     -> my-repo
+//   https://github.com/user/my-repo     -> my-repo
+function repoNameFromUrl(url) {
+  let s = String(url || "").trim().replace(/\/+$/, "").replace(/\.git$/i, "");
+  const idx = Math.max(s.lastIndexOf("/"), s.lastIndexOf(":"));
+  return idx >= 0 ? s.slice(idx + 1) : s;
+}
+
+/**
+ * Thêm 1 entry mới vào cuối danh sách `repositories:` trong `.project.yaml` (ghi trực tiếp vào
+ * FILE, không phải `.project.local.yaml`) — dùng bởi `pan clone <url>`. Chèn ngay TRƯỚC section
+ * top-level kế tiếp (nếu `repositories:` không phải section cuối file), hoặc cuối file nếu là
+ * section cuối; nếu file chưa có `repositories:` thì thêm mới section này ở cuối.
+ * @param {string} manifestPath
+ * @param {{name:string, url:string, path:string, description?:string}} repo
+ */
+function appendRepository(manifestPath, repo) {
+  const content = fs.readFileSync(manifestPath, "utf8");
+  const lines = content.split(/\r?\n/);
+  // Bỏ các dòng trống Ở CUỐI (do file gốc kết bằng newline) — tránh chèn nhầm sau dòng trống đó
+  // (sinh ra 1 dòng trống thừa) và đảm bảo luôn ghi lại với ĐÚNG 1 newline cuối file.
+  while (lines.length && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  const entryLines = [
+    `  - name: ${repo.name}`,
+    ...(repo.description ? [`    description: ${repo.description}`] : []),
+    `    url: ${repo.url}`,
+    `    path: ${repo.path}`,
+  ];
+
+  const repoLineIdx = lines.findIndex((l) => /^repositories:\s*$/.test(l));
+  if (repoLineIdx === -1) {
+    const trimmed = content.replace(/\s+$/, "");
+    fs.writeFileSync(manifestPath, `${trimmed}\n\nrepositories:\n${entryLines.join("\n")}\n`, "utf8");
+    return;
+  }
+
+  let endIdx = lines.length;
+  for (let i = repoLineIdx + 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent === 0) {
+      endIdx = i;
+      break;
+    }
+  }
+  const newLines = [...lines.slice(0, endIdx), ...entryLines, ...lines.slice(endIdx)];
+  fs.writeFileSync(manifestPath, `${newLines.join("\n")}\n`, "utf8");
+}
+
 function uniqueRepos(repos) {
   const seen = new Set();
   const result = [];
@@ -121,9 +209,14 @@ function validateRepo(repo) {
 
 module.exports = {
   PLACEHOLDER_VALUES,
+  LOCAL_MANIFEST_FILE,
   cleanValue,
   splitKeyValue,
   parseManifest,
+  parseManifestWithLocal,
+  looksLikeGitUrl,
+  repoNameFromUrl,
+  appendRepository,
   uniqueRepos,
   manifestRepos,
   validateRepo,

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

@@ -0,0 +1,416 @@
+const readline = require("readline");
+const { isGitRepo } = require("./git");
+const { helpTheme } = require("../../inquirer-theme");
+const { t } = require("../../i18n");
+const { menuSelect, menuCheckbox } = require("../../menu-prompt");
+
+// Lazy-load @inquirer/prompts (ESM) from CJS via dynamic import. Cached so
+// repeated pickers in one run reuse the same module. Returns null when the
+// dependency is missing (e.g. deps not installed) so callers can fall back to
+// the readline-based prompts.
+let inquirerModulePromise = null;
+async function loadInquirer() {
+  if (inquirerModulePromise === null) {
+    inquirerModulePromise = import("@inquirer/prompts").catch(() => null);
+  }
+  return inquirerModulePromise;
+}
+
+function isCancelError(err) {
+  if (!err) {
+    return false;
+  }
+  const name = String(err.name || "");
+  return (
+    name === "ExitPromptError" ||
+    name === "CancelPromptError" ||
+    /User force closed/i.test(String(err.message || ""))
+  );
+}
+
+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 splitSelectionTokens(text) {
+  return String(text || "")
+    .split(/[\s,]+/)
+    .map((tok) => tok.trim())
+    .filter(Boolean);
+}
+
+function findTargetsByNames(targets, names) {
+  const seen = new Set();
+  const picked = [];
+  const missing = [];
+  for (const raw of names) {
+    const name = String(raw || "").trim();
+    if (!name) {
+      continue;
+    }
+    const match = targets.find((target) => target.name === name);
+    if (!match) {
+      missing.push(name);
+      continue;
+    }
+    if (seen.has(match.name)) {
+      continue;
+    }
+    seen.add(match.name);
+    picked.push(match);
+  }
+  return { picked, missing };
+}
+
+function promptRepoChoiceReadline(targets, message) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log("");
+    console.log(message);
+    console.log(`  1. ${t("REPO_SELECT_ALL__N", { n: targets.length })}`);
+    targets.forEach((target, index) => {
+      console.log(`  ${index + 2}. ${target.label}`);
+      console.log(`     ${target.destination}`);
+    });
+    console.log("");
+
+    rl.question(t("REPO_SELECT_SINGLE_PROMPT"), (answer) => {
+      rl.close();
+      const choice = Number.parseInt(String(answer).trim(), 10);
+      if (
+        !Number.isFinite(choice) ||
+        choice < 1 ||
+        choice > targets.length + 1
+      ) {
+        reject(new Error(t("REPO_SELECT_INVALID")));
+        return;
+      }
+      if (choice === 1) {
+        resolve(targets);
+        return;
+      }
+      resolve([targets[choice - 2]]);
+    });
+  });
+}
+
+const ALL_SENTINEL = "__all__";
+
+async function promptRepoChoice(targets, { message } = {}) {
+  const promptMsg = message || t("REPO_SELECT_PROMPT_MSG");
+  const choices = [
+    {
+      name: t("REPO_SELECT_ALL__N", { n: targets.length }),
+      value: ALL_SENTINEL,
+      short: "all",
+    },
+    ...targets.map((target) => ({
+      name: `${target.label}  ${dimHint(target.destination)}`,
+      value: target,
+      short: target.name,
+    })),
+  ];
+  const hotkeys = [{ key: "x", label: t("EXIT_LABEL"), value: "__exit__" }];
+
+  // Ưu tiên menu-prompt (phím x thoát ngay); thiếu @inquirer/core → @inquirer/prompts select
+  // với item thoát ẩn ở cuối; thiếu cả hai → readline thô (không hotkey, Ctrl+C để thoát).
+  try {
+    const picked = await menuSelect({ message: promptMsg, choices, pageSize: Math.min(Math.max(targets.length + 2, 8), 20), hotkeys });
+    if (picked === "__exit__") {
+      console.log(t("EXITED"));
+      process.exit(0);
+    }
+    return picked === ALL_SENTINEL ? targets.slice() : [picked];
+  } catch (err) {
+    if (String(err && err.message) !== "no-core") {
+      if (isCancelError(err)) throw new Error(t("REPO_SELECT_CANCELLED"));
+      throw err;
+    }
+  }
+
+  const inq = await loadInquirer();
+  if (!inq || typeof inq.select !== "function") {
+    return promptRepoChoiceReadline(targets, promptMsg);
+  }
+
+  try {
+    const picked = await inq.select({
+      message: promptMsg,
+      choices: [...choices, new inq.Separator(), { name: `x  ${t("EXIT_LABEL")}`, value: "__exit__", short: "x" }],
+      pageSize: Math.min(Math.max(targets.length + 2, 8), 20),
+      loop: false,
+      theme: helpTheme(false),
+    });
+    if (picked === "__exit__") {
+      console.log(t("EXITED"));
+      process.exit(0);
+    }
+    return picked === ALL_SENTINEL ? targets.slice() : [picked];
+  } catch (err) {
+    if (isCancelError(err)) {
+      throw new Error(t("REPO_SELECT_CANCELLED"));
+    }
+    throw err;
+  }
+}
+
+async function resolveTargets({
+  repos,
+  workspaceRoot,
+  includeWorkspace,
+  selection,
+  message,
+}) {
+  const targets = buildTargets({ repos, workspaceRoot, includeWorkspace });
+  if (targets.length === 0) {
+    throw new Error(t("REPO_SELECT_NO_REPO_SYNC"));
+  }
+
+  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(
+        t("REPO_SELECT_ONE_MISSING__PICKED_ALL", { picked, all: names })
+      );
+    }
+    return matches;
+  }
+
+  if (process.stdin.isTTY) {
+    return promptRepoChoice(targets, { message: message || t("REPO_SELECT_SYNCMAIN_MSG") });
+  }
+
+  return targets;
+}
+
+function pickTargetsByIndices(targets, indices) {
+  const seen = new Set();
+  const picked = [];
+  for (const raw of indices) {
+    const num = Number.parseInt(String(raw).trim(), 10);
+    if (!Number.isFinite(num) || num < 1 || num > targets.length + 1) {
+      const err = new Error(t("REPO_SELECT_INVALID_INDEX__RAW", { raw }));
+      err.code = "INVALID_CHOICE";
+      throw err;
+    }
+    if (num === 1) {
+      return targets.slice();
+    }
+    const idx = num - 2;
+    if (seen.has(idx)) {
+      continue;
+    }
+    seen.add(idx);
+    picked.push(targets[idx]);
+  }
+  return picked;
+}
+
+function promptRepoChoiceMultiReadline(targets, { action } = {}) {
+  const actionLabel = action || t("REPO_SELECT_ACTION_CHOOSE");
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log("");
+    console.log(
+      t("REPO_SELECT_MULTI_HELP__ACTION", { action: actionLabel })
+    );
+    console.log(`  1. ${t("REPO_SELECT_ALL__N", { n: targets.length })}`);
+    targets.forEach((target, index) => {
+      console.log(`  ${index + 2}. ${target.label}`);
+      console.log(`     ${target.destination}`);
+    });
+    console.log("");
+
+    rl.question(t("REPO_SELECT_MULTI_PROMPT"), (answer) => {
+      rl.close();
+      const raw = String(answer || "").trim();
+      if (!raw) {
+        reject(new Error(t("REPO_SELECT_EMPTY_ANSWER")));
+        return;
+      }
+      if (raw.toLowerCase() === "all") {
+        resolve(targets.slice());
+        return;
+      }
+      const tokens = splitSelectionTokens(raw);
+      if (tokens.length === 0) {
+        reject(new Error(t("REPO_SELECT_INVALID")));
+        return;
+      }
+      try {
+        const picked = pickTargetsByIndices(targets, tokens);
+        if (picked.length === 0) {
+          reject(new Error(t("REPO_SELECT_NONE_PICKED")));
+          return;
+        }
+        resolve(picked);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+
+async function promptRepoChoiceMulti(targets, { action } = {}) {
+  const actionLabel = action || t("REPO_SELECT_ACTION_CHOOSE");
+  const choices = targets.map((target, i) => ({
+    name: `${target.label}  ${dimHint(target.destination)}`,
+    value: i,
+    short: target.name,
+  }));
+  const hotkeys = [{ key: "x", label: t("EXIT_LABEL"), value: "exit" }];
+
+  // Ưu tiên menu-prompt (menuCheckbox: có sẵn a=chọn tất cả, i=đảo chọn, x=thoát) — nhất quán
+  // với mọi nơi chọn-nhiều khác trong CLI; thiếu @inquirer/core → @inquirer/prompts checkbox
+  // (không có a/i, chỉ Enter/Space); thiếu cả hai → readline thô.
+  try {
+    const res = await menuCheckbox({
+      message: actionLabel,
+      choices,
+      hotkeys,
+      pageSize: Math.min(Math.max(targets.length + 2, 8), 20),
+    });
+    if (res.action === "exit") {
+      console.log(t("EXITED"));
+      process.exit(0);
+    }
+    const values = res.values || [];
+    if (values.length === 0) {
+      throw new Error(t("REPO_SELECT_NONE_PICKED"));
+    }
+    return values.map((i) => targets[i]);
+  } catch (err) {
+    if (String(err && err.message) !== "no-core") {
+      if (isCancelError(err)) throw new Error(t("REPO_SELECT_CANCELLED"));
+      throw err;
+    }
+  }
+
+  const inq = await loadInquirer();
+  if (!inq || typeof inq.checkbox !== "function") {
+    return promptRepoChoiceMultiReadline(targets, { action: actionLabel });
+  }
+
+  try {
+    const picked = await inq.checkbox({
+      message: actionLabel,
+      choices: targets.map((target) => ({
+        name: `${target.label}  ${dimHint(target.destination)}`,
+        value: target,
+        short: target.name,
+      })),
+      required: true,
+      pageSize: Math.min(Math.max(targets.length + 2, 8), 20),
+      theme: helpTheme(true),
+    });
+    if (!Array.isArray(picked) || picked.length === 0) {
+      throw new Error(t("REPO_SELECT_NONE_PICKED"));
+    }
+    return picked;
+  } catch (err) {
+    if (isCancelError(err)) {
+      throw new Error(t("REPO_SELECT_CANCELLED"));
+    }
+    throw err;
+  }
+}
+
+function dimHint(text) {
+  if (!process.stdout.isTTY || process.env.NO_COLOR) {
+    return `— ${text}`;
+  }
+  return `\u001b[2m— ${text}\u001b[0m`;
+}
+
+async function resolveMultiTargets({
+  repos,
+  workspaceRoot,
+  includeWorkspace,
+  selection,
+  action,
+}) {
+  const actionLabel = action || t("REPO_SELECT_ACTION_DEFAULT");
+  const targets = buildTargets({ repos, workspaceRoot, includeWorkspace });
+  if (targets.length === 0) {
+    throw new Error(t("REPO_SELECT_NO_REPO"));
+  }
+
+  const raw = String(selection || "").trim();
+  if (raw.toLowerCase() === "all") {
+    return targets.slice();
+  }
+  if (raw) {
+    const tokens = splitSelectionTokens(raw);
+    const allNumeric =
+      tokens.length > 0 && tokens.every((tok) => /^[0-9]+$/.test(tok));
+    if (allNumeric) {
+      const picked = pickTargetsByIndices(targets, tokens);
+      if (picked.length === 0) {
+        throw new Error(t("REPO_SELECT_NONE_PICKED"));
+      }
+      return picked;
+    }
+    const { picked, missing } = findTargetsByNames(targets, tokens);
+    if (missing.length > 0) {
+      const names = targets.map((target) => target.name).join(", ");
+      throw new Error(
+        t("REPO_SELECT_MISSING__MISSING_ALL", { missing: missing.join(", "), all: names })
+      );
+    }
+    if (picked.length === 0) {
+      throw new Error(t("REPO_SELECT_NONE_PICKED"));
+    }
+    return picked;
+  }
+
+  if (process.stdin.isTTY) {
+    return promptRepoChoiceMulti(targets, { action: actionLabel });
+  }
+
+  throw new Error(t("REPO_SELECT_NEED_NON_INTERACTIVE"));
+}
+
+module.exports = {
+  buildTargets,
+  findTargetsByNames,
+  pickTargetsByIndices,
+  resolveTargets,
+  resolveMultiTargets,
+  splitSelectionTokens,
+};

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

@@ -0,0 +1,161 @@
+const colors = require("./colors");
+const { getCurrentBranch, runGitCapture, isMergeOrRebaseInProgress } = require("./git");
+const { t } = require("../../i18n");
+
+const ICON = {
+  ok: "✅",
+  warn: "⚠️",
+  info: "ℹ️",
+  skip: "⏭️",
+  up: "↑",
+  down: "↓",
+};
+
+function computeAheadBehind(directory) {
+  const up = runGitCapture(["rev-parse", "--abbrev-ref", "@{u}"], { cwd: directory });
+  if (up.status !== 0 || !up.stdout) return { hasUpstream: false, ahead: 0, behind: 0 };
+  const rl = runGitCapture(["rev-list", "--left-right", "--count", "HEAD...@{u}"], { cwd: directory });
+  if (rl.status !== 0) return { hasUpstream: true, ahead: 0, behind: 0 };
+  const [ahead, behind] = rl.stdout.split(/\s+/).map((n) => parseInt(n, 10) || 0);
+  return { hasUpstream: true, ahead, behind };
+}
+
+function getRepoStatusSummary(directory) {
+  const branch = getCurrentBranch(directory);
+  const result = runGitCapture(["status", "--porcelain"], { cwd: directory });
+  if (result.status !== 0) {
+    return {
+      branch,
+      error: result.stderr || "git status failed",
+      total: 0,
+      staged: 0,
+      unstaged: 0,
+      untracked: 0,
+      ahead: 0,
+      behind: 0,
+      hasUpstream: false,
+      inProgress: "",
+    };
+  }
+
+  const lines = result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+
+  let staged = 0;
+  let unstaged = 0;
+  let untracked = 0;
+
+  for (const line of lines) {
+    const index = line[0];
+    const worktree = line[1];
+
+    if (index === "?" && worktree === "?") {
+      untracked += 1;
+      continue;
+    }
+
+    if (index !== " ") {
+      staged += 1;
+    }
+    if (worktree !== " ") {
+      unstaged += 1;
+    }
+  }
+
+  const { hasUpstream, ahead, behind } = computeAheadBehind(directory);
+
+  return {
+    branch,
+    total: lines.length,
+    staged,
+    unstaged,
+    untracked,
+    ahead,
+    behind,
+    hasUpstream,
+    inProgress: isMergeOrRebaseInProgress(directory), // "merge"|"rebase"|""
+  };
+}
+
+function formatFileBreakdown({ staged, unstaged, untracked }) {
+  const parts = [];
+  if (staged > 0) parts.push(t("BULK_BREAKDOWN_STAGED__N", { n: staged }));
+  if (unstaged > 0) parts.push(t("BULK_BREAKDOWN_UNSTAGED__N", { n: unstaged }));
+  if (untracked > 0) parts.push(t("BULK_BREAKDOWN_UNTRACKED__N", { n: untracked }));
+  return parts.join(" · ");
+}
+
+function formatSync(item) {
+  if (item.error) return colors.red(t("BULK_STATUS_ERROR"));
+  if (!item.hasUpstream) return colors.dim(t("BULK_STATUS_NO_UPSTREAM"));
+  if (item.behind === 0 && item.ahead === 0) return colors.green(t("BULK_STATUS_IN_SYNC"));
+  const parts = [];
+  if (item.behind) parts.push(colors.yellow(`${ICON.down} ${item.behind}`));
+  if (item.ahead) parts.push(colors.cyan(`${ICON.up} ${item.ahead}`));
+  return parts.join(" ");
+}
+
+function formatState(item) {
+  if (item.inProgress === "merge") return colors.red(t("BULK_STATUS_MERGING"));
+  if (item.inProgress === "rebase") return colors.red(t("BULK_STATUS_REBASING"));
+  if (item.error) return colors.red(t("BULK_STATUS_ERROR"));
+  if (item.total === 0) return colors.green(t("BULK_STATUS_CLEAN"));
+  const label = item.total === 1 ? t("BULK_FILES_ONE") : t("BULK_FILES_MANY");
+  return colors.yellow(`${item.total} ${label}`);
+}
+
+function printChangeSummary({ title, results, totalRepos }) {
+  const dirty = results.filter((item) => item.total > 0 || item.inProgress);
+  const errors = results.filter((item) => item.error);
+  const shown = results.filter((item) => item.total > 0 || item.inProgress || item.error);
+  const rows = shown.map((item) => ({
+    repo: item.error ? colors.red(item.name) : colors.cyan(item.name),
+    branch: item.branch || colors.dim(t("GST_DETACHED")),
+    state: formatState(item),
+    breakdown: item.total > 0 ? colors.dim(formatFileBreakdown(item)) : colors.dim("—"),
+    sync: formatSync(item),
+  }));
+
+  const totalFiles = dirty.reduce((sum, item) => sum + item.total, 0);
+  const cleanCount = totalRepos - dirty.length - errors.length;
+
+  console.log("");
+  console.log(colors.bold(`─── ${t("GST_TITLE")} ───`));
+  console.log(colors.dim(`${ICON.info} ${t("GST_FOOTER_COUNTS__TOTAL_DIRTY_FILES_CLEAN_ERRORS", {
+    total: totalRepos, dirty: dirty.length, files: totalFiles, clean: cleanCount, errors: errors.length,
+  })}`));
+
+  if (rows.length > 0) {
+    const { renderTable, bulkColumns } = require("./bulk-report");
+    console.log(renderTable(
+      bulkColumns([
+        { key: "repo", labelKey: "BULK_COL_REPO" },
+        { key: "branch", labelKey: "BULK_COL_BRANCH" },
+        { key: "state", labelKey: "BULK_COL_STATE" },
+        { key: "breakdown", labelKey: "BULK_COL_BREAKDOWN" },
+        { key: "sync", labelKey: "BULK_COL_SYNC" },
+      ]),
+      rows
+    ));
+  } else {
+    console.log("");
+    console.log(colors.green(t("GST_ALL_CLEAN__N", { n: totalRepos })));
+  }
+
+  if (errors.length > 0) {
+    console.log("");
+    console.log(colors.bold(colors.yellow(`${ICON.warn} ${t("GST_ERRORS_HEADER")}`)));
+    for (const item of errors) {
+      console.log(`  • ${item.name}: ${item.error}`);
+    }
+  }
+}
+
+module.exports = {
+  ICON,
+  getRepoStatusSummary,
+  formatFileBreakdown,
+  printChangeSummary,
+};