git-stack-cli 2.9.3 → 2.9.5

package/src/core/CommitMetadata.ts

@@ -3,6 +3,7 @@
 import { Store } from "~/app/Store";
 import * as git from "~/core/git";
 import * as github from "~/core/github";
+import { invariant } from "~/core/invariant";
 
 export type CommitRange = Awaited<ReturnType<typeof range>>;
 
@@ -28,14 +29,16 @@ type CommitRangeGroup = {
 type CommitGroupMap = { [sha: string]: CommitRangeGroup };
 
 export async function range(commit_group_map?: CommitGroupMap) {
-  const DEBUG = process.env.DEV && false;
-
   const state = Store.getState();
   const actions = state.actions;
+  const argv = state.argv;
+  const merge_base = state.merge_base;
   const master_branch = state.master_branch;
   const master_branch_name = master_branch.replace(/^origin\//, "");
   const commit_list = await git.get_commits(`${master_branch}..HEAD`);
 
+  invariant(merge_base, "merge_base must exist");
+
   const pr_lookup: Record<string, void | PullRequest> = {};
 
   let invalid = false;
@@ -125,6 +128,15 @@ export async function range(commit_group_map?: CommitGroupMap) {
     const group = group_value_list[i];
     const previous_group: undefined | CommitGroup = group_value_list[i - 1];
 
+    // actions.json({ group });
+    actions.debug(`title=${group.title}`);
+    actions.debug(`  id=${group.id}`);
+    actions.debug(`  master_base=${group.master_base}`);
+
+    // special case
+    // boundary between normal commits and master commits
+    const MASTER_BASE_BOUNDARY = !group.master_base && previous_group && previous_group.master_base;
+
     if (group.id !== UNASSIGNED) {
       let pr_result = pr_lookup[group.id];
 
@@ -145,9 +157,8 @@ export async function range(commit_group_map?: CommitGroupMap) {
     if (i === 0) {
       group.base = master_branch_name;
     } else {
-      const last_group = group_value_list[i - 1];
-      // console.debug("  ", "last_group", last_group.pr?.title.substring(0, 40));
-      // console.debug("  ", "last_group.id", last_group.id);
+      // console.debug("  ", "previous_group", previous_group.pr?.title.substring(0, 40));
+      // console.debug("  ", "previous_group.id", previous_group.id);
 
       if (group.master_base) {
         // explicitly set base to master when master_base is true
@@ -155,73 +166,93 @@ export async function range(commit_group_map?: CommitGroupMap) {
       } else if (group.id === UNASSIGNED) {
         // null out base when unassigned and after unassigned
         group.base = null;
-      } else if (last_group.base === null) {
+      } else if (MASTER_BASE_BOUNDARY) {
+        // ensure we set its base to `master`
+        actions.debug(`  MASTER_BASE_BOUNDARY set group.base = ${master_branch_name}`);
+        group.base = master_branch_name;
+      } else if (previous_group.base === null) {
         // null out base when last group base is null
         group.base = null;
       } else {
-        group.base = last_group.id;
+        group.base = previous_group.id;
       }
-
-      // console.debug("  ", "group.base", group.base);
     }
 
-    actions.json({ group });
+    actions.debug(`  base=${group.base}`);
 
     if (!group.pr) {
+      actions.debug(`  group.pr=${group.pr}`);
       group.dirty = true;
     } else {
-      if (group.pr.baseRefName !== group.base) {
-        actions.debug("PR_BASEREF_MISMATCH");
+      // actions.json(group.pr);
+      actions.debug(`  group.pr.state=${group.pr.state}`);
+      actions.debug(`  group.pr.baseRefName=${group.pr.baseRefName}`);
+
+      if (group.pr.state === "MERGED" || group.pr.state === "CLOSED") {
+        group.dirty = true;
+      } else if (group.pr.baseRefName !== group.base) {
+        actions.debug("  PR_BASEREF_MISMATCH");
         group.dirty = true;
       } else if (group.master_base) {
-        actions.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
-        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);
-
-        actions.json({ 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;
+        // first check if merge base has changed
+        let branch_compare = await github.pr_compare(group.pr.headRefName);
+        if (!(branch_compare instanceof Error)) {
+          if (branch_compare.merge_base_commit.sha !== merge_base) {
+            actions.debug("  MASTER_BASE_MERGE_BASE_MISMATCH");
+            group.dirty = true;
           }
         }
-        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);
+        // if still not dirty, check diffs
+        if (!group.dirty) {
+          actions.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
+          let diff_github = await github.pr_diff(group.pr.headRefName);
+          diff_github = normalize_diff(diff_github);
+
+          let diff_local = await git.diff_commits(group.commits);
+          diff_local = normalize_diff(diff_local);
+
+          // 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) {
+            actions.debug("  MASTER_BASE_DIFF_MISMATCH");
+            group.dirty = true;
+
+            if (argv.verbose) {
+              // 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);
-            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}⌃`);
+              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) {
+      } else if (MASTER_BASE_BOUNDARY) {
         // special case
         // boundary between normal commits and master commits
 
@@ -239,24 +270,23 @@ export async function range(commit_group_map?: CommitGroupMap) {
 
         // compare all commits against pr commits
         if (group.pr.commits.length !== all_commits.length) {
-          actions.debug("BOUNDARY_COMMIT_LENGTH_MISMATCH");
+          actions.debug("  BOUNDARY_COMMIT_LENGTH_MISMATCH");
           group.dirty = true;
         } else {
-          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];
 
             if (pr_commit.oid !== local_commit.sha) {
+              actions.debug("  BOUNDARY_COMMIT_SHA_MISMATCH");
               group.dirty = true;
             }
           }
         }
       } else if (group.pr.commits.length !== group.commits.length) {
-        actions.debug("COMMIT_LENGTH_MISMATCH");
+        actions.debug("  COMMIT_LENGTH_MISMATCH");
         group.dirty = true;
       } else {
-        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++) {
@@ -264,14 +294,14 @@ 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 });
+            actions.debug("  COMMIT_SHA_MISMATCH");
             group.dirty = true;
           }
         }
       }
     }
 
-    // console.debug("  ", "group.dirty", group.dirty);
+    actions.debug(`  group.dirty=${group.dirty}`);
   }
 
   // reverse group_list to match git log

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/cli.ts

@@ -8,6 +8,7 @@ type SpawnOptions = Parameters<typeof child.spawn>[2];
 type Options = SpawnOptions & {
   ignoreExitCode?: boolean;
   onOutput?: (data: string) => void;
+  quiet?: boolean;
 };
 
 type Return = {
@@ -45,13 +46,15 @@ export async function cli(
 
     const id = `${++i}-${command}`;
     state.actions.debug(log.start(command));
-    state.actions.debug(log.pending(command), id);
+    state.actions.debug_pending(id, log.pending(command));
 
     const timer = Timer();
 
     function write_output(value: string) {
       output += value;
-      state.actions.debug(value, id);
+      if (!options.quiet) {
+        state.actions.debug_pending(id, value);
+      }
       options.onOutput?.(value);
     }
 
@@ -79,9 +82,11 @@ export async function cli(
         duration,
       };
 
-      state.actions.set((state) => state.mutate.end_pending_output(state, id));
+      state.actions.debug_pending_end(id);
       state.actions.debug(log.end(result));
-      state.actions.debug(log.output(result));
+      if (!options.quiet) {
+        state.actions.debug(log.output(result));
+      }
 
       if (!options.ignoreExitCode && result.code !== 0) {
         state.actions.debug(log.non_zero_exit(result));
@@ -133,7 +138,9 @@ cli.sync = function cli_sync(
   };
 
   state.actions.debug(log.end(result));
-  state.actions.debug(log.output(result));
+  if (!options.quiet) {
+    state.actions.debug(log.output(result));
+  }
 
   if (!options.ignoreExitCode && result.code !== 0) {
     state.actions.debug(log.non_zero_exit(result));

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