@xuhaojun/githunk 0.1.3 → 0.3.0

package/README.md

@@ -5,19 +5,40 @@ A review-first Git TUI that mixes [lazygit](https://github.com/jesseduffield/laz
 
 ## Install
 
+No Node.js required — githunk ships as a standalone binary:
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/XuHaoJun/githunk/main/install.sh | sh
+```
+
+This installs the newest release into `~/.local/bin` (or `$XDG_BIN_HOME`, or `$GITHUNK_INSTALL_DIR`), verifying its checksum first. Pin a version with `sh -s -- 0.2.0`, or pass `--no-modify-path` to skip shell-startup PATH wiring. macOS and Linux only.
+
+Alternative via npm (needs Node.js 26.1.0 or newer just to install):
+
 ```sh
 npm install --global @xuhaojun/githunk
 ```
 
 ## Requirements
 
-- Node.js 26.1.0 or newer
 - Git
 - A terminal with interactive TUI support
 
 `gh` is optional. When it is installed and authenticated, githunk can show GitHub pull-request status; local Git review works without it.
 
-The installed launcher enables Node's experimental FFI support automatically for OpenTUI.
+The launcher prefers the prebuilt binary. On platforms without one it falls back to the Node.js bundle, which needs Node.js 26.1.0 or newer; the launcher enables Node's experimental FFI support automatically for OpenTUI.
+
+## Update
+
+```sh
+githunk update            # newest release
+githunk update 0.3.0      # a specific version
+githunk update --check    # report without installing
+```
+
+Standalone installs replace their own binary after checksum verification. npm installs update through npm instead: `npm update --global @xuhaojun/githunk`.
+
+Installer knobs: `GITHUNK_VERSION` pins the version, `GITHUNK_INSTALL_DIR` overrides the install directory, `GITHUNK_NO_MODIFY_PATH=1` skips shell-startup PATH wiring.
 
 ## Usage
 

package/bin/githunk.js

@@ -1,23 +1,95 @@
 #!/usr/bin/env node
 
+// githunk launcher: prefer the prebuilt standalone binary installed as an
+// optional platform package, and fall back to the Node bundle otherwise.
+//
+// npm installs only the optional dependency whose `os`/`cpu` matches this
+// machine, so the binary usually lives at
+// `<install-root>/node_modules/@xuhaojun/githunk-<os>-<arch>/bin/githunk`.
+// The lookup walks up from this file (the hunk `findInstalledBinary` shape in
+// `learn-projects/hunk/bin/hunk.cjs`), which keeps working no matter which
+// Node version owns the invoking shell: the prebuilt binary embeds its own
+// Bun runtime and takes no `--experimental-ffi` flag. `$GITHUNK_BIN_PATH`
+// overrides everything for debugging and custom installs.
+
 import { spawn } from "node:child_process"
+import { existsSync, realpathSync } from "node:fs"
 import { constants } from "node:os"
+import { dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
 
-const cliPath = fileURLToPath(new URL("../dist/githunk.js", import.meta.url))
-const child = spawn(process.execPath, ["--experimental-ffi", cliPath, ...process.argv.slice(2)], {
-  stdio: "inherit",
-})
+const PLATFORM_PACKAGES = [
+  { packageName: "@xuhaojun/githunk-darwin-arm64", binary: "bin/githunk" },
+  { packageName: "@xuhaojun/githunk-darwin-x64", binary: "bin/githunk" },
+  { packageName: "@xuhaojun/githunk-linux-arm64", binary: "bin/githunk" },
+  { packageName: "@xuhaojun/githunk-linux-x64", binary: "bin/githunk" },
+  { packageName: "@xuhaojun/githunk-windows-x64", binary: "bin/githunk.exe" },
+]
+
+function hostCandidates() {
+  const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+  }
+  const archMap = {
+    x64: "x64",
+    arm64: "arm64",
+  }
+  const platform = platformMap[process.platform]
+  const arch = archMap[process.arch]
+  if (platform === undefined || arch === undefined) return []
+  return PLATFORM_PACKAGES.filter((candidate) => candidate.packageName === `@xuhaojun/githunk-${platform}-${arch}`)
+}
+
+/** Find the prebuilt binary installed next to this package, walking up past nested installs. */
+function findInstalledBinary(startDir) {
+  let current = startDir
+  for (;;) {
+    const modulesDir = join(current, "node_modules")
+    for (const candidate of hostCandidates()) {
+      const resolved = join(modulesDir, ...candidate.packageName.split("/"), candidate.binary)
+      if (existsSync(resolved)) return resolved
+    }
+    const parent = dirname(current)
+    if (parent === current) return null
+    current = parent
+  }
+}
+
+function launch(target, args) {
+  const child = spawn(target, args, { stdio: "inherit" })
 
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"]) {
-  process.once(signal, () => { child.kill(signal) })
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"]) {
+    process.once(signal, () => { child.kill(signal) })
+  }
+
+  child.once("error", (error) => {
+    process.stderr.write(`githunk: failed to start: ${error instanceof Error ? error.message : String(error)}\n`)
+    process.exitCode = 1
+  })
+  child.once("close", (exitCode, signal) => {
+    const signalNumber = signal === null ? undefined : constants.signals[signal]
+    process.exitCode = exitCode ?? (signalNumber === undefined ? 1 : 128 + signalNumber)
+  })
 }
 
-child.once("error", (error) => {
-  process.stderr.write(`githunk: failed to start: ${error instanceof Error ? error.message : String(error)}\n`)
-  process.exitCode = 1
-})
-child.once("close", (exitCode, signal) => {
-  const signalNumber = signal === null ? undefined : constants.signals[signal]
-  process.exitCode = exitCode ?? (signalNumber === undefined ? 1 : 128 + signalNumber)
-})
+const forwardedArgs = process.argv.slice(2)
+const overrideBinary = process.env.GITHUNK_BIN_PATH
+if (typeof overrideBinary === "string" && overrideBinary !== "") {
+  launch(overrideBinary, forwardedArgs)
+} else {
+  let scriptDir = dirname(fileURLToPath(import.meta.url))
+  try {
+    scriptDir = realpathSync(scriptDir)
+  } catch {
+    // Unresolved symlinks just start the walk from the literal directory.
+  }
+  const prebuiltBinary = findInstalledBinary(scriptDir)
+  if (prebuiltBinary !== null) {
+    launch(prebuiltBinary, forwardedArgs)
+  } else {
+    const cliPath = fileURLToPath(new URL("../dist/githunk.js", import.meta.url))
+    launch(process.execPath, ["--experimental-ffi", cliPath, ...forwardedArgs])
+  }
+}

package/dist/githunk.js

@@ -1,36 +1,95 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import { spawnSync } from "node:child_process";
+import { chmodSync, cpSync, mkdtempSync, renameSync, rmSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join6 } from "node:path";
+
 // src/cli/args.ts
 import { Command, CommanderError } from "commander";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-var cachedVersion;
-function getCliVersion() {
-  if (cachedVersion !== undefined)
-    return cachedVersion;
-  let directory = dirname(fileURLToPath(import.meta.url));
-  for (let level = 0;level < 4; level += 1) {
-    try {
-      const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
-      if (manifest.name === "@xuhaojun/githunk" && typeof manifest.version === "string") {
-        cachedVersion = manifest.version;
-        return cachedVersion;
-      }
-    } catch {}
-    const parent = dirname(directory);
-    if (parent === directory)
-      break;
-    directory = parent;
+// package.json
+var package_default = {
+  name: "@xuhaojun/githunk",
+  version: "0.3.0",
+  description: "A review-first Git TUI combining lazygit's everyday Git workflow with focused hunk review.",
+  type: "module",
+  bin: {
+    githunk: "bin/githunk.js"
+  },
+  files: [
+    "bin",
+    "dist/githunk.js",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    start: "bun run src/main.ts",
+    dev: "bun --watch src/main.ts",
+    build: "bun build src/cli.ts --target=node --format=esm --packages=external --outfile=dist/githunk.js --banner '#!/usr/bin/env node'",
+    "build:bin": "bun run ./scripts/build-bin.ts",
+    "build:prebuilt:artifact": "bun run ./scripts/build-prebuilt-artifact.ts",
+    "stage:prebuilt:release": "bun run ./scripts/stage-prebuilt-npm.ts --artifact-root ./dist/release/artifacts",
+    "check:release-version": "bun run ./scripts/check-release-version.ts",
+    "check:prebuilt-pack": "bun run ./scripts/check-prebuilt-pack.ts",
+    "publish:prebuilt:npm": "bun run ./scripts/publish-prebuilt-npm.ts",
+    "smoke:prebuilt-install": "bun run ./scripts/smoke-prebuilt-install.ts",
+    prepack: "bun run build",
+    "pack:check": "npm pack --dry-run",
+    "spike:selection": "bun run spikes/selection/src/main.ts",
+    test: "bun test --path-ignore-patterns='learn-projects/**'",
+    typecheck: "tsc --noEmit",
+    check: "bun run typecheck && bun run test",
+    "bench:review-load": "bun run benchmarks/review-document-load.ts",
+    "bench:review-rows": "bun run benchmarks/review-row-plan.ts",
+    "bench:review-reconcile": "bun run benchmarks/review-reconcile.ts"
+  },
+  keywords: [
+    "git",
+    "tui",
+    "code-review",
+    "cli"
+  ],
+  homepage: "https://github.com/XuHaoJun/githunk#readme",
+  bugs: {
+    url: "https://github.com/XuHaoJun/githunk/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/XuHaoJun/githunk.git"
+  },
+  license: "MIT",
+  engines: {
+    node: ">=26.1.0"
+  },
+  packageManager: "bun@1.4.0",
+  publishConfig: {
+    access: "public"
+  },
+  dependencies: {
+    "@opentui/core": "0.5.10",
+    "@opentui/react": "0.5.10",
+    "@pierre/diffs": "1.3.5",
+    commander: "^15.0.0",
+    react: "19.2.8",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@types/bun": "1.4.0",
+    "@types/react": "19.2.8",
+    typescript: "5.9.2"
   }
-  cachedVersion = "0.0.0-dev";
-  return cachedVersion;
-}
+};
+
+// src/cli/args.ts
+var cliVersion = typeof package_default.version === "string" && package_default.version !== "" ? package_default.version : "0.0.0-dev";
 function parseCliArgs(argv) {
   let stdout = "";
   let stderr = "";
+  let update;
   const program = new Command;
-  program.name("githunk").description("A review-first Git TUI combining lazygit's everyday Git workflow with focused hunk review.").version(getCliVersion(), "-V, --version", "output the version number").option("-p, --path <dir>", "path to the Git repository to open").argument("[path]", "path to the Git repository to open").exitOverride().configureOutput({
+  program.name("githunk").description("A review-first Git TUI combining lazygit's everyday Git workflow with focused hunk review.").version(cliVersion, "-V, --version", "output the version number").option("-p, --path <dir>", "path to the Git repository to open").argument("[path]", "path to the Git repository to open").exitOverride().action(() => {}).configureOutput({
     writeOut: (text) => {
       stdout += text;
     },
@@ -38,6 +97,12 @@ function parseCliArgs(argv) {
       stderr += text;
     }
   });
+  program.command("update").description("update githunk to the newest (or a given) release").argument("[version]", "version to install; the newest release when omitted").option("--check", "report the installed and available versions without installing").action((version, options2) => {
+    update = {
+      ...version === undefined ? {} : { version },
+      check: options2.check ?? false
+    };
+  });
   try {
     program.parse([...argv], { from: "user" });
   } catch (error) {
@@ -51,12 +116,91 @@ function parseCliArgs(argv) {
     }
     throw error;
   }
+  if (update !== undefined)
+    return { kind: "update", ...update };
   const options = program.opts();
   const positional = program.args[0];
   const startDirectory = options.path ?? positional;
   return startDirectory === undefined ? { kind: "start" } : { kind: "start", startDirectory };
 }
 
+// src/cli/update.ts
+import { createHash } from "node:crypto";
+import { basename, join } from "node:path";
+function assetNameFor(platform, arch) {
+  const osToken = platform === "linux" ? "linux" : platform === "darwin" ? "darwin" : platform === "win32" ? "windows" : null;
+  const archToken = arch === "x64" ? "x64" : arch === "arm64" ? "arm64" : null;
+  if (osToken === null || archToken === null)
+    return null;
+  if (osToken === "windows" && archToken !== "x64")
+    return null;
+  return `githunk-${osToken}-${archToken}.tar.gz`;
+}
+function normalizeVersion(version) {
+  return version.trim().replace(/^v/, "");
+}
+function compareVersions(left, right) {
+  const parts = (version) => {
+    const [major = "0", minor = "0", patch = "0"] = normalizeVersion(version).split(".");
+    return [Number(major) || 0, Number(minor) || 0, Number(patch) || 0];
+  };
+  const [aMajor, aMinor, aPatch] = parts(left);
+  const [bMajor, bMinor, bPatch] = parts(right);
+  return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
+}
+function isSelfManagedBinary(executablePath) {
+  const base = basename(executablePath);
+  return base === "githunk" || base === "githunk.exe";
+}
+function verifyChecksum(tarball, checksums, asset) {
+  const actual = createHash("sha256").update(tarball).digest("hex");
+  const line = checksums.split(`
+`).map((entry) => entry.trim().split(/\s+/)).find((fields) => fields[fields.length - 1] === asset);
+  const expected = line?.[0];
+  if (expected === undefined || expected === "" || expected.toLowerCase() !== actual) {
+    throw new Error(`checksum mismatch for ${asset}`);
+  }
+}
+async function applyUpdate(target, asset, env) {
+  await env.withTempDir(async (dir) => {
+    const { tarball, checksums } = await env.fetchAsset(`v${target}`, asset);
+    verifyChecksum(tarball, checksums, asset);
+    const archivePath = join(dir, asset);
+    await env.writeFile(archivePath, tarball);
+    await env.extractTarball(archivePath, dir);
+    await env.writeBinary(env.stagedBinary(dir), env.executablePath);
+  });
+}
+async function runUpdate(request, env) {
+  try {
+    if (!isSelfManagedBinary(env.executablePath)) {
+      return {
+        exitCode: 1,
+        message: "githunk was installed via npm — update it with `npm update --global @xuhaojun/githunk`"
+      };
+    }
+    const asset = assetNameFor(env.platform, env.arch);
+    if (asset === null) {
+      return {
+        exitCode: 1,
+        message: `no prebuilt githunk binary ships for ${env.platform}-${env.arch} — install with \`npm install -g @xuhaojun/githunk\``
+      };
+    }
+    const current = normalizeVersion(env.installedVersion());
+    const target = normalizeVersion(request.version ?? normalizeVersion(await env.fetchReleaseTag()));
+    if (compareVersions(target, current) === 0) {
+      return { exitCode: 0, message: `githunk ${current} is already up to date` };
+    }
+    if (request.check) {
+      return { exitCode: 0, message: `update available: ${current} -> ${target}` };
+    }
+    await applyUpdate(target, asset, env);
+    return { exitCode: 0, message: `updated githunk ${current} -> ${target}` };
+  } catch (error) {
+    return { exitCode: 1, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
 // src/main.ts
 import { resolve as resolve4 } from "node:path";
 import { createCliRenderer } from "@opentui/core";
@@ -940,12 +1084,12 @@ function reviewStateFor(record, currentFingerprint) {
 }
 
 // src/review/working-tree-fingerprint.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function utf8(value) {
   return new TextEncoder().encode(value);
 }
 function sha256Tuple(parts) {
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const part of parts) {
     const bytes = utf8(part);
     const length = Buffer.allocUnsafe(4);
@@ -978,7 +1122,7 @@ function fingerprintWorkingTreeFile(target, filePatch) {
 
 // src/storage/local-state-file.ts
 import { mkdir, open, rename, stat, unlink, lstat, link, readFile } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute, join as join2, resolve } from "node:path";
+import { dirname, isAbsolute, join as join2, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 async function assertNoSymlinkInPath(path, pathKind) {
   const absolute = resolve(path);
@@ -1033,7 +1177,7 @@ class LocalStateFile {
   async writeText(text) {
     const path = await this.resolvePath();
     await assertNoSymlinkInPath(path, this.pathKind);
-    await mkdir(dirname2(path), { recursive: true, mode: 448 });
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
     const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
     await assertNoSymlinkInPath(temporary, this.pathKind);
     const handle = await open(temporary, "wx", 384);
@@ -1046,7 +1190,7 @@ class LocalStateFile {
     }
     await rename(temporary, path);
     try {
-      const directory = await open(dirname2(path), "r");
+      const directory = await open(dirname(path), "r");
       try {
         await directory.sync();
       } finally {
@@ -1070,7 +1214,7 @@ class LocalStateFile {
   async createTextExclusive(text) {
     const path = await this.resolvePath();
     await assertNoSymlinkInPath(path, this.pathKind);
-    await mkdir(dirname2(path), { recursive: true, mode: 448 });
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
     const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
     await assertNoSymlinkInPath(temporary, this.pathKind);
     const handle = await open(temporary, "wx", 384);
@@ -1099,7 +1243,7 @@ class LocalStateFile {
       return;
     });
     try {
-      const directory = await open(dirname2(path), "r");
+      const directory = await open(dirname(path), "r");
       try {
         await directory.sync();
       } finally {
@@ -1925,7 +2069,7 @@ function validateUpstream(upstream) {
     throw new Error("invalid upstream choice");
   }
 }
-async function fetch(runner, remote, options = {}) {
+async function fetch2(runner, remote, options = {}) {
   await runner.run(remote === undefined ? ["fetch"] : ["fetch", remote], options.background === true ? { dontLog: true } : { streamOutput: true });
 }
 async function pull(runner, options = {}) {
@@ -2134,7 +2278,7 @@ async function listReflog(runner, options = {}) {
 
 // src/git/worktrees.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 function finalizeEntry(entry) {
   return {
     path: entry.path,
@@ -2236,7 +2380,7 @@ async function resolveRepositoryPaths(runner) {
   const worktreeGitDirPath = lines[1] ?? "";
   const repoGitDirPath = lines[2] ?? "";
   const isSubmodule = (lines[3] ?? "").length > 0;
-  const repoPath = worktreeGitDirPath === repoGitDirPath || isSubmodule ? worktreePath : dirname3(repoGitDirPath);
+  const repoPath = worktreeGitDirPath === repoGitDirPath || isSubmodule ? worktreePath : dirname2(repoGitDirPath);
   return { worktreePath, worktreeGitDirPath, repoPath, repoGitDirPath };
 }
 async function isPathMissing(path) {
@@ -2890,7 +3034,7 @@ class AppController {
       return;
     if (options.background !== true)
       this.logAction(LOG_ACTIONS.fetch);
-    await this.runMutation(() => this.requireRunnerOperation((runner) => fetch(runner, remote, options)));
+    await this.runMutation(() => this.requireRunnerOperation((runner) => fetch2(runner, remote, options)));
   }
   async pull(options = {}) {
     if (!this.ensureWorkingTreeMutation())
@@ -5884,7 +6028,7 @@ function commitGraphRows(commits, getColor) {
 }
 
 // src/ui/author-style.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 var initialsCache = new Map;
 var colorCache = new Map;
 function randInt(bytes, max) {
@@ -5925,7 +6069,7 @@ function authorColor(authorName) {
   const cached = colorCache.get(authorName);
   if (cached !== undefined)
     return cached;
-  const hash = new Uint8Array(createHash2("md5").update(authorName).digest());
+  const hash = new Uint8Array(createHash3("md5").update(authorName).digest());
   const color = hslToHex(randFloat(hash.slice(0, 4)) * 360, 0.6 + 0.4 * randFloat(hash.slice(4, 8)), 0.4 + 0.2 * randFloat(hash.slice(8, 12)));
   colorCache.set(authorName, color);
   return color;
@@ -15418,7 +15562,7 @@ async function loadRefsSnapshot(runner) {
 }
 
 // src/git/editor.ts
-import { join as join5, basename } from "node:path";
+import { join as join5, basename as basename2 } from "node:path";
 function standardTerminalPreset(editor) {
   return {
     edit: `${editor} -- {{filename}}`,
@@ -15511,13 +15655,13 @@ function resolvePlaceholders(template, values) {
 }
 function guessEditorBase(env, gitEditor) {
   if (env.GITHUNK_EDITOR !== undefined && env.GITHUNK_EDITOR.trim().length > 0)
-    return basename(env.GITHUNK_EDITOR.split(" ")[0].trim());
+    return basename2(env.GITHUNK_EDITOR.split(" ")[0].trim());
   if (gitEditor !== undefined && gitEditor.trim().length > 0)
-    return basename(gitEditor.split(" ")[0].trim());
+    return basename2(gitEditor.split(" ")[0].trim());
   for (const key of ["GIT_EDITOR", "VISUAL", "EDITOR"]) {
     const value = env[key];
     if (value !== undefined && value.trim().length > 0)
-      return basename(value.split(" ")[0].trim());
+      return basename2(value.split(" ")[0].trim());
   }
   return "vi";
 }
@@ -15564,7 +15708,7 @@ import { isAbsolute as isAbsolute2, resolve as resolve3 } from "node:path";
 
 // src/app/index-watcher.ts
 import { watch, statSync } from "node:fs";
-import { basename as basename2, dirname as dirname4 } from "node:path";
+import { basename as basename3, dirname as dirname3 } from "node:path";
 var DEFAULT_INDEX_EVENT_DEBOUNCE_MS = 50;
 var BUSY_RETRY_MS = 50;
 function fingerprint(path) {
@@ -15594,7 +15738,7 @@ class IndexWatcher {
   stopped = true;
   constructor(options) {
     this.options = options;
-    this.indexName = basename2(options.indexPath);
+    this.indexName = basename3(options.indexPath);
     this.lockName = `${this.indexName}.lock`;
     this.debounceMs = options.debounceMs ?? DEFAULT_INDEX_EVENT_DEBOUNCE_MS;
     this.baseline = undefined;
@@ -15605,7 +15749,7 @@ class IndexWatcher {
     this.stopped = false;
     this.baseline = fingerprint(this.options.indexPath);
     try {
-      const watcher = watch(dirname4(this.options.indexPath), { persistent: false }, (_eventType, filename) => {
+      const watcher = watch(dirname3(this.options.indexPath), { persistent: false }, (_eventType, filename) => {
         if (this.stopped)
           return;
         const name = eventFileName(filename);
@@ -16271,7 +16415,7 @@ function reviewHelp(focus, state) {
 }
 
 // src/ui/review-workspace/review-sidebar.ts
-import { basename as basename3, dirname as dirname5 } from "node:path/posix";
+import { basename as basename4, dirname as dirname4 } from "node:path/posix";
 function normalizeDiffPath(p) {
   return p?.replace(/[\r\n]+$/u, "");
 }
@@ -16300,10 +16444,10 @@ function sidebarFileName(file) {
   const path = formatTerminalPath(normalizeDiffPath(file.path) ?? file.path);
   const previousPath = file.previousPath ? formatTerminalPath(normalizeDiffPath(file.previousPath) ?? file.previousPath) : undefined;
   if (previousPath === undefined || previousPath === path) {
-    return basename3(path);
+    return basename4(path);
   }
-  const previousName = basename3(previousPath);
-  const nextName = basename3(path);
+  const previousName = basename4(previousPath);
+  const nextName = basename4(path);
   return previousName === nextName ? nextName : `${previousName} -> ${nextName}`;
 }
 function formatSidebarStat(prefix, value, truncated = false) {
@@ -16357,7 +16501,7 @@ function buildReviewSidebarEntries(state) {
   let activeGroup;
   visible.forEach((file, index) => {
     const path = formatTerminalPath(normalizeDiffPath(file.path) ?? file.path);
-    const group = dirname5(path);
+    const group = dirname4(path);
     if (group !== activeGroup) {
       activeGroup = group;
       entries.push({
@@ -17549,9 +17693,9 @@ function syntaxThemeForAppearance(appearance) {
 import { parsePatchFiles as parsePatchFiles2 } from "@pierre/diffs";
 
 // src/review/core/identity.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function sha256Tuple2(parts) {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   for (const part of parts) {
     const bytes = new TextEncoder().encode(part);
     const length = Buffer.alloc(4);
@@ -21873,7 +22017,7 @@ class AppScreenController {
 }
 
 // src/ui/review-workspace/controller.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // src/review/core/state.ts
 function createInitialReviewState(document) {
@@ -23303,12 +23447,12 @@ function persistedFromReviewState(state) {
 }
 
 // src/review/storage/review-artifact-store.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function artifactRelativePath(reviewId, artifactId) {
   return `githunk/reviews/${reviewId}/${artifactId}.json`;
 }
 function artifactDigest(text) {
-  return createHash4("sha256").update(text, "utf8").digest("hex");
+  return createHash5("sha256").update(text, "utf8").digest("hex");
 }
 function artifactText(artifact) {
   return serializeReviewArtifactV1(artifact) + `
@@ -23817,7 +23961,7 @@ class ReviewWorkspaceController {
         artifactIdFromMarker = marker.artifactId;
         const raw = await this.artifactStore.readRaw(reviewId, marker.artifactId);
         if (raw !== undefined) {
-          const digest = createHash5("sha256").update(raw, "utf8").digest("hex");
+          const digest = createHash6("sha256").update(raw, "utf8").digest("hex");
           if (digest === marker.digest) {
             const parsed = JSON.parse(raw);
             const res = parseReviewArtifactV1(parsed);
@@ -24841,6 +24985,64 @@ ${detail}
 if (false) {}
 
 // src/cli.ts
+var RELEASES_API = "https://api.github.com/repos/XuHaoJun/githunk/releases/latest";
+var DOWNLOAD_BASE = "https://github.com/XuHaoJun/githunk/releases/download";
+async function fetchText(url) {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`request failed: ${url} (${response.status})`);
+  return response.text();
+}
+async function fetchBytes(url) {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`request failed: ${url} (${response.status})`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+function productionUpdateEnv() {
+  return {
+    executablePath: process.execPath,
+    platform: process.platform,
+    arch: process.arch,
+    installedVersion: () => {
+      const proc = spawnSync(process.execPath, ["--version"], { encoding: "utf8" });
+      if (proc.status !== 0)
+        throw new Error("could not read the installed version");
+      return proc.stdout.trim();
+    },
+    fetchReleaseTag: async () => {
+      const payload = JSON.parse(await fetchText(RELEASES_API));
+      const tag = typeof payload === "object" && payload !== null && "tag_name" in payload ? payload.tag_name : undefined;
+      if (typeof tag !== "string" || tag === "")
+        throw new Error("could not read the newest release");
+      return tag;
+    },
+    fetchAsset: async (tag, asset) => ({
+      tarball: await fetchBytes(`${DOWNLOAD_BASE}/${tag}/${asset}`),
+      checksums: await fetchText(`${DOWNLOAD_BASE}/${tag}/SHA256SUMS`)
+    }),
+    withTempDir: async (run) => {
+      const dir = mkdtempSync(join6(tmpdir(), "githunk-update-"));
+      try {
+        return await run(dir);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    },
+    writeFile: (path, data) => writeFile(path, data),
+    extractTarball: async (archivePath, destDir) => {
+      const proc = spawnSync("tar", ["-xzf", archivePath, "-C", destDir]);
+      if (proc.status !== 0)
+        throw new Error("could not extract the release archive (need tar on PATH)");
+    },
+    stagedBinary: (dir) => join6(dir, `githunk-${process.platform === "win32" ? "windows" : process.platform}-${process.arch === "arm64" ? "arm64" : "x64"}`, process.platform === "win32" ? "githunk.exe" : "githunk"),
+    writeBinary: async (stagedPath, destPath) => {
+      cpSync(stagedPath, `${destPath}.new`);
+      chmodSync(`${destPath}.new`, 493);
+      renameSync(`${destPath}.new`, destPath);
+    }
+  };
+}
 var result = parseCliArgs(process.argv.slice(2));
 if (result.kind === "help" || result.kind === "version") {
   process.stdout.write(result.text.endsWith(`
@@ -24852,6 +25054,13 @@ if (result.kind === "help" || result.kind === "version") {
 `) ? result.message : `${result.message}
 `);
   process.exitCode = result.exitCode;
+} else if (result.kind === "update") {
+  const outcome = await runUpdate({ ...result.version === undefined ? {} : { version: result.version }, check: result.check }, productionUpdateEnv());
+  const stream = outcome.exitCode === 0 ? process.stdout : process.stderr;
+  stream.write(outcome.message.endsWith(`
+`) ? outcome.message : `${outcome.message}
+`);
+  process.exitCode = outcome.exitCode;
 } else {
   process.exitCode = await startApp(result.startDirectory === undefined ? {} : { startDirectory: result.startDirectory });
 }

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@xuhaojun/githunk",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "A review-first Git TUI combining lazygit's everyday Git workflow with focused hunk review.",
-  "type": "module",
   "bin": {
     "githunk": "bin/githunk.js"
   },
@@ -12,42 +11,24 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "start": "bun run src/main.ts",
-    "dev": "bun --watch src/main.ts",
-    "build": "bun build src/cli.ts --target=node --format=esm --packages=external --outfile=dist/githunk.js --banner '#!/usr/bin/env node'",
-    "prepack": "bun run build",
-    "pack:check": "npm pack --dry-run",
-    "spike:selection": "bun run spikes/selection/src/main.ts",
-    "test": "bun test --path-ignore-patterns='learn-projects/**'",
-    "typecheck": "tsc --noEmit",
-    "check": "bun run typecheck && bun run test",
-    "bench:review-load": "bun run benchmarks/review-document-load.ts",
-    "bench:review-rows": "bun run benchmarks/review-row-plan.ts",
-    "bench:review-reconcile": "bun run benchmarks/review-reconcile.ts"
-  },
+  "type": "module",
   "keywords": [
     "git",
     "tui",
     "code-review",
     "cli"
   ],
-  "homepage": "https://github.com/XuHaoJun/githunk#readme",
-  "bugs": {
-    "url": "https://github.com/XuHaoJun/githunk/issues"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/XuHaoJun/githunk.git"
   },
-  "license": "MIT",
+  "homepage": "https://github.com/XuHaoJun/githunk#readme",
+  "bugs": {
+    "url": "https://github.com/XuHaoJun/githunk/issues"
+  },
   "engines": {
     "node": ">=26.1.0"
   },
-  "packageManager": "bun@1.4.0",
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "@opentui/core": "0.5.10",
     "@opentui/react": "0.5.10",
@@ -56,9 +37,15 @@
     "react": "19.2.8",
     "zod": "^4.4.3"
   },
-  "devDependencies": {
-    "@types/bun": "1.4.0",
-    "@types/react": "19.2.8",
-    "typescript": "5.9.2"
+  "optionalDependencies": {
+    "@xuhaojun/githunk-darwin-arm64": "0.3.0",
+    "@xuhaojun/githunk-darwin-x64": "0.3.0",
+    "@xuhaojun/githunk-linux-arm64": "0.3.0",
+    "@xuhaojun/githunk-linux-x64": "0.3.0",
+    "@xuhaojun/githunk-windows-x64": "0.3.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
   }
 }