git-stack-cli 0.7.5 → 0.8.0

package/dist/app/App.js

@@ -8,6 +8,7 @@ import { LocalCommitStatus } from "./LocalCommitStatus.js";
 import { Main } from "./Main.js";
 import { Output } from "./Output.js";
 import { Providers } from "./Providers.js";
+import { RebaseCheck } from "./RebaseCheck.js";
 import { Store } from "./Store.js";
 export function App() {
     const actions = Store.useActions();
@@ -27,10 +28,15 @@ export function App() {
     return (React.createElement(Providers, null,
         React.createElement(Debug, null),
         React.createElement(Output, null),
-        !argv.verbose ? null : React.createElement(GithubApiError, null),
-        React.createElement(DependencyCheck, null,
-            React.createElement(AutoUpdate, { name: "git-stack-cli", verbose: argv.verbose, onOutput: actions.output },
-                React.createElement(GatherMetadata, null,
-                    React.createElement(LocalCommitStatus, null,
-                        React.createElement(Main, null)))))));
+        React.createElement(AutoUpdate, { name: "git-stack-cli", verbose: argv.verbose || argv.update, timeoutMs: argv.update ? 30 * 1000 : 2 * 1000, onOutput: actions.output, onDone: () => {
+                if (argv.update) {
+                    actions.exit(0);
+                }
+            } },
+            React.createElement(RebaseCheck, null,
+                React.createElement(DependencyCheck, null,
+                    !argv.verbose ? null : React.createElement(GithubApiError, null),
+                    React.createElement(GatherMetadata, null,
+                        React.createElement(LocalCommitStatus, null,
+                            React.createElement(Main, null))))))));
 }

package/dist/app/AutoUpdate.js

@@ -5,12 +5,12 @@ import * as Ink from "ink";
 import { cli } from "../core/cli.js";
 import { colors } from "../core/colors.js";
 import { fetch_json } from "../core/fetch_json.js";
+import { is_finite_value } from "../core/is_finite_value.js";
 import { read_json } from "../core/read_json.js";
 import { semver_compare } from "../core/semver_compare.js";
 import { sleep } from "../core/sleep.js";
 import { Brackets } from "./Brackets.js";
 import { FormatText } from "./FormatText.js";
-import { Parens } from "./Parens.js";
 import { YesNoPrompt } from "./YesNoPrompt.js";
 function reducer(state, patch) {
     return { ...state, ...patch };
@@ -41,31 +41,33 @@ export function AutoUpdate(props) {
         let latest_version = null;
         async function auto_update() {
             if (props_ref.current.verbose) {
-                handle_output(React.createElement(Ink.Text, { key: "init", dimColor: true }, "Checking for latest version..."));
+                handle_output(React.createElement(Ink.Text, { key: "init" }, "Checking for latest version..."));
             }
-            const timeout_ms = 2 * 1000;
+            const timeout_ms = is_finite_value(props.timeoutMs)
+                ? props.timeoutMs
+                : 2 * 1000;
             const npm_json = await Promise.race([
                 fetch_json(`https://registry.npmjs.org/${props.name}`),
                 sleep(timeout_ms).then(() => {
-                    throw new Error("timeout");
+                    throw new Error("Timeout");
                 }),
             ]);
             latest_version = npm_json?.["dist-tags"]?.latest;
             if (!latest_version) {
-                throw new Error("unable to retrieve latest version from npm");
+                throw new Error("Unable to retrieve latest version from npm");
             }
             const script_dir = path.dirname(fs.realpathSync(process.argv[1]));
             const package_json_path = path.join(script_dir, "..", "package.json");
             const package_json = read_json(package_json_path);
             if (!package_json) {
                 // unable to find read package.json, skip auto update
-                throw new Error(`unable to find read package.json [${package_json_path}]`);
+                throw new Error(`Unable to find read package.json [${package_json_path}]`);
             }
             local_version = package_json.version;
             if (props_ref.current.verbose) {
-                handle_output(React.createElement(FormatText, { key: "versions", wrapper: React.createElement(Ink.Text, { dimColor: true }), message: "Auto update found latest version {latest_version} and current local version {local_version}", values: {
+                handle_output(React.createElement(FormatText, { key: "versions", wrapper: React.createElement(Ink.Text, null), message: "Auto update found latest version {latest_version} and current local version {local_version}", values: {
                         latest_version: React.createElement(Brackets, null, latest_version),
-                        local_version: React.createElement(Parens, null, local_version),
+                        local_version: React.createElement(Brackets, null, local_version),
                     } }));
             }
             const semver_result = semver_compare(latest_version, local_version);
@@ -88,8 +90,11 @@ export function AutoUpdate(props) {
             patch({ status, error, local_version, latest_version });
             onError(error);
             if (props_ref.current.verbose) {
-                handle_output(React.createElement(Ink.Text, { key: "error", dimColor: true, color: colors.red }, error?.message));
+                handle_output(React.createElement(Ink.Text, { key: "error", color: colors.red }, error?.message));
             }
+        })
+            .finally(() => {
+            props.onDone?.();
         });
     }, []);
     const status = (function render_status() {
@@ -105,7 +110,7 @@ export function AutoUpdate(props) {
                         patch({ status: "install" });
                         await cli(`npm install -g ${props.name}@latest`);
                         patch({ status: "exit" });
-                        handle_output(React.createElement(Ink.Text, { key: "done", dimColor: true }, "Auto update done."));
+                        handle_output(React.createElement(Ink.Text, { key: "done" }, "Auto update done."));
                     }, onNo: () => {
                         patch({ status: "done" });
                     } }));

package/dist/app/DependencyCheck.js

@@ -16,6 +16,10 @@ export function DependencyCheck(props) {
             "Checking ",
             React.createElement(Command, null, "git"),
             " install..."), function: async () => {
+            // await Promise.all([
+            //   cli(`for i in $(seq 1 5); do echo $i; sleep 1; done`),
+            //   cli(`for i in $(seq 5 1); do printf "$i "; sleep 1; done; echo`),
+            // ]);
             if (is_command_available("git")) {
                 return;
             }

package/dist/app/GatherMetadata copy.js

@@ -1,33 +1,60 @@
 import * as React from "react";
 import * as Ink from "ink";
 import { cli } from "../core/cli.js";
+import { colors } from "../core/colors.js";
 import { invariant } from "../core/invariant.js";
 import { match_group } from "../core/match_group.js";
 import { Await } from "./Await.js";
+import { Brackets } from "./Brackets.js";
+import { FormatText } from "./FormatText.js";
 import { Store } from "./Store.js";
 export function GatherMetadata(props) {
     const argv = Store.useState((state) => state.argv);
     invariant(argv, "argv must exist");
-    const fallback = (React.createElement(Ink.Text, { color: "yellow" }, "Gathering local git information..."));
+    const fallback = (React.createElement(Ink.Text, { color: colors.yellow }, "Gathering local git information..."));
     return (React.createElement(Await, { fallback: fallback, function: gather_metadata }, props.children));
 }
 async function gather_metadata() {
     const actions = Store.getState().actions;
+    const argv = Store.getState().argv;
+    invariant(argv, "argv must exist");
     try {
+        // default to master branch, fallback to main
+        let master_branch;
+        if (argv.branch) {
+            actions.debug(React.createElement(FormatText, { message: "Setting master branch to {branch}", values: {
+                    branch: React.createElement(Brackets, null, argv.branch),
+                } }));
+            master_branch = argv.branch;
+        }
+        else {
+            const detect_master = await cli(`git branch --list "${BRANCH.master}" --color=never`);
+            if (detect_master.stdout !== "") {
+                master_branch = BRANCH.master;
+            }
+            else {
+                actions.debug(React.createElement(FormatText, { message: "Could not find {master} branch, falling back to {main}", values: {
+                        master: React.createElement(Brackets, null, BRANCH.master),
+                        main: React.createElement(Brackets, null, BRANCH.main),
+                    } }));
+                master_branch = BRANCH.main;
+            }
+        }
         const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
         // handle when there are no detected changes
-        if (branch_name === "master") {
+        if (branch_name === master_branch) {
             actions.newline();
             actions.error("Must run within a branch.");
             actions.exit(0);
             return;
         }
         const head = (await cli("git rev-parse HEAD")).stdout;
-        const merge_base = (await cli("git merge-base HEAD master")).stdout;
+        const merge_base = (await cli(`git merge-base HEAD ${master_branch}`))
+            .stdout;
         // handle when there are no detected changes
         if (head === merge_base) {
             actions.newline();
-            actions.output(React.createElement(Ink.Text, { color: "gray" }, "No changes detected."));
+            actions.output(React.createElement(Ink.Text, { color: colors.gray }, "No changes detected."));
             actions.exit(0);
             return;
         }
@@ -37,6 +64,7 @@ async function gather_metadata() {
         const repo_path = match_group(origin_url, RE.repo_path, "repo_path");
         Store.setState((state) => {
             state.repo_path = repo_path;
+            state.master_branch = master_branch;
             state.head = head;
             state.merge_base = merge_base;
             state.branch_name = branch_name;
@@ -49,6 +77,7 @@ async function gather_metadata() {
                 actions.error(err.message);
             }
         }
+        actions.exit(7);
     }
 }
 const RE = {
@@ -56,3 +85,7 @@ const RE = {
     // https://github.com/magus/git-multi-diff-playground.git
     repo_path: /(?<repo_path>[^:^/]+\/[^/]+)\.git/,
 };
+const BRANCH = {
+    master: "master",
+    main: "main",
+};

package/dist/app/LocalMergeRebase.js

@@ -53,11 +53,22 @@ async function run() {
                         commit_message: React.createElement(Brackets, null, commit.message),
                     } }));
             }
-            const git_cherry_pick_command = [`git cherry-pick ${commit.sha}`];
+            await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
+            await cli(`git apply ${PATCH_FILE}`);
+            await cli(`rm ${PATCH_FILE}`);
+            await cli(`git add --all`);
+            let new_message;
+            if (commit.branch_id) {
+                new_message = await Metadata.write(commit.message, commit.branch_id);
+            }
+            else {
+                new_message = commit.message;
+            }
+            const git_commit_comand = [`git commit -m "${new_message}"`];
             if (argv.verify === false) {
-                git_cherry_pick_command.push("--no-verify");
+                git_commit_comand.push("--no-verify");
             }
-            await cli(git_cherry_pick_command);
+            await cli(git_commit_comand);
             if (commit.branch_id && !commit_pr) {
                 if (actions.isDebug()) {
                     actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Cleaning up unused group {group}", values: {
@@ -95,6 +106,11 @@ 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}`, spawn_options);
+        // always hard reset to allow subsequent checkout
+        // if there are files checkout will fail and cascade fail subsequent commands
+        cli.sync(`git reset --hard`, spawn_options);
         // always put self back in original branch
         cli.sync(`git checkout ${branch_name}`, spawn_options);
         // ...and cleanup temporary branch
@@ -119,3 +135,4 @@ async function run() {
         actions.exit(6);
     }
 }
+const PATCH_FILE = "mypatch.patch";

package/dist/app/ManualRebase.js

@@ -57,15 +57,16 @@ async function run(props) {
             const selected_url = get_group_url(group);
             // cherry-pick and amend commits one by one
             for (const commit of group.commits) {
-                const git_cherry_pick_command = [`git cherry-pick ${commit.sha}`];
+                await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
+                await cli(`git apply ${PATCH_FILE}`);
+                await cli(`rm ${PATCH_FILE}`);
+                await cli(`git add --all`);
+                const new_message = await Metadata.write(commit.message, group.id);
+                const git_commit_comand = [`git commit -m "${new_message}"`];
                 if (argv.verify === false) {
-                    git_cherry_pick_command.push("--no-verify");
-                }
-                await cli(git_cherry_pick_command);
-                if (commit.branch_id !== group.id) {
-                    const new_message = await Metadata.write(commit.message, group.id);
-                    await cli(`git commit --amend -m "${new_message}"`);
+                    git_commit_comand.push("--no-verify");
                 }
+                await cli(git_commit_comand);
             }
             actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Syncing {group}\u2026", values: {
                     group: (React.createElement(Brackets, null, group.pr?.title || group.title || group.id)),
@@ -164,6 +165,11 @@ async function run(props) {
         // 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 to allow subsequent checkout
+        // if there are files checkout will fail and cascade fail subsequent commands
+        cli.sync(`git reset --hard`, spawn_options);
         // always put self back in original branch
         cli.sync(`git checkout ${branch_name}`, spawn_options);
         // ...and cleanup temporary branch
@@ -189,3 +195,4 @@ async function run(props) {
     }
 }
 const get_group_url = (group) => group.pr?.url || group.id;
+const PATCH_FILE = "mypatch.patch";

package/dist/app/Output.js

@@ -3,7 +3,17 @@ import * as Ink from "ink";
 import { Store } from "./Store.js";
 export function Output() {
     const output = Store.useState((state) => state.output);
-    return (React.createElement(Ink.Static, { items: output }, (node, i) => {
-        return React.createElement(Ink.Box, { key: i }, node);
-    }));
+    const pending_output = Store.useState((state) => state.pending_output);
+    const pending_output_items = Object.values(pending_output);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Ink.Static, { items: output }, (node, i) => {
+            return React.createElement(Ink.Box, { key: i }, node);
+        }),
+        pending_output_items.map((node_list, i) => {
+            return (React.createElement(Ink.Box, { key: i },
+                React.createElement(Ink.Text, null, node_list.map((text, j) => {
+                    return (React.createElement(React.Fragment, { key: j },
+                        React.createElement(Ink.Text, null, text)));
+                }))));
+        })));
 }

package/dist/app/RebaseCheck.js

@@ -0,0 +1,56 @@
+import * as React from "react";
+import fs from "node:fs";
+import path from "node:path";
+import * as Ink from "ink";
+import { cli } from "../core/cli.js";
+import { colors } from "../core/colors.js";
+import { invariant } from "../core/invariant.js";
+import { Await } from "./Await.js";
+import { Store } from "./Store.js";
+import { YesNoPrompt } from "./YesNoPrompt.js";
+function reducer(state, patch) {
+    return { ...state, ...patch };
+}
+export function RebaseCheck(props) {
+    const actions = Store.useActions();
+    const argv = Store.useState((state) => state.argv);
+    invariant(argv, "argv must exist");
+    const [state, patch] = React.useReducer(reducer, {
+        status: "init",
+    });
+    switch (state.status) {
+        case "done":
+            return props.children;
+        case "prompt":
+            return (React.createElement(YesNoPrompt, { message: React.createElement(Ink.Text, { color: colors.yellow }, "Rebase detected, would you like to abort it?"), onYes: async () => {
+                    await cli(`git rebase --abort`);
+                    patch({ status: "done" });
+                }, onNo: async () => {
+                    actions.exit(0);
+                } }));
+        default:
+            return (React.createElement(Await, { fallback: React.createElement(Ink.Text, { color: colors.yellow }, "Checking for rebase..."), function: rebase_check }));
+    }
+    async function rebase_check() {
+        const actions = Store.getState().actions;
+        const argv = Store.getState().argv;
+        invariant(argv, "argv must exist");
+        try {
+            const repo_root = (await cli(`git rev-parse --absolute-git-dir`)).stdout;
+            let is_rebase = false;
+            is_rebase ||= fs.existsSync(path.join(repo_root, "rebase-apply"));
+            is_rebase ||= fs.existsSync(path.join(repo_root, "rebase-merge"));
+            const status = is_rebase ? "prompt" : "done";
+            patch({ status });
+        }
+        catch (err) {
+            actions.error("Unable to check for rebase.");
+            if (err instanceof Error) {
+                if (actions.isDebug()) {
+                    actions.error(err.message);
+                }
+            }
+            actions.exit(9);
+        }
+    }
+}

package/dist/app/Store.js

@@ -18,11 +18,13 @@ const BaseStore = createStore()(immer((set, get) => ({
     commit_map: null,
     step: "loading",
     output: [],
+    pending_output: {},
     pr: {},
     actions: {
         exit(code, clear = true) {
             set((state) => {
-                state.mutate.output(state, React.createElement(Exit, { clear: clear, code: code }));
+                const node = React.createElement(Exit, { clear: clear, code: code });
+                state.mutate.output(state, { node });
             });
         },
         clear() {
@@ -33,28 +35,37 @@ const BaseStore = createStore()(immer((set, get) => ({
         },
         newline() {
             set((state) => {
-                state.mutate.output(state, "‎");
+                const node = "‎";
+                state.mutate.output(state, { node });
             });
         },
         json(value) {
             set((state) => {
-                state.mutate.output(state, JSON.stringify(value, null, 2));
+                const node = JSON.stringify(value, null, 2);
+                state.mutate.output(state, { node });
             });
         },
         error(message) {
             set((state) => {
-                state.mutate.output(state, React.createElement(Ink.Text, { color: colors.red }, message));
+                const node = React.createElement(Ink.Text, { color: colors.red }, message);
+                state.mutate.output(state, { node });
             });
         },
         output(node) {
             set((state) => {
-                state.mutate.output(state, node);
+                state.mutate.output(state, { node });
             });
         },
-        debug(node) {
+        debug(node, id) {
             if (get().actions.isDebug()) {
+                const debug = true;
                 set((state) => {
-                    state.mutate.output(state, React.createElement(Ink.Text, { dimColor: true }, node));
+                    if (id) {
+                        state.mutate.pending_output(state, { id, node, debug });
+                    }
+                    else {
+                        state.mutate.output(state, { node, debug });
+                    }
                 });
             }
         },
@@ -74,15 +85,36 @@ const BaseStore = createStore()(immer((set, get) => ({
         },
     },
     mutate: {
-        output(state, node) {
-            switch (typeof node) {
+        output(state, args) {
+            switch (typeof args.node) {
                 case "boolean":
                 case "number":
                 case "string":
-                    state.output.push(React.createElement(Ink.Text, null, String(node)));
+                    state.output.push(React.createElement(Ink.Text, { dimColor: args.debug }, String(args.node)));
                     return;
             }
-            state.output.push(node);
+            state.output.push(args.node);
+        },
+        pending_output(state, args) {
+            const { id } = args;
+            if (!id) {
+                return;
+            }
+            if (!state.pending_output[id]) {
+                state.pending_output[id] = [];
+            }
+            switch (typeof args.node) {
+                case "boolean":
+                case "number":
+                case "string": {
+                    state.pending_output[id].push(React.createElement(Ink.Text, { dimColor: args.debug }, String(args.node)));
+                    return;
+                }
+            }
+            state.pending_output[id].push(args.node);
+        },
+        end_pending_output(state, id) {
+            delete state.pending_output[id];
         },
     },
     select: {

package/dist/command.js

@@ -26,6 +26,12 @@ export async function command() {
         alias: ["v"],
         default: false,
         description: "Print more detailed logs for debugging internals",
+    })
+        .option("update", {
+        type: "boolean",
+        alias: ["u"],
+        default: false,
+        description: "Check for updates",
     })
         .option("branch", {
         type: "string",

package/dist/core/StackSummaryTable.js

@@ -1,12 +1,17 @@
 export function write(args) {
     const stack_list = [];
-    for (const pr_url of args.pr_url_list) {
+    const digits = String(args.pr_url_list.length).length;
+    for (let i = 0; i < args.pr_url_list.length; i++) {
+        const pr_url = args.pr_url_list[i];
         if (pr_url) {
             const selected = args.selected_url === pr_url;
             const icon = selected ? "👉" : "⏳";
-            stack_list.push(`- ${icon} ${pr_url}`);
+            const num = String(i + 1).padStart(digits, "0");
+            stack_list.push(`- ${icon} \`${num}\` ${pr_url}`);
         }
     }
+    // reverse order of pr list to match the order of git stack
+    stack_list.reverse();
     let stack_table;
     if (stack_list.length > 1) {
         stack_table = TEMPLATE.stack_table(["", ...stack_list, "", ""].join("\n"));

package/dist/core/cli.js

@@ -1,8 +1,9 @@
 import * as child from "node:child_process";
 import { Store } from "../app/Store.js";
+let i = 0;
 export async function cli(unsafe_command, unsafe_options) {
-    const state = Store.getState();
     const options = Object.assign({}, unsafe_options);
+    const state = Store.getState();
     let command;
     if (Array.isArray(unsafe_command)) {
         command = unsafe_command.join(" ");
@@ -15,28 +16,38 @@ export async function cli(unsafe_command, unsafe_options) {
         let stdout = "";
         let stderr = "";
         let output = "";
+        const id = `${++i}-${command}`;
+        state.actions.debug(`[start] ${command}`);
+        state.actions.debug(`[start] ${command}\n`, id);
+        function write_output(value) {
+            output += value;
+            state.actions.debug(value, id);
+        }
         childProcess.stdout?.on("data", (data) => {
-            stdout += data.toString();
-            output += data.toString();
+            const value = String(data);
+            stdout += value;
+            write_output(value);
         });
         childProcess.stderr?.on("data", (data) => {
-            stderr += data.toString();
-            output += data.toString();
+            const value = String(data);
+            stderr += value;
+            write_output(value);
         });
-        childProcess.on("close", (code) => {
-            if (!options.ignoreExitCode && code !== 0) {
-                reject(new Error(`[${command}] (${code})`));
+        childProcess.on("close", (unsafe_code) => {
+            const result = {
+                command,
+                code: unsafe_code || 0,
+                stdout: stdout.trimEnd(),
+                stderr: stderr.trimEnd(),
+                output: output.trimEnd(),
+            };
+            state.actions.set((state) => state.mutate.end_pending_output(state, id));
+            state.actions.debug(`[end] ${command} (${result.code})`);
+            state.actions.debug(result.output);
+            if (!options.ignoreExitCode && result.code !== 0) {
+                reject(new Error(`[${command}] (${result.code})`));
             }
             else {
-                const result = {
-                    command,
-                    code: code || 0,
-                    stdout: stdout.trimEnd(),
-                    stderr: stderr.trimEnd(),
-                    output: output.trimEnd(),
-                };
-                state.actions.debug(`$ ${command}`);
-                state.actions.debug(result.output);
                 resolve(result);
             }
         });
@@ -45,12 +56,31 @@ export async function cli(unsafe_command, unsafe_options) {
         });
     });
 }
-cli.sync = function cli_sync(command, unsafe_options) {
+cli.sync = function cli_sync(unsafe_command, unsafe_options) {
     const options = Object.assign({}, unsafe_options);
+    const state = Store.getState();
+    let command;
+    if (Array.isArray(unsafe_command)) {
+        command = unsafe_command.join(" ");
+    }
+    else {
+        command = unsafe_command;
+    }
+    state.actions.debug(`[start] ${command}`);
     const spawn_return = child.spawnSync("sh", ["-c", command], options);
     const stdout = String(spawn_return.stdout);
     const stderr = String(spawn_return.stderr);
-    const output = String(spawn_return.output);
-    const code = spawn_return.status || 0;
-    return { command, code, stdout, stderr, output };
+    const result = {
+        command,
+        code: spawn_return.status || 0,
+        stdout,
+        stderr,
+        output: [stdout, stderr].join(""),
+    };
+    state.actions.debug(`[end] ${command} (${result.code})`);
+    state.actions.debug(result.output);
+    if (!options.ignoreExitCode && result.code !== 0) {
+        throw new Error(`[${command}] (${result.code})`);
+    }
+    return result;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "0.7.5",
+  "version": "0.8.0",
   "description": "",
   "author": "magus",
   "license": "MIT",