git-stack-cli 0.8.2 → 0.8.3

package/dist/app/ManualRebase copy.js

@@ -0,0 +1,127 @@
+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 * as github from "../core/github.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 { Store } from "./Store.js";
+export function ManualRebase(props) {
+    return (React.createElement(Await, { fallback: React.createElement(Ink.Text, { color: "yellow" }, "Rebasing commits..."), function: () => run(props) }));
+}
+async function run(props) {
+    const state = Store.getState();
+    const actions = state.actions;
+    const branch_name = state.branch_name;
+    const merge_base = state.merge_base;
+    const commit_map = state.commit_map;
+    invariant(branch_name, "branch_name must exist");
+    invariant(merge_base, "merge_base must exist");
+    invariant(commit_map, "commit_map must exist");
+    // always listen for SIGINT event and restore git state
+    process.once("SIGINT", handle_exit);
+    const temp_branch_name = `${branch_name}_${short_id()}`;
+    const commit_range = await CommitMetadata.range(commit_map);
+    // reverse commit list so that we can cherry-pick in order
+    commit_range.group_list.reverse();
+    let rebase_merge_base = merge_base;
+    let rebase_group_index = 0;
+    for (let i = 0; i < commit_range.group_list.length; i++) {
+        const group = commit_range.group_list[i];
+        if (!group.dirty) {
+            continue;
+        }
+        if (i > 0) {
+            const 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;
+            rebase_group_index = i;
+        }
+        break;
+    }
+    try {
+        // create temporary branch based on merge base
+        await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
+        for (let i = rebase_group_index; i < commit_range.group_list.length; i++) {
+            const group = commit_range.group_list[i];
+            invariant(group.base, "group.base must exist");
+            // cherry-pick and amend commits one by one
+            for (const commit of group.commits) {
+                await cli(`git cherry-pick ${commit.sha}`);
+                if (commit.branch_id !== group.id) {
+                    const new_message = await Metadata.write(commit.message, group.id);
+                    await cli(`git commit --amend -m "${new_message}"`);
+                }
+            }
+            actions.output(React.createElement(Ink.Text, { color: "yellow", wrap: "truncate-end" },
+                "Syncing ",
+                React.createElement(Brackets, null, group.pr?.title || group.id),
+                "..."));
+            if (!props.skipSync) {
+                // push to origin since github requires commit shas to line up perfectly
+                await cli(`git push -f origin HEAD:${group.id}`);
+                if (group.pr) {
+                    // ensure base matches pr in github
+                    await github.pr_base(group.id, group.base);
+                }
+                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
+                    await github.pr_create(group.id, group.base);
+                    // move back to temp branch
+                    await cli(`git checkout ${temp_branch_name}`);
+                }
+            }
+        }
+        // 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.output(React.createElement(Ink.Text, { color: "#ef4444" }, "Error during rebase."));
+        if (err instanceof Error) {
+            actions.debug(React.createElement(Ink.Text, { color: "#ef4444" }, 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);
+    }
+}

package/dist/app/ManualRebase.js

@@ -60,9 +60,13 @@ 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) {
+                // ensure clean base to avoid conflicts when applying patch
+                await cli(`git clean -fd`);
+                // create, apply and cleanup patch
                 await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
                 await cli(`git apply ${PATCH_FILE}`);
                 await cli(`rm ${PATCH_FILE}`);
+                // add all changes to stage
                 await cli(`git add --all`);
                 const new_message = await Metadata.write(commit.message, group.id);
                 const git_commit_comand = [`git commit -m "${new_message}"`];
@@ -199,4 +203,4 @@ async function run(props) {
     }
 }
 const get_group_url = (group) => group.pr?.url || group.id;
-const PATCH_FILE = "mypatch.patch";
+const PATCH_FILE = "git-stack-cli-patch.patch";

package/dist/app/MultiSelect copy.js

@@ -0,0 +1,76 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { clamp } from "../core/clamp.js";
+export function MultiSelect(props) {
+    const [selected, select] = React.useReducer((state, value) => {
+        const next = new Set(state);
+        if (next.has(value)) {
+            next.delete(value);
+        }
+        else {
+            next.add(value);
+        }
+        return next;
+    }, new Set());
+    // clamp index to keep in item range
+    const [index, set_index] = React.useReducer((_, value) => {
+        return clamp(value, 0, props.items.length - 1);
+    }, 0);
+    React.useEffect(() => {
+        const item = props.items[index];
+        const selected_list = Array.from(selected);
+        const list = selected_list.map((index) => props.items[index]);
+        props.onSelect(item, list);
+    }, [selected]);
+    Ink.useInput((_input, key) => {
+        if (key.return) {
+            return select(index);
+        }
+        if (key.upArrow) {
+            return set_index(index - 1);
+        }
+        if (key.downArrow) {
+            return set_index(index + 1);
+        }
+    });
+    return (React.createElement(Ink.Box, { flexDirection: "column" }, props.items.map((item, i) => {
+        const active = i === index;
+        return (React.createElement(ItemRow, { key: item.label, label: item.label, active: active, selected: selected.has(i) }));
+    })));
+}
+function Radio(props) {
+    let display;
+    let color;
+    if (props.selected) {
+        // display = "✓";
+        display = "◉";
+        color = "green";
+    }
+    else {
+        // display = " ";
+        display = "◯";
+        color = "";
+    }
+    return (React.createElement(Ink.Text, { bold: props.selected, color: color }, display));
+}
+function ItemRow(props) {
+    let color;
+    let underline;
+    let dimColor;
+    if (props.active) {
+        color = "#38bdf8";
+        underline = true;
+    }
+    else if (props.selected) {
+        // color = "";
+        dimColor = false;
+    }
+    else {
+        // color = "gray";
+        dimColor = true;
+    }
+    return (React.createElement(Ink.Box, { flexDirection: "row", gap: 1 },
+        React.createElement(Radio, { selected: props.selected }),
+        React.createElement(Ink.Box, null,
+            React.createElement(Ink.Text, { bold: props.selected, underline: underline, color: color, dimColor: dimColor, wrap: "truncate-end" }, props.label))));
+}

package/dist/app/NPMAutoUpdate.js

@@ -0,0 +1,34 @@
+import * as React from "react";
+import fs from "node:fs";
+import * as Ink from "ink";
+export function AutoUpdate(props) {
+    const props_ref = React.useRef(props);
+    props_ref.current = props;
+    React.useEffect(() => {
+        async function auto_update() {
+            try {
+                const npm_res = await fetch(`https://registry.npmjs.org/${props.name}`);
+                const npm_json = await npm_res.json();
+                const latest = npm_json["dist-tags"].latest;
+                console.debug({ latest });
+                const script_path = process.argv[1];
+                const path_list = [process.argv[1]];
+                const real_path_list = path_list.map((p) => fs.realpathSync(p));
+                console.debug({ real_path_list, path_list });
+                // const winner = await Promise.race([
+                //   sleep(Math.random() * 5000).then(() => "a"),
+                //   sleep(Math.random() * 5000).then(() => "b"),
+                // ]);
+                // console.debug({ winner });
+            }
+            catch (err) {
+                console.debug({ err });
+                // handled by catch below
+                throw err;
+            }
+        }
+        const onError = props_ref.current.onError || (() => { });
+        auto_update().catch(onError);
+    }, []);
+    return React.createElement(Ink.Text, { color: "yellow" }, "Checking for latest version...");
+}

package/dist/app/Parens copy.js

@@ -0,0 +1,9 @@
+import * as React from "react";
+import * as Ink from "ink";
+export function Parens(props) {
+    const color = "#38bdf8";
+    return (React.createElement(Ink.Text, null,
+        React.createElement(Ink.Text, { color: color }, "("),
+        props.children,
+        React.createElement(Ink.Text, { color: color }, ")")));
+}

package/dist/app/PostRebaseStatus copy.js

@@ -0,0 +1,23 @@
+import * as React from "react";
+import * as Ink from "ink";
+import * as CommitMetadata from "../core/CommitMetadata.js";
+import { invariant } from "../core/invariant.js";
+import { Await } from "./Await.js";
+import { StatusTable } from "./StatusTable.js";
+import { Store } from "./Store.js";
+export function PostRebaseStatus() {
+    const argv = Store.useState((state) => state.argv);
+    invariant(argv, "argv must exist");
+    return React.createElement(Await, { fallback: null, function: run });
+}
+async function run() {
+    const actions = Store.getState().actions;
+    // reset github pr cache before refreshing via commit range below
+    actions.reset_pr();
+    const commit_range = await CommitMetadata.range();
+    actions.set((state) => {
+        state.commit_range = commit_range;
+    });
+    actions.output(React.createElement(StatusTable, null));
+    actions.output(React.createElement(Ink.Text, null, "\u2705 Everything up to date."));
+}

package/dist/app/PreSelectCommitRanges copy.js

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { invariant } from "../core/invariant.js";
+import { Store } from "./Store.js";
+import { YesNoPrompt } from "./YesNoPrompt.js";
+export function PreSelectCommitRanges() {
+    const actions = Store.useActions();
+    const argv = Store.useState((state) => state.argv);
+    invariant(argv, "argv must exist");
+    React.useEffect(() => {
+        if (argv.force) {
+            Store.setState((state) => {
+                state.step = "select-commit-ranges";
+            });
+        }
+    }, [argv]);
+    return (React.createElement(YesNoPrompt, { message: "Some commits are new or outdated, would you like to select new commit ranges?", onYes: () => {
+            actions.set((state) => {
+                state.step = "select-commit-ranges";
+            });
+        }, onNo: () => actions.exit(0) }));
+}

package/dist/app/SelectCommitRange.js

@@ -0,0 +1 @@
+export {};

package/dist/app/Status copy.js

@@ -0,0 +1,46 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { invariant } from "../core/invariant.js";
+import { Await } from "./Await.js";
+import { StatusTable } from "./StatusTable.js";
+import { Store } from "./Store.js";
+export function Status() {
+    const argv = Store.useState((state) => state.argv);
+    invariant(argv, "argv must exist");
+    return React.createElement(Await, { fallback: null, function: () => run({ argv }) });
+}
+async function run(args) {
+    const actions = Store.getState().actions;
+    const commit_range = Store.getState().commit_range;
+    invariant(commit_range, "commit_range must exist");
+    actions.output(React.createElement(StatusTable, null));
+    let needs_update = false;
+    for (const group of commit_range.group_list) {
+        if (group.dirty) {
+            needs_update = true;
+            break;
+        }
+    }
+    if (args.argv.check) {
+        actions.exit(0);
+    }
+    else if (args.argv.force) {
+        Store.setState((state) => {
+            state.step = "select-commit-ranges";
+        });
+    }
+    else if (needs_update) {
+        Store.setState((state) => {
+            state.step = "pre-select-commit-ranges";
+        });
+    }
+    else {
+        actions.newline();
+        actions.output(React.createElement(Ink.Text, null, "\u2705 Everything up to date."));
+        actions.output(React.createElement(Ink.Text, { color: "gray" },
+            React.createElement(Ink.Text, null, "Run with"),
+            React.createElement(Ink.Text, { bold: true, color: "yellow" }, ` --force `),
+            React.createElement(Ink.Text, null, "to force update all pull requests.")));
+        actions.exit(0);
+    }
+}

package/dist/app/Url copy.js

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as Ink from "ink";
+export function Url(props) {
+    const text_color = "#38bdf8";
+    return React.createElement(Ink.Text, { color: text_color }, props.children);
+}

package/dist/app/YesNoPrompt copy.js

@@ -0,0 +1,24 @@
+import * as React from "react";
+import * as Ink from "ink";
+export function YesNoPrompt(props) {
+    Ink.useInput((input) => {
+        const inputLower = input.toLowerCase();
+        switch (inputLower) {
+            case "n":
+                return props.onNo();
+            case "y":
+                return props.onYes();
+        }
+    });
+    return (React.createElement(Ink.Box, { flexDirection: "column" },
+        React.createElement(Ink.Box, null,
+            React.createElement(Ink.Text, { color: "yellow" }, props.message),
+            React.createElement(Ink.Text, null, " "),
+            React.createElement(Ink.Text, { color: "#06b6d4" },
+                "(",
+                React.createElement(Ink.Text, { color: "gray" },
+                    React.createElement(Ink.Text, { color: "#22c55e", dimColor: true }, "Y"),
+                    "/",
+                    React.createElement(Ink.Text, { color: "#ef4444", dimColor: true }, "n")),
+                ")"))));
+}

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import * as React from "react";
+import * as Ink from "ink";
+import { App } from "./app/App.js";
+import { command } from "./command.js";
+const argv = await command();
+const ink = {};
+const app = Ink.render(React.createElement(App, { argv: argv, ink: ink }));
+Object.assign(ink, app);

package/dist/core/Metadata copy.js

@@ -0,0 +1,37 @@
+import { invariant } from "../core/invariant.js";
+import { safe_quote } from "../core/safe_quote.js";
+export function write(message, branch_id) {
+    let result = message;
+    // escape double-quote for cli
+    result = safe_quote(result);
+    // remove any previous metadata lines
+    result = remove(result);
+    const line_list = [result, "", TEMPLATE.branch_id(branch_id)];
+    const new_message = line_list.join("\n");
+    return new_message;
+}
+export function read(message) {
+    const match = message.match(RE.branch_id);
+    if (!match?.groups) {
+        return null;
+    }
+    const id = match.groups["id"];
+    invariant(id, "id must exist");
+    return id;
+}
+export function remove(message) {
+    let result = message;
+    // remove metadata
+    result = result.replace(new RegExp(RE.branch_id, "g"), "");
+    result = result.trimEnd();
+    return result;
+}
+const TEMPLATE = {
+    branch_id(id) {
+        return `git-stack-id: ${id}`;
+    },
+};
+const RE = {
+    all_double_quote: /"/g,
+    branch_id: new RegExp(TEMPLATE.branch_id("(?<id>[a-z0-9-+]+)"), "i"),
+};

package/dist/core/StackTable.js

@@ -0,0 +1,38 @@
+import { invariant } from "./invariant.js";
+import { safe_quote } from "./safe_quote.js";
+export function write(message, branch_id) {
+    let result = message;
+    // escape double-quote for cli
+    result = safe_quote(result);
+    // remove any previous metadata lines
+    result = remove(result);
+    const line_list = [result, "", TEMPLATE.branch_id(branch_id)];
+    const new_message = line_list.join("\n");
+    return new_message;
+}
+export function read(message) {
+    const match = message.match(RE.branch_id);
+    if (!match?.groups) {
+        return null;
+    }
+    const id = match.groups["id"];
+    invariant(id, "id must exist");
+    return id;
+}
+export function remove(message) {
+    let result = message;
+    // remove metadata
+    result = result.replace(new RegExp(RE.branch_id, "g"), "");
+    result = result.trimEnd();
+    return result;
+}
+const TEMPLATE = {
+    stack_table(rows) {
+        return `"#### git stack\n${rows}"`;
+    },
+};
+const RE = {
+    all_double_quote: /"/g,
+    // https://regex101.com/r/kqB9Ft/1
+    stack_table: new RegExp(TEMPLATE.branch_id("(?<id>[a-z0-9-+]+)"), "i"),
+};

package/dist/core/SummaryTable.js

@@ -0,0 +1,38 @@
+import { invariant } from "./invariant.js";
+import { safe_quote } from "./safe_quote.js";
+export function write(message, branch_id) {
+    let result = message;
+    // escape double-quote for cli
+    result = safe_quote(result);
+    // remove any previous metadata lines
+    result = remove(result);
+    const line_list = [result, "", TEMPLATE.branch_id(branch_id)];
+    const new_message = line_list.join("\n");
+    return new_message;
+}
+export function read(message) {
+    const match = message.match(RE.branch_id);
+    if (!match?.groups) {
+        return null;
+    }
+    const id = match.groups["id"];
+    invariant(id, "id must exist");
+    return id;
+}
+export function remove(message) {
+    let result = message;
+    // remove metadata
+    result = result.replace(new RegExp(RE.branch_id, "g"), "");
+    result = result.trimEnd();
+    return result;
+}
+const TEMPLATE = {
+    stack_table(rows) {
+        return `"#### git stack\n${rows}"`;
+    },
+};
+const RE = {
+    all_double_quote: /"/g,
+    // https://regex101.com/r/kqB9Ft/1
+    stack_table: new RegExp(TEMPLATE.branch_id("(?<id>[a-z0-9-+]+)"), "i"),
+};

package/dist/core/ZustandStore.js

@@ -0,0 +1,23 @@
+import { createStore, useStore } from "zustand";
+import { immer } from "zustand/middleware/immer";
+function ZustandStore() {
+    const BaseStore = createStore()(immer((set, get) => ({
+        actions: {
+            set(setter) {
+                set((state) => {
+                    setter(state);
+                });
+            },
+        },
+    })));
+    function useState(selector) {
+        return useStore(BaseStore, selector);
+    }
+    function useActions() {
+        return useState((state) => state.actions);
+    }
+    const getState = BaseStore.getState;
+    const setState = BaseStore.setState;
+    const subscribe = BaseStore.subscribe;
+    return { useActions, useState, getState, setState, subscribe };
+}

package/dist/core/cli copy.js

@@ -0,0 +1,44 @@
+import * as child from "node:child_process";
+export async function cli(command, unsafe_options) {
+    const options = Object.assign({}, unsafe_options);
+    return new Promise((resolve, reject) => {
+        const childProcess = child.spawn("sh", ["-c", command], options);
+        let stdout = "";
+        let stderr = "";
+        let output = "";
+        childProcess.stdout?.on("data", (data) => {
+            stdout += data.toString();
+            output += data.toString();
+        });
+        childProcess.stderr?.on("data", (data) => {
+            stderr += data.toString();
+            output += data.toString();
+        });
+        childProcess.on("close", (code) => {
+            if (!options.ignoreExitCode && code !== 0) {
+                reject(new Error(`[${command}] (${code})`));
+            }
+            else {
+                const result = {
+                    code: code || 0,
+                    stdout: stdout.trimEnd(),
+                    stderr: stderr.trimEnd(),
+                    output: output.trimEnd(),
+                };
+                resolve(result);
+            }
+        });
+        childProcess.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+cli.sync = function cli_sync(command, unsafe_options) {
+    const options = Object.assign({}, unsafe_options);
+    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 { code, stdout, stderr, output };
+};

package/dist/core/color.js

@@ -0,0 +1,83 @@
+import chalk from "chalk";
+function create_color_proxy(base) {
+    return new Proxy(base, {
+        get(target, prop) {
+            switch (prop) {
+                case "test":
+                    return test;
+                case "bracket":
+                    return (str) => [
+                        target.bold.whiteBright("["),
+                        str,
+                        target.bold.whiteBright("]"),
+                    ].join("");
+                case "url":
+                    return target.bold.underline.blueBright;
+                case "cmd":
+                    return target.bold.yellow;
+                case "branch":
+                    return target.bold.green;
+            }
+            const target_prop = target[prop];
+            return target_prop;
+        },
+        apply(target, _this_arg, arguments_list) {
+            return target(...arguments_list);
+        },
+    });
+}
+export const color = create_color_proxy(chalk);
+function test() {
+    const PROP_LIST = [
+        "reset",
+        "bold",
+        "dim",
+        "italic",
+        "underline",
+        "overline",
+        "inverse",
+        "hidden",
+        "strikethrough",
+        "visible",
+        "black",
+        "red",
+        "green",
+        "yellow",
+        "blue",
+        "magenta",
+        "cyan",
+        "white",
+        "blackBright",
+        "gray",
+        "grey",
+        "redBright",
+        "greenBright",
+        "yellowBright",
+        "blueBright",
+        "magentaBright",
+        "cyanBright",
+        "whiteBright",
+        "bgBlack",
+        "bgRed",
+        "bgGreen",
+        "bgYellow",
+        "bgBlue",
+        "bgMagenta",
+        "bgCyan",
+        "bgWhite",
+        "bgBlackBright",
+        "bgGray",
+        "bgGrey",
+        "bgRedBright",
+        "bgGreenBright",
+        "bgYellowBright",
+        "bgBlueBright",
+        "bgMagentaBright",
+        "bgCyanBright",
+        "bgWhiteBright",
+    ];
+    for (const prop of PROP_LIST) {
+        // eslint-disable-next-line no-console
+        console.debug(chalk[prop](prop));
+    }
+}