git-stack-cli 2.9.4 → 2.9.6

package/package.json

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

package/src/app/ManualRebase.tsx

@@ -147,6 +147,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 cherry-pick --abort`, spawn_options);
     cli.sync(`git clean -fd`, spawn_options);
 
     // always put self back in original branch

package/src/app/Store.tsx

@@ -78,6 +78,7 @@ export type State = {
   // cache
   pr: { [branch: string]: PullRequest };
   cache_gh_cli_by_branch: { [branch: string]: { [command: string]: string } };
+  cache_diff: { [key: string]: string };
 
   actions: {
     exit(code: number, args?: ExitArgs): void;
@@ -139,6 +140,7 @@ const BaseStore = createStore<State>()(
 
     pr: {},
     cache_gh_cli_by_branch: {},
+    cache_diff: {},
 
     actions: {
       exit(code, args) {
@@ -206,6 +208,9 @@ const BaseStore = createStore<State>()(
 
       output(node) {
         set((state) => {
+          if (typeof node === "string") {
+            node = <Ink.Text>{node}</Ink.Text>;
+          }
           state.mutate.output(state, { node });
         });
       },

package/src/app/SyncGithub.tsx

@@ -1,7 +1,5 @@
 import * as React from "react";
 
-import path from "node:path";
-
 import * as Ink from "ink-cjs";
 import last from "lodash/last";
 
@@ -10,9 +8,9 @@ import { Store } from "~/app/Store";
 import * as StackSummaryTable from "~/core/StackSummaryTable";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
+import * as git from "~/core/git";
 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";
@@ -26,7 +24,6 @@ async function run() {
   const actions = state.actions;
   const argv = state.argv;
   const branch_name = state.branch_name;
-  const merge_base = state.merge_base;
   const commit_map = state.commit_map;
   const master_branch = state.master_branch;
   const repo_path = state.repo_path;
@@ -319,42 +316,8 @@ async function run() {
   async function push_master_group(group: CommitMetadataGroup) {
     invariant(repo_path, "repo_path must exist");
 
-    const worktree_path = path.join(
-      process.env.HOME,
-      ".cache",
-      "git-stack",
-      "worktrees",
-      repo_path,
-      "push_master_group",
-    );
-
-    // 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}>{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 to 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 ${merge_base}`);
-    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 commit_list = group.commits;
+    const { worktree_path } = await git.worktree_add({ commit_list });
 
     const push_target = `HEAD:refs/heads/${group.id}`;
     const git_push_command = create_git_push_command(`git -C ${worktree_path}`, push_target);

package/src/commands/Rebase.tsx

@@ -184,6 +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 cherry-pick --abort`, spawn_options);
     cli.sync(`git clean -fd`, spawn_options);
 
     // always put self back in original branch

package/src/core/CommitMetadata.ts

@@ -215,7 +215,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
           let diff_github = await github.pr_diff(group.pr.headRefName);
           diff_github = normalize_diff(diff_github);
 
-          let diff_local = await git.get_diff(group.commits);
+          let diff_local = await git.diff_commits(group.commits);
           diff_local = normalize_diff(diff_local);
 
           // find the first differing character index
@@ -260,14 +260,21 @@ export async function range(commit_group_map?: CommitGroupMap) {
         const all_commits: Array<git.Commit> = [];
         const previous_groups = group_value_list.slice(0, i);
         for (const g of previous_groups) {
+          actions.debug(`  BOUNDARY_COMMIT group=${g.title}`);
+
           for (const c of g.commits) {
+            actions.debug(`  BOUNDARY_COMMIT   commit=${c.subject_line}`);
             all_commits.push(c);
           }
         }
         for (const c of group.commits) {
+          actions.debug(`  BOUNDARY_COMMIT commit=${c.subject_line}`);
           all_commits.push(c);
         }
 
+        actions.debug(`  BOUNDARY_COMMIT group.pr.commits.length=${group.pr.commits.length}`);
+        actions.debug(`  BOUNDARY_COMMIT all_commits=${all_commits.length}`);
+
         // compare all commits against pr commits
         if (group.pr.commits.length !== all_commits.length) {
           actions.debug("  BOUNDARY_COMMIT_LENGTH_MISMATCH");

package/src/core/cache_message.tsx

@@ -0,0 +1,36 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { FormatText } from "~/app/FormatText";
+import { colors } from "~/core/colors";
+
+type CacheMessageArgs = {
+  hit: boolean;
+  message: React.ReactNode;
+  extra: React.ReactNode;
+};
+
+export function cache_message(args: CacheMessageArgs) {
+  const status = args.hit ? (
+    <Ink.Text bold color={colors.green}>
+      HIT
+    </Ink.Text>
+  ) : (
+    <Ink.Text bold color={colors.red}>
+      MISS
+    </Ink.Text>
+  );
+
+  return (
+    <FormatText
+      wrapper={<Ink.Text dimColor />}
+      message="{message} {status} {extra}"
+      values={{
+        message: args.message,
+        status,
+        extra: args.extra,
+      }}
+    />
+  );
+}

package/src/core/git.tsx

@@ -0,0 +1,193 @@
+import * as React from "react";
+
+import path from "node:path";
+
+import * as Ink from "ink-cjs";
+
+import { Store } from "~/app/Store";
+import * as Metadata from "~/core/Metadata";
+import { cache_message } from "~/core/cache_message";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+import { safe_exists } from "~/core/safe_exists";
+
+type CommitList = Awaited<ReturnType<typeof get_commits>>;
+
+export type Commit = CommitList[0];
+
+export async function get_commits(dot_range: string) {
+  const log_result = await cli(`git log ${dot_range} --format=${FORMAT} --color=never`);
+
+  if (!log_result.stdout) {
+    return [];
+  }
+
+  const commit_list = [];
+
+  for (let record of log_result.stdout.split(SEP.record)) {
+    record = record.replace(/^\n/, "");
+    record = record.replace(/\n$/, "");
+
+    if (!record) continue;
+
+    const [sha, full_message] = record.split(SEP.field);
+
+    // ensure sha is a hex string, otherwise we should throw an error
+    if (!RE.git_sha.test(sha)) {
+      const actions = Store.getState().actions;
+      const sep_values = JSON.stringify(Object.values(SEP));
+      const message = `unable to parse git commits, maybe commit message contained ${sep_values}`;
+      actions.error(message);
+      actions.exit(19);
+    }
+
+    const metadata = Metadata.read(full_message);
+    const branch_id = metadata.id;
+    const subject_line = metadata.subject || "";
+    const title = metadata.title;
+    const master_base = metadata.base === "master";
+
+    const commit = {
+      sha,
+      full_message,
+      subject_line,
+      branch_id,
+      title,
+      master_base,
+    };
+
+    commit_list.push(commit);
+  }
+
+  commit_list.reverse();
+
+  return commit_list;
+}
+
+type WorktreeAddArgs = {
+  name?: string;
+  commit_list: CommitList;
+};
+
+type WorktreeAddResult = {
+  worktree_path: string;
+  merge_base: string;
+};
+
+export async function worktree_add(args: WorktreeAddArgs): Promise<WorktreeAddResult> {
+  const state = Store.getState();
+  const actions = state.actions;
+  const merge_base = state.merge_base;
+  invariant(merge_base, "merge_base must exist");
+  const repo_path = state.repo_path;
+  invariant(repo_path, "repo_path must exist");
+
+  const worktree_name = args.name || "push_master_group";
+  const worktree_path = path.join(
+    process.env.HOME,
+    ".cache",
+    "git-stack",
+    "worktrees",
+    repo_path,
+    worktree_name,
+  );
+
+  if (!(await safe_exists(worktree_path))) {
+    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 --detach ${worktree_path} ${merge_base}`);
+  }
+
+  // ensure worktree is clean + on the right base before applying commits
+  // - abort any in-progress cherry-pick/rebase
+  // - drop local changes/untracked files to fresh state
+  const quiet_ignore = { quiet: true, ignoreExitCode: true };
+  await cli(`git -C ${worktree_path} cherry-pick --abort`, quiet_ignore);
+  await cli(`git -C ${worktree_path} rebase --abort`, quiet_ignore);
+  await cli(`git -C ${worktree_path} merge --abort`, quiet_ignore);
+  await cli(`git -C ${worktree_path} checkout -f --detach ${merge_base}`);
+  await cli(`git -C ${worktree_path} clean -fd`);
+
+  // cherry-pick the group commits onto that base
+  const cp_commit_list = args.commit_list.map((c) => c.sha).join(" ");
+  await cli(`git -C ${worktree_path} cherry-pick ${cp_commit_list}`);
+
+  return { worktree_path, merge_base };
+}
+
+export async function diff_commits(commit_list: CommitList) {
+  const state = Store.getState();
+  const actions = state.actions;
+  const merge_base = state.merge_base;
+  invariant(merge_base, "merge_base must exist");
+
+  const cache_key = `${merge_base}:${commit_list.map((c) => c.sha).join(",")}`;
+
+  const cache = state.cache_diff[cache_key];
+
+  if (cache) {
+    if (actions.isDebug()) {
+      actions.debug(
+        cache_message({
+          hit: true,
+          message: "git diff_commits cache",
+          extra: cache_key,
+        }),
+      );
+    }
+
+    return cache;
+  }
+
+  if (actions.isDebug()) {
+    actions.debug(
+      cache_message({
+        hit: false,
+        message: "git diff_commits cache",
+        extra: cache_key,
+      }),
+    );
+  }
+
+  const { worktree_path } = await worktree_add({ commit_list });
+  const cli_result = await cli(
+    `git -C ${worktree_path} --no-pager diff --color=never ${merge_base}`,
+    { quiet: true },
+  );
+
+  if (cli_result.code !== 0) {
+    throw new Error(cli_result.output);
+  }
+
+  const diff = cli_result.stdout;
+
+  actions.set((state) => {
+    state.cache_diff[cache_key] = diff;
+  });
+
+  return diff;
+}
+
+// Why these separators?
+// - Rare in human written text
+// - Supported in git %xNN to write bytes
+// - Supported in javascript \xNN to write bytes
+// - Used historically as separators in unicode
+//   https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Field_separators
+const SEP = {
+  record: "\x1e",
+  field: "\x1f",
+};
+
+const FORMAT = `%H${SEP.field}%B${SEP.record}`;
+
+const RE = {
+  git_sha: /^[0-9a-fA-F]{40}$/,
+};

package/src/core/github.tsx

@@ -10,6 +10,7 @@ import { Brackets } from "~/app/Brackets";
 import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import { Timer } from "~/core/Timer";
+import { cache_message } from "~/core/cache_message";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
 import { get_tmp_dir } from "~/core/get_tmp_dir";
@@ -408,36 +409,6 @@ function safe_filename(value: string): string {
   return value.replace(RE.non_alphanumeric_dash, "-");
 }
 
-type CacheMessageArgs = {
-  hit: boolean;
-  message: React.ReactNode;
-  extra: React.ReactNode;
-};
-
-function cache_message(args: CacheMessageArgs) {
-  const status = args.hit ? (
-    <Ink.Text bold color={colors.green}>
-      HIT
-    </Ink.Text>
-  ) : (
-    <Ink.Text bold color={colors.red}>
-      MISS
-    </Ink.Text>
-  );
-
-  return (
-    <FormatText
-      wrapper={<Ink.Text dimColor />}
-      message="{message} {status} {extra}"
-      values={{
-        message: args.message,
-        status,
-        extra: args.extra,
-      }}
-    />
-  );
-}
-
 type Commit = {
   authoredDate: string; // "2023-10-22T23:13:35Z"
   authors: [

package/src/core/git.ts

@@ -1,83 +0,0 @@
-import { Store } from "~/app/Store";
-import * as Metadata from "~/core/Metadata";
-import { cli } from "~/core/cli";
-import { invariant } from "~/core/invariant";
-
-type CommitList = Awaited<ReturnType<typeof get_commits>>;
-
-export type Commit = CommitList[0];
-
-export async function get_commits(dot_range: string) {
-  const log_result = await cli(`git log ${dot_range} --format=${FORMAT} --color=never`);
-
-  if (!log_result.stdout) {
-    return [];
-  }
-
-  const commit_list = [];
-
-  for (let record of log_result.stdout.split(SEP.record)) {
-    record = record.replace(/^\n/, "");
-    record = record.replace(/\n$/, "");
-
-    if (!record) continue;
-
-    const [sha, full_message] = record.split(SEP.field);
-
-    // ensure sha is a hex string, otherwise we should throw an error
-    if (!RE.git_sha.test(sha)) {
-      const actions = Store.getState().actions;
-      const sep_values = JSON.stringify(Object.values(SEP));
-      const message = `unable to parse git commits, maybe commit message contained ${sep_values}`;
-      actions.error(message);
-      actions.exit(19);
-    }
-
-    const metadata = Metadata.read(full_message);
-    const branch_id = metadata.id;
-    const subject_line = metadata.subject || "";
-    const title = metadata.title;
-    const master_base = metadata.base === "master";
-
-    const commit = {
-      sha,
-      full_message,
-      subject_line,
-      branch_id,
-      title,
-      master_base,
-    };
-
-    commit_list.push(commit);
-  }
-
-  commit_list.reverse();
-
-  return commit_list;
-}
-
-export async function get_diff(commit_list: CommitList) {
-  invariant(commit_list.length, "commit_list must exist");
-  const first_commit = commit_list[0];
-  const last_commit = commit_list[commit_list.length - 1];
-  const sha_range = `${first_commit.sha}~1..${last_commit.sha}`;
-  const diff_result = await cli(`git --no-pager diff --color=never ${sha_range}`, { quiet: true });
-  return diff_result.stdout;
-}
-
-// Why these separators?
-// - Rare in human written text
-// - Supported in git %xNN to write bytes
-// - Supported in javascript \xNN to write bytes
-// - Used historically as separators in unicode
-//   https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Field_separators
-const SEP = {
-  record: "\x1e",
-  field: "\x1f",
-};
-
-const FORMAT = `%H${SEP.field}%B${SEP.record}`;
-
-const RE = {
-  git_sha: /^[0-9a-fA-F]{40}$/,
-};