git-stack-cli 0.8.2 → 0.8.4

package/dist/app/Main copy.js

@@ -0,0 +1,200 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { v4 as uuid_v4 } from "uuid";
+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 { match_group } from "../core/match_group.js";
+import { Await } from "./Await.js";
+import { Exit } from "./Exit.js";
+import { Store } from "./Store.js";
+export function GatherMetadata(props) {
+    const argv = Store.useState((state) => state.argv);
+    invariant(argv, "argv must exist");
+    return (React.createElement(Await, { fallback: null, function: () => gather_metadata({ argv }) }, props.children));
+}
+async function gather_metadata(args) {
+    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.output(React.createElement(Exit, { clear: true, code: 0 }));
+        return;
+    }
+    const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
+    // 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 commit_metadata_list = await CommitMetadata.all();
+    Store.setState((state) => {
+        state.head = head;
+        state.merge_base = merge_base;
+        state.branch_name = branch_name;
+        state.repo_path = repo_path;
+        state.commit_metadata_list = commit_metadata_list;
+    });
+    // print_table(repo_path, commit_metadata_list);
+    const needs_update = commit_metadata_list.some((meta) => !meta.pr_exists || meta.pr_dirty);
+    if (args.argv.check) {
+        actions.output(React.createElement(Exit, { clear: true, code: 0 }));
+        return;
+    }
+    if (!args.argv.force && !needs_update) {
+        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.output(React.createElement(Exit, { clear: true, code: 0 }));
+    }
+    Store.setState((state) => {
+        state.step = "select-commit-ranges";
+    });
+}
+async function manual_rebase(args) {
+    const temp_branch_name = `${args.branch_name}_${uuid_v4()}`;
+    try {
+        // create temporary branch based on merge base
+        await cli(`git checkout -b ${temp_branch_name} ${args.merge_base}`);
+        const picked_commit_metadata_list = [];
+        // cherry-pick and amend commits one by one
+        for (let i = 0; i < args.commit_metadata_list.length; i++) {
+            const sha = args.commit_metadata_list[i].sha;
+            let base;
+            if (i === 0) {
+                base = "master";
+            }
+            else {
+                base = picked_commit_metadata_list[i - 1].metadata.id;
+                invariant(base, `metadata must be set on previous commit [${i}]`);
+            }
+            await cli(`git cherry-pick ${sha}`);
+            const commit = await CommitMetadata.commit(sha, base);
+            if (!commit.metadata.id) {
+                commit.metadata.id = uuid_v4();
+                await Metadata.write(commit);
+            }
+            picked_commit_metadata_list.push(commit);
+            // always push to origin since github requires commit shas to line up perfectly
+            console.debug();
+            console.debug(`Syncing [${commit.metadata.id}] ...`);
+            await cli(`git push -f origin HEAD:${commit.metadata.id}`);
+            if (commit.pr_exists) {
+                // ensure base matches pr in github
+                await github.pr_base(commit.metadata.id, base);
+            }
+            else {
+                try {
+                    // delete metadata id branch if leftover
+                    await cli(`git branch -D ${commit.metadata.id}`, {
+                        ignoreExitCode: true,
+                    });
+                    // move to temporary branch for creating pr
+                    await cli(`git checkout -b ${commit.metadata.id}`);
+                    // create pr in github
+                    await github.pr_create(commit.metadata.id, base);
+                }
+                catch (err) {
+                    console.error("Moving back to temp branch...");
+                    console.error(err);
+                }
+                finally {
+                    // move back to temp branch
+                    await cli(`git checkout ${temp_branch_name}`);
+                    // delete metadata id branch if leftover
+                    await cli(`git branch -D ${commit.metadata.id}`, {
+                        ignoreExitCode: true,
+                    });
+                }
+            }
+        }
+        // after all commits have been cherry-picked and amended
+        // move the branch pointer to the temporary branch (with the metadata)
+        await cli(`git branch -f ${args.branch_name} ${temp_branch_name}`);
+    }
+    catch (err) {
+        console.error("Restoring original branch...");
+        console.error(err);
+    }
+    finally {
+        // always put self back in original branch
+        await cli(`git checkout ${args.branch_name}`);
+        // ...and cleanup temporary branch
+        await cli(`git branch -D ${temp_branch_name}`, { ignoreExitCode: true });
+    }
+    // print_table(repo_path, await CommitMetadata.all());
+}
+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/,
+};
+// function print_table(
+//   repo_path: string,
+//   commit_metadata_list: Array<Awaited<ReturnType<typeof CommitMetadata.commit>>>
+// ) {
+//   console.debug();
+//   for (const args of commit_metadata_list) {
+//     print_table_row(repo_path, args);
+//   }
+// }
+// function print_table_row(
+//   repo_path: string,
+//   args: Awaited<ReturnType<typeof CommitMetadata.commit>>
+// ) {
+//   let icon;
+//   let status;
+//   if (!args.pr_exists) {
+//     icon = "🌱";
+//     status = "NEW";
+//   } else if (args.pr_dirty) {
+//     icon = "⚠️";
+//     status = "OUTDATED";
+//   } else {
+//     icon = "✅";
+//     status = "SYNCED";
+//   }
+//   // print clean metadata about this commit / branch
+//   const parts = [
+//     icon,
+//     " ",
+//     col(status, 10, "left"),
+//     col(args.message, 80, "left"),
+//   ];
+//   if (args.pr?.number) {
+//     parts.push(` https://github.com/${repo_path}/pull/${args.pr.number}`);
+//   }
+//   console.debug(...parts);
+// }
+// const RE = {
+//   all_newline: /\n/g,
+//   // git@github.com:magus/git-multi-diff-playground.git
+//   // https://github.com/magus/git-multi-diff-playground.git
+//   repo_path: /(?<repo_path>[^:^/]+\/[^/]+)\.git/,
+// };
+// function trunc(value: string, length: number) {
+//   return value.substring(0, length);
+// }
+// function pad(value: string, length: number, align: "left" | "right") {
+//   const space_count = Math.max(0, length - value.length);
+//   const padding = " ".repeat(space_count);
+//   if (align === "left") {
+//     return `${value}${padding}`;
+//   } else {
+//     return `${padding}${value}`;
+//   }
+// }
+// function col(value: string, length: number, align: "left" | "right") {
+//   let column = value;
+//   column = column.replace(RE.all_newline, " ");
+//   column = trunc(column, length);
+//   column = pad(column, length, align);
+//   return column;
+// }

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

@@ -1,4 +1,5 @@
 import * as React from "react";
+import fs from "node:fs";
 import * as Ink from "ink";
 import * as CommitMetadata from "../core/CommitMetadata.js";
 import * as Metadata from "../core/Metadata.js";
@@ -22,10 +23,14 @@ async function run(props) {
     const branch_name = state.branch_name;
     const merge_base = state.merge_base;
     const commit_map = state.commit_map;
+    const cwd = state.cwd;
+    const repo_root = state.repo_root;
     invariant(argv, "argv must exist");
     invariant(branch_name, "branch_name must exist");
     invariant(merge_base, "merge_base must exist");
     invariant(commit_map, "commit_map must exist");
+    invariant(cwd, "cwd must exist");
+    invariant(repo_root, "repo_root must exist");
     // always listen for SIGINT event and restore git state
     process.once("SIGINT", handle_exit);
     const temp_branch_name = `${branch_name}_${short_id()}`;
@@ -48,6 +53,9 @@ async function run(props) {
         break;
     }
     try {
+        // must perform rebase from repo root for applying git patch
+        process.chdir(repo_root);
+        await cli(`pwd`);
         // create temporary branch based on merge base
         await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
         const pr_url_list = commit_range.group_list.map(get_group_url);
@@ -60,9 +68,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}"`];
@@ -184,6 +196,12 @@ async function run(props) {
                 cli.sync(`git branch -D ${group.id}`, spawn_options);
             }
         }
+        // restore back to original dir
+        invariant(cwd, "cwd must exist");
+        if (fs.existsSync(cwd)) {
+            process.chdir(cwd);
+        }
+        cli.sync(`pwd`, spawn_options);
     }
     function handle_exit() {
         actions.output(React.createElement(Ink.Text, { color: colors.yellow },
@@ -199,4 +217,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/Store.js

@@ -10,6 +10,7 @@ const BaseStore = createStore()(immer((set, get) => ({
     cwd: null,
     username: null,
     repo_path: null,
+    repo_root: null,
     master_branch: "master",
     head: null,
     merge_base: null,

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);