git-stack-cli 0.2.1

package/dist/core/CommitMetadata.js

@@ -0,0 +1,143 @@
+import * as Metadata from "./Metadata.js";
+import { cli } from "./cli.js";
+import * as github from "./github.js";
+export async function range(commit_map) {
+    const commit_list = await get_commit_list();
+    let invalid = false;
+    const group_map = new Map();
+    for (const commit of commit_list) {
+        let id = commit.branch_id;
+        // use commit map if provided (via select commit ranges)
+        if (commit_map) {
+            id = commit_map[commit.sha];
+        }
+        const pr = commit.pr;
+        if (!pr) {
+            // console.debug("INVALID", "MISSING PR", commit.message);
+            invalid = true;
+        }
+        if (id) {
+            const group_key_list = Array.from(group_map.keys());
+            const last_key = group_key_list[group_key_list.length - 1];
+            if (group_map.has(id) && last_key !== id) {
+                // if we've seen this id before and it's not
+                // the last added key then we are out of order
+                // console.debug("INVALID", "OUT OF ORDER", commit.message, id);
+                invalid = true;
+            }
+        }
+        else {
+            // console.debug("INVALID", "NEW COMMIT", { commit });
+            invalid = true;
+            id = UNASSIGNED;
+        }
+        const group = group_map.get(id) || {
+            id,
+            pr,
+            base: null,
+            dirty: false,
+            commits: [],
+        };
+        group.commits.push(commit);
+        group_map.set(id, group);
+    }
+    // check each group for dirty state and base
+    const group_value_list = Array.from(group_map.values());
+    const group_list = [];
+    let unassigned_group;
+    for (let i = 0; i < group_value_list.length; i++) {
+        const group = group_value_list[i];
+        // console.debug("group", group.pr?.title.substring(0, 40));
+        // console.debug("  ", "id", group.id);
+        if (group.id === UNASSIGNED) {
+            unassigned_group = group;
+        }
+        else {
+            group_list.push(group);
+        }
+        if (i === 0) {
+            group.base = "master";
+        }
+        else {
+            const last_group = group_value_list[i - 1];
+            // console.debug("  ", "last_group", last_group.pr?.title.substring(0, 40));
+            // console.debug("  ", "last_group.id", last_group.id);
+            // null out base when unassigned and after unassigned
+            if (group.id === UNASSIGNED) {
+                group.base = null;
+            }
+            else if (last_group.base === null) {
+                group.base = null;
+            }
+            else {
+                group.base = last_group.id;
+            }
+            // console.debug("  ", "group.base", group.base);
+        }
+        if (!group.pr) {
+            group.dirty = true;
+        }
+        else if (group.pr.commits.length !== group.commits.length) {
+            group.dirty = true;
+        }
+        else if (group.pr.baseRefName !== group.base) {
+            group.dirty = true;
+        }
+        else {
+            for (let i = 0; i < group.pr.commits.length; i++) {
+                const pr_commit = group.pr.commits[i];
+                const local_commit = group.commits[i];
+                if (pr_commit.oid !== local_commit.sha) {
+                    group.dirty = true;
+                }
+            }
+        }
+        // console.debug("  ", "group.dirty", group.dirty);
+    }
+    // reverse group_list to match git log
+    group_list.reverse();
+    // insert unassigned group at front
+    if (unassigned_group) {
+        group_list.unshift(unassigned_group);
+    }
+    return { invalid, group_list, commit_list, UNASSIGNED };
+}
+async function get_commit_list() {
+    const log_result = await cli(`git log master..HEAD --oneline --format=%H --color=never`);
+    const sha_list = lines(log_result.stdout).reverse();
+    const commit_metadata_list = [];
+    for (let i = 0; i < sha_list.length; i++) {
+        const sha = sha_list[i];
+        const commit_metadata = await commit(sha);
+        commit_metadata_list.push(commit_metadata);
+    }
+    return commit_metadata_list;
+}
+export async function commit(sha) {
+    const raw_message = (await cli(`git show -s --format=%B ${sha}`)).stdout;
+    const branch_id = await Metadata.read(raw_message);
+    const message = display_message(raw_message);
+    let pr = null;
+    if (branch_id) {
+        const pr_result = await github.pr_status(branch_id);
+        if (pr_result && pr_result.state === "OPEN") {
+            pr = pr_result;
+        }
+    }
+    return {
+        sha,
+        message,
+        raw_message,
+        pr,
+        branch_id,
+    };
+}
+function display_message(message) {
+    const line_list = lines(message);
+    const first_line = line_list[0];
+    return Metadata.remove(first_line);
+}
+function lines(value) {
+    return value.split("\n");
+}
+const UNASSIGNED = "unassigned";

package/dist/core/Metadata.js

@@ -0,0 +1,36 @@
+import { invariant } from "../core/invariant.js";
+export function write(message, branch_id) {
+    let result = message;
+    // escape double-quote for cli
+    result = result.replace(RE.all_double_quote, '\\"');
+    // 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-multi-diff-id: ${id}`;
+    },
+};
+const RE = {
+    all_double_quote: /"/g,
+    branch_id: new RegExp(TEMPLATE.branch_id("(?<id>[a-z0-9-]+)")),
+};

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

@@ -0,0 +1,4 @@
+export function assertNever(value) {
+    // eslint-disable-next-line no-console
+    console.error("[assertNever]", { value });
+}

package/dist/core/cache.js

@@ -0,0 +1,39 @@
+export function cache(cacheable) {
+    let status = "pending";
+    let response;
+    let suspender;
+    function reset() {
+        status = "pending";
+        response = undefined;
+        suspender = undefined;
+    }
+    function check() {
+        return status;
+    }
+    function read() {
+        // cacheable is a function to allow deferred reads
+        // this will call cacheable to kickoff async promise
+        if (!suspender) {
+            suspender = Promise.resolve().then(() => {
+                cacheable()
+                    .then((res) => {
+                    status = "success";
+                    response = res;
+                })
+                    .catch((err) => {
+                    status = "error";
+                    response = err;
+                });
+            });
+        }
+        switch (status) {
+            case "pending":
+                throw suspender;
+            case "error":
+                throw response;
+            default:
+                return response;
+        }
+    }
+    return { reset, check, read };
+}

package/dist/core/capitalize.js

@@ -0,0 +1,5 @@
+export function capitalize(value) {
+    const first_char = value.substring(0, 1).toLocaleUpperCase();
+    const rest_char = value.substring(1, value.length);
+    return first_char + rest_char;
+}

package/dist/core/clamp.js

@@ -0,0 +1,6 @@
+export function clamp(value, min, max) {
+    let result = value;
+    result = Math.max(result, min);
+    result = Math.min(result, max);
+    return result;
+}

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/cli.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));
+    }
+}

package/dist/core/date.js

@@ -0,0 +1,18 @@
+export function format(date) {
+    const year = intl_format(date, { year: "numeric" });
+    const month = intl_format(date, { month: "2-digit" });
+    const day = intl_format(date, { day: "2-digit" });
+    const time = format_time(date);
+    return `${year}-${month}-${day} ${time}`;
+}
+export function intl_format(date, options) {
+    return new Intl.DateTimeFormat("en-US", options).format(date);
+}
+export function format_time(date) {
+    const time = intl_format(date, {
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+    });
+    return time;
+}

package/dist/core/dependency_check.js

@@ -0,0 +1,27 @@
+import { cli } from "./cli.js";
+import { color } from "./color.js";
+import { is_command_available } from "./is_command_available.js";
+export async function dependency_check() {
+    if (!is_command_available("git")) {
+        console.error(`${color.cmd("git")} must be installed.`);
+        process.exitCode = 2;
+        return false;
+    }
+    if (!is_command_available("gh")) {
+        console.error(`${color.cmd("gh")} must be installed.`);
+        // prettier-ignore
+        console.error(`Visit ${color.url("https://cli.github.com/")} to install the github cli (${color.cmd("gh")})`);
+        process.exitCode = 3;
+        return false;
+    }
+    const gh_auth_status_cli = await cli(`gh auth status`, {
+        ignoreExitCode: true,
+    });
+    if (gh_auth_status_cli.code !== 0) {
+        // prettier-ignore
+        console.error(`${color.cmd('gh')} requires login, please run \`${color.cmd('gh auth login')}\`.`);
+        process.exitCode = 4;
+        return false;
+    }
+    return true;
+}

package/dist/core/exit.js

@@ -0,0 +1,4 @@
+export function exit(code) {
+    process.exitCode = code;
+    process.exit();
+}

package/dist/core/get_commit_metadata.js

@@ -0,0 +1,61 @@
+import * as github from "../core/github.js";
+import * as Metadata from "./Metadata.js";
+import { cli } from "./cli.js";
+async function all() {
+    const log_result = await cli(`git log master..HEAD --oneline --format=%H --color=never`);
+    const sha_list = lines(log_result.stdout).reverse();
+    const commit_metadata_list = [];
+    for (let i = 0; i < sha_list.length; i++) {
+        const sha = sha_list[i];
+        let base;
+        if (i === 0) {
+            base = "master";
+        }
+        else {
+            base = commit_metadata_list[i - 1].metadata.id;
+        }
+        const commit_metadata = await commit(sha, base);
+        commit_metadata_list.push(commit_metadata);
+    }
+    return commit_metadata_list;
+}
+export async function commit(sha, base) {
+    const raw_message = (await cli(`git show -s --format=%B ${sha}`)).stdout;
+    const metadata = await Metadata.read(raw_message);
+    const message = display_message(raw_message);
+    let pr = null;
+    let pr_exists = false;
+    let pr_dirty = false;
+    if (metadata.id) {
+        const pr_branch = metadata.id;
+        pr = await github.pr_status(pr_branch);
+        if (pr && pr.state === "OPEN") {
+            pr_exists = true;
+            const last_commit = pr.commits[pr.commits.length - 1];
+            pr_dirty = last_commit.oid !== sha;
+            if (pr.baseRefName !== base) {
+                // requires base update
+                pr_dirty = true;
+            }
+        }
+    }
+    return {
+        sha,
+        base,
+        message,
+        pr,
+        pr_exists,
+        pr_dirty,
+        metadata,
+    };
+}
+function display_message(message) {
+    // remove metadata
+    let result = message;
+    result = result.replace(Metadata.id_regex(), "");
+    result = result.trimEnd();
+    return result;
+}
+function lines(value) {
+    return value.split("\n");
+}

package/dist/core/github.js

@@ -0,0 +1,45 @@
+import * as React from "react";
+import * as Ink from "ink";
+import { Store } from "../app/Store.js";
+import { cli } from "./cli.js";
+export async function pr_status(branch) {
+    const state = Store.getState();
+    const actions = state.actions;
+    const result = await cli(`gh pr view ${branch} --json number,state,baseRefName,headRefName,commits,title,url`, {
+        ignoreExitCode: true,
+    });
+    if (result.code !== 0) {
+        actions.output(React.createElement(Ink.Text, { color: "#ef4444" }, result.output));
+        actions.set((state) => {
+            state.step = "github-api-error";
+        });
+        throw new Error("Unable to fetch PR status");
+    }
+    const cache = state.pr[branch];
+    if (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: "#22c55e" }, "HIT "),
+            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 pr = JSON.parse(result.stdout);
+    actions.set((state) => {
+        state.pr[pr.headRefName] = pr;
+    });
+    return pr;
+}
+export async function pr_create(branch, base) {
+    await cli(`gh pr create --fill --head ${branch} --base ${base}`);
+}
+export async function pr_base(branch, base) {
+    await cli(`gh pr edit ${branch} --base ${base}`);
+}

package/dist/core/invariant.js

@@ -0,0 +1,5 @@
+export function invariant(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}

package/dist/core/is_command_available.js

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import path from "node:path";
+import { invariant } from "./invariant.js";
+export function is_command_available(command) {
+    const PATH = process.env["PATH"];
+    invariant(PATH, "PATH env must exist");
+    const path_list = PATH.split(path.delimiter);
+    for (const dir of path_list) {
+        const full_path = path.join(dir, command);
+        if (fs.existsSync(full_path)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/core/json.js

@@ -0,0 +1,35 @@
+export function serialize(obj) {
+    if (obj instanceof Map) {
+        return {
+            _type: "Map",
+            _value: Array.from(obj.entries()).map(([k, v]) => [k, serialize(v)]),
+        };
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(serialize);
+    }
+    else if (obj !== null && typeof obj === "object") {
+        const serializedObj = {};
+        for (const [key, value] of Object.entries(obj)) {
+            serializedObj[key] = serialize(value);
+        }
+        return serializedObj;
+    }
+    return obj;
+}
+export function deserialize(obj) {
+    if (obj && obj._type === "Map") {
+        return new Map(obj._value.map(([k, v]) => [k, deserialize(v)]));
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(deserialize);
+    }
+    else if (obj !== null && typeof obj === "object") {
+        const deserializedObj = {};
+        for (const [key, value] of Object.entries(obj)) {
+            deserializedObj[key] = deserialize(value);
+        }
+        return deserializedObj;
+    }
+    return obj;
+}

package/dist/core/match_group.js

@@ -0,0 +1,9 @@
+import { invariant } from "./invariant.js";
+export function match_group(value, re, group) {
+    const match = value.match(re);
+    const debug = `[${value}.match(${re})]`;
+    invariant(match?.groups, `match.groups must exist ${debug}`);
+    const result = match?.groups[group];
+    invariant(result, `match.groups must contain [${group}] ${debug}`);
+    return result;
+}