git-stack-cli 0.3.1 → 0.5.0

package/dist/app/App.js

@@ -1,13 +1,16 @@
 import * as React from "react";
+import { AutoUpdate } from "./AutoUpdate.js";
 import { Debug } from "./Debug.js";
 import { DependencyCheck } from "./DependencyCheck.js";
 import { GatherMetadata } from "./GatherMetadata.js";
 import { GithubApiError } from "./GithubApiError.js";
+import { LocalCommitStatus } from "./LocalCommitStatus.js";
 import { Main } from "./Main.js";
 import { Output } from "./Output.js";
 import { Providers } from "./Providers.js";
 import { Store } from "./Store.js";
 export function App() {
+    const actions = Store.useActions();
     const ink = Store.useState((state) => state.ink);
     const argv = Store.useState((state) => state.argv);
     if (!ink || !argv) {
@@ -24,8 +27,10 @@ export function App() {
     return (React.createElement(Providers, null,
         React.createElement(Debug, null),
         React.createElement(Output, null),
-        !argv.debug ? null : React.createElement(GithubApiError, null),
+        !argv.verbose ? null : React.createElement(GithubApiError, null),
         React.createElement(DependencyCheck, null,
-            React.createElement(GatherMetadata, null,
-                React.createElement(Main, 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)))))));
 }

package/dist/app/AutoUpdate.js

@@ -0,0 +1,147 @@
+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 { read_json } from "../core/read_json.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 };
+}
+export function AutoUpdate(props) {
+    const props_ref = React.useRef(props);
+    props_ref.current = props;
+    const [output, set_output] = React.useState([]);
+    const [state, patch] = React.useReducer(reducer, {
+        error: null,
+        local_version: null,
+        latest_version: null,
+        status: "init",
+    });
+    function handle_output(node) {
+        if (typeof props.onOutput === "function") {
+            props.onOutput(node);
+        }
+        else {
+            set_output((current) => {
+                return [...current, node];
+            });
+        }
+    }
+    React.useEffect(() => {
+        let status = "done";
+        let local_version = null;
+        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..."));
+            }
+            const timeout_ms = 2 * 1000;
+            const npm_res = await Promise.race([
+                fetch(`https://registry.npmjs.org/${props.name}`),
+                sleep(timeout_ms).then(() => {
+                    throw new Error("timeout");
+                }),
+            ]);
+            const npm_json = await npm_res.json();
+            latest_version = npm_json?.["dist-tags"]?.latest;
+            if (!latest_version) {
+                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}]`);
+            }
+            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: {
+                        latest_version: React.createElement(Brackets, null, latest_version),
+                        local_version: React.createElement(Parens, null, local_version),
+                    } }));
+            }
+            const semver_result = semver_compare(latest_version, local_version);
+            if (semver_result === 0) {
+                return;
+            }
+            if (semver_result === -1) {
+                // latest version is less than or equal to local version, skip auto update
+                throw new Error(`latest version < local_version, skipping auto update [${latest_version} < ${local_version}]`);
+            }
+            // trigger yes no prompt
+            status = "prompt";
+        }
+        const onError = props_ref.current.onError || (() => { });
+        auto_update()
+            .then(() => {
+            patch({ status, local_version, latest_version });
+        })
+            .catch((error) => {
+            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: "red" }, error?.message));
+            }
+        });
+    }, []);
+    const status = (function render_status() {
+        switch (state.status) {
+            case "init":
+                return null;
+            case "prompt":
+                return (React.createElement(YesNoPrompt, { message: React.createElement(Ink.Text, { color: "yellow" }, "New version available, would you like to update?"), onYes: async () => {
+                        handle_output(React.createElement(FormatText, { key: "install", wrapper: React.createElement(Ink.Text, null), message: "Installing {name}@{version}...", values: {
+                                name: React.createElement(Ink.Text, { color: "yellow" }, props.name),
+                                version: (React.createElement(Ink.Text, { color: "#38bdf8" }, state.latest_version)),
+                            } }));
+                        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."));
+                    }, onNo: () => {
+                        patch({ status: "done" });
+                    } }));
+            case "install":
+                return null;
+            case "exit":
+                return null;
+            case "done":
+                return props.children;
+        }
+    })();
+    return (React.createElement(React.Fragment, null,
+        output,
+        status));
+}
+// returns +1 if version_a is greater than version_b
+// returns -1 if version_a is less than version_b
+// returns +0 if version_a is exactly equal to version_b
+//
+// Examples
+//
+//   semver_compare("0.1.1", "0.0.2"); //  1
+//   semver_compare("1.0.1", "0.0.2"); //  1
+//   semver_compare("0.0.1", "1.0.2"); // -1
+//   semver_compare("0.0.1", "0.1.2"); // -1
+//   semver_compare("1.0.1", "1.0.1"); //  0
+//
+function semver_compare(version_a, version_b) {
+    const split_a = version_a.split(".").map(Number);
+    const split_b = version_b.split(".").map(Number);
+    const max_split_parts = Math.max(split_a.length, split_b.length);
+    for (let i = 0; i < max_split_parts; i++) {
+        const num_a = split_a[i] || 0;
+        const num_b = split_b[i] || 0;
+        if (num_a > num_b)
+            return 1;
+        if (num_a < num_b)
+            return -1;
+    }
+    return 0;
+}

package/dist/app/Debug.js

@@ -9,10 +9,10 @@ export function Debug() {
     const actions = Store.useActions();
     const state = Store.useState((state) => state);
     const argv = Store.useState((state) => state.argv);
+    const debug = Store.useState((state) => state.select.debug(state));
     React.useEffect(function debugMessageOnce() {
-        actions.debug(React.createElement(Ink.Text, { color: "yellow" }, "Debug mode enabled"));
-        if (argv?.verbose) {
-            actions.debug(React.createElement(Ink.Text, { dimColor: true }, JSON.stringify(argv, null, 2)));
+        if (debug) {
+            actions.output(React.createElement(Ink.Text, { color: "yellow" }, "Debug mode enabled"));
         }
     }, [argv]);
     React.useEffect(function syncStateJson() {
@@ -20,7 +20,7 @@ export function Debug() {
         if (!argv?.["write-state-json"]) {
             return;
         }
-        const output_file = path.join(state.cwd, "git-multi-diff-state.json");
+        const output_file = path.join(state.cwd, "git-stack-state.json");
         if (fs.existsSync(output_file)) {
             fs.rmSync(output_file);
         }

package/dist/app/FormatText.js

@@ -1,7 +1,9 @@
 import * as React from "react";
+import * as Ink from "ink";
 import { FormattedMessage } from "react-intl";
 export function FormatText(props) {
+    const wrapper = props.wrapper || React.createElement(Ink.Text, null);
     return (React.createElement(FormattedMessage, { id: "FormatText", defaultMessage: props.message, values: props.values }, (chunks) => {
-        return React.cloneElement(props.wrapper, {}, chunks);
+        return React.cloneElement(wrapper, {}, chunks);
     }));
 }

package/dist/app/GatherMetadata copy.js

@@ -1,54 +1,58 @@
 import * as React from "react";
 import * as Ink from "ink";
-import * as CommitMetadata from "../core/CommitMetadata.js";
 import { cli } from "../core/cli.js";
 import { invariant } from "../core/invariant.js";
-import * as json from "../core/json.js";
+import { match_group } from "../core/match_group.js";
 import { Await } from "./Await.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" }, "Fetching PR status from Github..."));
-    if (argv["mock-metadata"]) {
-        return (React.createElement(Await, { fallback: fallback, function: mock_metadata }, props.children));
-    }
+    const fallback = (React.createElement(Ink.Text, { color: "yellow" }, "Gathering local git information..."));
     return (React.createElement(Await, { fallback: fallback, function: gather_metadata }, props.children));
 }
-async function mock_metadata() {
-    const module = await import("../__fixtures__/metadata.js");
-    const deserialized = json.deserialize(module.METADATA);
-    Store.setState((state) => {
-        Object.assign(state, deserialized);
-        state.step = "status";
-    });
-}
 async function gather_metadata() {
     const actions = Store.getState().actions;
-    const head = (await cli("git rev-parse HEAD")).stdout;
-    const merge_base = (await cli("git merge-base HEAD master")).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.exit(0);
-        return;
-    }
-    const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
     try {
-        const commit_range = await CommitMetadata.range();
+        const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
+        // handle when there are no detected changes
+        if (branch_name === "master") {
+            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;
+        // 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.exit(0);
+            return;
+        }
+        // git@github.com:magus/git-multi-diff-playground.git
+        // https://github.com/magus/git-multi-diff-playground.git
+        const origin_url = (await cli(`git config --get remote.origin.url`)).stdout;
+        const repo_path = match_group(origin_url, RE.repo_path, "repo_path");
         Store.setState((state) => {
+            state.repo_path = repo_path;
             state.head = head;
             state.merge_base = merge_base;
             state.branch_name = branch_name;
-            state.commit_range = commit_range;
-            state.step = "status";
         });
     }
     catch (err) {
-        actions.output(React.createElement(Ink.Text, { color: "#ef4444" }, "Error gathering metadata."));
+        actions.error("Unable to gather git metadata.");
         if (err instanceof Error) {
-            actions.debug(React.createElement(Ink.Text, { color: "#ef4444" }, err.message));
+            if (actions.isDebug()) {
+                actions.error(err.message);
+            }
         }
     }
 }
+const RE = {
+    // git@github.com:magus/git-multi-diff-playground.git
+    // https://github.com/magus/git-multi-diff-playground.git
+    repo_path: /(?<repo_path>[^:^/]+\/[^/]+)\.git/,
+};

package/dist/app/GatherMetadata.js

@@ -1,62 +1,53 @@
 import * as React from "react";
 import * as Ink from "ink";
-import * as CommitMetadata from "../core/CommitMetadata.js";
 import { cli } from "../core/cli.js";
 import { invariant } from "../core/invariant.js";
-import * as json from "../core/json.js";
 import { match_group } from "../core/match_group.js";
 import { Await } from "./Await.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" }, "Fetching PR status from Github..."));
-    if (argv["mock-metadata"]) {
-        return (React.createElement(Await, { fallback: fallback, function: mock_metadata }, props.children));
-    }
+    const fallback = (React.createElement(Ink.Text, { color: "yellow" }, "Gathering local git information..."));
     return (React.createElement(Await, { fallback: fallback, function: gather_metadata }, props.children));
 }
-async function mock_metadata() {
-    const module = await import("../__fixtures__/metadata.js");
-    const deserialized = json.deserialize(module.METADATA);
-    Store.setState((state) => {
-        Object.assign(state, deserialized);
-        state.step = "status";
-    });
-}
 async function gather_metadata() {
     const actions = Store.getState().actions;
-    const head = (await cli("git rev-parse HEAD")).stdout;
-    const merge_base = (await cli("git merge-base HEAD master")).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.exit(0);
-        return;
-    }
-    // git@github.com:magus/git-multi-diff-playground.git
-    // https://github.com/magus/git-multi-diff-playground.git
-    const origin_url = (await cli(`git config --get remote.origin.url`)).stdout;
-    const repo_path = match_group(origin_url, RE.repo_path, "repo_path");
-    const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
-    Store.setState((state) => {
-        state.repo_path = repo_path;
-        state.head = head;
-        state.merge_base = merge_base;
-        state.branch_name = branch_name;
-    });
     try {
-        const commit_range = await CommitMetadata.range();
+        const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
+        // handle when there are no detected changes
+        if (branch_name === "master") {
+            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;
+        // 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.exit(0);
+            return;
+        }
+        // git@github.com:magus/git-multi-diff-playground.git
+        // https://github.com/magus/git-multi-diff-playground.git
+        const origin_url = (await cli(`git config --get remote.origin.url`)).stdout;
+        const repo_path = match_group(origin_url, RE.repo_path, "repo_path");
         Store.setState((state) => {
-            state.commit_range = commit_range;
-            state.step = "status";
+            state.repo_path = repo_path;
+            state.head = head;
+            state.merge_base = merge_base;
+            state.branch_name = branch_name;
         });
     }
     catch (err) {
-        actions.output(React.createElement(Ink.Text, { color: "#ef4444" }, "Error gathering metadata."));
+        actions.error("Unable to gather git metadata.");
         if (err instanceof Error) {
-            actions.debug(React.createElement(Ink.Text, { color: "#ef4444" }, err.message));
+            if (actions.isDebug()) {
+                actions.error(err.message);
+            }
         }
     }
 }

package/dist/app/Input.js

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as Ink from "ink";
+export function Input(props) {
+    const [value, set_value] = React.useState(props.value || "");
+    Ink.useInput((input, key) => {
+        if (key.backspace) {
+            set_value((value) => value.slice(0, -1));
+        }
+        else {
+            set_value((value) => `${value}${input}`);
+        }
+    });
+    return (React.createElement(Ink.Box, { borderStyle: "single" },
+        React.createElement(Ink.Text, null, value)));
+}

package/dist/app/LocalCommitStatus.js

@@ -0,0 +1,42 @@
+import * as React from "react";
+import * as Ink from "ink";
+import * as CommitMetadata from "../core/CommitMetadata.js";
+import { invariant } from "../core/invariant.js";
+import * as json from "../core/json.js";
+import { Await } from "./Await.js";
+import { Store } from "./Store.js";
+export function LocalCommitStatus(props) {
+    const argv = Store.useState((state) => state.argv);
+    invariant(argv, "argv must exist");
+    const fallback = (React.createElement(Ink.Text, { color: "yellow" }, "Fetching PR status from Github..."));
+    if (argv["mock-metadata"]) {
+        return (React.createElement(Await, { fallback: fallback, function: mock_metadata }, props.children));
+    }
+    return (React.createElement(Await, { fallback: fallback, function: gather_metadata }, props.children));
+}
+async function mock_metadata() {
+    const module = await import("../__fixtures__/metadata.js");
+    const deserialized = json.deserialize(module.METADATA);
+    Store.setState((state) => {
+        Object.assign(state, deserialized);
+        state.step = "status";
+    });
+}
+async function gather_metadata() {
+    const actions = Store.getState().actions;
+    try {
+        const commit_range = await CommitMetadata.range();
+        Store.setState((state) => {
+            state.commit_range = commit_range;
+            state.step = "status";
+        });
+    }
+    catch (err) {
+        actions.error("Unable to retrieve local commit status.");
+        if (err instanceof Error) {
+            if (actions.isDebug()) {
+                actions.error(err.message);
+            }
+        }
+    }
+}

package/dist/app/LocalMergeRebase.js

@@ -0,0 +1,113 @@
+import * as React from "react";
+import * as Ink from "ink";
+import * as CommitMetadata from "../core/CommitMetadata.js";
+import * as Metadata from "../core/Metadata.js";
+import { cli } from "../core/cli.js";
+import { invariant } from "../core/invariant.js";
+import { short_id } from "../core/short_id.js";
+import { Await } from "./Await.js";
+import { Brackets } from "./Brackets.js";
+import { FormatText } from "./FormatText.js";
+import { Parens } from "./Parens.js";
+import { Store } from "./Store.js";
+export function LocalMergeRebase() {
+    return (React.createElement(Await, { fallback: React.createElement(Ink.Text, { color: "yellow" }, "Rebasing commits..."), function: run }));
+}
+async function run() {
+    const state = Store.getState();
+    const actions = state.actions;
+    const branch_name = state.branch_name;
+    const commit_range = state.commit_range;
+    invariant(branch_name, "branch_name must exist");
+    invariant(commit_range, "commit_range must exist");
+    // always listen for SIGINT event and restore git state
+    process.once("SIGINT", handle_exit);
+    const temp_branch_name = `${branch_name}_${short_id()}`;
+    try {
+        await cli(`git fetch --no-tags -v origin master:master`);
+        const master_sha = (await cli(`git rev-parse master`)).stdout;
+        const rebase_merge_base = master_sha;
+        // create temporary branch based on merge base
+        await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
+        for (let i = 0; i < commit_range.commit_list.length; i++) {
+            const commit = commit_range.commit_list[i];
+            const commit_pr = commit_range.pr_map.get(commit.branch_id || "");
+            // drop commits that are in groups of merged PRs
+            const merged_pr = commit_pr?.state === "MERGED";
+            if (merged_pr) {
+                if (actions.isDebug()) {
+                    actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: "yellow", wrap: "truncate-end" }), message: "Dropping {commit_message} {pr_status}", values: {
+                            commit_message: React.createElement(Brackets, null, commit.message),
+                            pr_status: React.createElement(Parens, null, "MERGED"),
+                        } }));
+                }
+                continue;
+            }
+            // cherry-pick and amend commits one by one
+            if (actions.isDebug()) {
+                actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: "yellow", wrap: "truncate-end" }), message: "Picking {commit_message}", values: {
+                        commit_message: React.createElement(Brackets, null, commit.message),
+                    } }));
+            }
+            await cli(`git cherry-pick ${commit.sha}`);
+            if (commit.branch_id && !commit_pr) {
+                if (actions.isDebug()) {
+                    actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: "yellow", wrap: "truncate-end" }), message: "Cleaning up unused group {group}", values: {
+                            group: React.createElement(Brackets, null, commit.branch_id),
+                        } }));
+                }
+                // missing PR, clear branch id from commit
+                const new_message = await Metadata.remove(commit.message);
+                await cli(`git commit --amend -m "${new_message}"`);
+            }
+        }
+        // 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();
+        const next_commit_range = await CommitMetadata.range();
+        actions.set((state) => {
+            state.commit_range = next_commit_range;
+            state.step = "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() {
+        // signint handler MUST run synchronously
+        // trying to use `await cli(...)` here will silently fail since
+        // all children processes receive the SIGINT signal
+        const spawn_options = { ignoreExitCode: true };
+        // always put self back in original branch
+        cli.sync(`git checkout ${branch_name}`, spawn_options);
+        // ...and cleanup temporary branch
+        cli.sync(`git branch -D ${temp_branch_name}`, spawn_options);
+        if (commit_range) {
+            // ...and cleanup pr group branches
+            for (const group of commit_range.group_list) {
+                cli.sync(`git branch -D ${group.id}`, spawn_options);
+            }
+        }
+    }
+    function handle_exit() {
+        actions.output(React.createElement(Ink.Text, { color: "yellow" },
+            "Restoring ",
+            React.createElement(Brackets, null, branch_name),
+            "..."));
+        restore_git();
+        actions.output(React.createElement(Ink.Text, { color: "yellow" },
+            "Restored ",
+            React.createElement(Brackets, null, branch_name),
+            "."));
+        actions.exit(5);
+    }
+}