pan-stack-cli 0.1.5 → 0.2.1

package/lib/create.js

@@ -1,9 +1,11 @@
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 const readline = require("readline");
 const { validateFolderName } = require("./platform");
+const { getRegistryBaseUrl, fetchRegistry, downloadAndExtract } = require("./skill-registry-client");
 
-const TEMPLATE_ROOT = path.join(__dirname, "..", "templates", "workspace");
+const TEMPLATE_NAME = "workspace";
 
 function promptFolderName() {
   return new Promise((resolve, reject) => {
@@ -32,6 +34,7 @@ function promptFolderName() {
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === "template.json") continue; // metadata riêng cho registry, không phải file scaffold
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
     if (entry.isDirectory()) {
@@ -67,11 +70,26 @@ async function runCreate(args = []) {
     throw new Error(`Folder already exists: ${targetDir}`);
   }
 
-  if (!fs.existsSync(TEMPLATE_ROOT)) {
-    throw new Error(`Template not found: ${TEMPLATE_ROOT}`);
+  // Template scaffold không còn bundle sẵn trong pan-stack-cli — tải từ registry server (giống
+  // cơ chế `pan ai install`). Cần PAN_SKILL_REGISTRY_URL (hoặc default localhost:4600) chạy được.
+  const baseUrl = getRegistryBaseUrl();
+  const items = await fetchRegistry(baseUrl);
+  const template = items.find((i) => i.type === "template" && i.name === TEMPLATE_NAME);
+  if (!template) {
+    throw new Error(
+      `Không tìm thấy template '${TEMPLATE_NAME}' trên registry server (${baseUrl}). Kiểm tra apps/pan-agent-skill-registry đã build/deploy đủ registry/templates/${TEMPLATE_NAME} chưa.`
+    );
+  }
+
+  const stagingDir = fs.mkdtempSync(path.join(os.tmpdir(), "pan-create-"));
+  let extractedDir;
+  try {
+    extractedDir = await downloadAndExtract(baseUrl, template, stagingDir);
+    copyDir(extractedDir, targetDir);
+  } finally {
+    fs.rmSync(stagingDir, { recursive: true, force: true });
   }
 
-  copyDir(TEMPLATE_ROOT, targetDir);
   applyPlaceholders(targetDir, folderName);
 
   console.log(`Created PAN Stack workspace: ${targetDir}`);

package/lib/discover.js

@@ -18,11 +18,27 @@ const BUILTIN_GIT_COMMANDS = new Set([
   "sync-main",
   "sm",
   "fetch",
+  "gfa",
   "push",
   "grv",
   "gst",
+  "mr",
+  "checkout",
+  "co",
+]);
+const BUILTIN_WORKSPACE_COMMANDS = new Set([
+  "create",
+  "serve",
+  "language",
+  "lang",
+  "ai",
+  "skills",
+  "ui",
+  "stats",
+  "graph",
+  "git",
+  ...BUILTIN_GIT_COMMANDS,
 ]);
-const BUILTIN_WORKSPACE_COMMANDS = new Set(["create", ...BUILTIN_GIT_COMMANDS]);
 
 function readProjectRoots() {
   const roots = [];
@@ -77,6 +93,47 @@ function findNearestProjectManifest(startDir = process.cwd()) {
   return walked[0] || null;
 }
 
+const DISCOVER_SKIP_DIRS = new Set([
+  ".git", "node_modules", ".pnpm", "dist", "build", ".next", "target", "vendor",
+]);
+
+/**
+ * Fallback khi không có .project.yaml: quét git repo từ CHÍNH thư mục đang gõ
+ * lệnh (startDir) xuống tối đa `maxDepth` cấp — bao gồm chính startDir, thư mục
+ * con trực tiếp, và các cấp con tiếp theo (đủ bắt submodule). Dùng chung cho
+ * `pan stats` và các lệnh git built-in (`pan pull|push|fetch|checkout|...`) khi
+ * chạy ngoài workspace pan-stack (không có `.project.yaml`).
+ * @returns {Array<{name,dir}>}
+ */
+function discoverGitRepos(startDir = process.cwd(), maxDepth = 2) {
+  const base = path.resolve(startDir);
+  const found = [];
+  const seen = new Set();
+
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((e) => e.name === ".git")) {
+      const abs = path.resolve(dir);
+      if (!seen.has(abs)) {
+        seen.add(abs);
+        found.push({ name: path.basename(abs), dir: abs });
+      }
+    }
+    for (const e of entries) {
+      if (e.isDirectory() && !DISCOVER_SKIP_DIRS.has(e.name)) walk(path.join(dir, e.name), depth + 1);
+    }
+  }
+
+  walk(base, 0);
+  return found.sort((a, b) => a.name.localeCompare(b.name));
+}
+
 function findNearestWorkspace(startDir = process.cwd()) {
   const manifestPath = findNearestProjectManifest(startDir);
   if (!manifestPath) {
@@ -225,6 +282,7 @@ module.exports = {
   PAN_CONFIG_FILE,
   findNearestProjectManifest,
   findNearestWorkspace,
+  discoverGitRepos,
   loadAllCommandSources,
   loadCommandSourcesForWorkspace,
   findSourcesWithCommand,

package/lib/git/git-checkout.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+/*
+ * Checkout a branch across PAN Stack workspace + child repos.
+ *
+ * Reads repos from .project.yaml (same source as other pan git commands).
+ * Interactive multi-select picker when running in a TTY without an explicit
+ * selection. Non-interactive selection: pass "all", a single repo name, or a
+ * comma/space-separated list of repo names.
+ *
+ * Modes:
+ *   pan checkout <branch>             switch to existing branch (local or origin/*)
+ *   pan checkout -b <branch>          create new branch (fails if it already exists)
+ *   pan checkout -B <branch>          create OR reset (git checkout -B)
+ *   pan checkout -b <branch> --start-point <ref>
+ *                                     base new branch on <ref> (e.g. origin/main)
+ *
+ * Does NOT push — commit + `pan push` yourself afterwards.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const {
+  looksLikeManifest,
+  loadManifestRepos,
+  printCommonOptions,
+} = require("./helpers/cli");
+const colors = require("./helpers/colors");
+const { resolveMultiTargets } = require("./helpers/repo-select");
+const {
+  runGitCapture,
+  getCurrentBranch,
+  refExists,
+  countDirtyFiles,
+} = require("./helpers/git");
+const { t } = require("../i18n");
+
+const ICON = {
+  ok: "✓",
+  exists: "=",
+  warn: "!",
+  skip: "-",
+  err: "✗",
+};
+
+function printHelp() {
+  console.log(`usage: pan checkout [-b|-B] <branch> [repo|all|list] [options]   (alias: pan co)
+
+Chuyển/tạo nhánh trên workspace + các repo trong .project.yaml.
+Interactive multi-select khi chạy trong TTY và không truyền lựa chọn.
+
+positional:
+  branch             Tên nhánh (bắt buộc). Vd: feat/#1234, main, develop.
+  repo|all|<list>    Repo áp dụng: tên repo trong .project.yaml, "all",
+                     hoặc danh sách phân tách bởi phẩy/space.
+
+flags:
+  -b                 Tạo nhánh mới (git checkout -b). Fail nếu đã tồn tại.
+  -B                 Tạo hoặc reset nhánh (git checkout -B).
+  --start-point REF  Base ref cho -b/-B (default: HEAD hiện tại).
+
+${printCommonOptions()}
+  --no-workspace     Bỏ qua workspace root (chỉ repo con)
+
+examples:
+  pan checkout main                              # switch tất cả sang main (tương tác chọn repo)
+  pan checkout -b feat/#1234                     # tạo nhánh mới (tương tác chọn repo)
+  pan co -b feat/#1234 all                       # tạo trên tất cả repo
+  pan co -b feat/#1234 csdl-cc-backend,csdl-cc-b-frontend
+  pan co -B hotfix/x --start-point origin/main   # reset hotfix/x từ origin/main
+  pan checkout develop csdl-cc-backend           # switch một repo
+
+Kết quả:
+  ✓  = đã chuyển / tạo · =  = đã ở nhánh sẵn · !  = cảnh báo (đã tồn tại)
+  -  = skip · ✗  = lỗi (dirty tree, không tồn tại, v.v.)`);
+}
+
+function parseCheckoutArgs(argv) {
+  const args = {
+    help: false,
+    manifest: "",
+    baseDir: ".",
+    dryRun: false,
+    noWorkspace: false,
+    create: false,
+    forceCreate: false,
+    startPoint: "",
+    branch: "",
+    selection: "",
+  };
+
+  const positional = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      args.help = true;
+      continue;
+    }
+    if (arg === "-b") {
+      args.create = true;
+      continue;
+    }
+    if (arg === "-B") {
+      args.forceCreate = true;
+      continue;
+    }
+    if (arg === "--base-dir") {
+      args.baseDir = argv[++index] || ".";
+      continue;
+    }
+    if (arg === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
+    if (arg === "--no-workspace") {
+      args.noWorkspace = true;
+      continue;
+    }
+    if (arg === "--start-point") {
+      args.startPoint = argv[++index] || "";
+      continue;
+    }
+    if (arg.startsWith("--start-point=")) {
+      args.startPoint = arg.slice("--start-point=".length);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    if (looksLikeManifest(arg) && !args.manifest) {
+      args.manifest = arg;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  if (args.create && args.forceCreate) {
+    throw new Error(t("CHECKOUT_ERR_B_AND_BB"));
+  }
+  if (positional[0]) {
+    args.branch = positional[0];
+  }
+  if (positional.length > 1) {
+    args.selection = positional.slice(1).join(" ");
+  }
+  if (args.startPoint && !args.create && !args.forceCreate) {
+    throw new Error(t("CHECKOUT_ERR_STARTPOINT"));
+  }
+
+  return args;
+}
+
+function truncate(text, max) {
+  const clean = String(text || "").replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+
+function processRepo({
+  name,
+  destination,
+  branch,
+  create,
+  forceCreate,
+  startPoint,
+  dryRun,
+}) {
+  const record = { name, status: "", message: "" };
+
+  if (!fs.existsSync(path.join(destination, ".git"))) {
+    return { ...record, status: "skip", message: t("CHECKOUT_MSG_NOT_CLONED") };
+  }
+
+  const currentBranch = getCurrentBranch(destination);
+  const from = currentBranch || t("CHECKOUT_DETACHED");
+
+  const localExists = refExists(destination, `refs/heads/${branch}`);
+
+  if (currentBranch === branch && !forceCreate) {
+    return {
+      ...record,
+      status: "exists",
+      message: t("CHECKOUT_MSG_ON_BRANCH__BRANCH", { branch }),
+    };
+  }
+
+  if (create) {
+    if (localExists) {
+      return {
+        ...record,
+        status: "warn",
+        message: t("CHECKOUT_MSG_LOCAL_EXISTS__BRANCH", { branch }),
+      };
+    }
+    if (startPoint && !refExists(destination, startPoint)) {
+      return {
+        ...record,
+        status: "err",
+        message: t("CHECKOUT_MSG_STARTPOINT_MISSING__STARTPOINT", { startPoint }),
+      };
+    }
+  } else if (!forceCreate) {
+    const remoteExists = refExists(destination, `refs/remotes/origin/${branch}`);
+    if (!localExists && !remoteExists) {
+      return {
+        ...record,
+        status: "err",
+        message: t("CHECKOUT_MSG_NO_BRANCH__BRANCH", { branch }),
+      };
+    }
+  } else if (forceCreate) {
+    if (startPoint && !refExists(destination, startPoint)) {
+      return {
+        ...record,
+        status: "err",
+        message: t("CHECKOUT_MSG_STARTPOINT_MISSING__STARTPOINT", { startPoint }),
+      };
+    }
+  }
+
+  const gitArgs = ["checkout"];
+  if (forceCreate) {
+    gitArgs.push("-B", branch);
+  } else if (create) {
+    gitArgs.push("-b", branch);
+  } else {
+    gitArgs.push(branch);
+  }
+  if ((create || forceCreate) && startPoint) {
+    gitArgs.push(startPoint);
+  }
+
+  if (dryRun) {
+    return {
+      ...record,
+      status: "skip",
+      message: `[dry-run] git ${gitArgs.join(" ")}`,
+    };
+  }
+
+  const dirty = countDirtyFiles(destination);
+
+  const result = runGitCapture(gitArgs, { cwd: destination });
+  if (result.status !== 0) {
+    const raw = result.stderr || result.stdout || t("CHECKOUT_MSG_FAILED");
+    const message = truncate(raw, 240);
+    if (dirty > 0 && /would be overwritten|local changes/i.test(raw)) {
+      return {
+        ...record,
+        status: "err",
+        message: `${message}${t("CHECKOUT_MSG_DIRTY__DIRTY", { dirty })}`,
+      };
+    }
+    return { ...record, status: "err", message };
+  }
+
+  if (forceCreate) {
+    if (localExists) {
+      return {
+        ...record,
+        status: "ok",
+        message: t("CHECKOUT_MSG_RESET__BRANCH_FROM", { branch, from: startPoint || from }),
+      };
+    }
+    return {
+      ...record,
+      status: "ok",
+      message: t("CHECKOUT_MSG_CREATE__BRANCH_FROM", { branch, from: startPoint || from }),
+    };
+  }
+  if (create) {
+    return {
+      ...record,
+      status: "ok",
+      message: t("CHECKOUT_MSG_CREATE__BRANCH_FROM", { branch, from: startPoint || from }),
+    };
+  }
+  return { ...record, status: "ok", message: `${from} → ${branch}` };
+}
+
+function styleForStatus(status) {
+  switch (status) {
+    case "ok":
+      return { icon: ICON.ok, color: colors.green };
+    case "exists":
+      return { icon: ICON.exists, color: colors.cyan };
+    case "warn":
+      return { icon: ICON.warn, color: colors.yellow };
+    case "skip":
+      return { icon: ICON.skip, color: colors.dim };
+    case "err":
+      return { icon: ICON.err, color: colors.red };
+    default:
+      return { icon: "?", color: (text) => text };
+  }
+}
+
+function printSummary(results, { branch, mode }) {
+  const nameWidth = results.reduce(
+    (max, item) => Math.max(max, item.name.length),
+    0
+  );
+
+  console.log("");
+  console.log(colors.bold(t("CHECKOUT_RESULT_HEADER__MODE_BRANCH", { mode, branch })));
+  for (const result of results) {
+    const { icon, color } = styleForStatus(result.status);
+    const line = `${icon} ${result.name.padEnd(nameWidth)}  ${result.message}`;
+    console.log(color(line));
+  }
+
+  const ok = results.filter((r) => r.status === "ok").length;
+  const already = results.filter((r) => r.status === "exists").length;
+  const warned = results.filter((r) => r.status === "warn").length;
+  const skipped = results.filter((r) => r.status === "skip").length;
+  const errored = results.filter((r) => r.status === "err").length;
+
+  console.log("");
+  console.log(colors.dim(t("CHECKOUT_LEGEND")));
+  console.log(
+    colors.bold(
+      t("CHECKOUT_SUMMARY__OK_EXISTS_WARN_SKIP_ERR", {
+        ok, exists: already, warn: warned, skip: skipped, err: errored,
+      })
+    )
+  );
+}
+
+async function main() {
+  const args = parseCheckoutArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  if (!args.branch) {
+    console.error(t("CHECKOUT_MISSING_BRANCH"));
+    console.error(t("CHECKOUT_MISSING_BRANCH_HELP"));
+    process.exit(1);
+  }
+
+  const mode = args.forceCreate ? "reset -B" : args.create ? "create -b" : "switch";
+
+  const { repos, workspaceRoot } = loadManifestRepos({
+    manifestPath: args.manifest,
+    baseDir: args.baseDir,
+  });
+
+  const targets = await resolveMultiTargets({
+    repos,
+    workspaceRoot,
+    includeWorkspace: !args.noWorkspace,
+    selection: args.selection,
+    action: t("CHECKOUT_SELECT_ACTION__MODE_BRANCH", { mode, branch: args.branch }),
+  });
+
+  const fromPart = args.startPoint
+    ? t("CHECKOUT_HEADER_FROM_SUFFIX__START", { start: args.startPoint })
+    : "";
+  console.log("");
+  console.log(
+    colors.bold(
+      t("CHECKOUT_HEADER__MODE_BRANCH_FROM_N", {
+        mode, branch: args.branch, fromPart, n: targets.length,
+      })
+    )
+  );
+  for (const target of targets) {
+    console.log(colors.dim(`  • ${target.name}  (${target.destination})`));
+  }
+
+  const results = [];
+  for (const target of targets) {
+    const result = processRepo({
+      name: target.name,
+      destination: target.destination,
+      branch: args.branch,
+      create: args.create,
+      forceCreate: args.forceCreate,
+      startPoint: args.startPoint,
+      dryRun: args.dryRun,
+    });
+    results.push(result);
+  }
+
+  printSummary(results, { branch: args.branch, mode });
+
+  const hasError = results.some(
+    (item) => item.status === "err" || item.status === "warn"
+  );
+  process.exit(hasError ? 1 : 0);
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});