@xuhaojun/githunk 0.2.0 → 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/dist/githunk.js

@@ -1,11 +1,18 @@
 #!/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";
 // package.json
 var package_default = {
   name: "@xuhaojun/githunk",
-  version: "0.2.0",
+  version: "0.3.0",
   description: "A review-first Git TUI combining lazygit's everyday Git workflow with focused hunk review.",
   type: "module",
   bin: {
@@ -80,8 +87,9 @@ var cliVersion = typeof package_default.version === "string" && package_default.
 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(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().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;
     },
@@ -89,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) {
@@ -102,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";
@@ -991,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);
@@ -1029,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, isAbsolute, join, 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);
@@ -1059,7 +1152,7 @@ class LocalStateFile {
     this.pathKind = options.pathKind ?? "state";
   }
   get path() {
-    return this.resolvedPath ?? join(this.runner.cwd, ".git", this.relativePath);
+    return this.resolvedPath ?? join2(this.runner.cwd, ".git", this.relativePath);
   }
   async resolvePath() {
     if (this.resolvedPath !== undefined)
@@ -1067,7 +1160,7 @@ class LocalStateFile {
     const output = (await this.runner.run(["rev-parse", "--git-path", this.relativePath], { readOnly: true })).stdout.trim();
     if (output.length === 0)
       throw new Error(`git returned an empty path for ${this.relativePath}`);
-    this.resolvedPath = isAbsolute(output) ? output : join(this.runner.cwd, output);
+    this.resolvedPath = isAbsolute(output) ? output : join2(this.runner.cwd, output);
     return this.resolvedPath;
   }
   async readText() {
@@ -1976,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 = {}) {
@@ -2185,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 dirname2, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 function finalizeEntry(entry) {
   return {
     path: entry.path,
@@ -2320,11 +2413,11 @@ async function readTrimmedFile(path) {
 }
 async function inProgressBranch(gitDir) {
   for (const directory of ["rebase-merge", "rebase-apply"]) {
-    const headName = await readTrimmedFile(join2(gitDir, directory, "head-name"));
+    const headName = await readTrimmedFile(join3(gitDir, directory, "head-name"));
     if (headName !== undefined)
       return headName.replace(/^refs\/heads\//, "");
   }
-  return await readTrimmedFile(join2(gitDir, "BISECT_START"));
+  return await readTrimmedFile(join3(gitDir, "BISECT_START"));
 }
 async function listWorktrees(runner) {
   const repositoryPaths = await resolveRepositoryPaths(runner);
@@ -2391,7 +2484,7 @@ function worktreeRemovalRequiresForce(error) {
 
 // src/git/submodules.ts
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join3, resolve as resolve2 } from "node:path";
+import { join as join4, resolve as resolve2 } from "node:path";
 
 // src/domain/submodule.ts
 function submoduleFullName(submodule) {
@@ -2446,7 +2539,7 @@ function parseGitModules(raw) {
 }
 async function readGitModules(directory) {
   try {
-    return await readFile3(join3(directory, ".gitmodules"), "utf8");
+    return await readFile3(join4(directory, ".gitmodules"), "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error) {
       const code = error.code;
@@ -2457,7 +2550,7 @@ async function readGitModules(directory) {
   }
 }
 async function collectSubmodules(worktreePath, parentModule, visited) {
-  const directory = parentModule === undefined ? worktreePath : join3(worktreePath, submoduleFullPath(parentModule));
+  const directory = parentModule === undefined ? worktreePath : join4(worktreePath, submoduleFullPath(parentModule));
   const resolved = resolve2(directory);
   if (visited.has(resolved))
     return [];
@@ -2941,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())
@@ -5935,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) {
@@ -5976,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;
@@ -15469,7 +15562,7 @@ async function loadRefsSnapshot(runner) {
 }
 
 // src/git/editor.ts
-import { join as join4, basename } from "node:path";
+import { join as join5, basename as basename2 } from "node:path";
 function standardTerminalPreset(editor) {
   return {
     edit: `${editor} -- {{filename}}`,
@@ -15562,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";
 }
@@ -15607,7 +15700,7 @@ async function resolveEditCommand(files, options = {}) {
 function absolutePath(repoRoot, relativePath) {
   if (relativePath.startsWith("/"))
     return relativePath;
-  return join4(repoRoot, relativePath);
+  return join5(repoRoot, relativePath);
 }
 
 // src/app/create-app.ts
@@ -15615,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 dirname3 } 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) {
@@ -15645,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;
@@ -16322,7 +16415,7 @@ function reviewHelp(focus, state) {
 }
 
 // src/ui/review-workspace/review-sidebar.ts
-import { basename as basename3, dirname as dirname4 } from "node:path/posix";
+import { basename as basename4, dirname as dirname4 } from "node:path/posix";
 function normalizeDiffPath(p) {
   return p?.replace(/[\r\n]+$/u, "");
 }
@@ -16351,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) {
@@ -17600,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);
@@ -21924,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) {
@@ -23354,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) + `
@@ -23868,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);
@@ -24892,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(`
@@ -24903,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,6 +1,6 @@
 {
   "name": "@xuhaojun/githunk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A review-first Git TUI combining lazygit's everyday Git workflow with focused hunk review.",
   "bin": {
     "githunk": "bin/githunk.js"
@@ -38,11 +38,11 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@xuhaojun/githunk-darwin-arm64": "0.2.0",
-    "@xuhaojun/githunk-darwin-x64": "0.2.0",
-    "@xuhaojun/githunk-linux-arm64": "0.2.0",
-    "@xuhaojun/githunk-linux-x64": "0.2.0",
-    "@xuhaojun/githunk-windows-x64": "0.2.0"
+    "@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": {