git-stack-cli 2.9.1 → 2.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "",
   "author": "magus",
   "license": "MIT",

package/scripts/bun-build.ts

@@ -48,6 +48,10 @@ const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
 
 const define = await get_define();
 
+if (DEV) {
+  define["process.env.DEV"] = JSON.stringify("true");
+}
+
 const BUILD_CONFIG = {
   entrypoints: ["./src/index.tsx"],
   outdir: "./dist/js",

package/scripts/core/get_define.ts

@@ -5,7 +5,7 @@ import { spawn } from "~/core/spawn";
 
 const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
 
-export async function get_define() {
+export async function get_define(): Promise<Record<string, string>> {
   const PACKAGE_JSON = await file.read_json(path.join(REPO_ROOT, "package.json"));
   const GIT_SEQUENCE_EDITOR_SCRIPT_PATH = path.join(REPO_ROOT, "scripts", "git-sequence-editor.sh");
   const UNSAFE_GIT_SEQUENCE_EDITOR_SCRIPT = await file.read_text(GIT_SEQUENCE_EDITOR_SCRIPT_PATH);

package/src/app/App.tsx

@@ -5,6 +5,7 @@ import { CherryPickCheck } from "~/app/CherryPickCheck";
 import { DependencyCheck } from "~/app/DependencyCheck";
 import { DetectInitialPR } from "~/app/DetectInitialPR";
 import { DirtyCheck } from "~/app/DirtyCheck";
+import { FetchPullRequests } from "~/app/FetchPullRequests";
 import { GatherMetadata } from "~/app/GatherMetadata";
 import { GithubApiError } from "~/app/GithubApiError";
 import { HandleCtrlCSigint } from "~/app/HandleCtrlCSigint";
@@ -100,9 +101,11 @@ function MaybeMain() {
       <DependencyCheck>
         <DirtyCheck>
           <GatherMetadata>
-            <LocalCommitStatus>
-              <Rebase />
-            </LocalCommitStatus>
+            <FetchPullRequests>
+              <LocalCommitStatus>
+                <Rebase />
+              </LocalCommitStatus>
+            </FetchPullRequests>
           </GatherMetadata>
         </DirtyCheck>
       </DependencyCheck>
@@ -117,11 +120,13 @@ function MaybeMain() {
         <DirtyCheck>
           <GatherMetadata>
             <RequireBranch>
-              <LocalCommitStatus>
-                <DetectInitialPR>
-                  <Main />
-                </DetectInitialPR>
-              </LocalCommitStatus>
+              <FetchPullRequests>
+                <LocalCommitStatus>
+                  <DetectInitialPR>
+                    <Main />
+                  </DetectInitialPR>
+                </LocalCommitStatus>
+              </FetchPullRequests>
             </RequireBranch>
           </GatherMetadata>
         </DirtyCheck>

package/src/app/AutoUpdate.tsx

@@ -152,6 +152,12 @@ export function AutoUpdate(props: Props) {
     init_state().catch(abort);
 
     async function init_state() {
+      if (process.env.DEV === "true") {
+        info(<Ink.Text color={colors.yellow}>Skip AutoUpdate</Ink.Text>);
+        patch({ status: "done" });
+        return;
+      }
+
       if (state.latest_version !== null) return;
 
       const local_version = process.env.CLI_VERSION;

package/src/app/FetchPullRequests.tsx

@@ -0,0 +1,40 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Await } from "~/app/Await";
+import { Store } from "~/app/Store";
+import { colors } from "~/core/colors";
+import * as github from "~/core/github";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export function FetchPullRequests(props: Props) {
+  const fallback = <Ink.Text color={colors.yellow}>Fetching pull requests…</Ink.Text>;
+
+  return (
+    <Await fallback={fallback} function={run}>
+      {props.children}
+    </Await>
+  );
+}
+
+async function run() {
+  const actions = Store.getState().actions;
+
+  try {
+    // gather all open prs in repo at once
+    // cheaper query to populate cache
+    await github.pr_list();
+  } catch (err) {
+    actions.error("Unable to fetch pull requests.");
+
+    if (err instanceof Error) {
+      actions.error(err.message);
+    }
+
+    actions.exit(24);
+  }
+}

package/src/app/GithubApiError.tsx

@@ -15,7 +15,12 @@ type Props = {
 };
 
 export function GithubApiError(props: Props) {
-  return <Await fallback={null} function={() => run(props)} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Fetching Github API usage…</Ink.Text>}
+      function={() => run(props)}
+    />
+  );
 }
 
 async function run(props: Props) {

package/src/app/PostRebaseStatus.tsx

@@ -6,17 +6,20 @@ import { Await } from "~/app/Await";
 import { StatusTable } from "~/app/StatusTable";
 import { Store } from "~/app/Store";
 import * as CommitMetadata from "~/core/CommitMetadata";
+import { colors } from "~/core/colors";
 
 export function PostRebaseStatus() {
-  return <Await fallback={null} function={run} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Fetching latest status…</Ink.Text>}
+      function={run}
+    />
+  );
 }
 
 async function run() {
   const actions = Store.getState().actions;
 
-  // reset github pr cache before refreshing via commit range below
-  actions.reset_pr();
-
   const commit_range = await CommitMetadata.range();
 
   actions.set((state) => {

package/src/app/PreManualRebase.tsx

@@ -14,7 +14,12 @@ import { invariant } from "~/core/invariant";
 import { safe_exists } from "~/core/safe_exists";
 
 export function PreManualRebase() {
-  return <Await fallback={null} function={run} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Check PR templates…</Ink.Text>}
+      function={run}
+    />
+  );
 }
 
 async function run() {

package/src/app/Status.tsx

@@ -9,7 +9,12 @@ import { colors } from "~/core/colors";
 import { invariant } from "~/core/invariant";
 
 export function Status() {
-  return <Await fallback={null} function={run} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Fetching latest status…</Ink.Text>}
+      function={run}
+    />
+  );
 }
 
 async function run() {

package/src/app/Store.tsx

@@ -76,7 +76,9 @@ export type State = {
   output: Array<React.ReactNode>;
   pending_output: Record<string, Array<React.ReactNode>>;
 
+  // cache
   pr: { [branch: string]: PullRequest };
+  cache_pr_diff: { [id: number]: string };
 
   actions: {
     exit(code: number, args?: ExitArgs): void;
@@ -90,7 +92,6 @@ export type State = {
 
     isDebug(): boolean;
 
-    reset_pr(): void;
     register_abort_handler(abort_handler: AbortHandler): void;
     unregister_abort_handler(): void;
 
@@ -138,6 +139,7 @@ const BaseStore = createStore<State>()(
     pending_output: {},
 
     pr: {},
+    cache_pr_diff: {},
 
     actions: {
       exit(code, args) {
@@ -177,7 +179,7 @@ const BaseStore = createStore<State>()(
       json(value) {
         set((state) => {
           const node = pretty_json(value);
-          state.mutate.output(state, { node });
+          state.actions.debug(node);
         });
       },
 
@@ -228,12 +230,6 @@ const BaseStore = createStore<State>()(
         return state.select.debug(state);
       },
 
-      reset_pr() {
-        set((state) => {
-          state.pr = {};
-        });
-      },
-
       register_abort_handler(abort_handler) {
         set((state) => {
           state.abort_handler = abort_handler;

package/src/app/SyncGithub.tsx

@@ -13,6 +13,7 @@ import { colors } from "~/core/colors";
 import * as github from "~/core/github";
 import { invariant } from "~/core/invariant";
 import { safe_exists } from "~/core/safe_exists";
+import { sleep } from "~/core/sleep";
 
 import type * as CommitMetadata from "~/core/CommitMetadata";
 
@@ -159,6 +160,25 @@ async function run() {
 
     actions.unregister_abort_handler();
 
+    // invalidate cache for PRs we pushed
+    actions.set((state) => {
+      for (const group of push_group_list) {
+        if (group.pr) {
+          delete state.pr[group.pr.headRefName];
+          delete state.cache_pr_diff[group.pr.number];
+        }
+      }
+    });
+
+    // wait a bit for github to settle after push / edits above
+    // we github.pr_list returns outdated information if called too quickly
+    await sleep(400);
+
+    // gather all open prs in repo at once
+    // cheaper query to populate cache
+    await github.pr_list();
+
+    // move to next step
     actions.set((state) => {
       state.step = "post-rebase-status";
     });
@@ -185,9 +205,13 @@ async function run() {
 
       const group = commit_range.group_list[index];
 
-      if (group.id !== commit_range.UNASSIGNED) {
-        push_group_list.unshift(group);
-      }
+      // skip the unassigned commits group
+      if (group.id === commit_range.UNASSIGNED) continue;
+
+      // if not --force, skip non-dirty master_base groups
+      if (group.master_base && !group.dirty && !argv.force) continue;
+
+      push_group_list.unshift(group);
     }
 
     return push_group_list;
@@ -300,14 +324,14 @@ async function run() {
   async function push_master_group(group: CommitMetadataGroup) {
     invariant(repo_root, "repo_root must exist");
 
-    const worktree_path = `.git/git-stack-worktrees/push_master_group`;
-    const worktree_path_absolute = path.join(repo_root, worktree_path);
+    const repo_rel_worktree_path = `.git/git-stack-worktrees/push_master_group`;
+    const worktree_path = path.join(repo_root, repo_rel_worktree_path);
 
     // ensure worktree for pushing master groups
-    if (!(await safe_exists(worktree_path_absolute))) {
+    if (!(await safe_exists(worktree_path))) {
       actions.output(
         <Ink.Text color={colors.white}>
-          Creating <Ink.Text color={colors.yellow}>{worktree_path}</Ink.Text>
+          Creating <Ink.Text color={colors.yellow}>{repo_rel_worktree_path}</Ink.Text>
         </Ink.Text>,
       );
       actions.output(

package/src/command.ts

@@ -60,7 +60,11 @@ export async function command(argv: string[], options: CommandOptions = {}) {
     .command(
       "config",
       "Generate a one-time configuration json based on the passed arguments",
-      (yargs) => yargs,
+      (yargs) => {
+        // match options for default command (since we are generating a config for its options)
+        let builder = yargs.options(DefaultOptions);
+        return builder;
+      },
     )
 
     .command(

package/src/commands/Config.tsx

@@ -10,7 +10,12 @@ import { colors } from "~/core/colors";
 import { invariant } from "~/core/invariant";
 
 export function Config() {
-  return <Await fallback={null} function={run} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Generating config…</Ink.Text>}
+      function={run}
+    />
+  );
 
   async function run() {
     const state = Store.getState();

package/src/commands/Fixup.tsx

@@ -10,7 +10,12 @@ import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
 
 export function Fixup() {
-  return <Await fallback={null} function={run} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Fixing up commits…</Ink.Text>}
+      function={run}
+    />
+  );
 }
 
 async function run() {

package/src/commands/Log.tsx

@@ -5,13 +5,19 @@ import * as Ink from "ink-cjs";
 import { Await } from "~/app/Await";
 import { Store } from "~/app/Store";
 import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
 import { invariant } from "~/core/invariant";
 
 export function Log() {
   const { stdout } = Ink.useStdout();
   const available_width = stdout.columns || 80;
 
-  return <Await fallback={null} function={() => run({ available_width })} />;
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Generating log…</Ink.Text>}
+      function={() => run({ available_width })}
+    />
+  );
 }
 
 type Args = {

package/src/core/CommitMetadata.ts

@@ -1,3 +1,5 @@
+/* eslint-disable no-console */
+
 import { Store } from "~/app/Store";
 import * as git from "~/core/git";
 import * as github from "~/core/github";
@@ -26,11 +28,11 @@ type CommitRangeGroup = {
 type CommitGroupMap = { [sha: string]: CommitRangeGroup };
 
 export async function range(commit_group_map?: CommitGroupMap) {
-  // gather all open prs in repo first
-  // cheaper query to populate cache
-  await github.pr_list();
+  const DEBUG = process.env.DEV && false;
 
-  const master_branch = Store.getState().master_branch;
+  const state = Store.getState();
+  const actions = state.actions;
+  const master_branch = state.master_branch;
   const master_branch_name = master_branch.replace(/^origin\//, "");
   const commit_list = await git.get_commits(`${master_branch}..HEAD`);
 
@@ -163,16 +165,16 @@ export async function range(commit_group_map?: CommitGroupMap) {
       // console.debug("  ", "group.base", group.base);
     }
 
-    // console.debug({ group });
+    actions.json({ group });
 
     if (!group.pr) {
       group.dirty = true;
     } else {
       if (group.pr.baseRefName !== group.base) {
-        // console.debug("PR_BASEREF_MISMATCH");
+        actions.debug("PR_BASEREF_MISMATCH");
         group.dirty = true;
       } else if (group.master_base) {
-        // console.debug("MASTER_BASE_DIFF_COMPARE");
+        actions.debug("MASTER_BASE_DIFF_COMPARE");
 
         // special case
         // master_base groups cannot be compared by commit sha
@@ -180,13 +182,15 @@ export async function range(commit_group_map?: CommitGroupMap) {
         // gh pr diff --color=never 110
         // git --no-pager diff --color=never 00c8fe0~1..00c8fe0
         let diff_github = await github.pr_diff(group.pr.number);
-        diff_github = diff_strip_index_lines(diff_github);
+        diff_github = normalize_diff(diff_github);
 
         let diff_local = await git.get_diff(group.commits);
-        diff_local = diff_strip_index_lines(diff_local);
+        diff_local = normalize_diff(diff_local);
+
+        actions.json({ diff_local, diff_github });
 
         // find the first differing character index
-        let compare_length = Math.min(diff_github.length, diff_local.length);
+        let compare_length = Math.max(diff_github.length, diff_local.length);
         let diff_index = -1;
         for (let c_i = 0; c_i < compare_length; c_i++) {
           if (diff_github[c_i] !== diff_local[c_i]) {
@@ -197,23 +201,25 @@ export async function range(commit_group_map?: CommitGroupMap) {
         if (diff_index > -1) {
           group.dirty = true;
 
-          // // print preview at diff_index for both strings
-          // const preview_radius = 30;
-          // const start_index = Math.max(0, diff_index - preview_radius);
-          // const end_index = Math.min(compare_length, diff_index + preview_radius);
+          if (DEBUG) {
+            // print preview at diff_index for both strings
+            const preview_radius = 30;
+            const start_index = Math.max(0, diff_index - preview_radius);
+            const end_index = Math.min(compare_length, diff_index + preview_radius);
 
-          // diff_github = diff_github.substring(start_index, end_index);
-          // diff_github = JSON.stringify(diff_github).slice(1, -1);
+            diff_github = diff_github.substring(start_index, end_index);
+            diff_github = JSON.stringify(diff_github).slice(1, -1);
 
-          // diff_local = diff_local.substring(start_index, end_index);
-          // diff_local = JSON.stringify(diff_local).slice(1, -1);
+            diff_local = diff_local.substring(start_index, end_index);
+            diff_local = JSON.stringify(diff_local).slice(1, -1);
 
-          // let pointer_indent = " ".repeat(diff_index - start_index + 1);
-          // console.warn(`⚠️ git diff mismatch`);
-          // console.warn(`              ${pointer_indent}⌄`);
-          // console.warn(`diff_github  …${diff_github}…`);
-          // console.warn(`diff_local   …${diff_local}…`);
-          // console.warn(`              ${pointer_indent}⌃`);
+            let pointer_indent = " ".repeat(diff_index - start_index + 1);
+            actions.debug(`⚠️ git diff mismatch`);
+            actions.debug(`              ${pointer_indent}⌄`);
+            actions.debug(`diff_github  …${diff_github}…`);
+            actions.debug(`diff_local   …${diff_local}…`);
+            actions.debug(`              ${pointer_indent}⌃`);
+          }
         }
       } else if (!group.master_base && previous_group && previous_group.master_base) {
         // special case
@@ -233,10 +239,10 @@ export async function range(commit_group_map?: CommitGroupMap) {
 
         // compare all commits against pr commits
         if (group.pr.commits.length !== all_commits.length) {
-          // console.debug("BOUNDARY_COMMIT_LENGTH_MISMATCH");
+          actions.debug("BOUNDARY_COMMIT_LENGTH_MISMATCH");
           group.dirty = true;
         } else {
-          // console.debug("BOUNDARY_COMMIT_SHA_COMPARISON");
+          actions.debug("BOUNDARY_COMMIT_SHA_COMPARISON");
           for (let i = 0; i < group.pr.commits.length; i++) {
             const pr_commit = group.pr.commits[i];
             const local_commit = all_commits[i];
@@ -247,10 +253,10 @@ export async function range(commit_group_map?: CommitGroupMap) {
           }
         }
       } else if (group.pr.commits.length !== group.commits.length) {
-        // console.debug("COMMIT_LENGTH_MISMATCH");
+        actions.debug("COMMIT_LENGTH_MISMATCH");
         group.dirty = true;
       } else {
-        // console.debug("COMMIT_SHA_COMPARISON");
+        actions.debug("COMMIT_SHA_COMPARISON");
         // if we still haven't marked this dirty, check each commit
         // comapre literal commit shas in group
         for (let i = 0; i < group.pr.commits.length; i++) {
@@ -258,6 +264,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
           const local_commit = group.commits[i];
 
           if (pr_commit.oid !== local_commit.sha) {
+            actions.json({ pr_commit, local_commit });
             group.dirty = true;
           }
         }
@@ -280,10 +287,17 @@ export async function range(commit_group_map?: CommitGroupMap) {
 
 export const UNASSIGNED = "unassigned";
 
-function diff_strip_index_lines(diff_text: string) {
-  return diff_text.replace(RE.diff_index_line, "");
+function normalize_diff(diff_text: string) {
+  diff_text = diff_text.replace(RE.diff_index_line, "");
+  diff_text = diff_text.replace(RE.diff_section_header, "");
+  return diff_text;
 }
 
 const RE = {
+  // index 8b7c5f7b37688..84124e0a677ca 100644
+  // https://regex101.com/r/YBwF6P/1
   diff_index_line: /^index [0-9a-f]+\.\.[0-9a-f]+.*?\n/gm,
+  // @@ -29,6 +29,7 @@ from caas_cli import cli as caas_cli  # type: ignore
+  // https://regex101.com/r/ohMeDC/1
+  diff_section_header: /^@@ .*? @@(?: .*)?\n/gm,
 };