git-stack-cli 1.0.7 → 1.2.0

package/README.md

@@ -87,14 +87,11 @@ npm run build:standalone
 >
 > **You must update the `version` in `package.json` and commit all changes first!**
 
-### NPM
-
 ```bash
-npm run release:npm
-```
+npm run release
 
-### Homebrew + Github
-
-```bash
+# release individually
+npm run release:npm
+npm run release:github
 npm run release:brew
 ```

package/dist/cjs/index.cjs

@@ -26883,6 +26883,12 @@ const RE$4 = {
 };
 
 function DependencyCheck(props) {
+    return (reactExports.createElement(CheckGit, null,
+        reactExports.createElement(CheckGithubCli, null,
+            reactExports.createElement(CheckGithubCliAuth, null,
+                reactExports.createElement(CheckGitRevise, null, props.children)))));
+}
+function CheckGit(props) {
     const actions = Store.useActions();
     return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
             "Checking ",
@@ -26899,65 +26905,84 @@ function DependencyCheck(props) {
                 reactExports.createElement(Command, null, "git"),
                 " must be installed."));
             actions.exit(2);
-        } },
-        reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
+        } }, props.children));
+}
+function CheckGithubCli(props) {
+    const actions = Store.useActions();
+    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
+            reactExports.createElement(Text, null,
                 "Checking ",
-                reactExports.createElement(Command, null, "node"),
-                " install..."), function: async () => {
-                const process_version = process.version.substring(1);
-                const semver_result = semver_compare(process_version, "14.0.0");
-                if (semver_result >= 0) {
+                reactExports.createElement(Command, null, "gh"),
+                " install...")), function: async () => {
+            if (is_command_available("gh")) {
+                return;
+            }
+            actions.output(reactExports.createElement(Text, { color: colors.yellow },
+                reactExports.createElement(Command, null, "gh"),
+                " must be installed."));
+            actions.output(reactExports.createElement(Text, { color: colors.yellow },
+                reactExports.createElement(Text, null, "Visit "),
+                reactExports.createElement(Url, null, "https://cli.github.com"),
+                reactExports.createElement(Text, null, " to install the github cli "),
+                reactExports.createElement(Parens, null,
+                    reactExports.createElement(Command, null, "gh"))));
+            actions.exit(3);
+        } }, props.children));
+}
+function CheckGithubCliAuth(props) {
+    const actions = Store.useActions();
+    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
+            reactExports.createElement(Text, null,
+                "Checking ",
+                reactExports.createElement(Command, null, "gh auth status"),
+                "...")), function: async () => {
+            const options = { ignoreExitCode: true };
+            const auth_status$1 = await cli(`gh auth status`, options);
+            if (auth_status$1.code === 0) {
+                const username = auth_status(auth_status$1.stdout);
+                if (username) {
+                    actions.set((state) => {
+                        state.username = username;
+                    });
                     return;
                 }
-                actions.output(reactExports.createElement(Text, { color: colors.yellow },
-                    reactExports.createElement(Command, null, "node"),
-                    " must be installed."));
-                actions.exit(2);
-            } },
-            reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
-                    reactExports.createElement(Text, null,
-                        "Checking ",
-                        reactExports.createElement(Command, null, "gh"),
-                        " install...")), function: async () => {
-                    if (is_command_available("gh")) {
-                        return;
-                    }
-                    actions.output(reactExports.createElement(Text, { color: colors.yellow },
-                        reactExports.createElement(Command, null, "gh"),
-                        " must be installed."));
-                    actions.output(reactExports.createElement(Text, { color: colors.yellow },
-                        reactExports.createElement(Text, null, "Visit "),
-                        reactExports.createElement(Url, null, "https://cli.github.com"),
-                        reactExports.createElement(Text, null, " to install the github cli "),
-                        reactExports.createElement(Parens, null,
-                            reactExports.createElement(Command, null, "gh"))));
-                    actions.exit(3);
-                } },
-                reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow },
-                        reactExports.createElement(Text, null,
-                            "Checking ",
-                            reactExports.createElement(Command, null, "gh auth status"),
-                            "...")), function: async () => {
-                        const options = { ignoreExitCode: true };
-                        const auth_status$1 = await cli(`gh auth status`, options);
-                        if (auth_status$1.code === 0) {
-                            const username = auth_status(auth_status$1.stdout);
-                            if (username) {
-                                actions.set((state) => {
-                                    state.username = username;
-                                });
-                                return;
-                            }
-                        }
-                        if (actions.isDebug()) {
-                            actions.error("gh auth status could not find username");
-                        }
-                        actions.output(reactExports.createElement(Text, { color: colors.yellow },
-                            reactExports.createElement(Command, null, "gh"),
-                            reactExports.createElement(Text, null, " requires login, please run "),
-                            reactExports.createElement(Command, null, "gh auth login")));
-                        actions.exit(4);
-                    } }, props.children)))));
+            }
+            if (actions.isDebug()) {
+                actions.error("gh auth status could not find username");
+            }
+            actions.output(reactExports.createElement(Text, { color: colors.yellow },
+                reactExports.createElement(Command, null, "gh"),
+                reactExports.createElement(Text, null, " requires login, please run "),
+                reactExports.createElement(Command, null, "gh auth login")));
+            actions.exit(4);
+        } }, props.children));
+}
+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 ",
+                reactExports.createElement(Command, null, "git-revise"),
+                " install...")), function: async () => {
+            if (is_command_available("git-revise")) {
+                return;
+            }
+            actions.output(reactExports.createElement(Text, { color: colors.yellow },
+                reactExports.createElement(Command, null, "git-revise"),
+                " must be installed."));
+            actions.output(reactExports.createElement(Text, { color: colors.yellow },
+                reactExports.createElement(Text, null, "Visit "),
+                reactExports.createElement(Url, null, "https://github.com/mystor/git-revise#install"),
+                reactExports.createElement(Text, null, " to install the git revise cli "),
+                reactExports.createElement(Parens, null,
+                    reactExports.createElement(Command, null, "git-revise"))));
+            actions.exit(10);
+        } }, props.children));
 }
 
 function GatherMetadata(props) {
@@ -27566,7 +27591,7 @@ async function run$3() {
             await cli(`git add --all`);
             let new_message;
             if (commit.branch_id) {
-                new_message = await write$1(commit.full_message, commit.branch_id);
+                new_message = write$1(commit.full_message, commit.branch_id);
             }
             else {
                 new_message = commit.full_message;
@@ -27651,6 +27676,69 @@ async function run$3() {
 }
 const PATCH_FILE$1 = "git-stack-cli-patch.patch";
 
+// https://git-revise.readthedocs.io/en/latest/man.html#interactive-mode
+//
+// # Interactive Revise Todos(4 commands)
+// #
+// # Commands:
+// #  p, pick <commit> = use commit
+// #  r, reword <commit> = use commit, but edit the commit message
+// #  s, squash <commit> = use commit, but meld into previous commit
+// #  f, fixup <commit> = like squash, but discard this commit's message
+// #  c, cut <commit> = interactively split commit into two smaller commits
+// #  i, index <commit> = leave commit changes staged, but uncommitted
+// #
+// # Each command block is prefixed by a '++' marker, followed by the command to
+// # run, the commit hash and after a newline the complete commit message until
+// # the next '++' marker or the end of the file.
+// #
+// # Commit messages will be reworded to match the provided message before the
+// # command is performed.
+// #
+// # These blocks are executed from top to bottom. They can be re-ordered and
+// # their commands can be changed, however the number of blocks must remain
+// # identical. If present, index blocks must be at the bottom of the list,
+// # i.e. they can not be followed by non-index blocks.
+// #
+// #
+// # If you remove everything, the revising process will be aborted.
+// calculate git-revise-todo from commit_range and rebase_group_index
+//
+// Example
+// ----------------------------
+//   ++ pick d36d63499425
+//   cantaloupe color
+//
+//   git-stack-id: E63ytp5dj
+//
+//   ++ pick 4f98dd3e67d0
+//   banana sweet
+//
+//   git-stack-id: E63ytp5dj
+//
+//   ++ pick f143d03c723c
+//   apple sweet
+//
+function GitReviseTodo(args) {
+    const entry_list = [];
+    const group_list = args.commit_range.group_list;
+    for (let i = args.rebase_group_index; i < group_list.length; i++) {
+        const group = group_list[i];
+        for (const commit of group.commits) {
+            // update git commit message with stack id
+            const message_with_id = write$1(commit.full_message, group.id);
+            // get first 12 characters of commit sha
+            const sha = commit.sha.slice(0, 12);
+            // generate git revise entry
+            const entry_lines = [`++ pick ${sha}`, message_with_id];
+            const entry = entry_lines.join("\n");
+            entry_list.push(entry);
+        }
+    }
+    const todo = entry_list.join("\n\n");
+    return todo;
+}
+
 function write(args) {
     const stack_table = table(args);
     let result = args.body;
@@ -27770,17 +27858,141 @@ async function run$2(props) {
             continue;
         }
         if (i > 0) {
-            const last_group = commit_range.group_list[i - 1];
-            const last_commit = last_group.commits[last_group.commits.length - 1];
-            rebase_merge_base = last_commit.sha;
+            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();
+        }
+        // after all commits have been cherry-picked and amended
+        // move the branch pointer to the newly created temporary branch
+        // now we are in locally in sync with github and on the original branch
+        await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
+        restore_git();
+        actions.set((state) => {
+            state.step = "post-rebase-status";
+        });
+    }
+    catch (err) {
+        actions.error("Unable to rebase.");
+        if (err instanceof Error) {
+            if (actions.isDebug()) {
+                actions.error(err.message);
+            }
+        }
+        handle_exit();
+    }
+    async function rebase_git_revise() {
+        invariant(argv, "argv must exist");
+        actions.debug(`rebase_git_revise`);
+        actions.output(reactExports.createElement(Text, { color: colors.yellow, wrap: "truncate-end" }, "Rebasing\u2026"));
+        // generate temporary directory and drop sequence editor script
+        const tmp_git_sequence_editor_path = path.join(os.tmpdir(), "git-sequence-editor.sh");
+        actions.debug(`tmp_git_sequence_editor_path=${tmp_git_sequence_editor_path}`);
+        // replaced at build time with literal contents of `scripts/git-sequence-editor.sh`
+        const GIT_SEQUENCE_EDITOR_SCRIPT = `#!/bin/sh
+
+# Example
+#
+#   GIT_REVISE_TODO="abc" GIT_EDITOR="$(pwd)/scripts/git-sequence-editor.sh" git revise --edit -i head~4
+#
+#   Note
+#   ----------------
+#   Use \`GIT_EDITOR\` above instead of \`GIT_SEQUENCE_EDITOR\` because \`git revise\` does not use
+#   \`GIT_SEQUENCE_EDITOR\` when passing the \`--edit\` flag, but does work without the \`--edit\` flag
+#
+#
+
+# debug print env variables
+echo "GIT_REVISE_TODO=$GIT_REVISE_TODO"
+echo "CLI=$0 $*"
+echo "PWD=$(pwd)"
+
+# ensure \`GIT_REVISE_TODO\` is not empty
+if [ -z "$GIT_REVISE_TODO" ]; then
+  echo "🚨 GIT_REVISE_TODO environment variable is empty" >&2
+  exit 1
+fi
+
+# first argument into git sequence editor is git-revise-todo file
+git_revise_todo_path="$1"
+
+# debug print git-revise-todo file passed into command
+echo "$git_revise_todo_path"
+echo "----- START -----"
+cat "$git_revise_todo_path"
+echo "------ END ------"
+
+# write content of \`GIT_REVISE_TODO\` env variable to \`git_revise_todo_path\`
+echo "$GIT_REVISE_TODO" > "$git_revise_todo_path"
+`;
+        // write script to temporary path
+        fs.writeFileSync(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
+        // ensure script is executable
+        fs.chmodSync(tmp_git_sequence_editor_path, "755");
+        // create temporary branch
+        await cli(`git checkout -b ${temp_branch_name}`);
+        const git_revise_todo = GitReviseTodo({ rebase_group_index, commit_range });
+        // execute cli with temporary git sequence editor script
+        // revise from merge base to pick correct commits
+        await cli([
+            `GIT_EDITOR="${tmp_git_sequence_editor_path}"`,
+            `GIT_REVISE_TODO="${git_revise_todo}"`,
+            `git`,
+            `revise --edit -i ${rebase_merge_base}`,
+        ]);
+        // 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() {
+        invariant(argv, "argv must exist");
+        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);
@@ -27790,7 +28002,6 @@ async function run$2(props) {
             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)),
                 } }));
-            const selected_url = get_group_url(group);
             // cherry-pick and amend commits one by one
             for (const commit of group.commits) {
                 // ensure clean base to avoid conflicts when applying patch
@@ -27801,63 +28012,78 @@ async function run$2(props) {
                 await cli(`rm ${PATCH_FILE}`);
                 // add all changes to stage
                 await cli(`git add --all`);
-                const new_message = await write$1(commit.full_message, group.id);
+                const new_message = write$1(commit.full_message, group.id);
                 const git_commit_comand = [`git commit -m "${new_message}"`];
                 if (argv.verify === false) {
                     git_commit_comand.push("--no-verify");
                 }
                 await cli(git_commit_comand);
             }
-            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)),
-                } }));
-            if (!props.skipSync) {
-                // 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);
-                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,
-                        }),
-                    });
-                }
-                else {
-                    // 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: "",
-                    });
-                    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
-                    await cli(`git checkout ${temp_branch_name}`);
+            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 (props.skipSync) {
+            return;
+        }
+        const { group, pr_url_list } = args;
+        invariant(argv, "argv must exist");
+        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)),
+            } }));
+        // 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,
+                }),
+            });
+        }
+        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: "",
+            });
+            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}`);
+            }
         }
-        // finally, ensure all prs have the updated stack table from updated pr_url_list
+    }
+    async function update_pr_tables(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
@@ -27881,23 +28107,6 @@ async function run$2(props) {
                 });
             }
         }
-        // after all commits have been cherry-picked and amended
-        // move the branch pointer to the newly created temporary branch
-        // now we are in locally in sync with github and on the original branch
-        await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
-        restore_git();
-        actions.set((state) => {
-            state.step = "post-rebase-status";
-        });
-    }
-    catch (err) {
-        actions.error("Unable to rebase.");
-        if (err instanceof Error) {
-            if (actions.isDebug()) {
-                actions.error(err.message);
-            }
-        }
-        handle_exit();
     }
     // cleanup git operations if cancelled during manual rebase
     function restore_git() {
@@ -28451,6 +28660,7 @@ function SelectCommitRangesInternal(props) {
                 switch (inputLower) {
                     case "s":
                         state.step = "manual-rebase";
+                        // state.step = "manual-rebase-no-sync";
                         break;
                 }
             });
@@ -34080,6 +34290,12 @@ async function command() {
         type: "boolean",
         default: true,
         description: "Skip git hooks such as pre-commit and pre-push",
+    })
+        .option("rebase", {
+        type: "string",
+        choices: [Rebase["git-revise"], Rebase["cherry-pick"]],
+        default: Rebase["git-revise"],
+        description: `Rebase implementation, "${Rebase["git-revise"]}" by default to perform in-memory rebase. "${Rebase["cherry-pick"]}" can be used to use disk and incrementally rebase each commit`,
     })
         .option("verbose", {
         type: "boolean",
@@ -34111,14 +34327,19 @@ async function command() {
         description: "Mock local store metadata for testing",
     })
         // do not wrap to 80 columns (yargs default)
-        // .wrap(yargs().terminalWidth()) will fill terminal (maximuize)
-        .wrap(null)
+        // 140 seems to look decent so lets do that instead
+        // passing null will wrap to terminal width
+        .wrap(140)
         // disallow unknown options
         .strict()
-        .version("1.0.7" )
+        .version("1.2.0" )
         .showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`")
         .help("help", "Show usage via `git stack help`").argv);
 }
+const Rebase = Object.freeze({
+    "git-revise": "git-revise",
+    "cherry-pick": "cherry-pick",
+});
 
 command()
     .then((argv) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "1.0.7",
+  "version": "1.2.0",
   "description": "",
   "author": "magus",
   "license": "MIT",
@@ -17,13 +17,13 @@
     "scripts",
     "src",
     "package-lock.json",
-    "rollup.config.mjs",
+    "rollup.config.js",
     "tsconfig.json"
   ],
   "scripts": {
     "dev": "npm run build -- --watch",
-    "build": "rollup -c rollup.config.mjs",
-    "build:standalone": "bun run scripts/build-standalone.ts",
+    "build": "rollup -c rollup.config.js",
+    "build:standalone": "GIT_STACK_STANDALONE=true bun run scripts/build-standalone.ts",
     "release:npm": "bun run scripts/release-npm.ts",
     "release:github": "bun run scripts/release-github.ts",
     "release:brew": "bun run scripts/release-brew.ts",

package/{rollup.config.mjs → rollup.config.js}

@@ -12,10 +12,16 @@ import replace from "@rollup/plugin-replace";
 import typescript from "@rollup/plugin-typescript";
 
 const SCRIPT_DIR = path.dirname(url.fileURLToPath(import.meta.url));
+
 const PACKAGE_JSON_PATH = path.join(SCRIPT_DIR, "package.json");
+const PACKAGE_JSON = JSON.parse(await fs.readFile(PACKAGE_JSON_PATH, "utf-8"));
 
-const package_json_str = await fs.readFile(PACKAGE_JSON_PATH, "utf-8");
-const package_json = JSON.parse(package_json_str);
+// prettier-ignore
+const GIT_SEQUENCE_EDITOR_SCRIPT_PATH = path.join(SCRIPT_DIR, "scripts", "git-sequence-editor.sh");
+// prettier-ignore
+const UNSAFE_GIT_SEQUENCE_EDITOR_SCRIPT = await fs.readFile(GIT_SEQUENCE_EDITOR_SCRIPT_PATH, "utf-8");
+// prettier-ignore
+const GIT_SEQUENCE_EDITOR_SCRIPT = UNSAFE_GIT_SEQUENCE_EDITOR_SCRIPT.replace(/`/g, "\\`");
 
 export default {
   input: "src/index.tsx",
@@ -39,7 +45,9 @@ export default {
       preventAssignment: true,
       values: {
         "process.env.NODE_ENV": JSON.stringify("production"),
-        "process.env.CLI_VERSION": JSON.stringify(String(package_json.version)),
+        "process.env.CLI_VERSION": JSON.stringify(String(PACKAGE_JSON.version)),
+        "process.env.GIT_STACK_STANDALONE": process.env.GIT_STACK_STANDALONE,
+        "process.env.GIT_SEQUENCE_EDITOR_SCRIPT": GIT_SEQUENCE_EDITOR_SCRIPT,
       },
     }),
   ],