nugit-cli 0.0.1-alpha → 0.1.0

package/src/stack-view/view-tui-sequential.js

@@ -0,0 +1,126 @@
+import React from "react";
+import { render } from "ink";
+import { StackPickInk } from "./stack-pick-ink.js";
+import { inferChainsToPickStacks } from "./infer-chains-to-pick-stacks.js";
+import { clearInkScreen } from "./terminal-fullscreen.js";
+
+/** Resolved by {@link pickStackIndexWithInk} when Backspace requests the repo picker (allowBackToRepo only). */
+export const STACK_PICK_BACK_TO_REPO = Symbol("STACK_PICK_BACK_TO_REPO");
+
+/**
+ * @param {object} args
+ * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string, prs: unknown[], tip_updated_at?: string, inferChainIndex?: number, inferDiffAdd?: number, inferDiffDel?: number }[]} args.stacks
+ * @param {string} [args.title]
+ * @param {boolean} [args.allowBackToRepo]
+ * @param {number | null | undefined} [args.viewingTipPrNumber]
+ * @param {string | null | undefined} [args.viewingHeadRef]
+ * @returns {Promise<(typeof args.stacks)[0] | null | typeof STACK_PICK_BACK_TO_REPO>}
+ */
+function runStackPickInkOnce({
+  stacks,
+  title = "Choose stack to view",
+  allowBackToRepo = false,
+  /** When true with {@link allowBackToRepo}, Esc and q also return to repo (repo-picker loop only). */
+  escapeToRepo = false,
+  viewingTipPrNumber,
+  viewingHeadRef
+}) {
+  clearInkScreen();
+  return new Promise((resolve) => {
+    let settled = false;
+    const inst = render(
+      React.createElement(StackPickInk, {
+        stacks,
+        title,
+        viewingTipPrNumber,
+        viewingHeadRef,
+        escapeToRepo: escapeToRepo === true,
+        onPick: (picked) => {
+          if (!settled) {
+            settled = true;
+            try {
+              inst.clear();
+            } catch {
+              /* ignore */
+            }
+            resolve(picked);
+          }
+        },
+        onRequestBack:
+          allowBackToRepo === true
+            ? () => {
+                if (!settled) {
+                  settled = true;
+                  try {
+                    inst.clear();
+                  } catch {
+                    /* ignore */
+                  }
+                  resolve(STACK_PICK_BACK_TO_REPO);
+                }
+              }
+            : undefined
+      })
+    );
+    void inst.waitUntilExit().then(() => {
+      try {
+        inst.clear();
+      } catch {
+        /* ignore */
+      }
+      if (!settled) {
+        settled = true;
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string, prs: unknown[], tip_updated_at?: string }[]} stacks
+ * @param {{ allowBackToRepo?: boolean, escapeToRepo?: boolean, viewingTipPrNumber?: number | null, viewingHeadRef?: string | null }} [opts]
+ * @returns {Promise<(typeof stacks)[0] | null | typeof STACK_PICK_BACK_TO_REPO>}
+ */
+export async function pickStackIndexWithInk(stacks, opts) {
+  return runStackPickInkOnce({
+    stacks,
+    title: "Choose stack to view",
+    allowBackToRepo: opts?.allowBackToRepo === true,
+    escapeToRepo: opts?.escapeToRepo === true,
+    viewingTipPrNumber: opts?.viewingTipPrNumber,
+    viewingHeadRef: opts?.viewingHeadRef
+  });
+}
+
+/**
+ * @param {number[][]} chains bottom → tip PR numbers per chain
+ * @param {unknown[]} pulls GitHub pull objects (same list used to build chains)
+ * @param {{ allowBackToRepo?: boolean }} [opts] Backspace resolves -2 for repo-picker loop
+ * @returns {Promise<number>} chain index, or -1 for q / cancel (use largest stack), or -2 back to repo
+ */
+export async function pickInferChainIndexWithInk(chains, pulls, opts) {
+  const stacks = inferChainsToPickStacks(chains, pulls);
+  const r = await runStackPickInkOnce({
+    stacks,
+    title: "Choose stack to view",
+    allowBackToRepo: opts?.allowBackToRepo === true,
+    escapeToRepo: opts?.allowBackToRepo === true
+  });
+  if (r === STACK_PICK_BACK_TO_REPO) {
+    return -2;
+  }
+  if (r == null) {
+    return -1;
+  }
+  if (typeof r.inferChainIndex === "number") {
+    return r.inferChainIndex;
+  }
+  const tip = typeof r.tip_pr_number === "number" ? r.tip_pr_number : null;
+  if (tip != null) {
+    const fi = chains.findIndex((c) => Array.isArray(c) && c.length > 0 && c[c.length - 1] === tip);
+    if (fi >= 0) {
+      return fi;
+    }
+  }
+  return -1;
+}