git-stack-cli 2.8.2 → 2.9.1

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,
+};