git-stack-cli 0.7.6 → 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/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

@@ -108,6 +108,9 @@ async function run() {
         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

package/dist/app/ManualRebase.js

@@ -167,6 +167,9 @@ async function run(props) {
         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

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/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

@@ -2,8 +2,8 @@ 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(" ");
@@ -33,19 +33,19 @@ export async function cli(unsafe_command, unsafe_options) {
             stderr += value;
             write_output(value);
         });
-        childProcess.on("close", (code) => {
+        childProcess.on("close", (unsafe_code) => {
             const result = {
                 command,
-                code: code || 0,
+                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}`);
+            state.actions.debug(`[end] ${command} (${result.code})`);
             state.actions.debug(result.output);
-            if (!options.ignoreExitCode && code !== 0) {
-                reject(new Error(`[${command}] (${code})`));
+            if (!options.ignoreExitCode && result.code !== 0) {
+                reject(new Error(`[${command}] (${result.code})`));
             }
             else {
                 resolve(result);
@@ -56,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.6",
+  "version": "0.8.0",
   "description": "",
   "author": "magus",
   "license": "MIT",