git-stack-cli 0.8.2 → 0.8.4

package/dist/core/Metadata copy.js

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

package/dist/core/StackTable.js

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

package/dist/core/SummaryTable.js

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

package/dist/core/ZustandStore.js

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

package/dist/core/cli copy.js

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

package/dist/core/color.js

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

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/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/invariant copy.js

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

package/dist/core/isFiniteValue.js

@@ -0,0 +1,3 @@
+export function isFiniteValue(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}

package/dist/core/is_dev.js

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

package/dist/core/readJson.js

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

package/dist/core/serialize_json.js

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

package/dist/core/sleep copy.js

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