git-stack-cli 1.12.0 → 1.13.1

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');
 
@@ -26212,6 +26213,7 @@ const BaseStore = createStore()(immer((set, get) => ({
     commit_map: null,
     pr_templates: [],
     pr_template_body: null,
+    sync_github: null,
     step: "loading",
     output: [],
     pending_output: {},
@@ -26520,9 +26522,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 +26609,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 +26776,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 +26816,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 +26869,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 +26889,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 +27030,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,7 +29796,8 @@ 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);
@@ -29785,6 +29806,9 @@ async function pr_edit(args) {
     }
 }
 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";
@@ -29827,7 +29851,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;
 }
@@ -29840,13 +29864,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;
 }
 
@@ -30128,9 +30151,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
@@ -30300,9 +30323,9 @@ function DirtyCheck(props) {
 
 function GatherMetadata(props) {
     const fallback = (reactExports.createElement(Text, { color: colors.yellow }, "Gathering local git information\u2026"));
-    return (reactExports.createElement(Await, { fallback: fallback, function: run$9 }, props.children));
+    return (reactExports.createElement(Await, { fallback: fallback, function: run$a }, props.children));
 }
-async function run$9() {
+async function run$a() {
     const actions = Store.getState().actions;
     const argv = Store.getState().argv;
     try {
@@ -30396,9 +30419,9 @@ function format_time(date) {
 }
 
 function GithubApiError() {
-    return reactExports.createElement(Await, { fallback: null, function: run$8 });
+    return reactExports.createElement(Await, { fallback: null, function: run$9 });
 }
-async function run$8() {
+async function run$9() {
     const actions = Store.getState().actions;
     const res = await cli(`gh api https://api.github.com/rate_limit`);
     const res_json = JSON.parse(res.stdout);
@@ -30440,7 +30463,7 @@ function LocalCommitStatus(props) {
     if (argv["mock-metadata"]) {
         return (reactExports.createElement(Await, { fallback: fallback, function: mock_metadata }, props.children));
     }
-    return (reactExports.createElement(Await, { fallback: fallback, function: run$7 }, props.children));
+    return (reactExports.createElement(Await, { fallback: fallback, function: run$8 }, props.children));
 }
 async function mock_metadata() {
     const module = await Promise.resolve().then(function () { return metadata; });
@@ -30450,7 +30473,7 @@ async function mock_metadata() {
         state.step = "status";
     });
 }
-async function run$7() {
+async function run$8() {
     const actions = Store.getState().actions;
     try {
         const commit_range = await range();
@@ -30529,10 +30552,22 @@ 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() {
+    const abort_handler = reactExports.useRef(() => { });
+    reactExports.useEffect(function listen_sigint() {
+        process.once("SIGINT", sigint_handler);
+        return function cleanup() {
+            process.removeListener("SIGINT", sigint_handler);
+        };
+        function sigint_handler() {
+            abort_handler.current();
+        }
+    }, []);
+    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: async function () {
+            await Rebase.run({ abort_handler });
+        } }));
 }
-Rebase$1.run = async function run() {
+Rebase.run = async function run(args) {
     const state = Store.getState();
     const actions = state.actions;
     const branch_name = state.branch_name;
@@ -30544,7 +30579,10 @@ Rebase$1.run = async function run() {
     invariant(commit_range, "commit_range must exist");
     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 = async function sigint_handler() {
+        actions.output(reactExports.createElement(Text, { color: colors.red }, "\uD83D\uDEA8 Abort"));
+        handle_exit(19);
+    };
     const temp_branch_name = `${branch_name}_${short_id()}`;
     try {
         // actions.debug(`commit_range=${JSON.stringify(commit_range, null, 2)}`);
@@ -30586,9 +30624,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();
@@ -30608,7 +30645,7 @@ Rebase$1.run = async function run() {
                 actions.error(err.message);
             }
         }
-        handle_exit();
+        handle_exit(20);
     }
     // cleanup git operations if cancelled during manual rebase
     function restore_git() {
@@ -30616,8 +30653,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);
@@ -30626,19 +30661,13 @@ 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);
         }
         cli.sync(`pwd`, spawn_options);
     }
-    function handle_exit() {
+    function handle_exit(code) {
         actions.output(reactExports.createElement(Text, { color: colors.yellow },
             "Restoring ",
             reactExports.createElement(Brackets, null, branch_name),
@@ -30648,126 +30677,30 @@ Rebase$1.run = async function run() {
             "Restored ",
             reactExports.createElement(Brackets, null, branch_name),
             "."));
-        actions.exit(6);
+        actions.exit(code);
     }
 };
-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) {
-    const stack_table = table(args);
-    let result = args.body;
-    if (RE.stack_table_link.test(result)) {
-        // replace stack table
-        result = result.replace(RE.stack_table_link, stack_table);
-    }
-    else if (RE.stack_table_legacy.test(result)) {
-        // replace stack table
-        result = result.replace(RE.stack_table_legacy, stack_table);
-    }
-    else {
-        // append stack table
-        result = `${result}\n\n${stack_table}`;
-    }
-    result = result.trimEnd();
-    return result;
-}
-function table(args) {
-    const stack_pr_url_list = [...args.pr_url_list];
-    const old_stack = parse(args.body);
-    // remove existing stack pr urls from the old stack pr urls
-    for (const pr_url of stack_pr_url_list) {
-        old_stack.delete(pr_url);
-    }
-    // add remaining old stack pr urls to the front of stack pr url list
-    const old_pr_list = Array.from(old_stack.keys());
-    old_pr_list.reverse();
-    for (const pr_url of old_pr_list) {
-        stack_pr_url_list.unshift(pr_url);
-    }
-    const stack_list = [];
-    const num_digits = String(stack_pr_url_list.length).length;
-    for (let i = 0; i < stack_pr_url_list.length; i++) {
-        const pr_url = stack_pr_url_list[i];
-        const selected = args.selected_url === pr_url;
-        let icon;
-        if (old_stack.has(pr_url)) {
-            icon = "✅";
-        }
-        else if (selected) {
-            icon = "👉";
-        }
-        else {
-            icon = "⏳";
-        }
-        const num = String(i + 1).padStart(num_digits, "0");
-        stack_list.push(TEMPLATE.row({ icon, num, pr_url }));
-    }
-    if (!stack_list.length) {
-        return "";
-    }
-    return TEMPLATE.stack_table_link(["", ...stack_list, "", ""].join("\n"));
-}
-function parse(body) {
-    let stack_table_match = body.match(RE.stack_table_link);
-    if (!stack_table_match?.groups) {
-        stack_table_match = body.match(RE.stack_table_legacy);
-    }
-    if (!stack_table_match?.groups) {
-        return new Map();
-    }
-    const rows_string = stack_table_match.groups["rows"];
-    const row_list = rows_string.split("\n");
-    const result = new Map();
-    for (const row of row_list) {
-        const row_match = row.match(RE.row);
-        const parsed_row = row_match?.groups;
-        if (!parsed_row) {
-            // skip invalid row
-            continue;
-        }
-        if (!RE.pr_url.test(parsed_row.pr_url)) {
-            continue;
-        }
-        result.set(parsed_row.pr_url, parsed_row);
-    }
-    return result;
-}
-const TEMPLATE = {
-    stack_table_legacy(rows) {
-        return `#### git stack${rows}`;
-    },
-    stack_table_link(rows) {
-        return `#### [git stack](https://github.com/magus/git-stack-cli)${rows}`;
-    },
-    row(args) {
-        return `- ${args.icon} \`${args.num}\` ${args.pr_url}`;
-    },
-};
-const RE = {
-    // https://regex101.com/r/kqB9Ft/1
-    stack_table_legacy: new RegExp(TEMPLATE.stack_table_legacy("\\s+(?<rows>(?:- [^\r^\n]*(?:[\r\n]+)?)+)")),
-    stack_table_link: new RegExp(TEMPLATE.stack_table_link("ROWS")
-        .replace("[", "\\[")
-        .replace("]", "\\]")
-        .replace("(", "\\(")
-        .replace(")", "\\)")
-        .replace("ROWS", "\\s+(?<rows>(?:- [^\r^\n]*(?:[\r\n]+)?)+)")),
-    row: new RegExp(TEMPLATE.row({
-        icon: "(?<icon>.+)",
-        num: "(?<num>\\d+)",
-        pr_url: "(?<pr_url>.+)",
-    })),
-    pr_url: /^https:\/\/.*$/,
-};
-
 function ManualRebase() {
-    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: run$6 }));
+    const abort_handler = reactExports.useRef(() => { });
+    reactExports.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 (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: async function () {
+            await run$7({ abort_handler });
+        } }));
 }
-async function run$6() {
+async function run$7(args) {
     const state = Store.getState();
     const actions = state.actions;
     const argv = state.argv;
@@ -30780,80 +30713,53 @@ async function run$6() {
     invariant(commit_map, "commit_map must exist");
     invariant(repo_root, "repo_root must exist");
     // always listen for SIGINT event and restore git state
-    process.once("SIGINT", handle_exit);
-    // get latest merge_base relative to local master
-    const merge_base = (await cli(`git merge-base HEAD ${master_branch}`)).stdout;
-    // immediately paint all commit to preserve selected commit ranges
-    let commit_range = await range(commit_map);
-    // reverse group list to ensure we create git revise in correct order
-    commit_range.group_list.reverse();
-    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;
-    }
-    await GitReviseTodo.execute({
-        rebase_group_index: 0,
-        rebase_merge_base: merge_base,
-        commit_range,
-    });
-    let DEFAULT_PR_BODY = "";
-    if (state.pr_template_body) {
-        DEFAULT_PR_BODY = state.pr_template_body;
-    }
+    args.abort_handler.current = function sigint_handler() {
+        actions.output(reactExports.createElement(Text, { color: colors.red }, "\uD83D\uDEA8 Abort"));
+        handle_exit(15);
+    };
     const temp_branch_name = `${branch_name}_${short_id()}`;
-    commit_range = await range(commit_map);
-    // 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;
-    for (let i = 0; i < commit_range.group_list.length; i++) {
-        const group = commit_range.group_list[i];
-        if (!group.dirty) {
-            continue;
-        }
-        if (i > 0) {
-            const prev_group = commit_range.group_list[i - 1];
-            const prev_commit = prev_group.commits[prev_group.commits.length - 1];
-            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();
+        // get latest merge_base relative to local master
+        const merge_base = (await cli(`git merge-base HEAD ${master_branch}`))
+            .stdout;
+        // immediately paint all commit to preserve selected commit ranges
+        let commit_range = await range(commit_map);
+        // reverse group list to ensure we create git revise in correct order
+        commit_range.group_list.reverse();
+        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;
         }
-        // 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";
+        await GitReviseTodo.execute({
+            rebase_group_index: 0,
+            rebase_merge_base: merge_base,
+            commit_range,
         });
-    }
-    catch (err) {
-        actions.error("Unable to rebase.");
-        if (err instanceof Error) {
-            if (actions.isDebug()) {
-                actions.error(err.message);
+        commit_range = await range(commit_map);
+        // 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;
+        for (let i = 0; i < commit_range.group_list.length; i++) {
+            const group = commit_range.group_list[i];
+            if (!group.dirty) {
+                continue;
+            }
+            if (i > 0) {
+                const prev_group = commit_range.group_list[i - 1];
+                const prev_commit = prev_group.commits[prev_group.commits.length - 1];
+                rebase_merge_base = prev_commit.sha;
+                rebase_group_index = i;
             }
+            break;
         }
-        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"));
+        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)}`);
+        // must perform rebase from repo root for applying git patch
+        process.chdir(repo_root);
+        await cli(`pwd`);
         // create temporary branch
         await cli(`git checkout -b ${temp_branch_name}`);
         await GitReviseTodo.execute({
@@ -30861,195 +30767,31 @@ async function run$6() {
             rebase_merge_base,
             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(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);
-            }
-            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;
-        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 = 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 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);
-        const selected_url = get_group_url(group);
-        if (group.pr) {
-            // ensure base matches pr in github
-            await pr_edit({
-                branch: group.id,
-                base: group.base,
-                body: write({
-                    body: group.pr.body,
-                    pr_url_list,
-                    selected_url,
-                }),
+        // 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}`);
+        restore_git();
+        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 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,
-                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) {
-        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 = 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,
-                });
-            }
+        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
     function restore_git() {
@@ -31057,8 +30799,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);
@@ -31067,19 +30807,13 @@ 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);
         }
         cli.sync(`pwd`, spawn_options);
     }
-    function handle_exit() {
+    function handle_exit(code) {
         actions.output(reactExports.createElement(Text, { color: colors.yellow },
             "Restoring ",
             reactExports.createElement(Brackets, null, branch_name),
@@ -31089,11 +30823,9 @@ async function run$6() {
             "Restored ",
             reactExports.createElement(Brackets, null, branch_name),
             "."));
-        actions.exit(5);
+        actions.exit(code);
     }
 }
-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) {
@@ -31272,9 +31004,9 @@ function get_status_bold(row) {
 }
 
 function PostRebaseStatus() {
-    return reactExports.createElement(Await, { fallback: null, function: run$5 });
+    return reactExports.createElement(Await, { fallback: null, function: run$6 });
 }
-async function run$5() {
+async function run$6() {
     const actions = Store.getState().actions;
     // reset github pr cache before refreshing via commit range below
     actions.reset_pr();
@@ -31304,9 +31036,9 @@ function PreLocalMergeRebase() {
 }
 
 function PreManualRebase() {
-    return reactExports.createElement(Await, { fallback: null, function: run$4 });
+    return reactExports.createElement(Await, { fallback: null, function: run$5 });
 }
-async function run$4() {
+async function run$5() {
     const state = Store.getState();
     const actions = state.actions;
     const repo_root = state.repo_root;
@@ -31325,8 +31057,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("")),
                 } }));
@@ -31335,8 +31067,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) => {
@@ -31815,9 +31547,9 @@ const SYMBOL = {
 };
 
 function Status() {
-    return reactExports.createElement(Await, { fallback: null, function: run$3 });
+    return reactExports.createElement(Await, { fallback: null, function: run$4 });
 }
-async function run$3() {
+async function run$4() {
     const state = Store.getState();
     const actions = state.actions;
     const argv = state.argv;
@@ -31862,6 +31594,366 @@ async function run$3() {
     }
 }
 
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+
+function last(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? array[length - 1] : undefined;
+}
+
+var last_1 = last;
+
+var last$1 = /*@__PURE__*/getDefaultExportFromCjs(last_1);
+
+function write(args) {
+    const stack_table = table(args);
+    let result = args.body;
+    if (RE.stack_table_link.test(result)) {
+        // replace stack table
+        result = result.replace(RE.stack_table_link, stack_table);
+    }
+    else if (RE.stack_table_legacy.test(result)) {
+        // replace stack table
+        result = result.replace(RE.stack_table_legacy, stack_table);
+    }
+    else {
+        // append stack table
+        result = `${result}\n\n${stack_table}`;
+    }
+    result = result.trimEnd();
+    return result;
+}
+function table(args) {
+    const stack_pr_url_list = [...args.pr_url_list];
+    const old_stack = parse(args.body);
+    // remove existing stack pr urls from the old stack pr urls
+    for (const pr_url of stack_pr_url_list) {
+        old_stack.delete(pr_url);
+    }
+    // add remaining old stack pr urls to the front of stack pr url list
+    const old_pr_list = Array.from(old_stack.keys());
+    old_pr_list.reverse();
+    for (const pr_url of old_pr_list) {
+        stack_pr_url_list.unshift(pr_url);
+    }
+    const stack_list = [];
+    const num_digits = String(stack_pr_url_list.length).length;
+    for (let i = 0; i < stack_pr_url_list.length; i++) {
+        const pr_url = stack_pr_url_list[i];
+        const selected = args.selected_url === pr_url;
+        let icon;
+        if (old_stack.has(pr_url)) {
+            icon = "✅";
+        }
+        else if (selected) {
+            icon = "👉";
+        }
+        else {
+            icon = "⏳";
+        }
+        const num = String(i + 1).padStart(num_digits, "0");
+        stack_list.push(TEMPLATE.row({ icon, num, pr_url }));
+    }
+    if (!stack_list.length) {
+        return "";
+    }
+    return TEMPLATE.stack_table_link(["", ...stack_list, "", ""].join("\n"));
+}
+function parse(body) {
+    let stack_table_match = body.match(RE.stack_table_link);
+    if (!stack_table_match?.groups) {
+        stack_table_match = body.match(RE.stack_table_legacy);
+    }
+    if (!stack_table_match?.groups) {
+        return new Map();
+    }
+    const rows_string = stack_table_match.groups["rows"];
+    const row_list = rows_string.split("\n");
+    const result = new Map();
+    for (const row of row_list) {
+        const row_match = row.match(RE.row);
+        const parsed_row = row_match?.groups;
+        if (!parsed_row) {
+            // skip invalid row
+            continue;
+        }
+        if (!RE.pr_url.test(parsed_row.pr_url)) {
+            continue;
+        }
+        result.set(parsed_row.pr_url, parsed_row);
+    }
+    return result;
+}
+const TEMPLATE = {
+    stack_table_legacy(rows) {
+        return `#### git stack${rows}`;
+    },
+    stack_table_link(rows) {
+        return `#### [git stack](https://github.com/magus/git-stack-cli)${rows}`;
+    },
+    row(args) {
+        return `- ${args.icon} \`${args.num}\` ${args.pr_url}`;
+    },
+};
+const RE = {
+    // https://regex101.com/r/kqB9Ft/1
+    stack_table_legacy: new RegExp(TEMPLATE.stack_table_legacy("\\s+(?<rows>(?:- [^\r^\n]*(?:[\r\n]+)?)+)")),
+    stack_table_link: new RegExp(TEMPLATE.stack_table_link("ROWS")
+        .replace("[", "\\[")
+        .replace("]", "\\]")
+        .replace("(", "\\(")
+        .replace(")", "\\)")
+        .replace("ROWS", "\\s+(?<rows>(?:- [^\r^\n]*(?:[\r\n]+)?)+)")),
+    row: new RegExp(TEMPLATE.row({
+        icon: "(?<icon>.+)",
+        num: "(?<num>\\d+)",
+        pr_url: "(?<pr_url>.+)",
+    })),
+    pr_url: /^https:\/\/.*$/,
+};
+
+function SyncGithub() {
+    const abort_handler = reactExports.useRef(() => { });
+    reactExports.useEffect(function listen_sigint() {
+        process.once("SIGINT", sigint_handler);
+        return function cleanup() {
+            process.removeListener("SIGINT", sigint_handler);
+        };
+        function sigint_handler() {
+            abort_handler.current();
+        }
+    }, []);
+    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Syncing\u2026"), function: async function () {
+            await run$3({ abort_handler });
+        } }));
+}
+async function run$3(args) {
+    const state = Store.getState();
+    const actions = state.actions;
+    const argv = state.argv;
+    const branch_name = state.branch_name;
+    const commit_map = state.commit_map;
+    const master_branch = state.master_branch;
+    const repo_root = state.repo_root;
+    const sync_github = state.sync_github;
+    invariant(branch_name, "branch_name must exist");
+    invariant(commit_map, "commit_map must exist");
+    invariant(repo_root, "repo_root must exist");
+    invariant(sync_github, "sync_github must exist");
+    const commit_range = sync_github.commit_range;
+    const rebase_group_index = sync_github.rebase_group_index;
+    // always listen for SIGINT event and restore pr state
+    args.abort_handler.current = function sigint_handler() {
+        actions.output(reactExports.createElement(Text, { color: colors.red }, "\uD83D\uDEA8 Abort"));
+        handle_exit(17);
+    };
+    let DEFAULT_PR_BODY = "";
+    if (state.pr_template_body) {
+        DEFAULT_PR_BODY = state.pr_template_body;
+    }
+    const push_group_list = get_push_group_list();
+    // 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
+    // --------------------------------------
+    try {
+        const before_push_tasks = [];
+        for (const group of push_group_list) {
+            before_push_tasks.push(before_push({ group }));
+        }
+        await Promise.all(before_push_tasks);
+        // git push -f origin HEAD~6:OtVX7Qvrw HEAD~3:E63ytp5dj HEAD~2:gs-NBabNSjXA HEAD~1:gs-UGVJdKNoD HEAD~0:gs-6LAx-On4
+        const git_push_command = [`git push -f origin`];
+        if (argv.verify === false) {
+            git_push_command.push("--no-verify");
+        }
+        for (const group of push_group_list) {
+            const last_commit = last$1(group.commits);
+            invariant(last_commit, "last_commit must exist");
+            const target = `${last_commit.sha}:${group.id}`;
+            git_push_command.push(target);
+        }
+        await cli(git_push_command);
+        const pr_url_list = commit_range.group_list.map(get_group_url);
+        const after_push_tasks = [];
+        for (const group of push_group_list) {
+            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
+        // this step must come after the after_push since that step may create new PRs
+        // we need the urls for all prs at this step so we run it after the after_push
+        const update_pr_body_tasks = [];
+        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];
+            const task = update_pr_body({ group, selected_url, pr_url_list });
+            update_pr_body_tasks.push(task);
+        }
+        await Promise.all(update_pr_body_tasks);
+        actions.set((state) => {
+            state.step = "post-rebase-status";
+        });
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            actions.error(err.message);
+        }
+        actions.error("Unable to sync.");
+        if (!argv.verbose) {
+            actions.error("Try again with `--verbose` to see more information.");
+        }
+        await handle_exit(18);
+    }
+    function get_push_group_list() {
+        // start from HEAD and work backward to rebase_group_index
+        const push_group_list = [];
+        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];
+            push_group_list.unshift(group);
+        }
+        return push_group_list;
+    }
+    async function before_push(args) {
+        const { group } = args;
+        invariant(group.base, "group.base must exist");
+        // 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,
+            });
+        }
+    }
+    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
+            await pr_edit({
+                branch: group.id,
+                base: group.base,
+                body: write({
+                    body: group.pr.body,
+                    pr_url_list,
+                    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 {
+            // create pr in github
+            const pr_url = await pr_create({
+                branch: group.id,
+                base: group.base,
+                title: group.title,
+                body: DEFAULT_PR_BODY,
+                draft: argv.draft,
+            });
+            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;
+                }
+            }
+        }
+    }
+    async function update_pr_body(args) {
+        const { group, selected_url, pr_url_list } = args;
+        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,
+            });
+        }
+    }
+    function handle_exit(code) {
+        actions.output(reactExports.createElement(Text, { color: colors.yellow }, "Restoring PR state\u2026"));
+        for (const group of push_group_list) {
+            // 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;
+            // restore PR to non-draft state
+            if (is_temp_draft) {
+                pr_draft({
+                    branch: group.id,
+                    draft: false,
+                })
+                    .catch(actions.error);
+            }
+        }
+        actions.output(reactExports.createElement(Text, { color: colors.yellow }, "Restored PR state."));
+        actions.exit(code);
+    }
+}
+const get_group_url = (group) => group.pr?.url || group.id;
+
 function Main() {
     const step = Store.useState((state) => state.step);
     switch (step) {
@@ -31883,6 +31975,8 @@ function Main() {
             return reactExports.createElement(PreManualRebase, null);
         case "manual-rebase":
             return reactExports.createElement(ManualRebase, null);
+        case "sync-github":
+            return reactExports.createElement(SyncGithub, null);
         case "post-rebase-status":
             return reactExports.createElement(PostRebaseStatus, null);
         default:
@@ -31943,8 +32037,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 });
         }
@@ -32151,7 +32245,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),
@@ -32490,14 +32584,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;
@@ -33703,7 +33797,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');
@@ -33751,14 +33845,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;
@@ -33989,7 +34083,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)
   },
@@ -37479,15 +37573,11 @@ async function command() {
         .wrap(123)
         // disallow unknown options
         .strict()
-        .version("1.12.0" )
+        .version("1.13.1" )
         .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",
@@ -37520,16 +37610,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"],
@@ -37578,7 +37658,10 @@ const FixupOptions = {
 
 command()
     .then((argv) => {
-    const ink = render(reactExports.createElement(App, null));
+    const ink = render(reactExports.createElement(App, null), {
+    // If true, each update will be rendered as a separate output, without replacing the previous one.
+    // debug: true,
+    });
     Store.setState((state) => {
         state.ink = ink;
         state.process_argv = process.argv;