git-stack-cli 1.0.7 → 1.2.0

package/scripts/git-sequence-editor.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# Example
+#
+#   GIT_REVISE_TODO="abc" GIT_EDITOR="$(pwd)/scripts/git-sequence-editor.sh" git revise --edit -i head~4
+#
+#   Note
+#   ----------------
+#   Use `GIT_EDITOR` above instead of `GIT_SEQUENCE_EDITOR` because `git revise` does not use
+#   `GIT_SEQUENCE_EDITOR` when passing the `--edit` flag, but does work without the `--edit` flag
+#
+#
+
+# debug print env variables
+echo "GIT_REVISE_TODO=$GIT_REVISE_TODO"
+echo "CLI=$0 $*"
+echo "PWD=$(pwd)"
+
+# ensure `GIT_REVISE_TODO` is not empty
+if [ -z "$GIT_REVISE_TODO" ]; then
+  echo "🚨 GIT_REVISE_TODO environment variable is empty" >&2
+  exit 1
+fi
+
+# first argument into git sequence editor is git-revise-todo file
+git_revise_todo_path="$1"
+
+# debug print git-revise-todo file passed into command
+echo "$git_revise_todo_path"
+echo "----- START -----"
+cat "$git_revise_todo_path"
+echo "------ END ------"
+
+# write content of `GIT_REVISE_TODO` env variable to `git_revise_todo_path`
+echo "$GIT_REVISE_TODO" > "$git_revise_todo_path"

package/src/app/DependencyCheck.tsx

@@ -10,7 +10,6 @@ import { Url } from "~/app/Url";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
 import { is_command_available } from "~/core/is_command_available";
-import { semver_compare } from "~/core/semver_compare";
 import * as gh from "~/github/gh";
 
 type Props = {
@@ -18,6 +17,21 @@ type Props = {
 };
 
 export function DependencyCheck(props: Props) {
+  return (
+    <CheckGit>
+      <CheckGithubCli>
+        <CheckGithubCliAuth>
+          <CheckGitRevise>
+            {/* force line break */}
+            {props.children}
+          </CheckGitRevise>
+        </CheckGithubCliAuth>
+      </CheckGithubCli>
+    </CheckGit>
+  );
+}
+
+function CheckGit(props: Props) {
   const actions = Store.useActions();
 
   return (
@@ -46,106 +60,147 @@ export function DependencyCheck(props: Props) {
         actions.exit(2);
       }}
     >
-      <Await
-        fallback={
-          <Ink.Text color={colors.yellow}>
-            Checking <Command>node</Command> install...
+      {props.children}
+    </Await>
+  );
+}
+
+function CheckGithubCli(props: Props) {
+  const actions = Store.useActions();
+
+  return (
+    <Await
+      fallback={
+        <Ink.Text color={colors.yellow}>
+          <Ink.Text>
+            Checking <Command>gh</Command> install...
           </Ink.Text>
+        </Ink.Text>
+      }
+      function={async () => {
+        if (is_command_available("gh")) {
+          return;
         }
-        function={async () => {
-          const process_version = process.version.substring(1);
-          const semver_result = semver_compare(process_version, "14.0.0");
 
-          if (semver_result >= 0) {
+        actions.output(
+          <Ink.Text color={colors.yellow}>
+            <Command>gh</Command> must be installed.
+          </Ink.Text>
+        );
+
+        actions.output(
+          <Ink.Text color={colors.yellow}>
+            <Ink.Text>{"Visit "}</Ink.Text>
+            <Url>https://cli.github.com</Url>
+            <Ink.Text>{" to install the github cli "}</Ink.Text>
+
+            <Parens>
+              <Command>gh</Command>
+            </Parens>
+          </Ink.Text>
+        );
+
+        actions.exit(3);
+      }}
+    >
+      {props.children}
+    </Await>
+  );
+}
+
+function CheckGithubCliAuth(props: Props) {
+  const actions = Store.useActions();
+
+  return (
+    <Await
+      fallback={
+        <Ink.Text color={colors.yellow}>
+          <Ink.Text>
+            Checking <Command>gh auth status</Command>...
+          </Ink.Text>
+        </Ink.Text>
+      }
+      function={async () => {
+        const options = { ignoreExitCode: true };
+        const auth_status = await cli(`gh auth status`, options);
+
+        if (auth_status.code === 0) {
+          const username = gh.auth_status(auth_status.stdout);
+
+          if (username) {
+            actions.set((state) => {
+              state.username = username;
+            });
+
             return;
           }
+        }
 
-          actions.output(
-            <Ink.Text color={colors.yellow}>
-              <Command>node</Command> must be installed.
-            </Ink.Text>
-          );
-
-          actions.exit(2);
-        }}
-      >
-        <Await
-          fallback={
-            <Ink.Text color={colors.yellow}>
-              <Ink.Text>
-                Checking <Command>gh</Command> install...
-              </Ink.Text>
-            </Ink.Text>
-          }
-          function={async () => {
-            if (is_command_available("gh")) {
-              return;
-            }
-
-            actions.output(
-              <Ink.Text color={colors.yellow}>
-                <Command>gh</Command> must be installed.
-              </Ink.Text>
-            );
-
-            actions.output(
-              <Ink.Text color={colors.yellow}>
-                <Ink.Text>{"Visit "}</Ink.Text>
-                <Url>https://cli.github.com</Url>
-                <Ink.Text>{" to install the github cli "}</Ink.Text>
-
-                <Parens>
-                  <Command>gh</Command>
-                </Parens>
-              </Ink.Text>
-            );
-
-            actions.exit(3);
-          }}
-        >
-          <Await
-            fallback={
-              <Ink.Text color={colors.yellow}>
-                <Ink.Text>
-                  Checking <Command>gh auth status</Command>...
-                </Ink.Text>
-              </Ink.Text>
-            }
-            function={async () => {
-              const options = { ignoreExitCode: true };
-              const auth_status = await cli(`gh auth status`, options);
-
-              if (auth_status.code === 0) {
-                const username = gh.auth_status(auth_status.stdout);
-
-                if (username) {
-                  actions.set((state) => {
-                    state.username = username;
-                  });
-
-                  return;
-                }
-              }
-
-              if (actions.isDebug()) {
-                actions.error("gh auth status could not find username");
-              }
-
-              actions.output(
-                <Ink.Text color={colors.yellow}>
-                  <Command>gh</Command>
-                  <Ink.Text>{" requires login, please run "}</Ink.Text>
-                  <Command>gh auth login</Command>
-                </Ink.Text>
-              );
-
-              actions.exit(4);
-            }}
-          >
-            {props.children}
-          </Await>
-        </Await>
-      </Await>
+        if (actions.isDebug()) {
+          actions.error("gh auth status could not find username");
+        }
+
+        actions.output(
+          <Ink.Text color={colors.yellow}>
+            <Command>gh</Command>
+            <Ink.Text>{" requires login, please run "}</Ink.Text>
+            <Command>gh auth login</Command>
+          </Ink.Text>
+        );
+
+        actions.exit(4);
+      }}
+    >
+      {props.children}
+    </Await>
+  );
+}
+
+function CheckGitRevise(props: Props) {
+  const actions = Store.useActions();
+  const argv = Store.useState((state) => state.argv);
+
+  // skip git revise check when `rebase` is not git-revise
+  if (argv?.["rebase"] !== "git-revise") {
+    return props.children;
+  }
+
+  return (
+    <Await
+      fallback={
+        <Ink.Text color={colors.yellow}>
+          <Ink.Text>
+            Checking <Command>git-revise</Command> install...
+          </Ink.Text>
+        </Ink.Text>
+      }
+      function={async () => {
+        if (is_command_available("git-revise")) {
+          return;
+        }
+
+        actions.output(
+          <Ink.Text color={colors.yellow}>
+            <Command>git-revise</Command> must be installed.
+          </Ink.Text>
+        );
+
+        actions.output(
+          <Ink.Text color={colors.yellow}>
+            <Ink.Text>{"Visit "}</Ink.Text>
+            <Url>https://github.com/mystor/git-revise#install</Url>
+            <Ink.Text>{" to install the git revise cli "}</Ink.Text>
+
+            <Parens>
+              <Command>git-revise</Command>
+            </Parens>
+          </Ink.Text>
+        );
+
+        actions.exit(10);
+      }}
+    >
+      {props.children}
     </Await>
   );
 }

package/src/app/LocalMergeRebase.tsx

@@ -112,10 +112,7 @@ async function run() {
 
       let new_message;
       if (commit.branch_id) {
-        new_message = await Metadata.write(
-          commit.full_message,
-          commit.branch_id
-        );
+        new_message = Metadata.write(commit.full_message, commit.branch_id);
       } else {
         new_message = commit.full_message;
       }

package/src/app/ManualRebase.tsx

@@ -1,6 +1,8 @@
 import * as React from "react";
 
 import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
 import * as Ink from "ink-cjs";
 
@@ -9,6 +11,7 @@ import { Brackets } from "~/app/Brackets";
 import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import * as CommitMetadata from "~/core/CommitMetadata";
+import { GitReviseTodo } from "~/core/GitReviseTodo";
 import * as Metadata from "~/core/Metadata";
 import * as StackSummaryTable from "~/core/StackSummaryTable";
 import { cli } from "~/core/cli";
@@ -68,20 +71,149 @@ async function run(props: Props) {
     }
 
     if (i > 0) {
-      const last_group = commit_range.group_list[i - 1];
-      const last_commit = last_group.commits[last_group.commits.length - 1];
-      rebase_merge_base = last_commit.sha;
+      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;
   }
 
+  actions.debug(`rebase_merge_base=${rebase_merge_base}`);
+  actions.debug(`rebase_group_index=${rebase_group_index}`);
+  actions.debug(`commit_range=${JSON.stringify(commit_range, null, 2)}`);
+
   try {
     // must perform rebase from repo root for applying git patch
     process.chdir(repo_root);
     await cli(`pwd`);
 
+    if (argv["rebase"] === "git-revise") {
+      await rebase_git_revise();
+    } else {
+      await rebase_cherry_pick();
+    }
+
+    // after all commits have been cherry-picked and amended
+    // move the branch pointer to the newly created temporary branch
+    // now we are in locally in sync with github and on the original branch
+    await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
+
+    restore_git();
+
+    actions.set((state) => {
+      state.step = "post-rebase-status";
+    });
+  } catch (err) {
+    actions.error("Unable to rebase.");
+
+    if (err instanceof Error) {
+      if (actions.isDebug()) {
+        actions.error(err.message);
+      }
+    }
+
+    handle_exit();
+  }
+
+  async function rebase_git_revise() {
+    invariant(argv, "argv must exist");
+
+    actions.debug(`rebase_git_revise`);
+
+    actions.output(
+      <Ink.Text color={colors.yellow} wrap="truncate-end">
+        Rebasing…
+      </Ink.Text>
+    );
+
+    // generate temporary directory and drop sequence editor script
+    const tmp_git_sequence_editor_path = path.join(
+      os.tmpdir(),
+      "git-sequence-editor.sh"
+    );
+
+    actions.debug(
+      `tmp_git_sequence_editor_path=${tmp_git_sequence_editor_path}`
+    );
+
+    // replaced at build time with literal contents of `scripts/git-sequence-editor.sh`
+    const GIT_SEQUENCE_EDITOR_SCRIPT = `process.env.GIT_SEQUENCE_EDITOR_SCRIPT`;
+
+    // write script to temporary path
+    fs.writeFileSync(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
+
+    // ensure script is executable
+    fs.chmodSync(tmp_git_sequence_editor_path, "755");
+
+    // create temporary branch
+    await cli(`git checkout -b ${temp_branch_name}`);
+
+    const git_revise_todo = GitReviseTodo({ rebase_group_index, commit_range });
+
+    // execute cli with temporary git sequence editor script
+    // revise from merge base to pick correct commits
+    await cli([
+      `GIT_EDITOR="${tmp_git_sequence_editor_path}"`,
+      `GIT_REVISE_TODO="${git_revise_todo}"`,
+      `git`,
+      `revise --edit -i ${rebase_merge_base}`,
+    ]);
+
+    // start from HEAD and work backward to rebase_group_index
+    const push_group_list = [];
+    let lookback_index = 0;
+    for (let i = 0; i < commit_range.group_list.length; i++) {
+      const index = commit_range.group_list.length - 1 - i;
+
+      // do not go past rebase_group_index
+      if (index < rebase_group_index) {
+        break;
+      }
+
+      const group = commit_range.group_list[index];
+      // console.debug({ i, index, group });
+
+      if (i > 0) {
+        const prev_group = commit_range.group_list[index + 1];
+        lookback_index += prev_group.commits.length;
+      }
+
+      // console.debug(`git show head~${lookback_index}`);
+
+      // push group and lookback_index onto front of push_group_list
+      push_group_list.unshift({ group, lookback_index });
+    }
+
+    const pr_url_list = commit_range.group_list.map(get_group_url);
+
+    // use push_group_list to sync each group HEAD to github
+    for (const push_group of push_group_list) {
+      const { group } = push_group;
+
+      // move to temporary branch for resetting to lookback_index to create PR
+      await cli(`git checkout -b ${group.id}`);
+
+      // prepare branch for sync, reset to commit at lookback index
+      await cli(`git reset --hard HEAD~${push_group.lookback_index}`);
+
+      await sync_group_github({ group, pr_url_list, skip_checkout: true });
+
+      // done, remove temp push branch and move back to temp branch
+      await cli(`git checkout ${temp_branch_name}`);
+      await cli(`git branch -D ${group.id}`);
+    }
+
+    // finally, ensure all prs have the updated stack table from updated pr_url_list
+    await update_pr_tables(pr_url_list);
+  }
+
+  async function rebase_cherry_pick() {
+    invariant(argv, "argv must exist");
+
+    actions.debug("rebase_cherry_pick");
+
     // create temporary branch based on merge base
     await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
 
@@ -104,8 +236,6 @@ async function run(props: Props) {
         />
       );
 
-      const selected_url = get_group_url(group);
-
       // cherry-pick and amend commits one by one
       for (const commit of group.commits) {
         // ensure clean base to avoid conflicts when applying patch
@@ -119,7 +249,7 @@ async function run(props: Props) {
         // add all changes to stage
         await cli(`git add --all`);
 
-        const new_message = await Metadata.write(commit.full_message, group.id);
+        const new_message = Metadata.write(commit.full_message, group.id);
         const git_commit_comand = [`git commit -m "${new_message}"`];
 
         if (argv.verify === false) {
@@ -129,73 +259,98 @@ async function run(props: Props) {
         await cli(git_commit_comand);
       }
 
-      actions.output(
-        <FormatText
-          wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
-          message="Syncing {group}…"
-          values={{
-            group: (
-              <Brackets>{group.pr?.title || group.title || group.id}</Brackets>
-            ),
-          }}
-        />
-      );
+      await sync_group_github({ group, pr_url_list, skip_checkout: false });
+    }
 
-      if (!props.skipSync) {
-        // push to origin since github requires commit shas to line up perfectly
-        const git_push_command = [`git push -f origin HEAD:${group.id}`];
+    // finally, ensure all prs have the updated stack table from updated pr_url_list
+    await update_pr_tables(pr_url_list);
+  }
 
-        if (argv.verify === false) {
-          git_push_command.push("--no-verify");
-        }
+  async function sync_group_github(args: {
+    group: CommitMetadataGroup;
+    pr_url_list: Array<string>;
+    skip_checkout: boolean;
+  }) {
+    if (props.skipSync) {
+      return;
+    }
+
+    const { group, pr_url_list } = args;
+
+    invariant(argv, "argv must exist");
+    invariant(group.base, "group.base must exist");
+
+    actions.output(
+      <FormatText
+        wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
+        message="Syncing {group}…"
+        values={{
+          group: (
+            <Brackets>{group.pr?.title || group.title || group.id}</Brackets>
+          ),
+        }}
+      />
+    );
+
+    // push to origin since github requires commit shas to line up perfectly
+    const git_push_command = [`git push -f origin HEAD:${group.id}`];
+
+    if (argv.verify === false) {
+      git_push_command.push("--no-verify");
+    }
+
+    await cli(git_push_command);
+
+    const selected_url = get_group_url(group);
+
+    if (group.pr) {
+      // 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,
+        }),
+      });
+    } else {
+      if (!args.skip_checkout) {
+        // delete local group branch if leftover
+        await cli(`git branch -D ${group.id}`, { ignoreExitCode: true });
 
-        await cli(git_push_command);
-
-        if (group.pr) {
-          // 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,
-            }),
-          });
-        } else {
-          // delete local group branch if leftover
-          await cli(`git branch -D ${group.id}`, { ignoreExitCode: true });
-
-          // move to temporary branch for creating pr
-          await cli(`git checkout -b ${group.id}`);
-
-          // create pr in github
-          const pr_url = await github.pr_create({
-            branch: group.id,
-            base: group.base,
-            title: group.title,
-            body: "",
-          });
-
-          if (!pr_url) {
-            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;
-            }
-          }
-
-          // move back to temp branch
-          await cli(`git checkout ${temp_branch_name}`);
+        // move to temporary branch for creating pr
+        await cli(`git checkout -b ${group.id}`);
+      }
+
+      // create pr in github
+      const pr_url = await github.pr_create({
+        branch: group.id,
+        base: group.base,
+        title: group.title,
+        body: "",
+      });
+
+      if (!pr_url) {
+        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;
         }
       }
+
+      // move back to temp branch
+      if (!args.skip_checkout) {
+        await cli(`git checkout ${temp_branch_name}`);
+      }
     }
+  }
 
-    // finally, ensure all prs have the updated stack table from updated pr_url_list
+  async function update_pr_tables(pr_url_list: Array<string>) {
     for (let i = 0; i < commit_range.group_list.length; i++) {
       const group = commit_range.group_list[i];
 
@@ -224,27 +379,6 @@ async function run(props: Props) {
         });
       }
     }
-
-    // after all commits have been cherry-picked and amended
-    // move the branch pointer to the newly created temporary branch
-    // now we are in locally in sync with github and on the original branch
-    await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
-
-    restore_git();
-
-    actions.set((state) => {
-      state.step = "post-rebase-status";
-    });
-  } catch (err) {
-    actions.error("Unable to rebase.");
-
-    if (err instanceof Error) {
-      if (actions.isDebug()) {
-        actions.error(err.message);
-      }
-    }
-
-    handle_exit();
   }
 
   // cleanup git operations if cancelled during manual rebase