pan-stack-cli 0.1.0

package/lib/git/git-gst.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/*
+ * Git status for PAN Stack project repositories.
+ *
+ * Alias tương đương gst trong oh-my-zsh — chạy git status trên workspace + repo con.
+ */
+
+const path = require("path");
+const { parseCommonArgs, loadManifestRepos, printCommonOptions } = require("./helpers/cli");
+const { ensureRepoExists, isGitRepo, runGitStatus } = require("./helpers/git");
+
+function printRepoStatus({ label, destination, dryRun, gitArgs }) {
+  const statusArgs = gitArgs.length > 0 ? gitArgs.join(" ") : "";
+  if (dryRun) {
+    console.log(`[dry-run] (in ${destination}) git status ${statusArgs}`.trim());
+    return;
+  }
+
+  console.log(`== ${label} ==`);
+  console.log(destination);
+  runGitStatus(destination, gitArgs);
+  console.log("");
+}
+
+function showWorkspaceRootStatus({ manifestPath, baseDir, dryRun, gitArgs }) {
+  const workspaceRoot = path.resolve(baseDir || path.dirname(manifestPath || ".project.yaml"));
+  if (!isGitRepo(workspaceRoot)) {
+    return;
+  }
+
+  printRepoStatus({
+    label: "workspace",
+    destination: workspaceRoot,
+    dryRun,
+    gitArgs,
+  });
+}
+
+function printHelp() {
+  console.log(`usage: git-gst.js [--base-dir BASE_DIR] [--dry-run] [--no-workspace] [manifest] [git status args...]
+
+Run git status for workspace root and each repository in the manifest.
+Extra args are forwarded to git status (vd: -s, -sb).
+
+${printCommonOptions()}
+  --no-workspace       Skip workspace root (chỉ repo trong manifest)`);
+}
+
+function main() {
+  const args = parseCommonArgs(process.argv.slice(2), {
+    defaults: { noWorkspace: false, gitArgs: [] },
+    passthrough: true,
+    handlers: {
+      "--no-workspace": (parsed) => {
+        parsed.noWorkspace = true;
+      },
+    },
+  });
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const gitArgs = args.gitArgs || [];
+  const manifestPath = path.resolve(args.manifest || ".project.yaml");
+  const repos = loadManifestRepos({
+    manifestPath,
+    baseDir: args.baseDir,
+  });
+
+  if (!args.noWorkspace) {
+    showWorkspaceRootStatus({
+      manifestPath,
+      baseDir: args.baseDir,
+      dryRun: args.dryRun,
+      gitArgs,
+    });
+  }
+
+  for (const repo of repos) {
+    if (!ensureRepoExists({ name: repo.name, destination: repo.destination })) {
+      continue;
+    }
+    printRepoStatus({
+      label: repo.name,
+      destination: repo.destination,
+      dryRun: args.dryRun,
+      gitArgs,
+    });
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/lib/git/git-pull.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/*
+ * Pull latest changes for PAN Stack project repositories from a clone manifest.
+ *
+ * Skips repositories that do not exist or are not git checkouts. Failures warn
+ * and continue so one broken repo does not block the rest.
+ */
+
+const { parseCommonArgs, loadManifestRepos, printCommonOptions } = require("./helpers/cli");
+const { ensureRepoExists, runGit } = require("./helpers/git");
+
+function pullRepo({ name, destination, dryRun, rebase }) {
+  if (!ensureRepoExists({ name, destination })) {
+    return;
+  }
+
+  const gitArgs = ["pull"];
+  if (rebase) {
+    gitArgs.push("--rebase");
+  }
+
+  const status = runGit(gitArgs, {
+    cwd: destination,
+    dryRun,
+    action: "pull",
+    name,
+  });
+  if (status !== 0) {
+    console.log(`[warn] ${name}: pull failed, check branch state or remote access`);
+  }
+}
+
+function printHelp() {
+  console.log(`usage: git-pull.js [--base-dir BASE_DIR] [--dry-run] [--rebase] [manifest]
+
+Pull latest changes for repositories listed in a PAN Stack clone manifest.
+
+${printCommonOptions()}
+  --rebase             Use git pull --rebase`);
+}
+
+function main() {
+  const args = parseCommonArgs(process.argv.slice(2), {
+    defaults: { rebase: false },
+    handlers: {
+      "--rebase": (parsed) => {
+        parsed.rebase = true;
+      },
+    },
+  });
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const repos = loadManifestRepos({
+    manifestPath: args.manifest,
+    baseDir: args.baseDir,
+  });
+
+  for (const repo of repos) {
+    pullRepo({
+      name: repo.name,
+      destination: repo.destination,
+      dryRun: args.dryRun,
+      rebase: args.rebase,
+    });
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/lib/git/git-push.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/*
+ * Push local commits for PAN Stack project repositories from a clone manifest.
+ *
+ * Skips repositories that do not exist or are not git checkouts. Failures warn
+ * and continue so one broken repo does not block the rest.
+ */
+
+const { parseCommonArgs, loadManifestRepos, printCommonOptions } = require("./helpers/cli");
+const { ensureRepoExists, runGit } = require("./helpers/git");
+
+function pushRepo({ name, destination, dryRun, setUpstream }) {
+  if (!ensureRepoExists({ name, destination })) {
+    return;
+  }
+
+  const gitArgs = ["push"];
+  if (setUpstream) {
+    gitArgs.push("-u", "origin", "HEAD");
+  }
+
+  const status = runGit(gitArgs, {
+    cwd: destination,
+    dryRun,
+    action: "push",
+    name,
+  });
+  if (status !== 0) {
+    console.log(`[warn] ${name}: push failed, check branch state or remote access`);
+  }
+}
+
+function printHelp() {
+  console.log(`usage: git-push.js [--base-dir BASE_DIR] [--dry-run] [--set-upstream] [manifest]
+
+Push local commits for repositories listed in a PAN Stack clone manifest.
+
+${printCommonOptions()}
+  --set-upstream       Use git push -u origin HEAD for new branches`);
+}
+
+function main() {
+  const args = parseCommonArgs(process.argv.slice(2), {
+    defaults: { setUpstream: false },
+    handlers: {
+      "--set-upstream": (parsed) => {
+        parsed.setUpstream = true;
+      },
+    },
+  });
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const repos = loadManifestRepos({
+    manifestPath: args.manifest,
+    baseDir: args.baseDir,
+  });
+
+  for (const repo of repos) {
+    pushRepo({
+      name: repo.name,
+      destination: repo.destination,
+      dryRun: args.dryRun,
+      setUpstream: args.setUpstream,
+    });
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/lib/git/helpers/cli.js

@@ -0,0 +1,103 @@
+const path = require("path");
+const fs = require("fs");
+const { parseManifest, manifestRepos, validateRepo } = require("./manifest");
+
+function parseCommonArgs(argv, extraFlags = {}) {
+  const args = {
+    manifest: "",
+    baseDir: ".",
+    dryRun: false,
+    ...extraFlags.defaults,
+  };
+
+  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 (extraFlags.handlers && extraFlags.handlers[arg]) {
+      extraFlags.handlers[arg](args, argv, () => {
+        index += 1;
+        return argv[index];
+      });
+    } else if (extraFlags.passthrough) {
+      if (!args.manifest && looksLikeManifest(arg)) {
+        args.manifest = arg;
+      } else {
+        args.gitArgs = args.gitArgs || [];
+        args.gitArgs.push(arg);
+      }
+    } else if (!args.manifest) {
+      args.manifest = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  return args;
+}
+
+function looksLikeManifest(arg) {
+  if (arg.endsWith(".yaml") || arg.endsWith(".yml")) {
+    return true;
+  }
+  try {
+    return fs.existsSync(arg) && fs.statSync(arg).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function loadManifestRepos({ manifestPath, baseDir }) {
+  const resolvedManifest = path.resolve(manifestPath || ".project.yaml");
+  if (!fs.existsSync(resolvedManifest)) {
+    throw new Error(`Manifest not found: ${manifestPath || ".project.yaml"}`);
+  }
+
+  const data = parseManifest(resolvedManifest);
+  const repos = manifestRepos(data);
+  if (repos.length === 0) {
+    throw new Error("No repositories found in manifest.");
+  }
+
+  const resolvedBaseDir = path.resolve(baseDir);
+  const results = [];
+  for (const repo of repos) {
+    try {
+      const { name, url, repoPath } = validateRepo(repo);
+      results.push({
+        name,
+        url,
+        repoPath,
+        destination: path.resolve(resolvedBaseDir, repoPath),
+      });
+    } catch (error) {
+      console.log(`[warn] ${error.message}`);
+    }
+  }
+
+  if (results.length === 0) {
+    throw new Error("No valid repositories found in manifest.");
+  }
+
+  return results;
+}
+
+function printCommonOptions() {
+  return `positional arguments:
+  manifest             Path to clone manifest YAML. Default: .project.yaml
+
+options:
+  -h, --help           show this help message and exit
+  --base-dir BASE_DIR  Base directory for relative repo paths. Default: current directory.
+  --dry-run            Print commands only`;
+}
+
+module.exports = {
+  parseCommonArgs,
+  loadManifestRepos,
+  printCommonOptions,
+};

package/lib/git/helpers/git.js

@@ -0,0 +1,61 @@
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+function isGitRepo(directory) {
+  return fs.existsSync(path.join(directory, ".git"));
+}
+
+function runGit(gitArgs, { cwd, dryRun, action, name }) {
+  const command = ["git", ...gitArgs];
+  if (dryRun) {
+    console.log(`[dry-run] (in ${cwd}) ${command.join(" ")}`);
+    return 0;
+  }
+
+  console.log(`[${action}] ${name}: ${cwd}`);
+  const result = spawnSync(command[0], command.slice(1), { stdio: "inherit", cwd });
+  return result.status ?? 1;
+}
+
+function ensureRepoExists({ name, destination }) {
+  if (!fs.existsSync(destination)) {
+    console.log(`[skip] ${name}: ${destination} does not exist`);
+    return false;
+  }
+  if (!isGitRepo(destination)) {
+    console.log(`[skip] ${name}: ${destination} is not a git repository`);
+    return false;
+  }
+  return true;
+}
+
+function listRemotesVerbose(directory) {
+  const result = spawnSync("git", ["remote", "-v"], {
+    cwd: directory,
+    encoding: "utf8",
+  });
+  if (result.status !== 0) {
+    return [];
+  }
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+}
+
+function runGitStatus(directory, gitArgs = []) {
+  const result = spawnSync("git", ["status", ...gitArgs], {
+    cwd: directory,
+    stdio: "inherit",
+  });
+  return result.status ?? 1;
+}
+
+module.exports = {
+  isGitRepo,
+  runGit,
+  ensureRepoExists,
+  listRemotesVerbose,
+  runGitStatus,
+};

package/lib/git/helpers/manifest.js

@@ -0,0 +1,130 @@
+const fs = require("fs");
+
+const PLACEHOLDER_VALUES = new Set(["", "repo_url_to_be_filled", "pan_stack_repo_url"]);
+
+function cleanValue(value) {
+  let result = String(value || "").trim();
+  const commentIndex = result.indexOf(" #");
+  if (commentIndex >= 0) {
+    result = result.slice(0, commentIndex).trimEnd();
+  }
+  if (
+    (result.startsWith('"') && result.endsWith('"')) ||
+    (result.startsWith("'") && result.endsWith("'"))
+  ) {
+    result = result.slice(1, -1);
+  }
+  return result;
+}
+
+function splitKeyValue(text) {
+  const index = text.indexOf(":");
+  if (index < 0) {
+    return [text.trim(), ""];
+  }
+  return [text.slice(0, index).trim(), cleanValue(text.slice(index + 1))];
+}
+
+function parseManifest(manifestPath) {
+  const data = { repositories: [], stack: {} };
+  let section = "";
+  let currentRepo = null;
+
+  const lines = fs.readFileSync(manifestPath, "utf8").split(/\r?\n/);
+  for (const rawLine of lines) {
+    if (!rawLine.trim() || rawLine.trimStart().startsWith("#")) {
+      continue;
+    }
+
+    const indent = rawLine.length - rawLine.trimStart().length;
+    const text = rawLine.trim();
+
+    if (indent === 0) {
+      const [key, value] = splitKeyValue(text);
+      section = key;
+      currentRepo = null;
+      if (value) {
+        data[key] = value;
+      } else if (!(key in data)) {
+        data[key] = {};
+      }
+      continue;
+    }
+
+    if (section === "stack" && indent === 2) {
+      const [key, value] = splitKeyValue(text);
+      data.stack[key] = value;
+      continue;
+    }
+
+    if (section === "repositories") {
+      if (indent === 2 && text.startsWith("- ")) {
+        currentRepo = {};
+        data.repositories.push(currentRepo);
+        const rest = text.slice(2).trim();
+        if (rest) {
+          const [key, value] = splitKeyValue(rest);
+          currentRepo[key] = value;
+        }
+        continue;
+      }
+      if (currentRepo && indent === 4) {
+        const [key, value] = splitKeyValue(text);
+        currentRepo[key] = value;
+        continue;
+      }
+    }
+  }
+
+  return data;
+}
+
+function uniqueRepos(repos) {
+  const seen = new Set();
+  const result = [];
+  for (const repo of repos) {
+    const key = [
+      cleanValue(repo.name),
+      cleanValue(repo.url),
+      cleanValue(repo.path),
+    ].join("\u0000");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(repo);
+  }
+  return result;
+}
+
+function manifestRepos(data) {
+  const repositories = data.repositories || [];
+  return uniqueRepos(repositories);
+}
+
+function validateRepo(repo) {
+  const name = cleanValue(repo.name);
+  const url = cleanValue(repo.url);
+  const repoPath = cleanValue(repo.path) || name;
+
+  if (!name) {
+    throw new Error("Repository entry is missing 'name'.");
+  }
+  if (PLACEHOLDER_VALUES.has(url)) {
+    throw new Error(`Repository '${name}' is missing a real url.`);
+  }
+  if (!repoPath) {
+    throw new Error(`Repository '${name}' is missing 'path'.`);
+  }
+  return { name, url, repoPath };
+}
+
+module.exports = {
+  PLACEHOLDER_VALUES,
+  cleanValue,
+  splitKeyValue,
+  parseManifest,
+  uniqueRepos,
+  manifestRepos,
+  validateRepo,
+};