git-stack-cli 0.3.1 → 0.5.0

package/dist/app/Status.js

@@ -14,19 +14,29 @@ async function run(args) {
     const commit_range = Store.getState().commit_range;
     invariant(commit_range, "commit_range must exist");
     actions.output(React.createElement(StatusTable, null));
+    let needs_rebase = false;
     let needs_update = false;
     for (const group of commit_range.group_list) {
         if (group.dirty) {
             needs_update = true;
-            break;
+        }
+        if (group.pr?.state === "MERGED") {
+            needs_rebase = true;
+        }
+    }
+    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 || "");
+        if (commit.branch_id && !commit_pr) {
+            needs_rebase = true;
         }
     }
     if (args.argv.check) {
         actions.exit(0);
     }
-    else if (args.argv.force) {
+    else if (needs_rebase) {
         Store.setState((state) => {
-            state.step = "select-commit-ranges";
+            state.step = "pre-local-merge-rebase";
         });
     }
     else if (needs_update) {
@@ -34,6 +44,11 @@ async function run(args) {
             state.step = "pre-select-commit-ranges";
         });
     }
+    else if (args.argv.force) {
+        Store.setState((state) => {
+            state.step = "select-commit-ranges";
+        });
+    }
     else {
         actions.output(React.createElement(Ink.Text, null, "\u2705 Everything up to date."));
         actions.output(React.createElement(Ink.Text, { color: "gray" },

package/dist/app/StatusTable.js

@@ -1,6 +1,5 @@
 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() {
@@ -49,7 +48,8 @@ export function StatusTable() {
         row_list.push(row);
     }
     if (!row_list.length) {
-        return React.createElement(Ink.Text, { dimColor: true }, "No data found.");
+        return (React.createElement(Container, null,
+            React.createElement(Ink.Text, { dimColor: true }, "No data found.")));
     }
     // walk data and discover max width for each column
     const sample_row = row_list[0];
@@ -67,9 +67,8 @@ export function StatusTable() {
     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 -
+    const breathing_room = 0;
+    const remaining_space = available_width -
         // icon
         max_col_width.icon -
         // status
@@ -78,28 +77,33 @@ export function StatusTable() {
         max_col_width.count -
         // url
         max_col_width.url -
-        // gap * col count
-        columnGap * col_list.length -
+        // gap * col count (minus one for row.id which is not shown but used at key)
+        columnGap * (col_list.length - 1) -
         // 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 },
+        breathing_room;
+    // add one for ellipsis character
+    const title_width = Math.min(max_col_width.title, remaining_space + 1);
+    // prettier-ignore
+    // console.debug({ available_width, remaining_space, title_width, max_col_width });
+    return (React.createElement(Container, null, row_list.map((row) => {
+        return (React.createElement(Ink.Box, { key: row.id, 
+            // 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))));
+    })));
+}
+function Container(props) {
+    return (React.createElement(Ink.Box, { flexDirection: "column" },
         React.createElement(Ink.Box, { height: 1 }),
-        row_list.map((row) => {
-            return (React.createElement(Ink.Box, { key: row.id, 
-                // 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))));
-        }),
+        props.children,
         React.createElement(Ink.Box, { height: 1 })));
 }
-const MAX_TITLE_LENGTH = 50;

package/dist/app/Store.js

@@ -31,7 +31,17 @@ const BaseStore = createStore()(immer((set, get) => ({
         },
         newline() {
             set((state) => {
-                state.mutate.output(state, React.createElement(Ink.Text, null, "\u200E"));
+                state.mutate.output(state, "‎");
+            });
+        },
+        json(value) {
+            set((state) => {
+                state.mutate.output(state, JSON.stringify(value, null, 2));
+            });
+        },
+        error(message) {
+            set((state) => {
+                state.mutate.output(state, React.createElement(Ink.Text, { color: "#ef4444" }, message));
             });
         },
         output(node) {
@@ -40,11 +50,15 @@ const BaseStore = createStore()(immer((set, get) => ({
             });
         },
         debug(node) {
-            set((state) => {
-                if (state.argv?.debug) {
-                    state.mutate.output(state, node);
-                }
-            });
+            if (get().actions.isDebug()) {
+                set((state) => {
+                    state.mutate.output(state, React.createElement(Ink.Text, { dimColor: true }, node));
+                });
+            }
+        },
+        isDebug() {
+            const state = get();
+            return state.select.debug(state);
         },
         reset_pr() {
             set((state) => {
@@ -59,9 +73,21 @@ const BaseStore = createStore()(immer((set, get) => ({
     },
     mutate: {
         output(state, node) {
+            switch (typeof node) {
+                case "boolean":
+                case "number":
+                case "string":
+                    state.output.push(React.createElement(Ink.Text, null, String(node)));
+                    return;
+            }
             state.output.push(node);
         },
     },
+    select: {
+        debug(state) {
+            return state.argv?.verbose || false;
+        },
+    },
 })));
 function useState(selector) {
     return useStore(BaseStore, selector);

package/dist/app/TextInput.js

@@ -0,0 +1,37 @@
+import * as React from "react";
+import * as Ink from "ink";
+export function TextInput(props) {
+    const [value, set_value] = React.useState(get_value(props));
+    React.useEffect(function sync_value_prop() {
+        set_value(get_value(props));
+    }, [props.value]);
+    Ink.useInput((input, key) => {
+        let next_value = value;
+        // console.debug("[useInput]", { input, key });
+        if (key.backspace || key.delete) {
+            next_value = value.slice(0, -1);
+        }
+        else if (key.return) {
+            props.onSubmit?.(next_value);
+        }
+        else {
+            switch (input) {
+                case "\r":
+                    if (props.multiline) {
+                        next_value = `${value}\n`;
+                    }
+                    break;
+                default:
+                    next_value = `${value}${input}`;
+            }
+        }
+        set_value(next_value);
+        props.onChange?.(next_value);
+    });
+    // console.debug("[TextInput]", { value });
+    return (React.createElement(Ink.Box, { borderStyle: "single", minHeight: 1, borderColor: "yellow", borderDimColor: true },
+        React.createElement(Ink.Text, null, value || "‎")));
+}
+function get_value(props) {
+    return props.value || "";
+}

package/dist/app/YesNoPrompt.js

@@ -32,7 +32,7 @@ export function YesNoPrompt(props) {
     }
     return (React.createElement(Ink.Box, { flexDirection: "column" },
         React.createElement(Ink.Box, null,
-            React.createElement(Ink.Text, { color: "yellow" }, props.message),
+            typeof props.message === "object" ? (props.message) : (React.createElement(Ink.Text, { color: "yellow" }, props.message)),
             React.createElement(Ink.Text, null, " "),
             React.createElement(Parens, null,
                 React.createElement(Ink.Text, { color: "gray" }, choices)))));

package/dist/app/main.js

@@ -1,8 +1,10 @@
 import * as React from "react";
 import { assertNever } from "../core/assertNever.js";
 import { GithubApiError } from "./GithubApiError.js";
+import { LocalMergeRebase } from "./LocalMergeRebase.js";
 import { ManualRebase } from "./ManualRebase.js";
 import { PostRebaseStatus } from "./PostRebaseStatus.js";
+import { PreLocalMergeRebase } from "./PreLocalMergeRebase.js";
 import { PreSelectCommitRanges } from "./PreSelectCommitRanges.js";
 import { SelectCommitRanges } from "./SelectCommitRanges.js";
 import { Status } from "./Status.js";
@@ -16,6 +18,10 @@ export function Main() {
             return null;
         case "status":
             return React.createElement(Status, null);
+        case "local-merge-rebase":
+            return React.createElement(LocalMergeRebase, null);
+        case "pre-local-merge-rebase":
+            return React.createElement(PreLocalMergeRebase, null);
         case "pre-select-commit-ranges":
             return React.createElement(PreSelectCommitRanges, null);
         case "select-commit-ranges":

package/dist/command.js

@@ -1,62 +1,43 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 export async function command() {
-    const debug_argv = await yargs(hideBin(process.argv))
-        .option("debug", {
-        type: "boolean",
-        description: "Enable debug mode with more options for debugging",
-    })
-        .help(false).argv;
-    if (!debug_argv.debug) {
-        return NormalMode();
-    }
-    return DebugMode();
-}
-function NormalMode() {
-    return (yargs(hideBin(process.argv))
-        .option("force", {
-        type: "boolean",
-        description: "Force sync even if no changes are detected",
-    })
-        .option("check", {
-        type: "boolean",
-        description: "Print status table without syncing",
-    })
-        .option("debug", {
-        type: "boolean",
-        description: "Enable debug mode with more options for debugging",
-    })
-        // disallow unknown options
-        .strict()
-        .help().argv);
-}
-function DebugMode() {
+    // https://yargs.js.org/docs/#api-reference-optionkey-opt
     return (yargs(hideBin(process.argv))
+        .usage("Usage: git stack [options]")
         .option("force", {
         type: "boolean",
+        alias: ["f"],
         description: "Force sync even if no changes are detected",
     })
         .option("check", {
         type: "boolean",
+        alias: ["c"],
         description: "Print status table without syncing",
     })
-        .option("debug", {
+        .option("no-verify", {
         type: "boolean",
-        description: "Enable debug mode with more options for debugging",
+        description: "Disable the pre-push hook, bypassing it completely",
     })
         .option("verbose", {
         type: "boolean",
-        description: "Log extra information during execution",
+        alias: ["v"],
+        description: "Enable verbose mode with more detailed output for debugging",
     })
         .option("write-state-json", {
+        hidden: true,
         type: "boolean",
         description: "Write state to local json file for debugging",
     })
         .option("mock-metadata", {
+        hidden: true,
         type: "boolean",
         description: "Mock local store metadata for testing",
     })
+        // do not wrap to 80 columns (yargs default)
+        // .wrap(yargs().terminalWidth()) will fill terminal (maximuize)
+        .wrap(null)
         // disallow unknown options
         .strict()
-        .help().argv);
+        .version()
+        .help("help").argv);
 }

package/dist/core/CommitMetadata.js

@@ -1,18 +1,24 @@
 import * as Metadata from "./Metadata.js";
 import { cli } from "./cli.js";
 import * as github from "./github.js";
-export async function range(commit_map) {
+export async function range(commit_group_map) {
     // gather all open prs in repo first
     // cheaper query to populate cache
     await github.pr_list();
     const commit_list = await get_commit_list();
+    const pr_map = new Map();
     let invalid = false;
     const group_map = new Map();
     for (const commit of commit_list) {
         let id = commit.branch_id;
+        let title = id;
         // use commit map if provided (via select commit ranges)
-        if (commit_map) {
-            id = commit_map[commit.sha];
+        if (commit_group_map) {
+            const group = commit_group_map[commit.sha];
+            if (group) {
+                id = group.id;
+                title = group.title;
+            }
         }
         if (!id) {
             // console.debug("INVALID", "MISSING ID", commit.message);
@@ -33,8 +39,12 @@ export async function range(commit_map) {
             invalid = true;
             id = UNASSIGNED;
         }
+        if (!title) {
+            title = id;
+        }
         const group = group_map.get(id) || {
             id,
+            title,
             pr: null,
             base: null,
             dirty: false,
@@ -53,6 +63,7 @@ export async function range(commit_map) {
             const pr_result = await github.pr_status(group.id);
             if (pr_result && pr_result.state !== "CLOSED") {
                 group.pr = pr_result;
+                pr_map.set(group.id, pr_result);
             }
         }
         // console.debug("group", group.pr?.title.substring(0, 40));
@@ -108,10 +119,13 @@ export async function range(commit_map) {
     if (unassigned_group) {
         group_list.unshift(unassigned_group);
     }
-    return { invalid, group_list, commit_list, UNASSIGNED };
+    return { invalid, group_list, commit_list, pr_map, UNASSIGNED };
 }
 async function get_commit_list() {
     const log_result = await cli(`git log master..HEAD --oneline --format=%H --color=never`);
+    if (!log_result.stdout) {
+        return [];
+    }
     const sha_list = lines(log_result.stdout).reverse();
     const commit_metadata_list = [];
     for (let i = 0; i < sha_list.length; i++) {

package/dist/core/Metadata.js

@@ -1,8 +1,9 @@
 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 = result.replace(RE.all_double_quote, '\\"');
+    result = safe_quote(result);
     // remove any previous metadata lines
     result = remove(result);
     const line_list = [result, "", TEMPLATE.branch_id(branch_id)];
@@ -27,10 +28,10 @@ export function remove(message) {
 }
 const TEMPLATE = {
     branch_id(id) {
-        return `git-multi-diff-id: ${id}`;
+        return `git-stack-id: ${id}`;
     },
 };
 const RE = {
     all_double_quote: /"/g,
-    branch_id: new RegExp(TEMPLATE.branch_id("(?<id>[a-z0-9-]+)")),
+    branch_id: new RegExp(TEMPLATE.branch_id("(?<id>[a-z0-9-+]+)"), "i"),
 };

package/dist/core/cli.js

@@ -1,5 +1,7 @@
 import * as child from "node:child_process";
+import { Store } from "../app/Store.js";
 export async function cli(command, unsafe_options) {
+    const state = Store.getState();
     const options = Object.assign({}, unsafe_options);
     return new Promise((resolve, reject) => {
         const childProcess = child.spawn("sh", ["-c", command], options);
@@ -26,6 +28,8 @@ export async function cli(command, unsafe_options) {
                     stderr: stderr.trimEnd(),
                     output: output.trimEnd(),
                 };
+                state.actions.debug(`$ ${command}`);
+                state.actions.debug(result.output);
                 resolve(result);
             }
         });

package/dist/core/github.js

@@ -4,6 +4,7 @@ import { Brackets } from "../app/Brackets.js";
 import { Store } from "../app/Store.js";
 import { cli } from "./cli.js";
 import { invariant } from "./invariant.js";
+import { safe_quote } from "./safe_quote.js";
 // prettier-ignore
 const JSON_FIELDS = "--json number,state,baseRefName,headRefName,commits,title,url";
 export async function pr_list() {
@@ -20,13 +21,15 @@ export async function pr_list() {
         handle_error(cli_result.output);
     }
     const result_pr_list = JSON.parse(cli_result.stdout);
-    actions.debug(React.createElement(Ink.Text, { dimColor: true },
-        React.createElement(Ink.Text, null, "Github cache "),
-        React.createElement(Ink.Text, { bold: true, color: "yellow" }, result_pr_list.length),
-        React.createElement(Ink.Text, null, " open PRs from "),
-        React.createElement(Brackets, null, repo_path),
-        React.createElement(Ink.Text, null, " authored by "),
-        React.createElement(Brackets, null, username)));
+    if (actions.isDebug()) {
+        actions.output(React.createElement(Ink.Text, { dimColor: true },
+            React.createElement(Ink.Text, null, "Github cache "),
+            React.createElement(Ink.Text, { bold: true, color: "yellow" }, result_pr_list.length),
+            React.createElement(Ink.Text, null, " open PRs from "),
+            React.createElement(Brackets, null, repo_path),
+            React.createElement(Ink.Text, null, " authored by "),
+            React.createElement(Brackets, null, username)));
+    }
     actions.set((state) => {
         for (const pr of result_pr_list) {
             state.pr[pr.headRefName] = pr;
@@ -43,20 +46,24 @@ export async function pr_status(branch) {
     invariant(repo_path, "repo_path must exist");
     const cache = state.pr[branch];
     if (cache) {
-        actions.debug(React.createElement(Ink.Text, null,
+        if (actions.isDebug()) {
+            actions.output(React.createElement(Ink.Text, null,
+                React.createElement(Ink.Text, { dimColor: true }, "Github pr_status cache"),
+                React.createElement(Ink.Text, null, " "),
+                React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, "HIT "),
+                React.createElement(Ink.Text, null, " "),
+                React.createElement(Ink.Text, { dimColor: true }, branch)));
+        }
+        return cache;
+    }
+    if (actions.isDebug()) {
+        actions.output(React.createElement(Ink.Text, null,
             React.createElement(Ink.Text, { dimColor: true }, "Github pr_status cache"),
             React.createElement(Ink.Text, null, " "),
-            React.createElement(Ink.Text, { bold: true, color: "#22c55e" }, "HIT "),
+            React.createElement(Ink.Text, { bold: true, color: "#ef4444" }, "MISS"),
             React.createElement(Ink.Text, null, " "),
             React.createElement(Ink.Text, { dimColor: true }, branch)));
-        return cache;
     }
-    actions.debug(React.createElement(Ink.Text, null,
-        React.createElement(Ink.Text, { dimColor: true }, "Github pr_status cache"),
-        React.createElement(Ink.Text, null, " "),
-        React.createElement(Ink.Text, { bold: true, color: "#ef4444" }, "MISS"),
-        React.createElement(Ink.Text, null, " "),
-        React.createElement(Ink.Text, { dimColor: true }, branch)));
     const cli_result = await cli(`gh pr view ${branch} --repo ${repo_path} ${JSON_FIELDS}`, {
         ignoreExitCode: true,
     });
@@ -70,8 +77,9 @@ export async function pr_status(branch) {
     });
     return pr;
 }
-export async function pr_create(branch, base) {
-    const cli_result = await cli(`gh pr create --fill --head ${branch} --base ${base}`);
+export async function pr_create(args) {
+    const title = safe_quote(args.title);
+    const cli_result = await cli(`gh pr create --fill --head ${args.branch} --base ${args.base} --title="${title}"`);
     if (cli_result.code !== 0) {
         handle_error(cli_result.output);
     }

package/dist/core/id.js

@@ -0,0 +1,61 @@
+import crypto from "node:crypto";
+// console.log(id());
+export function id() {
+    const timestamp = Date.now();
+    // 9 223 372 036 854 775 808
+    // 9 trillion possible values
+    // (2^53) * (2^10) = 2^63 = 9,223,372,036,854,775,808
+    const js_max_bits = 53;
+    const timestamp_bits = Math.floor(Math.log2(timestamp)) + 1;
+    // padding needed to reach 53 bits
+    const padding_bits = js_max_bits - timestamp_bits;
+    // random between 0 and 2^padding_bits - 1
+    const random = crypto.randomInt(0, Math.pow(2, padding_bits));
+    // combine timestamp and random value
+    const combined = interleave_bits(timestamp, random);
+    // console.debug({ combined, timestamp, random, padding_bits, timestamp_bits });
+    return encode(combined);
+}
+function binary(value) {
+    return BigInt(value).toString(2);
+}
+function rand_index(list) {
+    return Math.floor(Math.random() * list.length);
+}
+function interleave_bits(a, b) {
+    const a_binary = binary(a).split("");
+    const b_binary = binary(b).split("");
+    while (b_binary.length) {
+        // pull random bit out of b_binary
+        const b_index = rand_index(b_binary);
+        const [selected] = b_binary.splice(b_index, 1);
+        // insert random bit into a_binary
+        const a_index = rand_index(a_binary);
+        a_binary.splice(a_index, 0, selected);
+    }
+    // convert binary list back to integer
+    const a_value = parseInt(a_binary.join(""), 2);
+    return a_value;
+}
+function encode(value) {
+    // base64 encode (64 characters)
+    // max character necessary to encode is equal to maximum number
+    // of bits in value divided by bits per character in encoding
+    //
+    // Example
+    //   in base64 each characters can represent 6 bits (2^6 = 64)
+    //   53 bits / 6 bits = 8.833333333333334 characters (9 characters)
+    //
+    // prettier-ignore
+    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-+";
+    const bits_per_char = Math.log2(chars.length);
+    const max_value_bits = 53;
+    const max_char_size = Math.ceil(max_value_bits / bits_per_char);
+    let result = "";
+    while (value > 0) {
+        result = chars[value % chars.length] + result;
+        value = Math.floor(value / chars.length);
+    }
+    // pad the result to necessary characters
+    return result.padStart(max_char_size, "=");
+}

package/dist/core/readJson.js

@@ -0,0 +1,3 @@
+export async function sleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}

package/dist/core/read_json.js

@@ -0,0 +1,12 @@
+import fs from "node:fs";
+export function read_json(path) {
+    try {
+        const file_buffer = fs.readFileSync(path);
+        const json_str = String(file_buffer);
+        const json = JSON.parse(json_str);
+        return json;
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/core/safe_quote.js

@@ -0,0 +1,9 @@
+// escape double-quote for cli
+export function safe_quote(value) {
+    let result = value;
+    result = result.replace(RE.all_double_quote, '\\"');
+    return result;
+}
+const RE = {
+    all_double_quote: /"/g,
+};