git-stack-cli 2.7.8 → 2.8.0

package/package.json

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

package/scripts/bun-build.ts

@@ -67,10 +67,11 @@ async function run_build() {
   const result = await Bun.build(BUILD_CONFIG);
 
   const duration_ms = Date.now() - start;
+  const status = result.success ? "✅" : "❌";
 
-  log(`✅ Build (${duration_ms}ms)`);
+  log(`${status} build (${duration_ms}ms)`);
 
-  if (VERBOSE) {
+  if (VERBOSE || !result.success) {
     log({ result });
   }
 }

package/scripts/release-npm.ts

@@ -18,10 +18,9 @@ process.chdir(REPO_ROOT);
 
 // require clean git status besides changes to package.json version
 const git_status = await spawn.sync("git status --porcelain");
-if (!/^M\s+package.json/.test(git_status.stdout)) {
-  console.error(
-    "please commit local changes and only update package.json version before running release",
-  );
+if (!/^M\s+package.json$/.test(git_status.stdout)) {
+  console.error("please commit local changes");
+  console.error("only update package.json version before running release");
   process.exit(4);
 }
 
@@ -55,6 +54,9 @@ for (const filepath of package_json.files) {
   }
 }
 
+// ensure npm is authenticated
+await spawn(`npm whoami`);
+
 process.chdir(REPO_ROOT);
 
 await spawn.sync(`git commit -a -m ${version}`);

package/src/app/ManualRebase.tsx

@@ -57,6 +57,7 @@ async function run() {
       const group_from_map = commit_map[commit.sha];
       commit.branch_id = group_from_map.id;
       commit.title = group_from_map.title;
+      commit.master_base = group_from_map.master_base;
     }
 
     // // capture commit_range for GitReviseTodo test
@@ -78,21 +79,12 @@ async function run() {
     let rebase_merge_base = merge_base;
     let rebase_group_index = 0;
 
-    for (let i = 0; i < commit_range.group_list.length; i++) {
-      const group = commit_range.group_list[i];
+    inplace_order_commit_range_groups(commit_range);
 
-      if (!group.dirty) {
-        continue;
-      }
-
-      if (i > 0) {
-        const prev_group = commit_range.group_list[i - 1];
-        const prev_commit = prev_group.commits[prev_group.commits.length - 1];
-        rebase_merge_base = prev_commit.sha;
-        rebase_group_index = i;
-      }
-
-      break;
+    const dirty = find_first_dirty_group(commit_range);
+    if (dirty) {
+      rebase_merge_base = dirty.sha;
+      rebase_group_index = dirty.index;
     }
 
     actions.debug(`rebase_merge_base = ${rebase_merge_base}`);
@@ -185,3 +177,66 @@ async function run() {
     );
   }
 }
+
+function inplace_order_commit_range_groups(commit_range: CommitMetadata.CommitRange) {
+  const state = Store.getState();
+  const actions = state.actions;
+
+  // order groups with group.master_base first
+  const group_list_master: CommitGroupList = [];
+  const group_list_others: CommitGroupList = [];
+  for (const group of commit_range.group_list) {
+    if (group.master_base) {
+      group_list_master.push(group);
+    } else {
+      group_list_others.push(group);
+    }
+  }
+
+  const ordered_group_list = [...group_list_master, ...group_list_others];
+
+  // detect if group list order differs
+  let differs = false;
+  for (let i = 0; i < commit_range.group_list.length; i++) {
+    const original_group = commit_range.group_list[i];
+    const ordered_group = ordered_group_list[i];
+    if (original_group.id !== ordered_group.id) {
+      ordered_group.dirty = true;
+      const debug = JSON.stringify({ original_group, ordered_group });
+      actions.debug(`inplace_order_commit_range_groups ${debug}`);
+
+      differs = true;
+      break;
+    }
+  }
+
+  if (differs) {
+    commit_range.group_list = ordered_group_list;
+  }
+
+  return differs;
+}
+
+function find_first_dirty_group(commit_range: CommitMetadata.CommitRange) {
+  for (let i = 0; i < commit_range.group_list.length; i++) {
+    const group = commit_range.group_list[i];
+
+    if (!group.dirty) {
+      continue;
+    }
+
+    if (i > 0) {
+      const prev_group = commit_range.group_list[i - 1];
+      const prev_commit = prev_group.commits[prev_group.commits.length - 1];
+      const sha = prev_commit.sha;
+      const index = i;
+      return { sha, index };
+    }
+
+    break;
+  }
+
+  return null;
+}
+
+type CommitGroupList = CommitMetadata.CommitRange["group_list"];

package/src/app/MultiSelect.tsx

@@ -87,6 +87,25 @@ export function MultiSelect<T>(props: Props<T>) {
     },
   );
 
+  // ensure current index is valid and not disabled
+  React.useEffect(ensure_selectable_focus, [props.items]);
+  function ensure_selectable_focus() {
+    const current = props.items[index];
+    if (current && !current.disabled) {
+      return;
+    }
+
+    for (let i = 0; i < props.items.length; i++) {
+      // search items backwards
+      const index = props.items.length - 1 - i;
+      const item = props.items[index];
+      if (!item.disabled) {
+        set_index(index);
+        break;
+      }
+    }
+  }
+
   const selectRef = React.useRef(false);
 
   React.useEffect(() => {

package/src/app/SelectCommitRanges.tsx

@@ -15,6 +15,9 @@ import { short_id } from "~/core/short_id";
 import { wrap_index } from "~/core/wrap_index";
 
 import type { State } from "~/app/Store";
+import type * as CommitMetadata from "~/core/CommitMetadata";
+
+type CommitRangeGroup = NonNullable<Parameters<typeof CommitMetadata.range>[0]>[string];
 
 export function SelectCommitRanges() {
   const commit_range = Store.useState((state) => state.commit_range);
@@ -62,6 +65,23 @@ function SelectCommitRangesInternal(props: Props) {
     [],
   );
 
+  const [group_master_base, set_group_master_base] = React.useReducer(
+    (set: Set<string>, group_id: string) => {
+      set.has(group_id) ? set.delete(group_id) : set.add(group_id);
+      return new Set(set);
+    },
+    new Set<string>(),
+    (set) => {
+      for (const group of props.commit_range.group_list) {
+        if (group.master_base) {
+          set.add(group.id);
+        }
+      }
+
+      return new Set(set);
+    },
+  );
+
   const [commit_map, update_commit_map] = React.useReducer(
     (map: Map<string, null | string>, args: { key: string; value: null | string }) => {
       map.set(args.key, args.value);
@@ -84,18 +104,18 @@ function SelectCommitRangesInternal(props: Props) {
   Ink.useInput((input, key) => {
     const input_lower = input.toLowerCase();
 
-    if (input_lower === SYMBOL.s) {
-      // do not allow sync when inputting group title
-      if (group_input) {
-        return;
-      }
+    // do not allow input when inputting group title
+    if (group_input) {
+      return;
+    }
 
+    if (input_lower === SYMBOL.s) {
       if (sync_status === "disabled") {
         return;
       }
 
       actions.set((state) => {
-        const state_commit_map: Record<string, SimpleGroup> = {};
+        const state_commit_map: Record<string, CommitRangeGroup> = {};
 
         for (let [sha, id] of commit_map.entries()) {
           // console.debug({ sha, id });
@@ -104,14 +124,15 @@ function SelectCommitRangesInternal(props: Props) {
           if (!id) {
             id = props.commit_range.UNASSIGNED;
             const title = "allow_unassigned";
-            state_commit_map[sha] = { id, title };
+            state_commit_map[sha] = { id, title, master_base: false };
             continue;
           }
 
           const group = group_list.find((g) => g.id === id);
           invariant(group, "group must exist");
           // console.debug({ group });
-          state_commit_map[sha] = group;
+          const master_base = group_master_base.has(id);
+          state_commit_map[sha] = { ...group, master_base };
         }
 
         state.commit_map = state_commit_map;
@@ -127,6 +148,13 @@ function SelectCommitRangesInternal(props: Props) {
       return;
     }
 
+    // only allow setting base branch when on a created group
+    if (group.id !== props.commit_range.UNASSIGNED && input_lower === SYMBOL.m) {
+      const group = group_list[current_index];
+      set_group_master_base(group.id);
+      return;
+    }
+
     if (key.leftArrow) {
       const new_index = wrap_index(current_index - 1, group_list);
       const next_group = group_list[new_index];
@@ -196,6 +224,7 @@ function SelectCommitRangesInternal(props: Props) {
   // console.debug({ sync_status });
 
   const group = group_list[current_index];
+  const is_master_base = group_master_base.has(group.id);
 
   const multiselect_disabled = group_input;
   const multiselect_disableSelect = group.id === props.commit_range.UNASSIGNED;
@@ -281,6 +310,10 @@ function SelectCommitRangesInternal(props: Props) {
             <Ink.Text wrap="truncate-end" bold color={colors.white}>
               {group.title}
             </Ink.Text>
+            {!is_master_base ? null : (
+              // show base master
+              <Ink.Text color={colors.yellow}> (base: master)</Ink.Text>
+            )}
           </Ink.Box>
         </React.Fragment>
       )}
@@ -445,6 +478,27 @@ function SelectCommitRangesInternal(props: Props) {
           }}
         />
       </Ink.Box>
+
+      {group.id === props.commit_range.UNASSIGNED ? null : (
+        <Ink.Box>
+          <FormatText
+            wrapper={<Ink.Text color={colors.gray} />}
+            message={
+              is_master_base
+                ? "Press {m} to {reset} current PR base to stack position"
+                : "Press {m} to set current PR base to master"
+            }
+            values={{
+              m: (
+                <Ink.Text bold color={colors.green}>
+                  {SYMBOL.m}
+                </Ink.Text>
+              ),
+              reset: <Ink.Text color={colors.yellow}>reset</Ink.Text>,
+            }}
+          />
+        </Ink.Box>
+      )}
     </Ink.Box>
   );
 
@@ -518,6 +572,7 @@ const SYMBOL = {
   enter: "Enter",
   c: "c",
   s: "s",
+  m: "m",
 };
 
 const S_TO_SYNC_VALUES = {

package/src/app/SyncGithub.tsx

@@ -54,6 +54,17 @@ async function run() {
   // 2 create PR / edit PR
   // --------------------------------------
 
+  function create_git_push_command(base: string, target: string) {
+    const command = [`${base} push -f origin`];
+
+    if (argv.verify === false) {
+      command.push("--no-verify");
+    }
+
+    command.push(target);
+    return command;
+  }
+
   try {
     const before_push_tasks = [];
     for (const group of push_group_list) {
@@ -62,16 +73,18 @@ async function run() {
 
     await Promise.all(before_push_tasks);
 
-    const git_push_command = [`git push -f origin`];
-
-    if (argv.verify === false) {
-      git_push_command.push("--no-verify");
-    }
+    const git_push_target_list: Array<string> = [];
 
     for (const group of push_group_list) {
       const last_commit = last(group.commits);
       invariant(last_commit, "last_commit must exist");
 
+      // push group in isolation if master_base is set
+      if (group.master_base) {
+        await push_master_group(group);
+        continue;
+      }
+
       // explicit refs/heads head branch to avoid push failing
       //
       //   ❯ git push -f origin --no-verify f6e249051b4820a03deb957ddebc19acfd7dfd7c:gs-ED2etrzv2
@@ -90,29 +103,49 @@ async function run() {
       //   error: failed to push some refs to 'github.com:magus/git-multi-diff-playground.git'
       //
       const target = `${last_commit.sha}:refs/heads/${group.id}`;
-      git_push_command.push(target);
+      git_push_target_list.push(target);
     }
 
-    await cli(git_push_command);
+    if (git_push_target_list.length > 0) {
+      const push_target = git_push_target_list.join(" ");
+      const git_push_command = create_git_push_command("git", push_target);
+      await cli(git_push_command);
+    }
 
-    const pr_url_list = push_group_list.map(get_group_url);
+    const pr_url_by_group_id: Record<string, string> = {};
 
     const after_push_tasks = [];
     for (const group of push_group_list) {
-      after_push_tasks.push(after_push({ group, pr_url_list }));
+      after_push_tasks.push(after_push({ group, pr_url_by_group_id }));
     }
 
     await Promise.all(after_push_tasks);
 
-    // finally, ensure all prs have the updated stack table from updated pr_url_list
+    // finally, ensure all prs have the updated stack table from updated pr_url_by_group_id
     // this step must come after the after_push since that step may create new PRs
     // we need the urls for all prs at this step so we run it after the after_push
+    const all_pr_groups: Array<CommitMetadataGroup> = [];
+    // collect all groups and existing pr urls
+    for (const group of commit_range.group_list) {
+      if (group.id !== commit_range.UNASSIGNED) {
+        // collect all groups
+        all_pr_groups.push(group);
+
+        if (group.pr) {
+          pr_url_by_group_id[group.id] = group.pr.url;
+        }
+      }
+    }
+
+    // get pr url list for all pr groups
+    const pr_url_list = all_pr_groups.map((g) => pr_url_by_group_id[g.id]);
+
+    // update PR body for all pr groups (not just push_group_list)
     const update_pr_body_tasks = [];
-    for (let i = 0; i < push_group_list.length; i++) {
-      const group = push_group_list[i];
+    for (let i = 0; i < all_pr_groups.length; i++) {
+      const group = all_pr_groups[i];
 
-      // use the updated pr_url_list to get the actual selected_url
-      const selected_url = pr_url_list[i];
+      const selected_url = pr_url_by_group_id[group.id];
 
       const task = update_pr_body({ group, selected_url, pr_url_list });
       update_pr_body_tasks.push(task);
@@ -183,7 +216,7 @@ async function run() {
       // Unable to sync.
       // ```
       //
-      if (`origin/${group.pr.baseRefName}` !== master_branch) {
+      if (!is_master_base(group)) {
         await github.pr_edit({
           branch: group.id,
           base: master_branch,
@@ -192,34 +225,20 @@ async function run() {
     }
   }
 
-  async function after_push(args: { group: CommitMetadataGroup; pr_url_list: Array<string> }) {
-    const { group, pr_url_list } = args;
+  async function after_push(args: {
+    group: CommitMetadataGroup;
+    pr_url_by_group_id: Record<string, string>;
+  }) {
+    const { group } = args;
 
     invariant(group.base, "group.base must exist");
 
-    const selected_url = get_group_url(group);
-
     if (group.pr) {
-      if (`origin/${group.pr.baseRefName}` !== master_branch) {
+      if (!is_master_base(group)) {
         // ensure base matches pr in github
-        await github.pr_edit({
-          branch: group.id,
-          base: group.base,
-          body: StackSummaryTable.write({
-            body: group.pr.body,
-            pr_url_list,
-            selected_url,
-          }),
-        });
+        await github.pr_edit({ branch: group.id, base: group.base });
       } else {
-        await github.pr_edit({
-          branch: group.id,
-          body: StackSummaryTable.write({
-            body: group.pr.body,
-            pr_url_list,
-            selected_url,
-          }),
-        });
+        await github.pr_edit({ branch: group.id });
       }
     } else {
       // create pr in github
@@ -235,13 +254,8 @@ async function run() {
         throw new Error("unable to create pr");
       }
 
-      // update pr_url_list with created pr_url
-      for (let i = 0; i < pr_url_list.length; i++) {
-        const url = pr_url_list[i];
-        if (url === selected_url) {
-          pr_url_list[i] = pr_url;
-        }
-      }
+      // update pr_url_by_group_id with created pr_url
+      args.pr_url_by_group_id[group.id] = pr_url;
     }
   }
 
@@ -262,10 +276,12 @@ async function run() {
       selected_url,
     });
 
+    const debug_meta = `${group.id} ${selected_url}`;
+
     if (update_body === body) {
-      actions.debug(`Skipping body update for ${selected_url}`);
+      actions.debug(`Skipping body update ${debug_meta}`);
     } else {
-      actions.debug(`Update body for ${selected_url}`);
+      actions.debug(`Update body ${debug_meta}`);
 
       await github.pr_edit({
         branch: group.id,
@@ -274,7 +290,40 @@ async function run() {
       });
     }
   }
+
+  function is_master_base(group: CommitMetadataGroup) {
+    if (!group.pr) {
+      return false;
+    }
+
+    return group.master_base || `origin/${group.pr.baseRefName}` === master_branch;
+  }
+
+  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}`);
+    }
+  }
 }
 
 type CommitMetadataGroup = CommitMetadata.CommitRange["group_list"][number];
-const get_group_url = (group: CommitMetadataGroup) => group.pr?.url || group.id;

package/src/core/CommitMetadata.ts

@@ -14,10 +14,16 @@ type CommitGroup = {
   base: null | string;
   dirty: boolean;
   commits: Array<git.Commit>;
+  master_base: boolean;
 };
 
-export type SimpleGroup = { id: string; title: string };
-type CommitGroupMap = { [sha: string]: SimpleGroup };
+type CommitRangeGroup = {
+  id: string;
+  title: string;
+  master_base: boolean;
+};
+
+type CommitGroupMap = { [sha: string]: CommitRangeGroup };
 
 export async function range(commit_group_map?: CommitGroupMap) {
   // gather all open prs in repo first
@@ -25,6 +31,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
   await github.pr_list();
 
   const master_branch = Store.getState().master_branch;
+  const master_branch_name = master_branch.replace(/^origin\//, "");
   const commit_list = await git.get_commits(`${master_branch}..HEAD`);
 
   const pr_lookup: Record<string, void | PullRequest> = {};
@@ -37,6 +44,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
   for (const commit of commit_list) {
     let id = commit.branch_id;
     let title = commit.title || id;
+    let master_base = commit.master_base;
 
     // console.debug({ commit, id });
 
@@ -47,6 +55,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
       if (group) {
         id = group.id;
         title = group.title;
+        master_base = group.master_base;
       }
     }
 
@@ -75,6 +84,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
     const group = group_map.get(id) || {
       id,
       title,
+      master_base,
       pr: null,
       base: null,
       dirty: false,
@@ -130,17 +140,20 @@ export async function range(commit_group_map?: CommitGroupMap) {
     }
 
     if (i === 0) {
-      const master_branch_name = master_branch.replace(/^origin\//, "");
       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);
 
-      // null out base when unassigned and after unassigned
-      if (group.id === UNASSIGNED) {
+      if (group.master_base) {
+        // explicitly set base to master when master_base is true
+        group.base = master_branch_name;
+      } else if (group.id === UNASSIGNED) {
+        // null out base when unassigned and after unassigned
         group.base = null;
       } else if (last_group.base === null) {
+        // null out base when last group base is null
         group.base = null;
       } else {
         group.base = last_group.id;
@@ -155,7 +168,19 @@ export async function range(commit_group_map?: CommitGroupMap) {
       group.dirty = true;
     } else if (group.pr.baseRefName !== group.base) {
       group.dirty = true;
+    } else if (group.master_base) {
+      group.pr.number;
+      // 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 | pbcopy
+      const diff_github = await github.pr_diff(group.pr.number);
+      const diff_local = await git.get_diff(group.commits);
+      if (diff_github !== diff_local) {
+        group.dirty = true;
+      }
     } else {
+      // comapre literal commit shas in group
       for (let i = 0; i < group.pr.commits.length; i++) {
         const pr_commit = group.pr.commits[i];
         const local_commit = group.commits[i];