git-stack-cli 2.9.0 → 2.9.2

package/package.json

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

package/scripts/bun-build.ts

@@ -48,11 +48,15 @@ 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",
   target: "node",
-  env: "inline",
+  env: "disable",
   format: "esm",
   sourcemap: "inline",
   define,

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

@@ -2,7 +2,6 @@ import * as React from "react";
 
 import { AutoUpdate } from "~/app/AutoUpdate";
 import { CherryPickCheck } from "~/app/CherryPickCheck";
-import { Debug } from "~/app/Debug";
 import { DependencyCheck } from "~/app/DependencyCheck";
 import { DetectInitialPR } from "~/app/DetectInitialPR";
 import { DirtyCheck } from "~/app/DirtyCheck";
@@ -51,7 +50,6 @@ export function App() {
   return (
     <Providers>
       <ErrorBoundary>
-        <Debug />
         <Output />
 
         <ExitingGate>

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/Await.tsx

@@ -5,20 +5,13 @@ import { invariant } from "~/core/invariant";
 
 type Cache = ReturnType<typeof cache>;
 
-type BaseProps = {
+type Props = {
   function: Parameters<typeof cache>[0];
-};
-
-type WithChildrenProps = BaseProps & {
-  fallback: React.SuspenseProps["fallback"];
-  children: React.ReactNode;
+  fallback?: React.SuspenseProps["fallback"];
+  children?: React.ReactNode;
   delayFallbackMs?: number;
 };
 
-type WithoutChildrenProps = BaseProps;
-
-type Props = WithChildrenProps | WithoutChildrenProps;
-
 export function Await(props: Props) {
   const [display_fallback, set_display_fallback] = React.useState(false);
 
@@ -68,7 +61,7 @@ export function Await(props: Props) {
     );
   }
 
-  return <ReadCache cache={cacheRef.current} />;
+  return <ReadCache cache={cacheRef.current}>{props.children}</ReadCache>;
 }
 
 type ReadCacheProps = {

package/src/app/Exit.tsx

@@ -1,11 +1,17 @@
 import * as React from "react";
 
+import fs from "node:fs/promises";
+import path from "node:path";
+
 import * as Ink from "ink-cjs";
 
 import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
+import { get_tmp_dir } from "~/core/get_tmp_dir";
+import * as json from "~/core/json";
+import { pretty_json } from "~/core/pretty_json";
 import { sleep } from "~/core/sleep";
 
 type Props = {
@@ -29,6 +35,14 @@ Exit.handle_exit = async function handle_exit(props: Props) {
   const state = Store.getState();
   const actions = state.actions;
 
+  // write state to file for debugging
+  if (state.select.debug(state)) {
+    const tmp_state_path = path.join(await get_tmp_dir(), "git-stack-state.json");
+    await fs.writeFile(tmp_state_path, pretty_json(json.serialize(state)));
+    const output = <Ink.Text color={colors.gray}>Wrote state to {tmp_state_path}</Ink.Text>;
+    actions.output(output);
+  }
+
   actions.debug(`[Exit] handle_exit ${JSON.stringify(props)}`);
 
   let exit_code = props.code;

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/LocalCommitStatus.tsx

@@ -6,43 +6,22 @@ import { Await } from "~/app/Await";
 import { Store } from "~/app/Store";
 import * as CommitMetadata from "~/core/CommitMetadata";
 import { colors } from "~/core/colors";
-import * as json from "~/core/json";
 
 type Props = {
   children: React.ReactNode;
 };
 
 export function LocalCommitStatus(props: Props) {
-  const argv = Store.useState((state) => state.argv);
-
-  const fallback = <Ink.Text color={colors.yellow}>Fetching PR status from Github…</Ink.Text>;
-
-  if (argv["mock-metadata"]) {
-    return (
-      <Await fallback={fallback} function={mock_metadata}>
-        {props.children}
-      </Await>
-    );
-  }
-
   return (
-    <Await fallback={fallback} function={run}>
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Fetching PR status from Github…</Ink.Text>}
+      function={run}
+    >
       {props.children}
     </Await>
   );
 }
 
-async function mock_metadata() {
-  const module = await import("../__fixtures__/metadata");
-
-  const deserialized = json.deserialize(module.METADATA);
-
-  Store.setState((state) => {
-    Object.assign(state, deserialized);
-    state.step = "status";
-  });
-}
-
 async function run() {
   const actions = Store.getState().actions;
 

package/src/app/ManualRebase.tsx

@@ -129,10 +129,6 @@ async function run() {
     }
 
     actions.error("Unable to rebase.");
-    if (!argv.verbose) {
-      actions.error("Try again with `--verbose` to see more information.");
-    }
-
     actions.exit(16);
   }
 
@@ -146,7 +142,7 @@ async function run() {
     // always hard reset and clean to allow subsequent checkout
     // if there are files checkout will fail and cascade fail subsequent commands
     cli.sync(`git reset --hard`, spawn_options);
-    cli.sync(`git clean -df`, spawn_options);
+    cli.sync(`git clean -fd`, spawn_options);
 
     // always put self back in original branch
     cli.sync(`git checkout ${branch_name}`, spawn_options);

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) {
@@ -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

@@ -1,5 +1,7 @@
 import * as React from "react";
 
+import path from "node:path";
+
 import * as Ink from "ink-cjs";
 import last from "lodash/last";
 
@@ -10,6 +12,7 @@ import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
 import * as github from "~/core/github";
 import { invariant } from "~/core/invariant";
+import { safe_exists } from "~/core/safe_exists";
 
 import type * as CommitMetadata from "~/core/CommitMetadata";
 
@@ -81,9 +84,7 @@ async function run() {
       invariant(last_commit, "last_commit must exist");
 
       // push group in isolation if master_base is set
-      // for the first group (i > 0) we can skip this
-      // since it'll be based off master anyway
-      if (group.master_base && i > 0) {
+      if (group.master_base) {
         await push_master_group(group);
         continue;
       }
@@ -159,6 +160,15 @@ async function run() {
     actions.unregister_abort_handler();
 
     actions.set((state) => {
+      // invalidate cache for PRs we pushed
+      for (const group of push_group_list) {
+        if (group.pr) {
+          delete state.pr[group.pr.headRefName];
+          delete state.cache_pr_diff[group.pr.number];
+        }
+      }
+
+      // move to next step
       state.step = "post-rebase-status";
     });
   } catch (err) {
@@ -167,10 +177,6 @@ async function run() {
     }
 
     actions.error("Unable to sync.");
-    if (!argv.verbose) {
-      actions.error("Try again with `--verbose` to see more information.");
-    }
-
     actions.exit(15);
   }
 
@@ -188,9 +194,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;
@@ -301,29 +311,43 @@ async function run() {
   }
 
   async function push_master_group(group: CommitMetadataGroup) {
-    const worktree_path = `.git/git-stack-worktrees/push_master_group`;
-
-    // ensure previous instance of worktree is removed
-    await cli(`git worktree remove --force ${worktree_path}`, { ignoreExitCode: true });
-
-    // create temp worktree at master (or group.base if you prefer)
-    await cli(`git worktree add -f ${worktree_path} ${master_branch}`);
-
-    try {
-      // cherry-pick the group commits onto that base
-      const cp_commit_list = group.commits.map((c) => c.sha);
-      await cli(`git -C ${worktree_path} cherry-pick ${cp_commit_list}`);
-
-      `git -C ${worktree_path} push -f origin HEAD:refs/heads/${group.id}`;
-
-      const push_target = `HEAD:refs/heads/${group.id}`;
-      const git_push_command = create_git_push_command(`git -C ${worktree_path}`, push_target);
-
-      await cli(git_push_command);
-    } finally {
-      // clean up even if push fails
-      await cli(`git worktree remove --force ${worktree_path}`);
+    invariant(repo_root, "repo_root must exist");
+
+    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))) {
+      actions.output(
+        <Ink.Text color={colors.white}>
+          Creating <Ink.Text color={colors.yellow}>{repo_rel_worktree_path}</Ink.Text>
+        </Ink.Text>,
+      );
+      actions.output(
+        <Ink.Text color={colors.gray}>(this may take a moment the first time…)</Ink.Text>,
+      );
+      await cli(`git worktree add -f ${worktree_path} ${master_branch}`);
     }
+
+    // ensure worktree is clean + on the right base before applying commits
+    // - abort any in-progress cherry-pick/rebase
+    // - drop local changes/untracked files (including ignored) for a truly fresh state
+    // - reset to the desired base
+    await cli(`git -C ${worktree_path} cherry-pick --abort`, { ignoreExitCode: true });
+    await cli(`git -C ${worktree_path} rebase --abort`, { ignoreExitCode: true });
+    await cli(`git -C ${worktree_path} merge --abort`, { ignoreExitCode: true });
+    await cli(`git -C ${worktree_path} checkout -f ${master_branch}`);
+    await cli(`git -C ${worktree_path} reset --hard ${master_branch}`);
+    await cli(`git -C ${worktree_path} clean -fd`);
+
+    // cherry-pick the group commits onto that base
+    const cp_commit_list = group.commits.map((c) => c.sha).join(" ");
+    await cli(`git -C ${worktree_path} cherry-pick ${cp_commit_list}`);
+
+    const push_target = `HEAD:refs/heads/${group.id}`;
+    const git_push_command = create_git_push_command(`git -C ${worktree_path}`, push_target);
+
+    await cli(git_push_command);
   }
 }
 

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(
@@ -160,20 +164,6 @@ const DefaultOptions = {
       "Disable with --no-template",
     ].join("\n"),
   },
-
-  "write-state-json": {
-    hidden: true,
-    type: "boolean",
-    default: false,
-    description: "Write state to local json file for debugging",
-  },
-
-  "mock-metadata": {
-    hidden: true,
-    type: "boolean",
-    default: false,
-    description: "Mock local store metadata for testing",
-  },
 } satisfies YargsOptions;
 
 const FixupOptions = {

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/commands/Rebase.tsx

@@ -184,7 +184,7 @@ Rebase.run = async function run(props: Props) {
     // always hard reset and clean to allow subsequent checkout
     // if there are files checkout will fail and cascade fail subsequent commands
     cli.sync(`git reset --hard`, spawn_options);
-    cli.sync(`git clean -df`, spawn_options);
+    cli.sync(`git clean -fd`, spawn_options);
 
     // always put self back in original branch
     cli.sync(`git checkout ${branch_name}`, spawn_options);

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,6 +28,8 @@ type CommitRangeGroup = {
 type CommitGroupMap = { [sha: string]: CommitRangeGroup };
 
 export async function range(commit_group_map?: CommitGroupMap) {
+  const DEBUG = process.env.DEV && false;
+
   // gather all open prs in repo first
   // cheaper query to populate cache
   await github.pr_list();
@@ -163,21 +167,65 @@ export async function range(commit_group_map?: CommitGroupMap) {
       // console.debug("  ", "group.base", group.base);
     }
 
+    if (DEBUG) {
+      console.debug({ group });
+    }
+
     if (!group.pr) {
       group.dirty = true;
     } else {
       if (group.pr.baseRefName !== group.base) {
+        // console.debug("PR_BASEREF_MISMATCH");
         group.dirty = true;
-      } else if (group.master_base && i > 0) {
+      } else if (group.master_base) {
+        // console.debug("MASTER_BASE_DIFF_COMPARE");
+
         // special case
         // master_base groups cannot be compared by commit sha
         // instead compare the literal diff local against origin
         // gh pr diff --color=never 110
         // git --no-pager diff --color=never 00c8fe0~1..00c8fe0
-        const diff_github = await github.pr_diff(group.pr.number);
-        const diff_local = await git.get_diff(group.commits);
-        if (diff_github !== diff_local) {
+        let diff_github = await github.pr_diff(group.pr.number);
+        diff_github = normalize_diff(diff_github);
+
+        let diff_local = await git.get_diff(group.commits);
+        diff_local = normalize_diff(diff_local);
+
+        if (DEBUG) {
+          console.debug({ diff_local, diff_github });
+        }
+
+        // find the first differing character index
+        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]) {
+            diff_index = c_i;
+            break;
+          }
+        }
+        if (diff_index > -1) {
           group.dirty = true;
+
+          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_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}⌃`);
+          }
         }
       } else if (!group.master_base && previous_group && previous_group.master_base) {
         // special case
@@ -197,8 +245,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");
           group.dirty = true;
         } else {
+          // console.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];
@@ -209,8 +259,10 @@ export async function range(commit_group_map?: CommitGroupMap) {
           }
         }
       } else if (group.pr.commits.length !== group.commits.length) {
+        // console.debug("COMMIT_LENGTH_MISMATCH");
         group.dirty = true;
       } else {
+        // console.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++) {
@@ -239,3 +291,18 @@ export async function range(commit_group_map?: CommitGroupMap) {
 }
 
 export const UNASSIGNED = "unassigned";
+
+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,
+};