git-stack-cli 0.2.1

package/dist/app/SelectCommitRanges.js

@@ -0,0 +1,182 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { v4 as uuid_v4 } from "uuid";
+import { invariant } from "../core/invariant.js";
+import { wrap_index } from "../core/wrap_index.js";
+import { MultiSelect } from "./MultiSelect.js";
+import { Parens } from "./Parens.js";
+import { Store } from "./Store.js";
+export function SelectCommitRanges() {
+    const commit_range = Store.useState((state) => state.commit_range);
+    invariant(commit_range, "commit_range must exist");
+    return React.createElement(SelectCommitRangesInternal, { commit_range: commit_range });
+}
+function SelectCommitRangesInternal(props) {
+    const actions = Store.useActions();
+    const [new_group_list, create_group] = React.useReducer((group_list, id) => {
+        return group_list.concat({
+            id,
+            title: id,
+        });
+    }, []);
+    const [commit_map, update_commit_map] = React.useReducer((map, args) => {
+        map.set(args.key, args.value);
+        // console.debug("update_commit_map", map, args);
+        return new Map(map);
+    }, new Map(), (map) => {
+        for (const commit of props.commit_range.commit_list) {
+            map.set(commit.sha, commit.branch_id);
+        }
+        return new Map(map);
+    });
+    const group_list = [];
+    // detect if there are unassigned commits
+    // unshift an unassigned group if so to collect them
+    let unassigned_count = 0;
+    for (const [, group_id] of commit_map.entries()) {
+        if (group_id === null) {
+            // console.debug("unassigned commit detected", sha);
+            unassigned_count++;
+        }
+    }
+    if (unassigned_count) {
+        group_list.push({
+            id: "unassigned",
+            title: "Unassigned",
+        });
+    }
+    group_list.push(...new_group_list);
+    for (const group of props.commit_range.group_list) {
+        if (group.pr) {
+            group_list.push({
+                id: group.id,
+                title: group.pr.title,
+            });
+        }
+    }
+    const [selected_group_id, set_selected_group_id] = React.useState(group_list[0].id);
+    const isUnassigned = selected_group_id === "unassigned";
+    const current_index = group_list.findIndex((g) => g.id === selected_group_id);
+    Ink.useInput((input, key) => {
+        const inputLower = input.toLowerCase();
+        if (unassigned_count === 0 && inputLower === "s") {
+            actions.set((state) => {
+                state.commit_map = {};
+                for (const [sha, id] of commit_map.entries()) {
+                    if (id) {
+                        state.commit_map[sha] = id;
+                    }
+                }
+                state.step = "manual-rebase";
+            });
+            return;
+        }
+        // only allow create when on unassigned group
+        if (isUnassigned && inputLower === "c") {
+            const id = uuid_v4();
+            actions.output(React.createElement(Ink.Box, null,
+                React.createElement(Ink.Text, { dimColor: true }, "Created new group "),
+                React.createElement(Ink.Text, { color: "blueBright" }, id)));
+            create_group(id);
+            set_selected_group_id(id);
+            return;
+        }
+        if (key.leftArrow) {
+            const new_index = wrap_index(current_index - 1, group_list);
+            const next_group = group_list[new_index];
+            return set_selected_group_id(next_group.id);
+        }
+        if (key.rightArrow) {
+            const new_index = wrap_index(current_index + 1, group_list);
+            const next_group = group_list[new_index];
+            return set_selected_group_id(next_group.id);
+        }
+    });
+    const group = group_list[current_index];
+    // <-  (2/4) #742 Title A ->
+    const max_group_label_width = 64;
+    let group_title_width = max_group_label_width;
+    const left_arrow = `${SYMBOL.left} `;
+    const right_arrow = ` ${SYMBOL.right}`;
+    const group_position = `(${current_index + 1}/${group_list.length}) `;
+    const title = group.title || "Unassigned";
+    group_title_width -= group_position.length;
+    group_title_width -= left_arrow.length + right_arrow.length;
+    group_title_width = Math.min(title.length, group_title_width);
+    const items = props.commit_range.commit_list.map((commit) => {
+        const commit_metadata_id = commit_map.get(commit.sha);
+        const selected = commit_metadata_id !== null;
+        let disabled;
+        if (isUnassigned) {
+            disabled = true;
+        }
+        else {
+            disabled = Boolean(selected && commit_metadata_id !== group.id);
+        }
+        return {
+            label: commit.message,
+            value: commit,
+            selected,
+            disabled,
+        };
+    });
+    items.reverse();
+    // console.debug({ group, isUnassigned });
+    return (React.createElement(Ink.Box, { flexDirection: "column" },
+        React.createElement(Ink.Box, { height: 1 }),
+        React.createElement(MultiSelect, { key: current_index, items: items, onSelect: (args) => {
+                // console.debug("onSelect", args);
+                const key = args.item.sha;
+                let value;
+                if (args.selected) {
+                    value = group.id;
+                }
+                else {
+                    value = null;
+                }
+                update_commit_map({ key, value });
+            } }),
+        React.createElement(Ink.Box, { height: 1 }),
+        React.createElement(Ink.Box, { width: max_group_label_width, flexDirection: "row" },
+            React.createElement(Ink.Text, null, left_arrow),
+            React.createElement(Ink.Text, null, group_position),
+            React.createElement(Ink.Box, { width: group_title_width, justifyContent: "center" },
+                React.createElement(Ink.Text, { wrap: "truncate-end" }, title)),
+            React.createElement(Ink.Text, null, right_arrow)),
+        React.createElement(Ink.Box, { height: 1 }),
+        unassigned_count > 0 ? (React.createElement(Ink.Text, { color: "gray" },
+            React.createElement(Ink.Text, { color: "#3b82f6", bold: true }, unassigned_count),
+            React.createElement(Ink.Text, null, " unassigned commits"),
+            !isUnassigned ? null : (React.createElement(Ink.Text, { color: "gray" },
+                React.createElement(Ink.Text, null, ", press "),
+                React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, "c"),
+                " to ",
+                React.createElement(Ink.Text, { bold: true, color: "#22c55e" },
+                    React.createElement(Parens, null, "c"),
+                    "reate"),
+                " a new group")))) : (React.createElement(Ink.Text, null,
+            "🎉 Done! Press ",
+            React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, "s"),
+            " to ",
+            React.createElement(Ink.Text, { bold: true, color: "#22c55e" },
+                React.createElement(Parens, null, "s"),
+                "ync"),
+            " the commits to Github")),
+        React.createElement(Ink.Box, null,
+            React.createElement(Ink.Text, { color: "gray" },
+                React.createElement(Ink.Text, null, "Press "),
+                React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, SYMBOL.left),
+                " and ",
+                React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, SYMBOL.right),
+                " to view PR groups")),
+        React.createElement(Ink.Box, null,
+            React.createElement(Ink.Text, { color: "gray" },
+                React.createElement(Ink.Text, null, "Press "),
+                React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, SYMBOL.enter),
+                " to toggle commit selection"))));
+}
+const SYMBOL = {
+    left: "←",
+    right: "→",
+    enter: "Enter",
+};

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/Status.js

@@ -0,0 +1,45 @@
+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.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/StatusTable.js

@@ -0,0 +1,94 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { clamp } from "../core/clamp.js";
+import { invariant } from "../core/invariant.js";
+import { Store } from "./Store.js";
+export function StatusTable() {
+    const commit_range = Store.useState((state) => state.commit_range);
+    invariant(commit_range, "commit_range must exist");
+    const row_list = [];
+    for (const group of commit_range.group_list) {
+        const row = {
+            icon: "",
+            count: "",
+            status: "",
+            title: "",
+            url: "",
+        };
+        if (!group.pr) {
+            row.icon = "⭑";
+            row.status = "NEW";
+            row.title = "Unassigned";
+            row.count = `0/${group.commits.length}`;
+            row.url = "";
+        }
+        else {
+            if (group.dirty) {
+                row.icon = "!";
+                row.status = "OUTDATED";
+            }
+            else {
+                row.icon = "✔";
+                row.status = "SYNCED";
+            }
+            row.title = group.pr.title;
+            row.count = `${group.pr.commits.length}/${group.commits.length}`;
+            row.url = group.pr.url;
+        }
+        row_list.push(row);
+    }
+    if (!row_list.length) {
+        return React.createElement(Ink.Text, { dimColor: true }, "No data found.");
+    }
+    // walk data and discover max width for each column
+    const sample_row = row_list[0];
+    const col_list = Object.keys(sample_row);
+    const max_col_width = {};
+    for (const col of col_list) {
+        max_col_width[col] = 0;
+    }
+    for (const row of row_list) {
+        for (const col of col_list) {
+            const value = row[col];
+            max_col_width[col] = Math.max(value.length, max_col_width[col]);
+        }
+    }
+    const { stdout } = Ink.useStdout();
+    const available_width = stdout.columns;
+    const columnGap = 2;
+    const breathing_room = 10;
+    const max_title_width = Math.min(max_col_width.title, MAX_TITLE_LENGTH);
+    const remaining_space = clamp(available_width -
+        // icon
+        max_col_width.icon -
+        // status
+        max_col_width.status -
+        // commits
+        max_col_width.count -
+        // url
+        max_col_width.url -
+        // gap * col count
+        columnGap * col_list.length -
+        // remove some extra space
+        breathing_room, 0, max_title_width);
+    const title_width = remaining_space;
+    return (React.createElement(Ink.Box, { flexDirection: "column", width: available_width },
+        React.createElement(Ink.Box, { height: 1 }),
+        row_list.map((row) => {
+            return (React.createElement(Ink.Box, { key: row.url, 
+                // borderStyle="round"
+                flexDirection: "row", columnGap: columnGap, width: available_width },
+                React.createElement(Ink.Box, { width: max_col_width.icon },
+                    React.createElement(Ink.Text, null, row.icon)),
+                React.createElement(Ink.Box, { width: max_col_width.status },
+                    React.createElement(Ink.Text, null, row.status)),
+                React.createElement(Ink.Box, { width: max_col_width.count },
+                    React.createElement(Ink.Text, null, row.count)),
+                React.createElement(Ink.Box, { width: title_width },
+                    React.createElement(Ink.Text, { wrap: "truncate-end" }, row.title)),
+                React.createElement(Ink.Box, { width: max_col_width.url },
+                    React.createElement(Ink.Text, null, row.url))));
+        }),
+        React.createElement(Ink.Box, { height: 1 })));
+}
+const MAX_TITLE_LENGTH = 50;

package/dist/app/Store.js

@@ -0,0 +1,73 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { createStore, useStore } from "zustand";
+import { immer } from "zustand/middleware/immer";
+import { Exit } from "./Exit.js";
+const BaseStore = createStore()(immer((set, get) => ({
+    argv: null,
+    ink: null,
+    cwd: null,
+    head: null,
+    merge_base: null,
+    branch_name: null,
+    commit_range: null,
+    commit_map: null,
+    step: "loading",
+    output: [],
+    pr: {},
+    actions: {
+        exit(code, clear = true) {
+            set((state) => {
+                state.mutate.output(state, React.createElement(Exit, { clear: clear, code: code }));
+            });
+        },
+        clear() {
+            get().ink?.clear();
+        },
+        unmount() {
+            get().ink?.unmount();
+        },
+        newline() {
+            set((state) => {
+                state.mutate.output(state, React.createElement(Ink.Text, null, "\u200E"));
+            });
+        },
+        output(node) {
+            set((state) => {
+                state.mutate.output(state, node);
+            });
+        },
+        debug(node) {
+            set((state) => {
+                if (state.argv?.debug) {
+                    state.mutate.output(state, node);
+                }
+            });
+        },
+        reset_pr() {
+            set((state) => {
+                state.pr = {};
+            });
+        },
+        set(setter) {
+            set((state) => {
+                setter(state);
+            });
+        },
+    },
+    mutate: {
+        output(state, node) {
+            state.output.push(node);
+        },
+    },
+})));
+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;
+export const Store = { useActions, useState, getState, setState, subscribe };

package/dist/app/Waterfall.js

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { sleep } from "../core/sleep.js";
+import { Await } from "./Await.js";
+import { Store } from "./Store.js";
+export function Waterfall() {
+    return (React.createElement(Await, { fallback: React.createElement(Ink.Text, null, "Loading..."), function: async () => {
+            await sleep(3 * 1000);
+            Store.getState().actions.output(React.createElement(Ink.Text, null, "apple"));
+        } },
+        React.createElement(Await, { fallback: React.createElement(Ink.Text, null, "Loading..."), function: async () => {
+                await sleep(3 * 1000);
+                Store.getState().actions.output(React.createElement(Ink.Text, null, "banana"));
+            } },
+            React.createElement(Await, { fallback: React.createElement(Ink.Text, null, "Loading..."), function: async () => {
+                    await sleep(3 * 1000);
+                    Store.getState().actions.output(React.createElement(Ink.Text, null, "orange"));
+                } },
+                React.createElement(Ink.Text, null, "Waterfall")))));
+}

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/app/YesNoPrompt.js

@@ -0,0 +1,23 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { Parens } from "./Parens.js";
+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(Parens, null,
+                React.createElement(Ink.Text, { color: "gray" },
+                    React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, "Y"),
+                    "/",
+                    React.createElement(Ink.Text, { color: "#ef4444" }, "n"))))));
+}

package/dist/app/main.js

@@ -0,0 +1,31 @@
+import * as React from "react";
+import { assertNever } from "../core/assertNever.js";
+import { GithubApiError } from "./GithubApiError.js";
+import { ManualRebase } from "./ManualRebase.js";
+import { PostRebaseStatus } from "./PostRebaseStatus.js";
+import { PreSelectCommitRanges } from "./PreSelectCommitRanges.js";
+import { SelectCommitRanges } from "./SelectCommitRanges.js";
+import { Status } from "./Status.js";
+import { Store } from "./Store.js";
+export function Main() {
+    const step = Store.useState((state) => state.step);
+    switch (step) {
+        case "github-api-error":
+            return React.createElement(GithubApiError, null);
+        case "loading":
+            return null;
+        case "status":
+            return React.createElement(Status, null);
+        case "pre-select-commit-ranges":
+            return React.createElement(PreSelectCommitRanges, null);
+        case "select-commit-ranges":
+            return React.createElement(SelectCommitRanges, null);
+        case "manual-rebase":
+            return React.createElement(ManualRebase, null);
+        case "post-rebase-status":
+            return React.createElement(PostRebaseStatus, null);
+        default:
+            assertNever(step);
+            return null;
+    }
+}

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/command.js

@@ -0,0 +1,22 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+export async function command() {
+    return yargs(hideBin(process.argv))
+        .option("force", {
+        type: "boolean",
+        description: "force",
+    })
+        .option("check", {
+        type: "boolean",
+        description: "check",
+    })
+        .option("debug", {
+        type: "boolean",
+        description: "debug",
+    })
+        .option("mock-metadata", {
+        type: "boolean",
+        description: "mock-metadata",
+    })
+        .help().argv;
+}