git-stack-cli 1.11.7 → 1.13.0

package/dist/cjs/index.cjs

@@ -11,12 +11,13 @@ var node_events = require('node:events');
 var fs = require('node:fs');
 var require$$1 = require('module');
 var node_buffer = require('node:buffer');
+var fs$1 = require('node:fs/promises');
 var path = require('node:path');
 var child = require('node:child_process');
 var https = require('node:https');
 var crypto = require('node:crypto');
 var path$1 = require('path');
-var fs$1 = require('fs');
+var fs$2 = require('fs');
 var util = require('util');
 var url = require('url');
 
@@ -26520,9 +26521,9 @@ function is_finite_value(value) {
     return typeof value === "number" && Number.isFinite(value);
 }
 
-function read_json(path) {
+async function read_json(path) {
     try {
-        const file_buffer = fs.readFileSync(path);
+        const file_buffer = await fs$1.readFile(path);
         const json_str = String(file_buffer);
         const json = JSON.parse(json_str);
         return json;
@@ -26607,10 +26608,11 @@ function AutoUpdate(props) {
             if (!latest_version) {
                 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$1.realpath(process.argv[1]);
+            const script_dir = path.dirname(script_path);
             // dist/ts/index.js
             const package_json_path = path.join(script_dir, "..", "..", "package.json");
-            const package_json = read_json(package_json_path);
+            const package_json = await read_json(package_json_path);
             if (!package_json) {
                 // unable to find read package.json, skip auto update
                 throw new Error(`Unable to read package.json [${package_json_path}]`);
@@ -26773,6 +26775,16 @@ function Command(props) {
     return (reactExports.createElement(Text, { bold: true, color: text_color }, props.children));
 }
 
+async function safe_exists(filepath) {
+    try {
+        await fs$1.access(filepath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
 function reducer$3(state, patch) {
     return { ...state, ...patch };
 }
@@ -26803,7 +26815,8 @@ function CherryPickCheck(props) {
         const actions = Store.getState().actions;
         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 });
         }
@@ -26855,6 +26868,16 @@ function deserialize(obj) {
     return obj;
 }
 
+async function safe_rm(filepath) {
+    try {
+        await fs$1.access(filepath);
+        await fs$1.rm(filepath);
+    }
+    catch {
+        // if access fails there is no file to remove this is safe
+    }
+}
+
 function Debug() {
     const actions = Store.useActions();
     const state = Store.useState((state) => state);
@@ -26865,17 +26888,18 @@ function Debug() {
             actions.output(reactExports.createElement(Text, { color: colors.yellow }, "Debug mode enabled"));
         }
     }, [argv]);
-    reactExports.useEffect(function syncStateJson() {
+    reactExports.useEffect(function sync_state_json() {
         if (!argv?.["write-state-json"]) {
             return;
         }
-        const output_file = path.join(state.cwd, "git-stack-state.json");
-        if (fs.existsSync(output_file)) {
-            fs.rmSync(output_file);
+        sync().catch(actions.error);
+        async function sync() {
+            const output_file = path.join(state.cwd, "git-stack-state.json");
+            await safe_rm(output_file);
+            const serialized = serialize(state);
+            const content = JSON.stringify(serialized, null, 2);
+            await fs$1.writeFile(output_file, content);
         }
-        const serialized = serialize(state);
-        const content = JSON.stringify(serialized, null, 2);
-        fs.writeFileSync(output_file, content);
     }, [argv, state]);
     return null;
 }
@@ -27005,11 +27029,6 @@ function CheckGithubCliAuth(props) {
 }
 function CheckGitRevise(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 (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
             reactExports.createElement(Text, null,
                 "Checking ",
@@ -29776,8 +29795,43 @@ async function pr_create(args) {
 async function pr_edit(args) {
     const command_parts = [`gh pr edit ${args.branch} --base ${args.base}`];
     if (args.body) {
-        command_parts.push(`--body-file="${body_file(args.body)}"`);
+        const body_file = await write_body_file(args);
+        command_parts.push(`--body-file="${body_file}"`);
+    }
+    const command = command_parts.join(" ");
+    const cli_result = await cli(command);
+    if (cli_result.code !== 0) {
+        handle_error(cli_result.output);
+    }
+}
+async function pr_draft(args) {
+    // https://cli.github.com/manual/gh_api
+    // https://docs.github.com/en/graphql/reference/mutations#convertpullrequesttodraft
+    // https://docs.github.com/en/graphql/reference/mutations#markpullrequestreadyforreview
+    const mutation_name = args.draft
+        ? "convertPullRequestToDraft"
+        : "markPullRequestReadyForReview";
+    let query = `
+    mutation($id: ID!) {
+      ${mutation_name}(input: { pullRequestId: $id }) {
+        pullRequest {
+          id
+          number
+          isDraft
+        }
+      }
     }
+  `;
+    query = query.replace(/\n/g, " ");
+    query = query.replace(/\s+/g, " ");
+    query = query.trim();
+    // lookup id from pr cache using args.branch
+    const state = Store.getState();
+    const cache_pr = state.pr[args.branch];
+    invariant(cache_pr, "cache_pr must exist");
+    const command_parts = [
+        `gh api graphql -F id="${cache_pr.id}" -f query='${query}'`,
+    ];
     const command = command_parts.join(" ");
     const cli_result = await cli(command);
     if (cli_result.code !== 0) {
@@ -29785,7 +29839,7 @@ async function pr_edit(args) {
     }
 }
 // prettier-ignore
-const JSON_FIELDS = "--json number,state,baseRefName,headRefName,commits,title,body,url";
+const JSON_FIELDS = "--json id,number,state,baseRefName,headRefName,commits,title,body,url,isDraft";
 // consistent handle gh cli commands returning json
 // redirect to tmp file to avoid scrollback overflow causing scrollback to be cleared
 async function gh_json(command) {
@@ -29796,7 +29850,7 @@ async function gh_json(command) {
         return new Error(cli_result.output);
     }
     // read from file
-    const json_str = fs.readFileSync(tmp_pr_json, "utf-8");
+    const json_str = await fs$1.readFile(tmp_pr_json, "utf-8");
     const json = JSON.parse(json_str);
     return json;
 }
@@ -29809,13 +29863,12 @@ function handle_error(output) {
     throw new Error(output);
 }
 // convert a string to a file for use via github cli `--body-file`
-function body_file(body) {
+async function write_body_file(args) {
+    invariant(args.body, "args.body must exist");
     const temp_dir = os.tmpdir();
-    const temp_path = path.join(temp_dir, "git-stack-body");
-    if (fs.existsSync(temp_path)) {
-        fs.rmSync(temp_path);
-    }
-    fs.writeFileSync(temp_path, body);
+    const temp_path = path.join(temp_dir, `git-stack-body-${args.base}`);
+    await safe_rm(temp_path);
+    await fs$1.writeFile(temp_path, args.body);
     return temp_path;
 }
 
@@ -30097,9 +30150,9 @@ echo "------ END ------"
 echo "$GIT_REVISE_TODO" > "$git_revise_todo_path"
 `;
     // write script to temporary path
-    fs.writeFileSync(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
+    await fs$1.writeFile(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
     // ensure script is executable
-    fs.chmodSync(tmp_git_sequence_editor_path, "755");
+    await fs$1.chmod(tmp_git_sequence_editor_path, "755");
     const git_revise_todo = GitReviseTodo(args);
     // execute cli with temporary git sequence editor script
     // revise from merge base to pick correct commits
@@ -30498,10 +30551,10 @@ function encode(value) {
     return result.padStart(max_char_size, "=");
 }
 
-function Rebase$1() {
-    return (reactExports.createElement(Await, { function: Rebase$1.run, fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026") }));
+function Rebase() {
+    return (reactExports.createElement(Await, { function: Rebase.run, fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026") }));
 }
-Rebase$1.run = async function run() {
+Rebase.run = async function run() {
     const state = Store.getState();
     const actions = state.actions;
     const branch_name = state.branch_name;
@@ -30555,9 +30608,8 @@ Rebase$1.run = async function run() {
             const sha_list = picked_commit_list.map((commit) => commit.sha).join(" ");
             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();
         const next_commit_range = await range();
@@ -30585,8 +30637,6 @@ Rebase$1.run = async function run() {
         // trying to use `await cli(...)` here will silently fail since
         // all children processes receive the SIGINT signal
         const spawn_options = { ignoreExitCode: true };
-        // always clean up any patch files
-        cli.sync(`rm ${PATCH_FILE$1}`, 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);
@@ -30595,12 +30645,6 @@ Rebase$1.run = async function run() {
         cli.sync(`git checkout ${branch_name}`, spawn_options);
         // ...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);
@@ -30620,10 +30664,9 @@ Rebase$1.run = async function run() {
         actions.exit(6);
     }
 };
-const PATCH_FILE$1 = "git-stack-cli-patch.patch";
 
 function LocalMergeRebase() {
-    return reactExports.createElement(Rebase$1, null);
+    return reactExports.createElement(Rebase, null);
 }
 
 function write(args) {
@@ -30796,44 +30839,36 @@ async function run$6() {
         // 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
+        actions.output(reactExports.createElement(Text, { color: colors.yellow, wrap: "truncate-end" }, "Rebasing\u2026"));
+        // create temporary branch
+        await cli(`git checkout -b ${temp_branch_name}`);
+        await GitReviseTodo.execute({
+            rebase_group_index,
+            rebase_merge_base,
+            commit_range,
+        });
+        // 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) {
-        actions.error("Unable to rebase.");
         if (err instanceof Error) {
-            if (actions.isDebug()) {
-                actions.error(err.message);
-            }
+            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 rebase_git_revise() {
-        actions.debug(`rebase_git_revise`);
-        actions.output(reactExports.createElement(Text, { color: colors.yellow, wrap: "truncate-end" }, "Rebasing\u2026"));
-        // create temporary branch
-        await cli(`git checkout -b ${temp_branch_name}`);
-        await GitReviseTodo.execute({
-            rebase_group_index,
-            rebase_merge_base,
-            commit_range,
-        });
-        // early return since we do not need to sync
-        if (!argv.sync) {
-            return;
-        }
+    async function sync_github() {
         // 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
@@ -30855,80 +30890,97 @@ async function run$6() {
             // push group and lookback_index onto front of push_group_list
             push_group_list.unshift({ group, lookback_index });
         }
+        actions.output(reactExports.createElement(FormatText, { wrapper: reactExports.createElement(Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Syncing {group_list}\u2026", values: {
+                group_list: (reactExports.createElement(reactExports.Fragment, null, push_group_list.map((push_group) => {
+                    const group = push_group.group;
+                    return (reactExports.createElement(Brackets, { key: group.id }, group.pr?.title || group.title || group.id));
+                }))),
+            } }));
+        // 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) {
+            before_push_tasks.push(before_push(push_group));
+        }
+        await Promise.all(before_push_tasks);
+        const push_target_list = push_group_list.map((push_group) => {
+            return `HEAD~${push_group.lookback_index}:${push_group.group.id}`;
+        });
+        const push_target_args = push_target_list.join(" ");
+        const git_push_command = [`git push -f origin ${push_target_args}`];
+        if (argv.verify === false) {
+            git_push_command.push("--no-verify");
+        }
+        await cli(git_push_command);
         const pr_url_list = commit_range.group_list.map(get_group_url);
-        // use push_group_list to sync each group HEAD to github
+        const after_push_tasks = [];
         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}`);
+            const group = push_group.group;
+            after_push_tasks.push(after_push({ group, pr_url_list }));
         }
+        await Promise.all(after_push_tasks);
         // 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++) {
+        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");
-            actions.output(reactExports.createElement(FormatText, { wrapper: reactExports.createElement(Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Rebasing {group}\u2026", values: {
-                    group: (reactExports.createElement(Brackets, null, group.pr?.title || group.title || group.id)),
-                } }));
-            // 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 = write$1(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);
+            const body = group.pr?.body || DEFAULT_PR_BODY;
+            const update_body = 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 pr_edit({
+                    branch: group.id,
+                    base: group.base,
+                    body: update_body,
+                });
             }
-            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) {
-        if (!argv.sync) {
-            return;
-        }
-        const { group, pr_url_list } = args;
+    async function before_push(args) {
+        const { group } = args;
         invariant(group.base, "group.base must exist");
-        actions.output(reactExports.createElement(FormatText, { wrapper: reactExports.createElement(Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Syncing {group}\u2026", values: {
-                group: (reactExports.createElement(Brackets, null, group.pr?.title || group.title || group.id)),
-            } }));
+        // 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;
         // 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 pr_draft({
+                    branch: group.id,
+                    draft: true,
+                });
+            }
             await 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);
+    }
+    async function after_push(args) {
+        const { group, pr_url_list } = args;
+        invariant(group.base, "group.base must exist");
         const selected_url = get_group_url(group);
         if (group.pr) {
             // ensure base matches pr in github
@@ -30941,14 +30993,18 @@ async function run$6() {
                     selected_url,
                 }),
             });
+            // 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 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 pr_create({
                 branch: group.id,
@@ -30967,38 +31023,6 @@ async function run$6() {
                     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) {
-        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 = 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 pr_edit({
-                    branch: group.id,
-                    base: group.base,
-                    body: update_body,
-                });
-            }
         }
     }
     // cleanup git operations if cancelled during manual rebase
@@ -31007,8 +31031,6 @@ async function run$6() {
         // trying to use `await cli(...)` here will silently fail since
         // 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);
@@ -31017,12 +31039,6 @@ async function run$6() {
         cli.sync(`git checkout ${branch_name}`, spawn_options);
         // ...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);
@@ -31043,7 +31059,6 @@ async function run$6() {
     }
 }
 const get_group_url = (group) => group.pr?.url || group.id;
-const PATCH_FILE = "git-stack-cli-patch.patch";
 
 function Table(props) {
     if (!props.data.length) {
@@ -31275,8 +31290,8 @@ async function run$4() {
     // ./docs/pull_request_template.md
     for (const key of PR_TEMPLATE_KEY_LIST) {
         const pr_template_fn = PR_TEMPLATE[key];
-        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$1.readFile(pr_template_fn(repo_root), "utf-8");
             actions.output(reactExports.createElement(FormatText, { wrapper: reactExports.createElement(Text, { color: colors.yellow }), message: "Using PR template {pr_filepath}", values: {
                     pr_filepath: reactExports.createElement(Brackets, null, pr_template_fn("")),
                 } }));
@@ -31285,8 +31300,8 @@ async function run$4() {
     }
     // ./.github/PULL_REQUEST_TEMPLATE/*.md
     let pr_templates = [];
-    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$1.readdir(PR_TEMPLATE.TemplateDir(repo_root));
     }
     // check if repo has multiple pr templates
     actions.set((state) => {
@@ -31893,8 +31908,8 @@ function RebaseCheck(props) {
         try {
             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 });
         }
@@ -32101,7 +32116,7 @@ function MaybeMain() {
     else if (positional_list.has("rebase")) {
         return (reactExports.createElement(GatherMetadata, null,
             reactExports.createElement(LocalCommitStatus, null,
-                reactExports.createElement(Rebase$1, null))));
+                reactExports.createElement(Rebase, null))));
     }
     return (reactExports.createElement(DirtyCheck, null,
         !argv.verbose ? null : reactExports.createElement(GithubApiError, null),
@@ -32440,14 +32455,14 @@ function ui (opts) {
 
 function escalade (start, callback) {
 	let dir = path$1.resolve('.', start);
-	let tmp, stats = fs$1.statSync(dir);
+	let tmp, stats = fs$2.statSync(dir);
 
 	if (!stats.isDirectory()) {
 		dir = path$1.dirname(dir);
 	}
 
 	while (true) {
-		tmp = callback(dir, fs$1.readdirSync(dir));
+		tmp = callback(dir, fs$2.readdirSync(dir));
 		if (tmp) return path$1.resolve(dir, tmp);
 		dir = path$1.dirname(tmp = dir);
 		if (tmp === dir) break;
@@ -33653,7 +33668,7 @@ const parser = new YargsParser({
         }
         else if (path.match(/\.json$/)) {
             // Addresses: https://github.com/yargs/yargs/issues/2040
-            return JSON.parse(fs$1.readFileSync(path, 'utf8'));
+            return JSON.parse(fs$2.readFileSync(path, 'utf8'));
         }
         else {
             throw Error('only .json config files are supported in ESM');
@@ -33701,14 +33716,14 @@ class YError extends Error {
 
 var shim$3 = {
     fs: {
-        readFileSync: fs$1.readFileSync,
-        writeFile: fs$1.writeFile
+        readFileSync: fs$2.readFileSync,
+        writeFile: fs$2.writeFile
     },
     format: util.format,
     resolve: path$1.resolve,
     exists: (file) => {
         try {
-            return fs$1.statSync(file).isFile();
+            return fs$2.statSync(file).isFile();
         }
         catch (err) {
             return false;
@@ -33939,7 +33954,7 @@ var shim$1 = {
     nextTick: process.nextTick,
     stdColumns: typeof process.stdout.columns !== 'undefined' ? process.stdout.columns : null
   },
-  readFileSync: fs$1.readFileSync,
+  readFileSync: fs$2.readFileSync,
   require: () => {
     throw new YError(REQUIRE_ERROR)
   },
@@ -37429,15 +37444,11 @@ async function command() {
         .wrap(123)
         // disallow unknown options
         .strict()
-        .version("1.11.7" )
+        .version("1.13.0" )
         .showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`")
         .help("help", "Show usage via `git stack help`")
         .argv;
 }
-const Rebase = Object.freeze({
-    "git-revise": "git-revise",
-    "cherry-pick": "cherry-pick",
-});
 const GlobalOptions = {
     verbose: {
         type: "boolean",
@@ -37470,16 +37481,6 @@ const DefaultOptions = {
         default: true,
         description: "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"],