pan-stack-cli 0.1.5 → 0.2.1

package/lib/git/git-mr.js

@@ -0,0 +1,546 @@
+#!/usr/bin/env node
+/*
+ * Create GitLab Merge Requests for 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.
+ *
+ * Does NOT auto-push — run `pan push` first if HEAD is not on the remote yet.
+ * Skips repos with no commits ahead of origin/<target>.
+ *
+ * Token resolution order:
+ *   1. --token flag
+ *   2. GITLAB_TOKEN env var
+ *   3. GITLAB_TOKEN in <workspace>/.pan-env-build.yaml
+ */
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const {
+  looksLikeManifest,
+  loadManifestRepos,
+  printCommonOptions,
+} = require("./helpers/cli");
+const colors = require("./helpers/colors");
+const { resolveMultiTargets } = require("./helpers/repo-select");
+const { runGitCapture, getCurrentBranch, refExists } = require("./helpers/git");
+const { t } = require("../i18n");
+
+const ICON = {
+  ok: "✓",
+  exists: "=",
+  warn: "!",
+  skip: "-",
+  err: "✗",
+};
+
+const DEFAULT_TARGET_BRANCH = "main";
+
+function printHelp() {
+  console.log(`usage: pan mr [target] [repo|all|repo1,repo2] [options]
+
+Tạo GitLab Merge Request cho 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:
+  target             Branch đích (default: ${DEFAULT_TARGET_BRANCH}). Vd: pan mr develop
+  repo|all|<list>    Repo tạo MR: tên repo trong .project.yaml, "all",
+                     hoặc danh sách phân tách bởi phẩy/space.
+
+${printCommonOptions()}
+  --no-workspace       Bỏ qua workspace root (chỉ repo con)
+  --gitlab-host HOST   Override GitLab host (default: derive từ origin URL)
+  --token TOKEN        Override GitLab token (default: env → .pan-env-build.yaml)
+
+examples:
+  pan mr                            # target=main, chọn tương tác
+  pan mr develop                    # target=develop, chọn tương tác
+  pan mr main all                   # target=main, tất cả repo
+  pan mr main csdl-cc-backend       # target=main, một repo
+  pan mr main csdl-cc-backend,csdl-cc-b-frontend
+
+env:
+  GITLAB_TOKEN         Personal Access Token (scope: api).
+                       Fallback: đọc từ <workspace>/.pan-env-build.yaml.`);
+}
+
+function parseMrArgs(argv) {
+  const args = {
+    help: false,
+    manifest: "",
+    baseDir: ".",
+    dryRun: false,
+    noWorkspace: false,
+    gitlabHost: "",
+    token: "",
+    target: "",
+    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 === "--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 === "--gitlab-host") {
+      args.gitlabHost = argv[++index] || "";
+      continue;
+    }
+    if (arg === "--token") {
+      args.token = argv[++index] || "";
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    if (looksLikeManifest(arg) && !args.manifest) {
+      args.manifest = arg;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  if (positional[0]) {
+    args.target = positional[0];
+  }
+  if (positional.length > 1) {
+    args.selection = positional.slice(1).join(" ");
+  }
+
+  return args;
+}
+
+// ── Env & URL helpers ───────────────────────────────────────────────────────
+
+function loadGitlabToken(workspaceRoot, override) {
+  if (override) {
+    return override;
+  }
+  if (process.env.GITLAB_TOKEN) {
+    return process.env.GITLAB_TOKEN;
+  }
+  const envFile = path.join(workspaceRoot, ".pan-env-build.yaml");
+  if (!fs.existsSync(envFile)) {
+    return "";
+  }
+  const content = fs.readFileSync(envFile, "utf8");
+  for (const rawLine of content.split(/\r?\n/)) {
+    let line = rawLine;
+    const commentIdx = line.indexOf("#");
+    if (commentIdx >= 0) {
+      line = line.slice(0, commentIdx);
+    }
+    line = line.trim();
+    if (!line) {
+      continue;
+    }
+    const idx = line.indexOf(":");
+    if (idx < 0) {
+      continue;
+    }
+    const key = line.slice(0, idx).trim();
+    let val = line.slice(idx + 1).trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    if (key === "GITLAB_TOKEN" && val) {
+      return val;
+    }
+  }
+  return "";
+}
+
+function extractProjectPath(originUrl) {
+  return String(originUrl || "")
+    .replace(/^https?:\/\/[^/]+\//, "")
+    .replace(/^git@[^:]+:/, "")
+    .replace(/\.git$/, "");
+}
+
+function extractGitlabHost(originUrl) {
+  const httpsMatch = String(originUrl || "").match(/^https?:\/\/([^/]+)/);
+  if (httpsMatch) {
+    return httpsMatch[1];
+  }
+  const sshMatch = String(originUrl || "").match(/^git@([^:]+):/);
+  if (sshMatch) {
+    return sshMatch[1];
+  }
+  return "";
+}
+
+function getOriginUrl(directory) {
+  const result = runGitCapture(["remote", "get-url", "origin"], {
+    cwd: directory,
+  });
+  if (result.status !== 0) {
+    return "";
+  }
+  return result.stdout;
+}
+
+function apiRequest(host, method, urlPath, token, body) {
+  return new Promise((resolve, reject) => {
+    const payload = body != null ? Buffer.from(body, "utf8") : null;
+    const options = {
+      hostname: host,
+      port: 443,
+      path: urlPath,
+      method,
+      headers: {
+        "PRIVATE-TOKEN": token,
+        "User-Agent": "pan-stack-cli",
+        Accept: "application/json",
+      },
+    };
+    if (payload) {
+      options.headers["Content-Type"] = "application/json";
+      options.headers["Content-Length"] = payload.length;
+    }
+
+    const req = https.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const text = Buffer.concat(chunks).toString("utf8");
+        resolve({ status: res.statusCode || 0, body: text });
+      });
+    });
+    req.on("error", (err) => reject(err));
+    if (payload) {
+      req.write(payload);
+    }
+    req.end();
+  });
+}
+
+// ── Per-repo processing ────────────────────────────────────────────────────
+
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function truncate(text, max) {
+  const clean = String(text || "").replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+
+async function processRepo({
+  name,
+  destination,
+  target,
+  token,
+  gitlabHostOverride,
+  dryRun,
+}) {
+  const record = { name, status: "", message: "", url: "" };
+
+  if (!fs.existsSync(path.join(destination, ".git"))) {
+    return { ...record, status: "skip", message: t("MR_MSG_NOT_CLONED") };
+  }
+
+  const originUrl = getOriginUrl(destination);
+  if (!originUrl) {
+    return { ...record, status: "skip", message: t("MR_MSG_NO_ORIGIN") };
+  }
+
+  const projPath = extractProjectPath(originUrl);
+  const host = gitlabHostOverride || extractGitlabHost(originUrl);
+  if (!host) {
+    return {
+      ...record,
+      status: "err",
+      message: t("MR_MSG_HOST_PARSE__URL", { url: originUrl }),
+    };
+  }
+
+  const branch = getCurrentBranch(destination);
+  if (!branch) {
+    return { ...record, status: "skip", message: t("MR_MSG_HEAD_DETACHED") };
+  }
+  if (branch === target) {
+    return {
+      ...record,
+      status: "skip",
+      message: t("MR_MSG_ON_TARGET__TARGET", { target }),
+    };
+  }
+
+  console.log(colors.dim(`→ [${name}] fetch origin...`));
+  runGitCapture(["fetch", "--quiet", "origin"], { cwd: destination });
+
+  if (!refExists(destination, `refs/remotes/origin/${target}`)) {
+    return {
+      ...record,
+      status: "err",
+      message: t("MR_MSG_ORIGIN_MISSING__TARGET", { target }),
+    };
+  }
+
+  const aheadTargetResult = runGitCapture(
+    ["rev-list", "--count", `origin/${target}..HEAD`],
+    { cwd: destination }
+  );
+  const aheadTarget = Number.parseInt(aheadTargetResult.stdout || "0", 10) || 0;
+  if (aheadTarget === 0) {
+    return {
+      ...record,
+      status: "skip",
+      message: t("MR_MSG_NO_AHEAD__TARGET", { target }),
+    };
+  }
+
+  if (!refExists(destination, `refs/remotes/origin/${branch}`)) {
+    return {
+      ...record,
+      status: "warn",
+      message: t("MR_MSG_BRANCH_MISSING_REMOTE__BRANCH", { branch }),
+    };
+  }
+  const aheadRemoteResult = runGitCapture(
+    ["rev-list", "--count", `origin/${branch}..HEAD`],
+    { cwd: destination }
+  );
+  const aheadRemote = Number.parseInt(aheadRemoteResult.stdout || "0", 10) || 0;
+  if (aheadRemote > 0) {
+    return {
+      ...record,
+      status: "warn",
+      message: t("MR_MSG_HEAD_AHEAD__BRANCH_N", { branch, n: aheadRemote }),
+    };
+  }
+
+  const apiBase = `/api/v4/projects/${encodeURIComponent(projPath)}`;
+  const listQuery =
+    `${apiBase}/merge_requests?state=opened` +
+    `&source_branch=${encodeURIComponent(branch)}` +
+    `&target_branch=${encodeURIComponent(target)}`;
+
+  if (dryRun) {
+    return {
+      ...record,
+      status: "skip",
+      message: t("MR_MSG_DRY_RUN_GET__URL", { url: `https://${host}${listQuery}` }),
+    };
+  }
+
+  let listRes;
+  try {
+    listRes = await apiRequest(host, "GET", listQuery, token);
+  } catch (err) {
+    return { ...record, status: "err", message: t("MR_MSG_GET_ERROR__MSG", { msg: err.message }) };
+  }
+  if (listRes.status !== 200) {
+    return {
+      ...record,
+      status: "err",
+      message: t("MR_MSG_GET_HTTP__STATUS_BODY", {
+        status: listRes.status, body: truncate(listRes.body, 200),
+      }),
+    };
+  }
+  const list = safeJsonParse(listRes.body);
+  if (Array.isArray(list) && list.length > 0 && list[0].web_url) {
+    return {
+      ...record,
+      status: "exists",
+      url: list[0].web_url,
+      message: list[0].web_url,
+    };
+  }
+
+  const titleResult = runGitCapture(
+    ["log", "--reverse", "--pretty=%s", `origin/${target}..HEAD`],
+    { cwd: destination }
+  );
+  const firstTitle = (titleResult.stdout || "").split(/\r?\n/)[0] || "";
+  const title = firstTitle || `Merge ${branch} → ${target}`;
+  const descResult = runGitCapture(
+    ["log", "--pretty=- %s (%h)", `origin/${target}..HEAD`],
+    { cwd: destination }
+  );
+  const description = descResult.stdout || "";
+
+  const body = JSON.stringify({
+    source_branch: branch,
+    target_branch: target,
+    title,
+    description,
+    remove_source_branch: false,
+    squash: false,
+  });
+
+  let createRes;
+  try {
+    createRes = await apiRequest(
+      host,
+      "POST",
+      `${apiBase}/merge_requests`,
+      token,
+      body
+    );
+  } catch (err) {
+    return { ...record, status: "err", message: t("MR_MSG_POST_ERROR__MSG", { msg: err.message }) };
+  }
+  if (createRes.status !== 201) {
+    return {
+      ...record,
+      status: "err",
+      message: t("MR_MSG_POST_HTTP__STATUS_BODY", {
+        status: createRes.status, body: truncate(createRes.body, 300),
+      }),
+    };
+  }
+  const created = safeJsonParse(createRes.body);
+  if (created && created.web_url) {
+    return {
+      ...record,
+      status: "ok",
+      url: created.web_url,
+      message: created.web_url,
+    };
+  }
+  return { ...record, status: "err", message: t("MR_MSG_NO_WEB_URL") };
+}
+
+// ── Reporting ──────────────────────────────────────────────────────────────
+
+function styleForStatus(status) {
+  switch (status) {
+    case "ok":
+      return { icon: ICON.ok, suffix: t("MR_LABEL_NEW"), color: colors.green };
+    case "exists":
+      return { icon: ICON.exists, suffix: t("MR_LABEL_EXISTS"), color: colors.cyan };
+    case "warn":
+      return { icon: ICON.warn, suffix: "", color: colors.yellow };
+    case "skip":
+      return { icon: ICON.skip, suffix: "", color: colors.dim };
+    case "err":
+      return { icon: ICON.err, suffix: "", color: colors.red };
+    default:
+      return { icon: "?", suffix: "", color: (text) => text };
+  }
+}
+
+function printSummary(results, { target }) {
+  const nameWidth = results.reduce(
+    (max, item) => Math.max(max, item.name.length),
+    0
+  );
+
+  console.log("");
+  console.log(colors.bold(t("MR_RESULT_HEADER__TARGET", { target })));
+  for (const result of results) {
+    const { icon, suffix, color } = styleForStatus(result.status);
+    const line = `${icon} ${result.name.padEnd(nameWidth)}  ${result.message}${suffix}`;
+    console.log(color(line));
+  }
+
+  const created = results.filter((r) => r.status === "ok").length;
+  const existing = 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("MR_LEGEND")));
+  console.log(
+    colors.bold(
+      t("MR_SUMMARY__OK_EXISTS_WARN_SKIP_ERR", {
+        ok: created, exists: existing, warn: warned, skip: skipped, err: errored,
+      })
+    )
+  );
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = parseMrArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const target = (args.target || DEFAULT_TARGET_BRANCH).trim();
+
+  const { repos, workspaceRoot } = loadManifestRepos({
+    manifestPath: args.manifest,
+    baseDir: args.baseDir,
+  });
+
+  const token = loadGitlabToken(workspaceRoot, args.token);
+  if (!token) {
+    console.error(t("MR_MISSING_TOKEN"));
+    console.error(t("MR_MISSING_TOKEN_1"));
+    console.error(t("MR_MISSING_TOKEN_2__PATH", { path: workspaceRoot }));
+    console.error(t("MR_MISSING_TOKEN_URL"));
+    process.exit(1);
+  }
+
+  const targets = await resolveMultiTargets({
+    repos,
+    workspaceRoot,
+    includeWorkspace: !args.noWorkspace,
+    selection: args.selection,
+    action: t("MR_SELECT_ACTION__TARGET", { target }),
+  });
+
+  console.log("");
+  console.log(
+    colors.bold(t("MR_HEADER__TARGET_N", { target, n: targets.length }))
+  );
+  for (const target1 of targets) {
+    console.log(colors.dim(`  • ${target1.name}  (${target1.destination})`));
+  }
+
+  const results = [];
+  for (const target1 of targets) {
+    console.log("");
+    const result = await processRepo({
+      name: target1.name,
+      destination: target1.destination,
+      target,
+      token,
+      gitlabHostOverride: args.gitlabHost,
+      dryRun: args.dryRun,
+    });
+    results.push(result);
+  }
+
+  printSummary(results, { target });
+
+  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);
+});