git-stack-cli 2.3.2 → 2.4.1

package/dist/js/index.js

@@ -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;
+}
+function to_number(value) {
+  if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(value);
   }
-  return result.padStart(max_char_size, "=");
+  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) {
@@ -45666,7 +45662,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.2").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.1").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.2",
+  "version": "2.4.1",
   "description": "",
   "author": "magus",
   "license": "MIT",

package/scripts/release-npm.ts

@@ -55,11 +55,6 @@ for (const filepath of package_json.files) {
   }
 }
 
-process.env.GS_RELEASE_NPM = "true";
-console.info("Publishing to NPM requires a one-time password");
-const otp = await input("Enter OTP: ");
-await spawn(["npm", "publish", `--otp=${otp}`]);
-
 process.chdir(REPO_ROOT);
 
 await spawn.sync(`git commit -a -m ${version}`);
@@ -70,6 +65,11 @@ await spawn.sync(`git push`);
 await spawn.sync(`git tag -a ${version} -m ${version}`);
 await spawn.sync(`git push origin ${version}`);
 
+process.env.GS_RELEASE_NPM = "true";
+console.info("Publishing to NPM requires a one-time password");
+const otp = await input("Enter OTP: ");
+await spawn(["npm", "publish", `--otp=${otp}`]);
+
 console.debug();
 console.debug("✅", "published", version);
 console.debug();

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