git-stack-cli 2.3.1 → 2.4.0

package/dist/js/index.js

@@ -32698,34 +32698,34 @@ async function sleep(time) {
 // src/app/Exit.tsx
 function Exit(props) {
   React14.useEffect(() => {
-    handle_exit().catch((err) => {
+    Exit.handle_exit(props).catch((err) => {
       console.error(err);
     });
-    async function handle_exit() {
-      const state = Store.getState();
-      const actions = state.actions;
-      actions.debug(`[Exit] handle_exit ${JSON.stringify(props)}`);
-      let exit_code = props.code;
-      if (state.abort_handler) {
-        exit_code = await state.abort_handler();
-      }
-      if (state.is_dirty_check_stash) {
-        await cli("git stash pop");
-        actions.output(/* @__PURE__ */ React14.createElement(Text, {
-          color: colors.green
-        }, "✅ Changes restored from stash"));
-      }
-      await sleep(1);
-      if (props.clear) {
-        actions.clear();
-      }
-      actions.unmount();
-      process.exitCode = exit_code;
-      process.exit();
-    }
   }, [props.clear, props.code]);
   return null;
 }
+Exit.handle_exit = async function handle_exit(props) {
+  const state = Store.getState();
+  const actions = state.actions;
+  actions.debug(`[Exit] handle_exit ${JSON.stringify(props)}`);
+  let exit_code = props.code;
+  if (state.abort_handler) {
+    exit_code = await state.abort_handler();
+  }
+  if (state.is_dirty_check_stash) {
+    await cli("git stash pop");
+    actions.output(/* @__PURE__ */ React14.createElement(Text, {
+      color: colors.green
+    }, "✅ Changes restored from stash"));
+  }
+  await sleep(1);
+  if (props.clear) {
+    actions.clear();
+  }
+  actions.unmount();
+  process.exitCode = exit_code;
+  process.exit();
+};
 
 // src/app/LogTimestamp.tsx
 var React15 = __toESM(require_react(), 1);
@@ -39153,44 +39153,40 @@ async function run4() {
 // src/core/short_id.ts
 import crypto2 from "node:crypto";
 function short_id() {
-  const timestamp = Date.now();
-  const js_max_bits = 53;
-  const timestamp_bits = Math.floor(Math.log2(timestamp)) + 1;
-  const padding_bits = js_max_bits - timestamp_bits;
-  const random = crypto2.randomInt(0, Math.pow(2, padding_bits));
-  const combined = interleave_bits(timestamp, random);
-  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, b2) {
-  const a_binary = binary(a).split("");
-  const b_binary = binary(b2).split("");
-  while (b_binary.length) {
-    const b_index = rand_index(b_binary);
-    const [selected] = b_binary.splice(b_index, 1);
-    const a_index = rand_index(a_binary);
-    a_binary.splice(a_index, 0, selected);
-  }
-  const a_value = parseInt(a_binary.join(""), 2);
-  return a_value;
-}
-function encode(value) {
-  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);
+  const timestamp = BigInt(Date.now());
+  const random = BigInt(crypto2.randomInt(0, 1 << RANDOM_BITS));
+  const combined = timestamp << BigInt(RANDOM_BITS) | random;
+  const id = encode(combined, ID_LENGTH);
+  return id;
+}
+function encode(value, length) {
   let result = "";
-  while (value > 0) {
-    result = chars[value % chars.length] + result;
-    value = Math.floor(value / chars.length);
+  if (value > 0n) {
+    while (value > 0n) {
+      const digit = to_number(value % BASE);
+      result = CHARS[digit] + result;
+      value /= BASE;
+    }
+  }
+  if (length) {
+    result = result.padStart(length, PAD);
   }
-  return result.padStart(max_char_size, "=");
+  return result;
+}
+function to_number(value) {
+  if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(value);
+  }
+  throw new Error("BigInt value outside safe integer range");
 }
+var CHARS = "-0123456789_abcdefghijklmnopqrstuvwxyz".split("").sort().join("");
+var PAD = CHARS[0];
+var BASE = BigInt(CHARS.length);
+var CHAR_BITS = Math.log2(to_number(BASE));
+var TIMESTAMP_BITS = 53;
+var RANDOM_BITS = 30;
+var ID_BITS = TIMESTAMP_BITS + RANDOM_BITS;
+var ID_LENGTH = Math.ceil(ID_BITS / CHAR_BITS);
 
 // src/commands/Rebase.tsx
 function Rebase(props) {
@@ -39216,7 +39212,7 @@ Rebase.run = async function run5(props) {
     actions.output(/* @__PURE__ */ React34.createElement(Text, {
       color: colors.red
     }, "\uD83D\uDEA8 Abort"));
-    handle_exit();
+    handle_exit2();
     return 19;
   });
   const temp_branch_name = `${branch_name}_${short_id()}`;
@@ -39310,7 +39306,7 @@ Rebase.run = async function run5(props) {
     }
     cli.sync(`pwd`, spawn_options);
   }
-  function handle_exit() {
+  function handle_exit2() {
     actions.output(/* @__PURE__ */ React34.createElement(Text, {
       color: colors.yellow
     }, "Restoring ", /* @__PURE__ */ React34.createElement(Brackets, null, branch_name), "…"));
@@ -39360,7 +39356,7 @@ async function run6() {
     actions.output(/* @__PURE__ */ React36.createElement(Text, {
       color: colors.red
     }, "\uD83D\uDEA8 Abort"));
-    handle_exit();
+    handle_exit2();
     return 15;
   });
   const temp_branch_name = `${branch_name}_${short_id()}`;
@@ -39439,7 +39435,7 @@ async function run6() {
     }
     cli.sync(`pwd`, spawn_options);
   }
-  function handle_exit() {
+  function handle_exit2() {
     actions.output(/* @__PURE__ */ React36.createElement(Text, {
       color: colors.yellow
     }, "Restoring ", /* @__PURE__ */ React36.createElement(Brackets, null, branch_name), "…"));
@@ -40098,8 +40094,7 @@ function SelectCommitRangesInternal(props) {
     let branch_prefix = "";
     if (argv["branch-prefix"]) {
       branch_prefix = argv["branch-prefix"];
-    } else if (process.env.GIT_STACK_BRANCH_PREFIX) {
-      branch_prefix = process.env.GIT_STACK_BRANCH_PREFIX;
+    } else if ("") {
     }
     return `${branch_prefix}${gs_short_id()}`;
   }
@@ -40258,7 +40253,7 @@ async function run9() {
     actions.output(/* @__PURE__ */ React44.createElement(Text, {
       color: colors.red
     }, "\uD83D\uDEA8 Abort"));
-    handle_exit();
+    handle_exit2();
     return 17;
   });
   let DEFAULT_PR_BODY = "";
@@ -40403,7 +40398,7 @@ async function run9() {
       });
     }
   }
-  function handle_exit() {
+  function handle_exit2() {
     actions.output(/* @__PURE__ */ React44.createElement(Text, {
       color: colors.yellow
     }, "Restoring PR state…"));
@@ -40709,7 +40704,9 @@ class ErrorBoundary extends React52.Component {
       component_stack = component_stack.split(`
 `).slice(1).join(`
 `);
-      this.setState({ component_stack });
+      this.setState({ component_stack }, async () => {
+        await Exit.handle_exit({ code: 30, clear: true });
+      });
     }
   }
   render() {
@@ -45664,7 +45661,7 @@ var yargs_default = Yargs;
 
 // src/command.ts
 async function command2() {
-  return yargs_default(hideBin(process.argv)).scriptName("git stack").usage("Usage: git stack [command] [options]").command("$0", "Sync commit ranges to Github", (yargs) => yargs.options(DefaultOptions)).command("fixup [commit]", "Amend staged changes to a specific commit in history", (yargs) => yargs.positional("commit", FixupOptions.commit)).command("log [args...]", "Print an abbreviated log with numbered commits, useful for git stack fixup", (yargs) => yargs.strict(false)).command("rebase", "Update local branch via rebase with latest changes from origin master branch", (yargs) => yargs).option("verbose", GlobalOptions.verbose).wrap(123).strict().version("2.3.1").showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`").help("help", "Show usage via `git stack help`").argv;
+  return yargs_default(hideBin(process.argv)).scriptName("git stack").usage("Usage: git stack [command] [options]").command("$0", "Sync commit ranges to Github", (yargs) => yargs.options(DefaultOptions)).command("fixup [commit]", "Amend staged changes to a specific commit in history", (yargs) => yargs.positional("commit", FixupOptions.commit)).command("log [args...]", "Print an abbreviated log with numbered commits, useful for git stack fixup", (yargs) => yargs.strict(false)).command("rebase", "Update local branch via rebase with latest changes from origin master branch", (yargs) => yargs).option("verbose", GlobalOptions.verbose).wrap(123).strict().version("2.4.0").showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`").help("help", "Show usage via `git stack help`").argv;
 }
 var GlobalOptions = {
   verbose: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "",
   "author": "magus",
   "license": "MIT",

package/src/app/Exit.tsx

@@ -15,44 +15,44 @@ type Props = {
 export function Exit(props: Props) {
   React.useEffect(() => {
     // immediately handle exit on mount
-    handle_exit().catch((err) => {
+    Exit.handle_exit(props).catch((err) => {
       // eslint-disable-next-line no-console
       console.error(err);
     });
+  }, [props.clear, props.code]);
 
-    async function handle_exit() {
-      const state = Store.getState();
-      const actions = state.actions;
+  return null;
+}
 
-      actions.debug(`[Exit] handle_exit ${JSON.stringify(props)}`);
+Exit.handle_exit = async function handle_exit(props: Props) {
+  const state = Store.getState();
+  const actions = state.actions;
 
-      let exit_code = props.code;
+  actions.debug(`[Exit] handle_exit ${JSON.stringify(props)}`);
 
-      // run abort_handler if it exists
-      if (state.abort_handler) {
-        exit_code = await state.abort_handler();
-      }
+  let exit_code = props.code;
 
-      // restore git stash if necessary
-      if (state.is_dirty_check_stash) {
-        await cli("git stash pop");
-        actions.output(<Ink.Text color={colors.green}>✅ Changes restored from stash</Ink.Text>);
-      }
+  // run abort_handler if it exists
+  if (state.abort_handler) {
+    exit_code = await state.abort_handler();
+  }
 
-      // ensure output has a chance to render
-      await sleep(1);
+  // restore git stash if necessary
+  if (state.is_dirty_check_stash) {
+    await cli("git stash pop");
+    actions.output(<Ink.Text color={colors.green}>✅ Changes restored from stash</Ink.Text>);
+  }
 
-      // finally handle the actual app and process exit
-      if (props.clear) {
-        actions.clear();
-      }
+  // ensure output has a chance to render
+  await sleep(1);
 
-      actions.unmount();
+  // finally handle the actual app and process exit
+  if (props.clear) {
+    actions.clear();
+  }
 
-      process.exitCode = exit_code;
-      process.exit();
-    }
-  }, [props.clear, props.code]);
+  actions.unmount();
 
-  return null;
-}
+  process.exitCode = exit_code;
+  process.exit();
+};

package/src/components/ErrorBoundary.tsx

@@ -3,6 +3,7 @@ import * as React from "react";
 
 import * as Ink from "ink-cjs";
 
+import { Exit } from "~/app/Exit";
 import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import { colors } from "~/core/colors";
@@ -36,7 +37,9 @@ export class ErrorBoundary extends React.Component<Props, State> {
     if (component_stack) {
       // remove first line of component_stack
       component_stack = component_stack.split("\n").slice(1).join("\n");
-      this.setState({ component_stack });
+      this.setState({ component_stack }, async () => {
+        await Exit.handle_exit({ code: 30, clear: true });
+      });
     }
   }
 

package/src/core/short_id.test.ts

@@ -0,0 +1,30 @@
+import { test, expect } from "bun:test";
+
+import { short_id } from "~/core/short_id";
+
+const GENERATE_COUNT = 1000;
+
+test("short_id is 15 characters", () => {
+  const id = short_id();
+  expect(id.length).toBe(16);
+});
+
+test("unique enough in practice", () => {
+  const id_set = new Set();
+  for (let i = 0; i < GENERATE_COUNT; i++) {
+    const id = short_id();
+    id_set.add(id);
+  }
+
+  expect(id_set.size).toBe(GENERATE_COUNT);
+});
+
+test("sorts lexicographically", () => {
+  const id_list = [];
+  for (let i = 0; i < GENERATE_COUNT; i++) {
+    const id = short_id();
+    id_list.push(id);
+  }
+
+  expect(id_list.sort()).toEqual(id_list);
+});

package/src/core/short_id.ts

@@ -1,87 +1,70 @@
 import crypto from "node:crypto";
 
 export function short_id() {
-  const timestamp = Date.now();
+  // wall-clock milliseconds
+  const timestamp = BigInt(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;
+  // random int value between 0 and 2^RANDOM_BITS - 1
+  const random = BigInt(crypto.randomInt(0, 1 << RANDOM_BITS));
 
-  const timestamp_bits = Math.floor(Math.log2(timestamp)) + 1;
+  // concatenate timestamp (high bits) and random value
+  const combined = (timestamp << BigInt(RANDOM_BITS)) | random;
 
-  // padding needed to reach 53 bits
-  const padding_bits = js_max_bits - timestamp_bits;
+  const id = encode(combined, ID_LENGTH);
 
-  // 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: number) {
-  return BigInt(value).toString(2);
+  // console.debug({ id, timestamp, random, combined });
+  return id;
 }
 
-function rand_index(list: Array<any>) {
-  return Math.floor(Math.random() * list.length);
-}
-
-function interleave_bits(a: number, b: number) {
-  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
+// converting value into base based on available chars
+function encode(value: bigint, length?: number) {
+  let result = "";
 
-    const a_index = rand_index(a_binary);
+  // avoid zero division
+  if (value > 0n) {
+    while (value > 0n) {
+      // convert least significant digit
+      const digit = to_number(value % BASE);
+      result = CHARS[digit] + result;
 
-    a_binary.splice(a_index, 0, selected);
+      // drop the digit we just divided by
+      value /= BASE;
+    }
   }
 
-  // convert binary list back to integer
-
-  const a_value = parseInt(a_binary.join(""), 2);
+  // left pad with 0 to guarantee chars
+  if (length) {
+    result = result.padStart(length, PAD);
+  }
 
-  return a_value;
+  return result;
 }
 
-function encode(value: number) {
-  // 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);
+function to_number(value: bigint) {
+  if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(value);
   }
 
-  // pad the result to necessary characters
-  return result.padStart(max_char_size, "=");
+  throw new Error("BigInt value outside safe integer range");
 }
+
+// valid characters to use for the short id
+// use only lowercase letters and numbers to avoid
+// confusing file system issues with git branch names
+const CHARS = "-0123456789_abcdefghijklmnopqrstuvwxyz".split("").sort().join("");
+const PAD = CHARS[0];
+const BASE = BigInt(CHARS.length);
+// bits carried by each char log2(BASE) ≈ 5.32
+const CHAR_BITS = Math.log2(to_number(BASE));
+
+// javascript Date.now returns a Number that will overflow eventually
+// 2^53 max integer, overflows in 2^53 milliseconds (285_616 years)
+// (1n<<53n) / 1_000n / 60n / 60n / 24n / 365n ≈ 285616n
+const TIMESTAMP_BITS = 53;
+
+// collision probability for identical timestamps (milliseconds)
+// ≈ 1 / 2^30 ≈ 1 / 1_073_741_824 (1.1 billion)
+const RANDOM_BITS = 30;
+
+const ID_BITS = TIMESTAMP_BITS + RANDOM_BITS;
+const ID_LENGTH = Math.ceil(ID_BITS / CHAR_BITS);