git-stack-cli 2.9.0 → 2.9.1

package/package.json

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

package/scripts/bun-build.ts

@@ -52,7 +52,7 @@ const BUILD_CONFIG = {
   entrypoints: ["./src/index.tsx"],
   outdir: "./dist/js",
   target: "node",
-  env: "inline",
+  env: "disable",
   format: "esm",
   sourcemap: "inline",
   define,

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/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/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/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;
       }
@@ -167,10 +168,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);
   }
 
@@ -301,29 +298,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}`);
+    invariant(repo_root, "repo_root must exist");
 
-    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}`);
+    const worktree_path = `.git/git-stack-worktrees/push_master_group`;
+    const worktree_path_absolute = path.join(repo_root, worktree_path);
+
+    // ensure worktree for pushing master groups
+    if (!(await safe_exists(worktree_path_absolute))) {
+      actions.output(
+        <Ink.Text color={colors.white}>
+          Creating <Ink.Text color={colors.yellow}>{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

@@ -160,20 +160,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/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

@@ -163,21 +163,57 @@ export async function range(commit_group_map?: CommitGroupMap) {
       // console.debug("  ", "group.base", group.base);
     }
 
+    // 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 = diff_strip_index_lines(diff_github);
+
+        let diff_local = await git.get_diff(group.commits);
+        diff_local = diff_strip_index_lines(diff_local);
+
+        // find the first differing character index
+        let compare_length = Math.min(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;
+
+          // // 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 +233,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 +247,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 +279,11 @@ 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, "");
+}
+
+const RE = {
+  diff_index_line: /^index [0-9a-f]+\.\.[0-9a-f]+.*?\n/gm,
+};