git-stack-cli 1.13.0 → 1.13.2

package/dist/cjs/index.cjs

@@ -26213,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: {},
@@ -29781,7 +29782,13 @@ async function pr_status(branch) {
 }
 async function pr_create(args) {
     const title = safe_quote(args.title);
-    let command = `gh pr create --fill --head ${args.branch} --base ${args.base} --title="${title}" --body="${args.body}"`;
+    // explicit refs/heads head branch to avoid creation failing
+    //
+    //   ❯ gh pr create --head origin/gs-ED2etrzv2 --base gs-6LAx-On45 --title="2024-01-05 test" --body=""
+    //   pull request create failed: GraphQL: Head sha can't be blank, Base sha can't be blank, No commits between gs-6LAx-On45 and origin/gs-ED2etrzv2, Head ref must be a branch (createPullRequest)
+    //
+    // https://github.com/cli/cli/issues/5465
+    let command = `gh pr create --head refs/heads/${args.branch} --base ${args.base} --title="${title}" --body="${args.body}"`;
     if (args.draft) {
         command += " --draft";
     }
@@ -30322,9 +30329,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 {
@@ -30418,9 +30425,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);
@@ -30462,7 +30469,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; });
@@ -30472,7 +30479,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();
@@ -30552,9 +30559,21 @@ function encode(value) {
 }
 
 function Rebase() {
-    return (reactExports.createElement(Await, { function: Rebase.run, fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026") }));
+    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.run = async function run() {
+Rebase.run = async function run(args) {
     const state = Store.getState();
     const actions = state.actions;
     const branch_name = state.branch_name;
@@ -30566,7 +30585,10 @@ Rebase.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)}`);
@@ -30629,7 +30651,7 @@ Rebase.run = async function run() {
                 actions.error(err.message);
             }
         }
-        handle_exit();
+        handle_exit(20);
     }
     // cleanup git operations if cancelled during manual rebase
     function restore_git() {
@@ -30651,7 +30673,7 @@ Rebase.run = async function run() {
         }
         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),
@@ -30661,7 +30683,7 @@ Rebase.run = async function run() {
             "Restored ",
             reactExports.createElement(Brackets, null, branch_name),
             "."));
-        actions.exit(6);
+        actions.exit(code);
     }
 };
 
@@ -30669,117 +30691,22 @@ function LocalMergeRebase() {
     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;
@@ -30792,54 +30719,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;
+    try {
+        // 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;
         }
-        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;
+        await GitReviseTodo.execute({
+            rebase_group_index: 0,
+            rebase_merge_base: merge_base,
+            commit_range,
+        });
+        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;
         }
-        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 {
+        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`);
-        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({
@@ -30850,13 +30776,18 @@ async function run$6() {
         // 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) {
-            await sync_github();
+            actions.set((state) => {
+                state.step = "sync-github";
+                state.sync_github = { commit_range, rebase_group_index };
+            });
+        }
+        else {
+            actions.set((state) => {
+                state.step = "post-rebase-status";
+            });
         }
-        restore_git();
-        actions.set((state) => {
-            state.step = "post-rebase-status";
-        });
     }
     catch (err) {
         if (err instanceof Error) {
@@ -30866,164 +30797,7 @@ async function run$6() {
         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
-        // 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 });
-        }
-        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);
-        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 }));
-        }
-        await Promise.all(after_push_tasks);
-        // 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];
-            // 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,
-                });
-            }
-        }
-    }
-    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;
-                }
-            }
-        }
+        handle_exit(16);
     }
     // cleanup git operations if cancelled during manual rebase
     function restore_git() {
@@ -31045,7 +30819,7 @@ async function run$6() {
         }
         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),
@@ -31055,10 +30829,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;
 
 function Table(props) {
     if (!props.data.length) {
@@ -31237,9 +31010,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();
@@ -31269,9 +31042,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;
@@ -31773,59 +31546,435 @@ function SelectCommitRangesInternal(props) {
         set_group_input(false);
     }
 }
-const SYMBOL = {
-    left: "←",
-    right: "→",
-    enter: "Enter",
+const SYMBOL = {
+    left: "←",
+    right: "→",
+    enter: "Enter",
+};
+
+function Status() {
+    return reactExports.createElement(Await, { fallback: null, function: run$4 });
+}
+async function run$4() {
+    const state = Store.getState();
+    const actions = state.actions;
+    const argv = state.argv;
+    const commit_range = Store.getState().commit_range;
+    invariant(commit_range, "commit_range must exist");
+    actions.output(reactExports.createElement(StatusTable, null));
+    let needs_rebase = false;
+    let needs_update = false;
+    for (const group of commit_range.group_list) {
+        if (group.dirty) {
+            needs_update = true;
+        }
+        if (group.pr?.state === "MERGED") {
+            needs_rebase = true;
+        }
+    }
+    if (argv.check) {
+        actions.exit(0);
+    }
+    else if (needs_rebase) {
+        Store.setState((state) => {
+            state.step = "pre-local-merge-rebase";
+        });
+    }
+    else if (needs_update) {
+        Store.setState((state) => {
+            state.step = "pre-select-commit-ranges";
+        });
+    }
+    else if (argv.force) {
+        Store.setState((state) => {
+            state.step = "select-commit-ranges";
+        });
+    }
+    else {
+        actions.output(reactExports.createElement(Text, null, "\u2705 Everything up to date."));
+        actions.output(reactExports.createElement(Text, { color: colors.gray },
+            reactExports.createElement(Text, null, "Run with"),
+            reactExports.createElement(Text, { bold: true, color: colors.yellow }, ` --force `),
+            reactExports.createElement(Text, null, "to force update all pull requests.")));
+        actions.exit(0);
+    }
+}
+
+/**
+ * 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 Status() {
-    return reactExports.createElement(Await, { fallback: null, function: run$3 });
+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() {
+async function run$3(args) {
     const state = Store.getState();
     const actions = state.actions;
     const argv = state.argv;
-    const commit_range = Store.getState().commit_range;
-    invariant(commit_range, "commit_range must exist");
-    actions.output(reactExports.createElement(StatusTable, null));
-    let needs_rebase = false;
-    let needs_update = false;
-    for (const group of commit_range.group_list) {
-        if (group.dirty) {
-            needs_update = true;
+    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 }));
         }
-        if (group.pr?.state === "MERGED") {
-            needs_rebase = true;
+        await Promise.all(before_push_tasks);
+        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");
+            // explicit refs/heads head branch to avoid push failing
+            //
+            //   ❯ git push -f origin --no-verify f6e249051b4820a03deb957ddebc19acfd7dfd7c:gs-ED2etrzv2
+            //   error: The destination you provided is not a full refname (i.e.,
+            //   starting with "refs/"). We tried to guess what you meant by:
+            //
+            //   - Looking for a ref that matches 'gs-ED2etrzv2' on the remote side.
+            //   - Checking if the <src> being pushed ('f6e249051b4820a03deb957ddebc19acfd7dfd7c')
+            //     is a ref in "refs/{heads,tags}/". If so we add a corresponding
+            //     refs/{heads,tags}/ prefix on the remote side.
+            //
+            //   Neither worked, so we gave up. You must fully qualify the ref.
+            //   hint: The <src> part of the refspec is a commit object.
+            //   hint: Did you mean to create a new branch by pushing to
+            //   hint: 'f6e249051b4820a03deb957ddebc19acfd7dfd7c:refs/heads/gs-ED2etrzv2'?
+            //   error: failed to push some refs to 'github.com:magus/git-multi-diff-playground.git'
+            //
+            const target = `${last_commit.sha}:refs/heads/${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);
     }
-    if (argv.check) {
-        actions.exit(0);
+    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;
     }
-    else if (needs_rebase) {
-        Store.setState((state) => {
-            state.step = "pre-local-merge-rebase";
-        });
+    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,
+            });
+        }
     }
-    else if (needs_update) {
-        Store.setState((state) => {
-            state.step = "pre-select-commit-ranges";
-        });
+    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;
+                }
+            }
+        }
     }
-    else if (argv.force) {
-        Store.setState((state) => {
-            state.step = "select-commit-ranges";
+    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,
+            });
+        }
     }
-    else {
-        actions.output(reactExports.createElement(Text, null, "\u2705 Everything up to date."));
-        actions.output(reactExports.createElement(Text, { color: colors.gray },
-            reactExports.createElement(Text, null, "Run with"),
-            reactExports.createElement(Text, { bold: true, color: colors.yellow }, ` --force `),
-            reactExports.createElement(Text, null, "to force update all pull requests.")));
-        actions.exit(0);
+    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);
@@ -31848,6 +31997,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:
@@ -37444,7 +37595,7 @@ async function command() {
         .wrap(123)
         // disallow unknown options
         .strict()
-        .version("1.13.0" )
+        .version("1.13.2" )
         .showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`")
         .help("help", "Show usage via `git stack help`")
         .argv;
@@ -37529,7 +37680,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;