git-stack-cli 1.12.0 → 1.13.1

package/package.json

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

package/src/app/AutoUpdate.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
 
 import * as Ink from "ink-cjs";
@@ -90,7 +90,8 @@ export function AutoUpdate(props: Props) {
         throw new Error("Unable to retrieve latest version from npm");
       }
 
-      const script_dir = path.dirname(fs.realpathSync(process.argv[1]));
+      const script_path = await fs.realpath(process.argv[1]);
+      const script_dir = path.dirname(script_path);
 
       // dist/ts/index.js
       const package_json_path = path.join(
@@ -100,7 +101,8 @@ export function AutoUpdate(props: Props) {
         "package.json"
       );
 
-      const package_json = read_json<{ version: string }>(package_json_path);
+      type PackageJson = { version: string };
+      const package_json = await read_json<PackageJson>(package_json_path);
 
       if (!package_json) {
         // unable to find read package.json, skip auto update

package/src/app/CherryPickCheck.tsx

@@ -1,6 +1,5 @@
 import * as React from "react";
 
-import fs from "node:fs";
 import path from "node:path";
 
 import * as Ink from "ink-cjs";
@@ -11,6 +10,7 @@ import { Store } from "~/app/Store";
 import { YesNoPrompt } from "~/app/YesNoPrompt";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
+import { safe_exists } from "~/core/safe_exists";
 
 type Props = {
   children: React.ReactNode;
@@ -73,11 +73,11 @@ export function CherryPickCheck(props: Props) {
     try {
       const git_dir = (await cli(`git rev-parse --absolute-git-dir`)).stdout;
 
-      const is_cherry_pick = fs.existsSync(
-        path.join(git_dir, "CHERRY_PICK_HEAD")
-      );
+      const cherry_pick_file = path.join(git_dir, "CHERRY_PICK_HEAD");
+      const is_cherry_pick = await safe_exists(cherry_pick_file);
 
       const status = is_cherry_pick ? "prompt" : "done";
+
       patch({ status });
     } catch (err) {
       actions.error("Must be run from within a git repository.");

package/src/app/Debug.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
 
 import * as Ink from "ink-cjs";
@@ -8,6 +8,7 @@ import * as Ink from "ink-cjs";
 import { Store } from "~/app/Store";
 import { colors } from "~/core/colors";
 import * as json from "~/core/json";
+import { safe_rm } from "~/core/safe_rm";
 
 export function Debug() {
   const actions = Store.useActions();
@@ -27,20 +28,22 @@ export function Debug() {
   );
 
   React.useEffect(
-    function syncStateJson() {
+    function sync_state_json() {
       if (!argv?.["write-state-json"]) {
         return;
       }
 
-      const output_file = path.join(state.cwd, "git-stack-state.json");
+      sync().catch(actions.error);
 
-      if (fs.existsSync(output_file)) {
-        fs.rmSync(output_file);
-      }
+      async function sync() {
+        const output_file = path.join(state.cwd, "git-stack-state.json");
+
+        await safe_rm(output_file);
 
-      const serialized = json.serialize(state);
-      const content = JSON.stringify(serialized, null, 2);
-      fs.writeFileSync(output_file, content);
+        const serialized = json.serialize(state);
+        const content = JSON.stringify(serialized, null, 2);
+        await fs.writeFile(output_file, content);
+      }
     },
     [argv, state]
   );

package/src/app/DependencyCheck.tsx

@@ -163,12 +163,6 @@ function CheckGithubCliAuth(props: Props) {
 
 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

package/src/app/Main.tsx

@@ -10,6 +10,7 @@ import { PreSelectCommitRanges } from "~/app/PreSelectCommitRanges";
 import { SelectCommitRanges } from "~/app/SelectCommitRanges";
 import { Status } from "~/app/Status";
 import { Store } from "~/app/Store";
+import { SyncGithub } from "~/app/SyncGithub";
 import { assertNever } from "~/core/assertNever";
 
 export function Main() {
@@ -43,6 +44,9 @@ export function Main() {
     case "manual-rebase":
       return <ManualRebase />;
 
+    case "sync-github":
+      return <SyncGithub />;
+
     case "post-rebase-status":
       return <PostRebaseStatus />;
 

package/src/app/ManualRebase.tsx

@@ -6,28 +6,44 @@ import * as Ink from "ink-cjs";
 
 import { Await } from "~/app/Await";
 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";
 import { colors } from "~/core/colors";
-import * as github from "~/core/github";
 import { invariant } from "~/core/invariant";
 import { short_id } from "~/core/short_id";
 
 export function ManualRebase() {
+  const abort_handler = React.useRef(() => {});
+
+  React.useEffect(function listen_sigint() {
+    process.once("SIGINT", sigint_handler);
+
+    return function cleanup() {
+      process.removeListener("SIGINT", sigint_handler);
+    };
+
+    async function sigint_handler() {
+      abort_handler.current();
+    }
+  }, []);
+
   return (
     <Await
       fallback={<Ink.Text color={colors.yellow}>Rebasing commits…</Ink.Text>}
-      function={run}
+      function={async function () {
+        await run({ abort_handler });
+      }}
     />
   );
 }
 
-async function run() {
+type Args = {
+  abort_handler: React.MutableRefObject<() => void>;
+};
+
+async function run(args: Args) {
   const state = Store.getState();
   const actions = state.actions;
   const argv = state.argv;
@@ -42,108 +58,70 @@ async function run() {
   invariant(repo_root, "repo_root must exist");
 
   // always listen for SIGINT event and restore git state
-  process.once("SIGINT", handle_exit);
+  args.abort_handler.current = function sigint_handler() {
+    actions.output(<Ink.Text color={colors.red}>🚨 Abort</Ink.Text>);
+    handle_exit(15);
+  };
 
-  // get latest merge_base relative to local master
-  const merge_base = (await cli(`git merge-base HEAD ${master_branch}`)).stdout;
+  const temp_branch_name = `${branch_name}_${short_id()}`;
 
-  // immediately paint all commit to preserve selected commit ranges
-  let commit_range = await CommitMetadata.range(commit_map);
+  try {
+    // get latest merge_base relative to local master
+    const merge_base = (await cli(`git merge-base HEAD ${master_branch}`))
+      .stdout;
 
-  // reverse group list to ensure we create git revise in correct order
-  commit_range.group_list.reverse();
+    // immediately paint all commit to preserve selected commit ranges
+    let commit_range = await CommitMetadata.range(commit_map);
 
-  for (const commit of commit_range.commit_list) {
-    const group_from_map = commit_map[commit.sha];
-    commit.branch_id = group_from_map.id;
-    commit.title = group_from_map.title;
-  }
+    // reverse group list to ensure we create git revise in correct order
+    commit_range.group_list.reverse();
 
-  await GitReviseTodo.execute({
-    rebase_group_index: 0,
-    rebase_merge_base: merge_base,
-    commit_range,
-  });
+    for (const commit of commit_range.commit_list) {
+      const group_from_map = commit_map[commit.sha];
+      commit.branch_id = group_from_map.id;
+      commit.title = group_from_map.title;
+    }
 
-  let DEFAULT_PR_BODY = "";
-  if (state.pr_template_body) {
-    DEFAULT_PR_BODY = state.pr_template_body;
-  }
+    await GitReviseTodo.execute({
+      rebase_group_index: 0,
+      rebase_merge_base: merge_base,
+      commit_range,
+    });
 
-  const temp_branch_name = `${branch_name}_${short_id()}`;
+    commit_range = await CommitMetadata.range(commit_map);
 
-  commit_range = await CommitMetadata.range(commit_map);
+    // reverse commit list so that we can cherry-pick in order
+    commit_range.group_list.reverse();
 
-  // reverse commit list so that we can cherry-pick in order
-  commit_range.group_list.reverse();
+    let rebase_merge_base = merge_base;
+    let rebase_group_index = 0;
 
-  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];
 
-  for (let i = 0; i < commit_range.group_list.length; i++) {
-    const group = commit_range.group_list[i];
+      if (!group.dirty) {
+        continue;
+      }
 
-    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;
+      }
 
-    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;
     }
 
-    break;
-  }
+    actions.debug(`rebase_merge_base = ${rebase_merge_base}`);
+    actions.debug(`rebase_group_index = ${rebase_group_index}`);
 
-  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)}`);
 
-  // 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() {
-    actions.debug(`rebase_git_revise`);
-
-    actions.output(
-      <Ink.Text color={colors.yellow} wrap="truncate-end">
-        Rebasing…
-      </Ink.Text>
-    );
-
     // create temporary branch
     await cli(`git checkout -b ${temp_branch_name}`);
 
@@ -153,268 +131,33 @@ async function run() {
       commit_range,
     });
 
-    // early return since we do not need to sync
-    if (!argv.sync) {
-      return;
-    }
-
-    // in order to sync we walk from rebase_group_index to HEAD
-    // checking out each group and syncing to github
-
-    // 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() {
-    actions.debug("rebase_cherry_pick");
-
-    // create temporary branch based on merge base
-    await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
-
-    const pr_url_list = commit_range.group_list.map(get_group_url);
-
-    for (let i = rebase_group_index; i < commit_range.group_list.length; i++) {
-      const group = commit_range.group_list[i];
-
-      invariant(group.base, "group.base must exist");
-
-      actions.output(
-        <FormatText
-          wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
-          message="Rebasing {group}…"
-          values={{
-            group: (
-              <Brackets>{group.pr?.title || group.title || group.id}</Brackets>
-            ),
-          }}
-        />
-      );
-
-      // cherry-pick and amend commits one by one
-      for (const commit of group.commits) {
-        // ensure clean base to avoid conflicts when applying patch
-        await cli(`git clean -fd`);
-
-        // create, apply and cleanup patch
-        await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
-        await cli(`git apply ${PATCH_FILE}`);
-        await cli(`rm ${PATCH_FILE}`);
-
-        // add all changes to stage
-        await cli(`git add --all`);
-
-        const metadata = { id: group.id, title: group.title };
-        const new_message = Metadata.write(commit.full_message, metadata);
-        const git_commit_comand = [`git commit -m "${new_message}"`];
-
-        if (argv.verify === false) {
-          git_commit_comand.push("--no-verify");
-        }
-
-        await cli(git_commit_comand);
-      }
-
-      await sync_group_github({ group, pr_url_list, skip_checkout: false });
-    }
-
-    // finally, ensure all prs have the updated stack table from updated pr_url_list
-    await update_pr_tables(pr_url_list);
-  }
-
-  async function sync_group_github(args: {
-    group: CommitMetadataGroup;
-    pr_url_list: Array<string>;
-    skip_checkout: boolean;
-  }) {
-    if (!argv.sync) {
-      return;
-    }
-
-    const { group, pr_url_list } = args;
-
-    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>
-          ),
-        }}
-      />
-    );
-
-    // we may temporarily mark PR as a draft before editing it
-    // if it is not already a draft PR, to avoid notification spam
-    let is_temp_draft = false;
-
-    // before pushing reset base to master temporarily
-    // avoid accidentally pointing to orphaned parent commit
-    // should hopefully fix issues where a PR includes a bunch of commits after pushing
-    if (group.pr) {
-      if (!group.pr.isDraft) {
-        is_temp_draft = true;
-      }
-
-      if (is_temp_draft) {
-        await github.pr_draft({
-          branch: group.id,
-          draft: true,
-        });
-      }
-
-      await github.pr_edit({
-        branch: group.id,
-        base: master_branch,
-      });
-    }
-
-    // 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);
+    // after all commits have been modified move the pointer
+    // of original branch to the newly created temporary branch
+    await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
 
-    const selected_url = get_group_url(group);
+    restore_git();
 
-    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,
-        }),
+    if (argv.sync) {
+      actions.set((state) => {
+        state.step = "sync-github";
+        state.sync_github = { commit_range, rebase_group_index };
       });
-
-      if (is_temp_draft) {
-        // mark pr as ready for review again
-        await github.pr_draft({
-          branch: group.id,
-          draft: false,
-        });
-      }
     } else {
-      if (!args.skip_checkout) {
-        // 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: DEFAULT_PR_BODY,
-        draft: argv.draft,
+      actions.set((state) => {
+        state.step = "post-rebase-status";
       });
-
-      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}`);
-      }
     }
-  }
-
-  async function update_pr_tables(pr_url_list: Array<string>) {
-    if (!argv.sync) {
-      return;
+  } catch (err) {
+    if (err instanceof Error) {
+      actions.error(err.message);
     }
 
-    for (let i = 0; i < commit_range.group_list.length; i++) {
-      const group = commit_range.group_list[i];
-
-      // use the updated pr_url_list to get the actual selected_url
-      const selected_url = pr_url_list[i];
-
-      invariant(group.base, "group.base must exist");
-
-      const body = group.pr?.body || DEFAULT_PR_BODY;
-
-      const update_body = StackSummaryTable.write({
-        body,
-        pr_url_list,
-        selected_url,
-      });
-
-      if (update_body === body) {
-        actions.debug(`Skipping body update for ${selected_url}`);
-      } else {
-        actions.debug(`Update body for ${selected_url}`);
-
-        await github.pr_edit({
-          branch: group.id,
-          base: group.base,
-          body: update_body,
-        });
-      }
+    actions.error("Unable to rebase.");
+    if (!argv.verbose) {
+      actions.error("Try again with `--verbose` to see more information.");
     }
+
+    handle_exit(16);
   }
 
   // cleanup git operations if cancelled during manual rebase
@@ -424,9 +167,6 @@ async function run() {
     // all children processes receive the SIGINT signal
     const spawn_options = { ignoreExitCode: true };
 
-    // always clean up any patch files
-    cli.sync(`rm ${PATCH_FILE}`, spawn_options);
-
     // 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);
@@ -438,13 +178,6 @@ async function run() {
     // ...and cleanup temporary branch
     cli.sync(`git branch -D ${temp_branch_name}`, spawn_options);
 
-    if (commit_range) {
-      // ...and cleanup pr group branches
-      for (const group of commit_range.group_list) {
-        cli.sync(`git branch -D ${group.id}`, spawn_options);
-      }
-    }
-
     // restore back to original dir
     if (fs.existsSync(cwd)) {
       process.chdir(cwd);
@@ -452,7 +185,7 @@ async function run() {
     cli.sync(`pwd`, spawn_options);
   }
 
-  function handle_exit() {
+  function handle_exit(code: number) {
     actions.output(
       <Ink.Text color={colors.yellow}>
         Restoring <Brackets>{branch_name}</Brackets>…
@@ -467,11 +200,6 @@ async function run() {
       </Ink.Text>
     );
 
-    actions.exit(5);
+    actions.exit(code);
   }
 }
-
-type CommitMetadataGroup = CommitMetadata.CommitRange["group_list"][number];
-const get_group_url = (group: CommitMetadataGroup) => group.pr?.url || group.id;
-
-const PATCH_FILE = "git-stack-cli-patch.patch";