nugit-cli 0.1.0 → 0.1.1

package/src/nugit.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import fs from "fs";
 import chalk from "chalk";
 import { Command } from "commander";
 import {
@@ -7,148 +6,102 @@ import {
   pollDeviceFlow,
   pollDeviceFlowUntilComplete,
   savePat,
-  listMyPulls,
-  listOpenPullsInRepo,
-  fetchRemoteStackJson,
-  getPull,
-  authMe,
-  createPullRequest,
-  getRepoMetadata
+  authMe
 } from "./api-client.js";
-import {
-  findGitRoot,
-  readStackFile,
-  writeStackFile,
-  createInitialStackDoc,
-  validateStackDoc,
-  parseRepoFullName,
-  nextStackPosition,
-  stackEntryFromGithubPull,
-  stackJsonPath,
-  parseStackAddPrNumbers
-} from "./nugit-stack.js";
-import { runStackPropagate } from "./stack-propagate.js";
-import { registerStackExtraCommands } from "./stack-extra-commands.js";
+import { findGitRoot, parseRepoFullName } from "./nugit-stack.js";
 import { runNugitViewEntry } from "./stack-view/run-view-entry.js";
-import {
-  printJson,
-  formatWhoamiHuman,
-  formatPrSearchHuman,
-  formatOpenPullsHuman,
-  formatStackDocHuman,
-  formatStackEnrichHuman,
-  formatStacksListHuman,
-  formatPrCreatedHuman,
-  formatPatOkHuman
-} from "./cli-output.js";
 import { getRepoFullNameFromGitRoot } from "./git-info.js";
-import { discoverStacksInRepo } from "./stack-discover.js";
-import { getStackDiscoveryOpts, effectiveMaxOpenPrs } from "./stack-discovery-config.js";
 import {
-  tryLoadStackIndex,
-  writeStackIndex,
-  compileStackGraph,
-  readStackHistoryLines
-} from "./stack-graph.js";
-import { runSplitCommand } from "./split-view/run-split.js";
-import { getConfigPath } from "./user-config.js";
+  runConfigInit,
+  runConfigShow,
+  runConfigSet,
+  runEnvExport
+} from "./nugit-config.js";
 import { openInBrowser } from "./open-browser.js";
 import {
   writeStoredGithubToken,
   clearStoredGithubToken,
   getGithubTokenPath
 } from "./token-store.js";
-import {
-  runConfigInit,
-  runConfigShow,
-  runConfigSet,
-  runEnvExport,
-  runStart,
-  runStartHub
-} from "./nugit-start.js";
+import { getConfigPath } from "./user-config.js";
+import { runNugitTui } from "./tui/run-tui.js";
 
 const program = new Command();
-program.name("nugit").description("Nugit CLI — stack state in .nugit/stack.json");
+program.name("nugit").description("Nugit — browse and review stacked GitHub PRs");
+
+// ---------------------------------------------------------------------------
+// Default: TTY → launch the TUI; non-TTY scripting flags supported
+//
+//   nugit                         → TUI (home screen)
+//   nugit --repo owner/repo       → TUI starting from that repo's stack viewer
+//   nugit --no-tui --repo o/r     → print stack summary (non-interactive)
+//   nugit --review-hub            → TUI review hub
+//   nugit --no-tui --review-hub   → print sorted repo list
+// ---------------------------------------------------------------------------
 
 program
-  .command("init")
-  .description(
-    "Create or reset .nugit/stack.json (empty prs[]); clears any existing stack in that file"
-  )
-  .option("--repo <owner/repo>", "Override repository full name")
-  .option("--user <github-login>", "Override created_by metadata")
+  .option("--no-tui", "Non-interactive: print stack summary or repo list to stdout")
+  .option("--repo <owner/repo>", "Skip home screen and open this repo directly")
+  .option("--ref <branch>", "Branch or SHA for --repo (default: GitHub default branch)")
+  .option("--review-hub", "Open review hub instead of home screen")
+  .option("--auto-apply", "With --review-hub: auto-approve allowlisted PRs when stale approval + merge-only delta")
   .action(async (opts) => {
-    const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
-    const repoFull = opts.repo || getRepoFullNameFromGitRoot(root);
-    let user = opts.user;
-    if (!user) {
-      const me = await authMe();
-      user = me.login;
-      if (!user) {
-        throw new Error(
-          "Could not resolve login; pass --user or run `nugit auth login` / set NUGIT_USER_TOKEN"
-        );
+    const tty = process.stdin.isTTY && process.stdout.isTTY;
+
+    if (opts.reviewHub) {
+      if (!opts.tui || !tty) {
+        const { runReviewHub } = await import("./review-hub/run-review-hub.js");
+        await runReviewHub({ noTui: true, autoApply: !!opts.autoApply });
+        return;
       }
-      console.error(`Using GitHub login: ${user}`);
+      await runNugitTui({ startAt: "review_hub" });
+      return;
     }
-    let cleared = 0;
-    const p = stackJsonPath(root);
-    if (fs.existsSync(p)) {
-      try {
-        const prev = JSON.parse(fs.readFileSync(p, "utf8"));
-        if (prev && Array.isArray(prev.prs)) {
-          cleared = prev.prs.length;
-        }
-      } catch {
-        /* ignore parse errors */
+
+    if (opts.repo) {
+      const repoFull = String(opts.repo);
+      if (!opts.tui || !tty) {
+        await runNugitViewEntry(repoFull, opts.ref, { noTui: true });
+        return;
       }
+      await runNugitTui({ startRepo: repoFull, startRef: opts.ref });
+      return;
     }
-    const doc = createInitialStackDoc(repoFull, user);
-    writeStackFile(root, doc);
-    console.log(`Wrote ${root}/.nugit/stack.json (${repoFull})`);
-    if (cleared > 0) {
-      console.error(`Cleared previous stack (${cleared} PR${cleared === 1 ? "" : "s"}).`);
+
+    if (tty) {
+      await runNugitTui({});
+    } else {
+      program.outputHelp();
     }
-    console.error(
-      "Add PRs with `nugit stack add --pr N [N...]` (bottom→top), then `nugit stack propagate` (auto-commits this file on the tip if needed)."
-    );
   });
 
+// ---------------------------------------------------------------------------
+// auth
+// ---------------------------------------------------------------------------
+
 const auth = new Command("auth").description("GitHub authentication");
 
 auth
   .command("login")
   .description(
-    "OAuth device flow: opens browser (pre-filled code), waits for approval, saves token to ~/.config/nugit/github-token. Uses bundled OAuth App client id unless GITHUB_OAUTH_CLIENT_ID is set. NUGIT_USER_TOKEN still overrides the saved file."
+    "OAuth device flow: opens browser (pre-filled code), waits for approval, saves token to ~/.config/nugit/github-token. " +
+      "Uses bundled OAuth App client id unless GITHUB_OAUTH_CLIENT_ID is set."
   )
   .option("--no-browser", "Do not launch a browser (open the printed URL yourself)", false)
-  .option(
-    "--no-wait",
-    "Only request a device code and print instructions (use nugit auth poll --device-code …)",
-    false
-  )
+  .option("--no-wait", "Only request a device code and print instructions (use nugit auth poll --device-code …)", false)
   .option("--json", "With --no-wait: raw device response. Otherwise: { login, token_path } after save", false)
   .action(async (opts) => {
     const result = await startDeviceFlow();
     const deviceCode = result.device_code;
-    if (!deviceCode || typeof deviceCode !== "string") {
-      throw new Error("GitHub did not return device_code");
-    }
+    if (!deviceCode || typeof deviceCode !== "string") throw new Error("GitHub did not return device_code");
     const interval = Number(result.interval) || 5;
 
     if (opts.noWait) {
       if (opts.json) {
-        printJson(result);
+        console.log(JSON.stringify(result, null, 2));
       } else if (result.verification_uri && result.user_code) {
-        console.error(
-          `Open ${result.verification_uri} and enter code ${chalk.bold(String(result.user_code))}`
-        );
-        console.error(
-          `Then: ${chalk.bold(`nugit auth poll --device-code ${deviceCode}`)} (poll every ${interval}s)`
-        );
+        console.error(`Open ${result.verification_uri} and enter code ${chalk.bold(String(result.user_code))}`);
+        console.error(`Then: ${chalk.bold(`nugit auth poll --device-code ${deviceCode}`)} (poll every ${interval}s)`);
       }
       return;
     }
@@ -156,9 +109,7 @@ auth
     const baseUri = String(result.verification_uri || "https://github.com/login/device");
     const userCode = result.user_code != null ? String(result.user_code) : "";
     const sep = baseUri.includes("?") ? "&" : "?";
-    const verifyUrl = userCode
-      ? `${baseUri}${sep}user_code=${encodeURIComponent(userCode)}`
-      : baseUri;
+    const verifyUrl = userCode ? `${baseUri}${sep}user_code=${encodeURIComponent(userCode)}` : baseUri;
 
     if (opts.noBrowser) {
       console.error(`Open in your browser:\n  ${chalk.blue.underline(verifyUrl)}`);
@@ -170,30 +121,18 @@ auth
         console.error(`Could not open a browser. Open:\n  ${chalk.blue.underline(verifyUrl)}`);
       }
     }
-    if (userCode) {
-      console.error(`If prompted, code: ${chalk.bold(userCode)}`);
-    }
+    if (userCode) console.error(`If prompted, code: ${chalk.bold(userCode)}`);
     console.error(chalk.dim("\nWaiting for you to authorize on GitHub…\n"));
 
     const final = await pollDeviceFlowUntilComplete(deviceCode, interval);
-    if (!final.access_token) {
-      throw new Error("No access_token from GitHub");
-    }
+    if (!final.access_token) throw new Error("No access_token from GitHub");
     const me = await savePat(final.access_token);
     writeStoredGithubToken(final.access_token);
     const tokenPath = getGithubTokenPath();
     if (opts.json) {
-      printJson({
-        login: me.login,
-        token_path: tokenPath,
-        saved: true
-      });
+      console.log(JSON.stringify({ login: me.login, token_path: tokenPath, saved: true }, null, 2));
     } else {
-      console.error(
-        chalk.green(
-          `\nSigned in as ${chalk.bold(String(me.login))}. Token saved to ${chalk.cyan(tokenPath)}`
-        )
-      );
+      console.error(chalk.green(`\nSigned in as ${chalk.bold(String(me.login))}. Token saved to ${chalk.cyan(tokenPath)}`));
       console.error(
         chalk.dim(
           "Future `nugit` runs will use this token automatically. " +
@@ -205,9 +144,7 @@ auth
 
 auth
   .command("poll")
-  .description(
-    "Complete GitHub device flow (polls until authorized); or --once for a single poll"
-  )
+  .description("Complete GitHub device flow (polls until authorized); or --once for a single poll")
   .requiredOption("--device-code <code>", "device_code from nugit auth login")
   .option("--interval <sec>", "Initial poll interval from login response", "5")
   .option("--once", "Single poll only (manual retry)", false)
@@ -222,16 +159,9 @@ auth
       return;
     }
     if (result.access_token) {
-      const me = await savePat(result.access_token);
+      await savePat(result.access_token);
       writeStoredGithubToken(result.access_token);
-      const t = JSON.stringify(result.access_token);
-      console.error(
-        `\nToken saved to ${chalk.cyan(getGithubTokenPath())} (signed in as ${chalk.bold(String(me.login))}).`
-      );
-      console.error(
-        chalk.dim("Optional — use env instead of file:\n") +
-          `  export NUGIT_USER_TOKEN=${t}\n  # or: export STACKPR_USER_TOKEN=${t}`
-      );
+      console.error(`\nToken saved to ${chalk.cyan(getGithubTokenPath())} (signed in as ${chalk.bold(String((await authMe()).login))}).`);
     }
   });
 
@@ -251,13 +181,10 @@ auth
   .action(async (opts) => {
     const result = await savePat(opts.token);
     if (opts.json) {
-      printJson(result);
+      console.log(JSON.stringify(result, null, 2));
     } else {
-      console.log(formatPatOkHuman(result));
-    }
-    if (result.access_token) {
-      const t = JSON.stringify(result.access_token);
-      console.error(`\nexport NUGIT_USER_TOKEN=${t}\n# or: export STACKPR_USER_TOKEN=${t}`);
+      const login = result.login || result.me?.login;
+      console.log(login ? chalk.green(`Token valid — signed in as ${chalk.bold(String(login))}`) : chalk.green("Token valid"));
     }
   });
 
@@ -268,575 +195,90 @@ auth
   .action(async (opts) => {
     const me = await authMe();
     if (opts.json) {
-      printJson(me);
+      console.log(JSON.stringify(me, null, 2));
     } else {
-      console.log(formatWhoamiHuman(/** @type {Record<string, unknown>} */ (me)));
+      const login = me && typeof me.login === "string" ? me.login : "(unknown)";
+      console.log(login);
     }
   });
 
 program.addCommand(auth);
 
+// ---------------------------------------------------------------------------
+// config
+// ---------------------------------------------------------------------------
+
 const config = new Command("config").description(
-  "Persist monorepo path + .env for `nugit start` or `eval \"$(nugit env)\"`"
+  "Persist install root + .env path for `eval \"$(nugit env)\"`"
 );
 
 config
   .command("init")
-  .description(
-    "Write ~/.config/nugit/config.json (defaults: this repo root + <root>/.env)"
-  )
+  .description("Write ~/.config/nugit/config.json (defaults: this repo root + <root>/.env)")
   .option("--install-root <path>", "Nugit monorepo root (contains scripts/ and cli/)")
   .option("--env-file <path>", "Dotenv file to load (default: <install-root>/.env)")
-  .option(
-    "--working-directory <path>",
-    "Default cwd when running `nugit start` (optional)"
-  )
+  .option("--working-directory <path>", "Default cwd when running `nugit start` (optional)")
   .action(async (opts) => {
-    runConfigInit({
-      installRoot: opts.installRoot,
-      envFile: opts.envFile,
-      workingDirectory: opts.workingDirectory
-    });
+    runConfigInit({ installRoot: opts.installRoot, envFile: opts.envFile, workingDirectory: opts.workingDirectory });
   });
 
 config
   .command("show")
   .description("Print saved config JSON")
-  .action(() => {
-    runConfigShow();
-  });
+  .action(() => runConfigShow());
 
 config
   .command("path")
   .description("Print path to config.json")
-  .action(() => {
-    console.log(getConfigPath());
-  });
+  .action(() => console.log(getConfigPath()));
 
 config
   .command("set")
   .description("Set install-root, env-file, or working-directory")
   .argument("<key>", "install-root | env-file | working-directory")
   .argument("<value>", "path")
-  .action((key, value) => {
-    runConfigSet(key, value);
-  });
+  .action((key, value) => runConfigSet(key, value));
 
 program.addCommand(config);
 
+// ---------------------------------------------------------------------------
+// env
+// ---------------------------------------------------------------------------
+
 program
-  .command("start")
-  .description(
-    "Interactive shell with saved .env + PATH including nugit scripts (needs `nugit config init`)"
-  )
-  .option(
-    "-c, --command <string>",
-    "Run one command via shell -lc instead of opening an interactive shell"
-  )
-  .option(
-    "--shell",
-    "Open the configured shell immediately (skip the TTY hub menu: view / split / shell)",
-    false
-  )
+  .command("env")
+  .description("Print export lines from saved config — bash/zsh: eval \"$(nugit env)\"")
+  .option("--fish", "Emit fish `set -gx` instead of sh export", false)
   .action(async (opts) => {
-    if (opts.command) {
-      runStart({ command: opts.command });
-      return;
-    }
-    const tty = process.stdin.isTTY && process.stdout.isTTY;
-    if (opts.shell || !tty) {
-      runStart({});
-      return;
-    }
-    await runStartHub();
+    runEnvExport(opts.fish ? "fish" : "bash");
   });
 
+// ---------------------------------------------------------------------------
+// split
+// ---------------------------------------------------------------------------
+
 program
   .command("split")
   .description(
-    "Split one PR into layered branches and new GitHub PRs (TUI assigns files to layers; updates local stack.json when the PR is listed there)"
+    "Split one PR into layered branches and new GitHub PRs (TUI assigns files to layers)"
   )
   .requiredOption("--pr <n>", "PR number to split")
   .option("--dry-run", "Materialize local branches only; do not push or create PRs", false)
   .option("--remote <name>", "Git remote name", "origin")
   .action(async (opts) => {
     const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
+    if (!root) throw new Error("Not inside a git repository");
     const repoFull = getRepoFullNameFromGitRoot(root);
     const { owner, repo: repoName } = parseRepoFullName(repoFull);
     const n = Number.parseInt(String(opts.pr), 10);
-    if (!Number.isFinite(n) || n < 1) {
-      throw new Error("Invalid --pr");
-    }
-    await runSplitCommand({
-      root,
-      owner,
-      repo: repoName,
-      prNumber: n,
-      dryRun: opts.dryRun,
-      remote: opts.remote
-    });
+    if (!Number.isFinite(n) || n < 1) throw new Error("Invalid --pr");
+    const { runSplitCommand } = await import("./split-view/run-split.js");
+    await runSplitCommand({ root, owner, repo: repoName, prNumber: n, dryRun: opts.dryRun, remote: opts.remote });
   });
 
-program
-  .command("view")
-  .description(
-    "Interactive stack viewer (GitHub). Pass owner/repo and optional ref, or run with no args on a TTY to search/pick a repo (and [c] for this directory’s remote)."
-  )
-  .argument("[repo]", "owner/repo")
-  .argument("[ref]", "branch or sha (default: GitHub default branch)")
-  .option("--no-tui", "Print stack + comment counts to stdout (no Ink UI)", false)
-  .option("--repo <owner/repo>", "Same as [repo] (for scripts)")
-  .option("--ref <branch>", "Same as [ref]")
-  .option("--file <path>", "Load stack.json from this path")
-  .action(async (repoArg, refArg, opts) => {
-    await runNugitViewEntry(repoArg, refArg, opts);
-  });
-
-program
-  .command("review")
-  .description(
-    "Review hub: repos you can access (OAuth or PAT), pending review requests first; open inferred PR stacks in the TUI. See docs/stack-view.md."
-  )
-  .option("--no-tui", "Print repo list (sorted by pending reviews) instead of Ink picker", false)
-  .option(
-    "--auto-apply",
-    "After loading a stack, auto-approve allowlisted PRs when stale approval + merge-only delta (review-autoapprove.json)",
-    false
-  )
-  .action(async (opts) => {
-    const { runReviewHub } = await import("./review-hub/run-review-hub.js");
-    await runReviewHub({ noTui: opts.noTui, autoApply: opts.autoApply });
-  });
-
-program
-  .command("env")
-  .description(
-    "Print export lines from saved config — bash/zsh: eval \"$(nugit env)\""
-  )
-  .option("--fish", "Emit fish `set -gx` instead of sh export", false)
-  .action(async (opts) => {
-    runEnvExport(opts.fish ? "fish" : "bash");
-  });
-
-const prs = new Command("prs").description("Pull requests");
-
-prs
-  .command("list")
-  .description(
-    "List open PRs in the repo (default: origin from cwd), paginated — use numbers with nugit stack add. Use --mine for only your PRs."
-  )
-  .option("--repo <owner/repo>", "Repository (default: github.com remote from current git repo)")
-  .option("--mine", "Only PRs authored by you (GitHub search)", false)
-  .option("--page <n>", "Page number (1-based)", "1")
-  .option("--per-page <n>", "Results per page (max 100)", "20")
-  .option("--json", "Print raw API response", false)
-  .action(async (opts) => {
-    const page = Number.parseInt(String(opts.page), 10) || 1;
-    const perPage = Math.min(100, Math.max(1, Number.parseInt(String(opts.perPage), 10) || 20));
-    const root = findGitRoot();
-    const repoFull =
-      opts.repo || (root ? getRepoFullNameFromGitRoot(root) : null);
-    if (!repoFull) {
-      throw new Error("Pass --repo owner/repo or run inside a git clone with a github.com origin");
-    }
-    const { owner, repo } = parseRepoFullName(repoFull);
-
-    if (opts.mine) {
-      const result = await listMyPulls({
-        repo: repoFull,
-        page,
-        perPage
-      });
-      if (opts.json) {
-        printJson(result);
-      } else {
-        console.log(
-          formatPrSearchHuman(/** @type {{ total_count?: number, items?: unknown[] }} */ (result), {
-            page,
-            perPage
-          })
-        );
-      }
-      return;
-    }
-
-    const result = await listOpenPullsInRepo(owner, repo, { page, perPage });
-    if (opts.json) {
-      printJson(result);
-    } else {
-      console.log(
-        formatOpenPullsHuman(
-          /** @type {{ pulls: unknown[], page: number, per_page: number, repo_full_name: string, has_more: boolean }} */ (
-            result
-          )
-        )
-      );
-    }
-  });
-
-prs
-  .command("create")
-  .description("Open a GitHub PR (push the head branch first). Repo defaults to origin.")
-  .requiredOption("--head <branch>", "Head branch name (exists on GitHub)")
-  .requiredOption("--title <title>", "PR title")
-  .option("--base <branch>", "Base branch (default: repo default_branch from GitHub)")
-  .option("--body <markdown>", "PR body")
-  .option("--repo <owner/repo>", "Override; default from git remote origin")
-  .option("--draft", "Create as draft", false)
-  .option("--json", "Print full API response", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    if (!opts.repo && !root) {
-      throw new Error("Not in a git repo: pass --repo owner/repo or run from a clone");
-    }
-    const repoFull = opts.repo || getRepoFullNameFromGitRoot(root);
-    const { owner, repo } = parseRepoFullName(repoFull);
-    let base = opts.base;
-    if (!base) {
-      const meta = await getRepoMetadata(owner, repo);
-      base = meta.default_branch;
-      if (!base) {
-        throw new Error("Could not determine default branch; pass --base");
-      }
-      console.error(`Using base branch: ${base}`);
-    }
-    const created = await createPullRequest(owner, repo, {
-      title: opts.title,
-      head: opts.head,
-      base,
-      body: opts.body,
-      draft: opts.draft
-    });
-    if (opts.json) {
-      printJson(created);
-    } else {
-      console.log(formatPrCreatedHuman(/** @type {Record<string, unknown>} */ (created)));
-    }
-    if (created.number) {
-      console.error(`\nAdd to stack: nugit stack add --pr ${created.number}`);
-    }
-  });
-
-program.addCommand(prs);
-
-const stack = new Command("stack").description("Local .nugit/stack.json");
-
-stack
-  .command("show")
-  .description("Print local .nugit/stack.json")
-  .option("--json", "Raw JSON", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
-    const doc = readStackFile(root);
-    if (!doc) {
-      throw new Error("No .nugit/stack.json in this repo");
-    }
-    validateStackDoc(doc);
-    if (opts.json) {
-      printJson(doc);
-    } else {
-      console.log(formatStackDocHuman(/** @type {Record<string, unknown>} */ (doc)));
-    }
-  });
-
-stack
-  .command("fetch")
-  .description("Fetch .nugit/stack.json from GitHub (needs token)")
-  .option("--repo <owner/repo>", "Default: git remote origin when run inside a repo")
-  .option("--ref <ref>", "branch or sha", "")
-  .option("--json", "Raw JSON", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    const repoFull =
-      opts.repo || (root ? getRepoFullNameFromGitRoot(root) : null);
-    if (!repoFull) {
-      throw new Error("Pass --repo owner/repo or run from a git clone with github.com origin");
-    }
-    const doc = await fetchRemoteStackJson(repoFull, opts.ref || undefined);
-    validateStackDoc(doc);
-    if (opts.json) {
-      printJson(doc);
-    } else {
-      console.log(formatStackDocHuman(/** @type {Record<string, unknown>} */ (doc)));
-    }
-  });
-
-stack
-  .command("enrich")
-  .description("Print stack with PR titles from GitHub (local file + API)")
-  .option("--json", "Raw JSON", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
-    const doc = readStackFile(root);
-    if (!doc) {
-      throw new Error("No .nugit/stack.json");
-    }
-    validateStackDoc(doc);
-    const { owner, repo } = parseRepoFullName(doc.repo_full_name);
-    const ordered = [...doc.prs].sort((a, b) => a.position - b.position);
-    const out = [];
-    for (const pr of ordered) {
-      try {
-        const g = await getPull(owner, repo, pr.pr_number);
-        out.push({
-          ...pr,
-          title: g.title,
-          html_url: g.html_url,
-          state: g.state
-        });
-      } catch (e) {
-        out.push({ ...pr, error: String(e.message || e) });
-      }
-    }
-    if (opts.json) {
-      printJson({ ...doc, prs: out });
-    } else {
-      console.log(
-        formatStackEnrichHuman(/** @type {Record<string, unknown>} */ (doc), /** @type {Record<string, unknown>[]} */ (out))
-      );
-    }
-  });
-
-stack
-  .command("list")
-  .description(
-    "Discover nugit stacks in the repo: scan open PR heads for .nugit/stack.json, dedupe by stack tip (for review / triage)"
-  )
-  .option("--repo <owner/repo>", "Default: github.com origin from cwd")
-  .option(
-    "--max-open-prs <n>",
-    "Max open PRs to scan (0 = all pages). Default: config / discovery mode"
-  )
-  .option(
-    "--fetch-concurrency <n>",
-    "Parallel GitHub API calls. Default: config (see stack-discovery-fetch-concurrency)"
-  )
-  .option(
-    "--full",
-    "Full scan for lazy mode (same as NUGIT_STACK_DISCOVERY_FULL=1)",
-    false
-  )
-  .option("--no-enrich", "Skip loading PR titles from the API (faster)", false)
-  .option("--json", "Machine-readable result", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    const repoFull =
-      opts.repo || (root ? getRepoFullNameFromGitRoot(root) : null);
-    if (!repoFull) {
-      throw new Error(
-        "Pass --repo owner/repo or run inside a git clone with github.com origin"
-      );
-    }
-    const { owner, repo } = parseRepoFullName(repoFull);
-    const discovery = getStackDiscoveryOpts();
-    const maxOpenPrs =
-      opts.maxOpenPrs != null && String(opts.maxOpenPrs).length
-        ? Number.parseInt(String(opts.maxOpenPrs), 10)
-        : effectiveMaxOpenPrs(discovery, opts.full);
-    const fetchConcurrency =
-      opts.fetchConcurrency != null && String(opts.fetchConcurrency).length
-        ? Math.max(1, Math.min(32, Number.parseInt(String(opts.fetchConcurrency), 10) || 8))
-        : discovery.fetchConcurrency;
-    const result = await discoverStacksInRepo(owner, repo, {
-      maxOpenPrs: Number.isNaN(maxOpenPrs) ? discovery.maxOpenPrs : maxOpenPrs,
-      enrich: !opts.noEnrich,
-      fetchConcurrency
-    });
-    if (opts.json) {
-      printJson(result);
-    } else {
-      console.log(formatStacksListHuman(result));
-    }
-  });
-
-stack
-  .command("index")
-  .description("Write .nugit/stack-index.json from GitHub discovery (for lazy/manual modes)")
-  .option("--repo <owner/repo>", "Default: github.com origin from cwd")
-  .option("--max-open-prs <n>", "Max open PRs to scan (default: config)")
-  .option("--no-enrich", "Skip PR title fetch", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
-    const repoFull =
-      opts.repo || (root ? getRepoFullNameFromGitRoot(root) : null);
-    if (!repoFull) {
-      throw new Error("Pass --repo owner/repo or run from a clone with github.com origin");
-    }
-    const { owner, repo } = parseRepoFullName(repoFull);
-    const discovery = getStackDiscoveryOpts();
-    const max =
-      opts.maxOpenPrs != null && String(opts.maxOpenPrs).length
-        ? Number.parseInt(String(opts.maxOpenPrs), 10)
-        : discovery.maxOpenPrs;
-    const result = await discoverStacksInRepo(owner, repo, {
-      maxOpenPrs: Number.isNaN(max) ? discovery.maxOpenPrs : max,
-      enrich: !opts.noEnrich,
-      fetchConcurrency: discovery.fetchConcurrency
-    });
-    writeStackIndex(root, result);
-    console.error(`Wrote ${root}/.nugit/stack-index.json (${result.stacks_found} stack(s))`);
-  });
-
-stack
-  .command("graph")
-  .description("Print compiled stack graph from stack-index.json + .nugit/stack-history.jsonl")
-  .option("--live", "Rediscover from GitHub if index missing", false)
-  .option("--json", "Machine-readable", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
-    const repoFull = getRepoFullNameFromGitRoot(root);
-    let discovered = tryLoadStackIndex(root, repoFull);
-    if (!discovered && opts.live) {
-      const { owner, repo } = parseRepoFullName(repoFull);
-      const d = getStackDiscoveryOpts();
-      discovered = await discoverStacksInRepo(owner, repo, {
-        maxOpenPrs: d.maxOpenPrs,
-        enrich: false,
-        fetchConcurrency: d.fetchConcurrency
-      });
-    }
-    if (!discovered) {
-      throw new Error("No stack-index.json — run: nugit stack index (or use --live)");
-    }
-    const hist = readStackHistoryLines(root);
-    const graph = compileStackGraph(discovered, hist);
-    if (opts.json) {
-      printJson(graph);
-    } else {
-      console.log(JSON.stringify(graph, null, 2));
-    }
-  });
-
-stack
-  .command("add")
-  .description("Append one or more PRs to the stack (metadata from GitHub), bottom→top order")
-  .requiredOption(
-    "--pr <n...>",
-    "Pull request number(s): stack order bottom first — space- or comma-separated, or repeat --pr"
-  )
-  .option("--json", "Print entries as JSON", false)
-  .action(async (opts) => {
-    const root = findGitRoot();
-    if (!root) {
-      throw new Error("Not inside a git repository");
-    }
-    const doc = readStackFile(root);
-    if (!doc) {
-      throw new Error("No .nugit/stack.json — run nugit init first");
-    }
-    validateStackDoc(doc);
-    const prNums = parseStackAddPrNumbers(opts.pr);
-    const { owner, repo } = parseRepoFullName(doc.repo_full_name);
-    /** @type {ReturnType<typeof stackEntryFromGithubPull>[]} */
-    const added = [];
-    for (const prNum of prNums) {
-      if (doc.prs.some((p) => p.pr_number === prNum)) {
-        throw new Error(`PR #${prNum} is already in the stack`);
-      }
-      const pull = await getPull(owner, repo, prNum);
-      const position = nextStackPosition(doc.prs);
-      const entry = stackEntryFromGithubPull(pull, position);
-      doc.prs.push(entry);
-      added.push(entry);
-    }
-    writeStackFile(root, doc);
-    if (opts.json) {
-      printJson(added.length === 1 ? added[0] : added);
-    } else {
-      for (const e of added) {
-        console.log(
-          chalk.bold(`PR #${e.pr_number}`) +
-            chalk.dim(`  ${e.head_branch} ← ${e.base_branch}`)
-        );
-      }
-    }
-    console.error(
-      `\nUpdated stack (${doc.prs.length} PRs). Run \`nugit stack propagate --push\` to commit the stack on the tip if needed, write prefix metadata on each head, merge lower→upper, and push.`
-    );
-  });
-
-function addPropagateOptions(cmd) {
-  return cmd
-    .option(
-      "-m, --message <msg>",
-      "Commit message for each branch",
-      "nugit: propagate stack metadata"
-    )
-    .option("--push", "Run git push for each head after committing", false)
-    .option("--dry-run", "Print git actions without changing branches or committing", false)
-    .option("--remote <name>", "Remote name (default: origin)", "origin")
-    .option(
-      "--no-merge-lower",
-      "Do not merge each lower stacked head into the current head before writing stack.json (can break PR chains; not recommended)",
-      false
-    )
-    .option(
-      "--no-bootstrap",
-      "Do not auto-commit a dirty .nugit/stack.json on the tip before propagating (you must commit it yourself)",
-      false
-    );
-}
-
-addPropagateOptions(
-  stack
-    .command("propagate")
-    .description(
-      "Commit .nugit/stack.json on each stacked head: prs prefix through that layer, plus layer (with tip). Auto-commits tip stack file if it is the only dirty path; merges each lower head into the next so PRs stay mergeable."
-    )
-).action(async (opts) => {
-  const root = findGitRoot();
-  if (!root) {
-    throw new Error("Not inside a git repository");
-  }
-  await runStackPropagate({
-    root,
-    message: opts.message,
-    push: opts.push,
-    dryRun: opts.dryRun,
-    remote: opts.remote,
-    noMergeLower: opts.noMergeLower,
-    bootstrapCommit: !opts.noBootstrap
-  });
-});
-
-addPropagateOptions(
-  stack
-    .command("commit")
-    .description("Alias for `nugit stack propagate` — prefix stack metadata on each stacked head")
-).action(async (opts) => {
-  const root = findGitRoot();
-  if (!root) {
-    throw new Error("Not inside a git repository");
-  }
-  await runStackPropagate({
-    root,
-    message: opts.message,
-    push: opts.push,
-    dryRun: opts.dryRun,
-    remote: opts.remote,
-    noMergeLower: opts.noMergeLower,
-    bootstrapCommit: !opts.noBootstrap
-  });
-});
-
-registerStackExtraCommands(stack);
-
-program.addCommand(stack);
+// ---------------------------------------------------------------------------
+// Parse
+// ---------------------------------------------------------------------------
 
 program.parseAsync().catch((error) => {
   console.error(error.message || error);