git-stack-cli 1.12.0 → 1.13.0

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/ManualRebase.tsx

@@ -10,7 +10,6 @@ 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";
@@ -107,37 +106,6 @@ async function run() {
     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…
@@ -153,11 +121,33 @@ async function run() {
       commit_range,
     });
 
-    // early return since we do not need to sync
-    if (!argv.sync) {
-      return;
+    // 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}`);
+
+    if (argv.sync) {
+      await sync_github();
     }
 
+    restore_git();
+
+    actions.set((state) => {
+      state.step = "post-rebase-status";
+    });
+  } catch (err) {
+    if (err instanceof Error) {
+      actions.error(err.message);
+    }
+
+    actions.error("Unable to rebase.");
+    if (!argv.verbose) {
+      actions.error("Try again with `--verbose` to see more information.");
+    }
+
+    handle_exit();
+  }
+
+  async function sync_github() {
     // in order to sync we walk from rebase_group_index to HEAD
     // checking out each group and syncing to github
 
@@ -186,113 +176,110 @@ async function run() {
       push_group_list.unshift({ group, lookback_index });
     }
 
-    const pr_url_list = commit_range.group_list.map(get_group_url);
+    actions.output(
+      <FormatText
+        wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
+        message="Syncing {group_list}…"
+        values={{
+          group_list: (
+            <React.Fragment>
+              {push_group_list.map((push_group) => {
+                const group = push_group.group;
+
+                return (
+                  <Brackets key={group.id}>
+                    {group.pr?.title || group.title || group.id}
+                  </Brackets>
+                );
+              })}
+            </React.Fragment>
+          ),
+        }}
+      />
+    );
 
-    // use push_group_list to sync each group HEAD to github
+    // for all push targets in push_group_list
+    // things that can be done in parallel are grouped by numbers
+    //
+    // -----------------------------------
+    // 1 (before_push) temp mark draft
+    // --------------------------------------
+    // 2 push simultaneously to github
+    // --------------------------------------
+    // 2 create PR / edit PR
+    // 2 (after_push) undo temp mark draft
+    // --------------------------------------
+
+    const before_push_tasks = [];
     for (const push_group of push_group_list) {
-      const { group } = push_group;
+      before_push_tasks.push(before_push(push_group));
+    }
 
-      // move to temporary branch for resetting to lookback_index to create PR
-      await cli(`git checkout -b ${group.id}`);
+    await Promise.all(before_push_tasks);
 
-      // prepare branch for sync, reset to commit at lookback index
-      await cli(`git reset --hard HEAD~${push_group.lookback_index}`);
+    const push_target_list = push_group_list.map((push_group) => {
+      return `HEAD~${push_group.lookback_index}:${push_group.group.id}`;
+    });
 
-      await sync_group_github({ group, pr_url_list, skip_checkout: true });
+    const push_target_args = push_target_list.join(" ");
 
-      // 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}`);
+    const git_push_command = [`git push -f origin ${push_target_args}`];
+
+    if (argv.verify === false) {
+      git_push_command.push("--no-verify");
     }
 
-    // finally, ensure all prs have the updated stack table from updated pr_url_list
-    await update_pr_tables(pr_url_list);
-  }
+    await cli(git_push_command);
 
-  async function rebase_cherry_pick() {
-    actions.debug("rebase_cherry_pick");
+    const pr_url_list = commit_range.group_list.map(get_group_url);
 
-    // create temporary branch based on merge base
-    await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
+    const after_push_tasks = [];
+    for (const push_group of push_group_list) {
+      const group = push_group.group;
+      after_push_tasks.push(after_push({ group, pr_url_list }));
+    }
 
-    const pr_url_list = commit_range.group_list.map(get_group_url);
+    await Promise.all(after_push_tasks);
 
-    for (let i = rebase_group_index; i < commit_range.group_list.length; i++) {
+    // finally, ensure all prs have the updated stack table from updated pr_url_list
+    for (let i = 0; i < commit_range.group_list.length; i++) {
       const group = commit_range.group_list[i];
 
-      invariant(group.base, "group.base must exist");
+      // use the updated pr_url_list to get the actual selected_url
+      const selected_url = pr_url_list[i];
 
-      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");
-        }
+      invariant(group.base, "group.base must exist");
 
-        await cli(git_commit_comand);
-      }
+      const body = group.pr?.body || DEFAULT_PR_BODY;
 
-      await sync_group_github({ group, pr_url_list, skip_checkout: false });
-    }
+      const update_body = StackSummaryTable.write({
+        body,
+        pr_url_list,
+        selected_url,
+      });
 
-    // finally, ensure all prs have the updated stack table from updated pr_url_list
-    await update_pr_tables(pr_url_list);
-  }
+      if (update_body === body) {
+        actions.debug(`Skipping body update for ${selected_url}`);
+      } else {
+        actions.debug(`Update body for ${selected_url}`);
 
-  async function sync_group_github(args: {
-    group: CommitMetadataGroup;
-    pr_url_list: Array<string>;
-    skip_checkout: boolean;
-  }) {
-    if (!argv.sync) {
-      return;
+        await github.pr_edit({
+          branch: group.id,
+          base: group.base,
+          body: update_body,
+        });
+      }
     }
+  }
 
-    const { group, pr_url_list } = args;
+  async function before_push(args: { group: CommitMetadataGroup }) {
+    const { group } = 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;
+    let is_temp_draft = !group.pr?.isDraft;
 
     // before pushing reset base to master temporarily
     // avoid accidentally pointing to orphaned parent commit
@@ -314,15 +301,15 @@ async function run() {
         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");
-    }
+  async function after_push(args: {
+    group: CommitMetadataGroup;
+    pr_url_list: Array<string>;
+  }) {
+    const { group, pr_url_list } = args;
 
-    await cli(git_push_command);
+    invariant(group.base, "group.base must exist");
 
     const selected_url = get_group_url(group);
 
@@ -338,6 +325,10 @@ async function run() {
         }),
       });
 
+      // 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 = !group.pr?.isDraft;
+
       if (is_temp_draft) {
         // mark pr as ready for review again
         await github.pr_draft({
@@ -346,14 +337,6 @@ async function run() {
         });
       }
     } 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,
@@ -374,46 +357,6 @@ async function run() {
           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;
-    }
-
-    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,
-        });
-      }
     }
   }
 
@@ -424,9 +367,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 +378,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);
@@ -473,5 +406,3 @@ async function run() {
 
 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";

package/src/app/PreManualRebase.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";
@@ -11,6 +11,7 @@ import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import { colors } from "~/core/colors";
 import { invariant } from "~/core/invariant";
+import { safe_exists } from "~/core/safe_exists";
 
 export function PreManualRebase() {
   return <Await fallback={null} function={run} />;
@@ -40,8 +41,8 @@ async function run() {
   for (const key of PR_TEMPLATE_KEY_LIST) {
     const pr_template_fn = PR_TEMPLATE[key as keyof typeof PR_TEMPLATE];
 
-    if (fs.existsSync(pr_template_fn(repo_root))) {
-      pr_template_body = fs.readFileSync(pr_template_fn(repo_root), "utf-8");
+    if (await safe_exists(pr_template_fn(repo_root))) {
+      pr_template_body = await fs.readFile(pr_template_fn(repo_root), "utf-8");
 
       actions.output(
         <FormatText
@@ -59,8 +60,8 @@ async function run() {
 
   // ./.github/PULL_REQUEST_TEMPLATE/*.md
   let pr_templates: Array<string> = [];
-  if (fs.existsSync(PR_TEMPLATE.TemplateDir(repo_root))) {
-    pr_templates = fs.readdirSync(PR_TEMPLATE.TemplateDir(repo_root));
+  if (await safe_exists(PR_TEMPLATE.TemplateDir(repo_root))) {
+    pr_templates = await fs.readdir(PR_TEMPLATE.TemplateDir(repo_root));
   }
 
   // check if repo has multiple pr templates

package/src/app/RebaseCheck.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;
@@ -74,8 +74,8 @@ export function RebaseCheck(props: Props) {
       const git_dir = (await cli(`git rev-parse --absolute-git-dir`)).stdout;
 
       let is_rebase = false;
-      is_rebase ||= fs.existsSync(path.join(git_dir, "rebase-apply"));
-      is_rebase ||= fs.existsSync(path.join(git_dir, "rebase-merge"));
+      is_rebase ||= await safe_exists(path.join(git_dir, "rebase-apply"));
+      is_rebase ||= await safe_exists(path.join(git_dir, "rebase-merge"));
 
       const status = is_rebase ? "prompt" : "done";
       patch({ status });

package/src/command.ts

@@ -52,11 +52,6 @@ export async function command() {
   );
 }
 
-const Rebase = Object.freeze({
-  "git-revise": "git-revise",
-  "cherry-pick": "cherry-pick",
-});
-
 const GlobalOptions = {
   verbose: {
     type: "boolean",
@@ -95,17 +90,6 @@ const DefaultOptions = {
       "Run git hooks such as pre-commit and pre-push, disable with --no-verify",
   },
 
-  "rebase": {
-    type: "string",
-    choices: [Rebase["git-revise"], Rebase["cherry-pick"]],
-    default: Rebase["git-revise"],
-    description: [
-      "Strategy used for syncing branches",
-      `${Rebase["git-revise"]}: perform faster in-memory rebase`,
-      `${Rebase["cherry-pick"]}: use disk and incrementally rebase each commit`,
-    ].join(" | "),
-  },
-
   "update": {
     type: "boolean",
     alias: ["u", "upgrade"],

package/src/commands/Rebase.tsx

@@ -111,9 +111,8 @@ Rebase.run = async function run() {
       await cli(`git cherry-pick --keep-redundant-commits ${sha_list}`);
     }
 
-    // after all commits have been cherry-picked and amended
-    // move the branch pointer to the newly created temporary branch
-    // now we are locally in sync with github and on the original branch
+    // after all commits have been cherry-picked move the pointer
+    // of original branch to the newly created temporary branch
     await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
 
     restore_git();
@@ -154,9 +153,6 @@ Rebase.run = 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);
@@ -168,13 +164,6 @@ Rebase.run = 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);
@@ -200,5 +189,3 @@ Rebase.run = async function run() {
     actions.exit(6);
   }
 };
-
-const PATCH_FILE = "git-stack-cli-patch.patch";

package/src/core/GitReviseTodo.ts

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -120,10 +120,10 @@ GitReviseTodo.execute = async function grt_execute(args: ExecuteArgs) {
   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);
+  await fs.writeFile(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
 
   // ensure script is executable
-  fs.chmodSync(tmp_git_sequence_editor_path, "755");
+  await fs.chmod(tmp_git_sequence_editor_path, "755");
 
   const git_revise_todo = GitReviseTodo(args);