@n-seiji/nuthatch 0.1.4 → 0.1.7

package/README.ja.md

@@ -24,7 +24,7 @@
 
 ```sh
 hop                # worktree/branch を対話的に選んで cd
-hop feat/foo       # feat/foo の worktree へ cd — 未作成ならその場で作成
+hop feat/foo       # feat/foo の worktree へ cd (未作成なら --create でその場で作成)
 hop root           # root clone へ cd
 hop -              # 直前の worktree へ戻る
 
@@ -38,6 +38,10 @@ hop root -         # root clone を元に戻す (root の branch のみ; swap
 hop -- <branch>    # 予約コマンドと被る branch 名をエスケープ
                    # (`hop` 自体と同名の branch (例: `hop -- hop`) にも必要)
 hop --help         # usage を表示 (-h / hop help でも同じ)
+
+hop --version          # hop の version を表示
+hop --update           # 最新リリースへ、インストールした方法のまま更新
+hop --update --check   # --update が何をするかを報告するだけ — 何も変更しない
 ```
 
 同じ branch が複数の worktree で checkout されている場合、branch だけを指定する
@@ -79,14 +83,14 @@ picker は terminal の alternate screen buffer (fzf や vim と同じ仕組み)
 ### 対話的 picker のキー
 
 action panel は候補一覧の隣に列として表示される (overlay ではない) ので、
-action を選ぶ間も一覧が見え続ける。60 列未満の terminal では横に並べられ
-ないため、一覧の下にスタックする形にフォールバックする。
+action を選ぶ間も一覧が見え続ける。横に並べられない幅 (おおよそ 94 列
+未満) の terminal では、一覧の下にスタックする形にフォールバックする。
 
 | キー | 動作 |
 |---|---|
 | `Enter` | 選択中の候補へ cd |
 | `Tab`, `→`, `Ctrl+L`, `Ctrl+F` | 選択中の候補の action panel を開く (ここで cd / 削除 / root 切替) |
-| `Ctrl+X` | 選択中の worktree を削除 (`external` は先に y/N を確認) |
+| `Ctrl+X` | 選択中の worktree を削除 (常に先に y/N を確認) |
 | `Ctrl+R` | root clone を選択中の branch へ切替 (`external` は先に y/N を確認) |
 | `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K`/`Ctrl+J` | 選択を移動 (矢印・emacs・vim キーがすべて併用可) |
 | `Esc` | 静かにキャンセル — exit 0、stdout は空のまま (shell wrapper は cd しない) |
@@ -99,8 +103,9 @@ action panel 内: 同じ上下移動キー (左右は閉じる操作に予約さ
 対になっている; `Tab` はどちらの状態からでもトグルする — Ghostty のように
 Cmd+K のようなキーの組み合わせを Tab に remap する terminal で便利)。
 `delete` はすでに作成済みの worktree (`managed` / `external`) すべてに
-表示される (`external` の削除は panel からでも Ctrl+X からでも必ず y/N
-を確認する); `switch root here` は root worktree 自身には表示されず、
+表示される (panel からの削除は、`external` worktree と、git が作業ツリーを
+見失った prunable な worktree なら先に y/N を確認する。Ctrl+X は常に
+確認する); `switch root here` は root worktree 自身には表示されず、
 `external` worktree に対しては HEAD を detach する可能性があるため
 同じく先に y/N を確認する。削除すると候補一覧が再読み込みされ、picker を
 抜けずに削除を続けられる; cd と switch-root は終了して結果の path を
@@ -137,6 +142,31 @@ install script は `hop` を `~/.local/bin` に置き (`HOP_INSTALL_DIR` で
 には `HOP_VERSION=vX.Y.Z` を使う。Linux arm64 はビルド済みバイナリが
 まだないため、npm install を使う。
 
+### 更新
+
+```sh
+hop --update          # 最新リリースへ、インストールした方法のまま更新
+hop --update --check  # 報告だけ: current / latest / method / 実行されるコマンド
+hop --version         # 今どの version か
+```
+
+`hop --update` は hop のインストール方法を判定する。`install.sh` で入れた
+バイナリは、置き場のディレクトリに書き込めて (バイナリと checksum の
+ダウンロードの前に確認する)、かつリリースに添付された `.sha256` と SHA-256 が
+一致した場合にだけその場で差し替える — 不一致なら何も置換しない。
+mise / npm / bun 経由の install は、そのツール自身の upgrade コマンド
+(`mise upgrade …`、
+`npm install -g --prefix <hop が入っている prefix> @n-seiji/nuthatch@latest`、
+`bun add -g @n-seiji/nuthatch@latest`) をホームディレクトリで実行して更新する
+ので、グローバルの mise 設定で固定した version が優先され (hop は先に mise へ
+問い合わせ、upgrade するものが無ければ警告する)、プロジェクトの `mise.toml`
+には左右されず、npm の更新は hop が今入っている prefix に入る。`npx` / `bunx`、
+ソースチェックアウト、Homebrew・Nix・aqua・proto など他のバージョン管理ツール
+が自分用にコピーを持っているバイナリ、hop が扱わない配置 (pnpm・yarn の
+global、プロジェクトの依存) は、代わりにどうすればよいかを示して拒否する。
+hop がネットワークに出るのはこれだけで、GitHub と npm の固定アドレスへの
+HTTPS リクエストのみ (タイムアウトとサイズ上限つき)。
+
 ## トラブルシューティング
 
 `hop: git executable not found. Looked in: …` は git のバイナリを見つけられ

package/README.md

@@ -26,7 +26,7 @@ doesn't exist yet. Built for humans (interactive picker) and AI coding agents
 
 ```sh
 hop                # pick a worktree/branch interactively and cd into it
-hop feat/foo       # cd into feat/foo's worktree — created on demand
+hop feat/foo       # cd into feat/foo's worktree (add --create to create it if missing)
 hop root           # cd into the root clone
 hop -              # cd back to the previous worktree
 
@@ -40,6 +40,10 @@ hop root -         # switch the root clone back (only root's branch; a swapped-o
 hop -- <branch>    # escape a branch name that collides with a reserved command
                    # (also required for a branch named the same as your `hop` binary/alias, e.g. `hop -- hop`)
 hop --help         # print usage (also -h / hop help)
+
+hop --version          # print hop's version
+hop --update           # update hop to the latest release, the way it was installed
+hop --update --check   # only report what --update would do — changes nothing
 ```
 
 If Git reports the same branch checked out in multiple worktrees, the
@@ -87,14 +91,14 @@ screen on exit, however it exits (selection, Esc/Ctrl-C, or an interrupt).
 
 The action panel renders as a column beside the candidate list (not an
 overlay), so the list stays visible while you pick an action. On terminals
-narrower than 60 columns it falls back to stacking below the list instead,
-since the two can't fit side by side.
+too narrow to fit both (under about 94 columns) it falls back to stacking
+below the list instead.
 
 | Key | Action |
 |---|---|
 | `Enter` | cd into the selected candidate |
 | `Tab`, `→`, `Ctrl+L`, `Ctrl+F` | Open the action panel for the selected candidate (cd / delete / switch root here) |
-| `Ctrl+X` | Delete the selected worktree (asks y/N first for an `external` worktree) |
+| `Ctrl+X` | Delete the selected worktree (always asks y/N first) |
 | `Ctrl+R` | Switch the root clone to the selected branch (asks y/N first for an `external` worktree) |
 | `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K`/`Ctrl+J` | Move the selection (arrow, emacs, and vim keys all work side by side) |
 | `Esc` | Cancel quietly — exit 0, stdout stays empty (the shell wrapper just doesn't cd) |
@@ -106,8 +110,9 @@ highlighted action, `c`/`d`/`r` to run cd/delete/switch-root directly, and
 `Esc`, `Tab`, `←`, or `Ctrl+H` to close it back to the list (`←`/`Ctrl+H`
 mirror the `→`/`Ctrl+L`/`Ctrl+F` that open it; `Tab` toggles either way —
 handy on terminals like Ghostty that remap a chord such as Cmd+K to Tab). `delete`
-appears for any already-created worktree (`managed` or `external` — deleting
-an `external` one always asks y/N, whether from the panel or Ctrl+X); `switch
+appears for any already-created worktree (`managed` or `external` — from the
+panel, deleting an `external` worktree, or a prunable one (git can no longer
+find its working tree), asks y/N first; Ctrl+X always asks); `switch
 root here` doesn't appear on the root worktree itself, and also asks y/N
 first for an `external` worktree, since it can detach that worktree's HEAD.
 Deleting reloads the
@@ -123,9 +128,6 @@ eval "$(hop init zsh)"
 
 ## Install
 
-> Not released yet — no version has been published or tagged. Once the first
-> `v*` tag ships, the options below will work as described.
-
 Recommended: the GitHub Release binary (built with bun; via mise,
 `mise use github:n-seiji/nuthatch`). The npm version runs on Node, so its git
 calls are slower (hop ls ~400ms vs ~60ms) — prefer the binary for CI or
@@ -146,6 +148,31 @@ The install script places `hop` in `~/.local/bin` (override with
 specific version with `HOP_VERSION=vX.Y.Z`. Linux arm64 has no prebuilt
 binary yet — use the npm install instead.
 
+### Updating
+
+```sh
+hop --update          # update to the latest release, the way hop was installed
+hop --update --check  # just report: current, latest, method, and the command it would run
+hop --version         # which version do I have?
+```
+
+`hop --update` detects how hop was installed. A binary from `install.sh` is
+replaced in place, but only if its directory is writable (checked before the
+binary or its checksum is downloaded) and only after its SHA-256 matches the
+`.sha256` attached to the release — on a mismatch nothing is replaced. A mise /
+npm / bun install is updated by running that tool's own upgrade command from
+your home directory (`mise upgrade …`,
+`npm install -g --prefix <the prefix hop lives in> @n-seiji/nuthatch@latest`,
+`bun add -g @n-seiji/nuthatch@latest`), so a version pinned in your global mise
+config still wins (hop asks mise first and warns when it has nothing to
+upgrade), a project's own `mise.toml` cannot interfere, and an npm update lands
+in the prefix hop is already in. `npx` / `bunx`, a source checkout, a binary
+that Homebrew, Nix, aqua, proto or another version manager keeps its own copy
+of, and layouts hop does not drive (a pnpm or yarn global, a project
+dependency) are refused with a note on what to do instead. This is the only
+thing hop does over the network: HTTPS requests to fixed GitHub and npm
+addresses, each with a timeout and a size cap.
+
 ## Troubleshooting
 
 `hop: git executable not found. Looked in: …` means hop could not find a git

package/dist/clean-n2f9z8n3.js

@@ -0,0 +1,208 @@
+import {
+  messageOf
+} from "./cli-qrxgkskr.js";
+import {
+  upstreamStateOf
+} from "./cli-pqd2qe7v.js";
+import {
+  withRepoLock
+} from "./cli-rcw5adqd.js";
+import {
+  loadRepoContext,
+  nestedWorktrees,
+  worktreeDirtyState
+} from "./cli-7jg5qqs9.js";
+import {
+  EXIT_USAGE_ERROR,
+  ok,
+  fail
+} from "./cli-2bhb9p0x.js";
+
+// src/domain/garbage.ts
+var classifyGarbage = (input) => {
+  if (input.prunable) {
+    return "prunable";
+  }
+  if (!input.clean) {
+    return null;
+  }
+  if (input.mergedIntoDefault === true) {
+    return "merged";
+  }
+  if (input.upstreamGone && input.allCommitsReachableFromDefault === true) {
+    return "gone";
+  }
+  return null;
+};
+
+// src/commands/clean-candidates.ts
+var buildCleanCandidates = async (git, fs, context, ext) => {
+  const [defaultRef, upstreams] = await Promise.all([
+    git.resolveDefaultBranchRef(context.rootPath),
+    git.upstreamStates(context.rootPath)
+  ]);
+  const targets = context.worktrees.filter((wt) => wt.kind === "managed" || ext && wt.kind === "external");
+  const results = await Promise.all(targets.map(async (wt) => {
+    const reason = await classifyWorktree(wt, { git, fs, defaultRef, upstreams, context });
+    if (reason === null) {
+      return null;
+    }
+    return { branch: wt.branch ?? "", path: wt.path, reason };
+  }));
+  return results.filter((candidate) => candidate !== null);
+};
+var classifyWorktree = async (wt, { git, fs, defaultRef, upstreams, context }) => {
+  if (wt.prunable) {
+    return classifyGarbage({
+      prunable: true,
+      clean: false,
+      mergedIntoDefault: "unknown",
+      upstreamGone: false,
+      allCommitsReachableFromDefault: "unknown"
+    });
+  }
+  if (wt.branch === null) {
+    return null;
+  }
+  const { rootPath, worktrees } = context;
+  const upstreamGone = upstreamStateOf(upstreams, wt.branch).kind === "gone";
+  const mergedIntoDefault = defaultRef === null ? "unknown" : await git.isAncestor(rootPath, wt.branch, defaultRef);
+  const allCommitsReachableFromDefault = defaultRef === null || mergedIntoDefault === true || !upstreamGone ? "unknown" : await git.hasEquivalentCommits(rootPath, wt.branch, defaultRef);
+  const facts = {
+    prunable: false,
+    mergedIntoDefault,
+    upstreamGone,
+    allCommitsReachableFromDefault
+  };
+  if (classifyGarbage({ ...facts, clean: true }) === null) {
+    return null;
+  }
+  const dirtyState = await worktreeDirtyState(git, fs, worktrees, wt);
+  const input = { ...facts, clean: dirtyState === false };
+  return classifyGarbage(input);
+};
+
+// src/commands/clean.ts
+var clean = async (git, fs, term, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const candidates = await buildCleanCandidates(git, fs, context, options.ext);
+  if (options.dryRun) {
+    return ok({ data: { candidates } });
+  }
+  if (candidates.length === 0) {
+    return ok({ data: { candidates, removed: [] } });
+  }
+  if (!options.yes) {
+    if (!term.isTTY()) {
+      return fail(EXIT_USAGE_ERROR, "hop clean would remove worktrees; re-run with --yes (non-interactive) or --dry-run to only list candidates.");
+    }
+    for (const candidate of candidates) {
+      term.logStderr(`${candidate.reason}	${candidate.branch}	${candidate.path}`);
+    }
+    const confirmed = await term.confirm(`Remove ${candidates.length} worktree(s) above?`);
+    if (!confirmed) {
+      return ok({ data: { candidates, removed: [] } });
+    }
+  }
+  return executeClean({
+    git,
+    fs,
+    context,
+    candidates,
+    cleanOptions: options
+  });
+};
+var removeCandidate = async ({
+  git,
+  rootPath,
+  candidate,
+  deleteBranch,
+  worktrees
+}) => {
+  if (nestedWorktrees(worktrees, candidate.path).length > 0) {
+    return "nested";
+  }
+  try {
+    await git.removeWorktree(rootPath, candidate.path, false);
+    if (deleteBranch && candidate.branch.length > 0) {
+      await git.deleteBranch(rootPath, candidate.branch);
+    }
+    return "removed";
+  } catch {
+    return "failed";
+  }
+};
+var canDeletePrunableBranch = async (git, rootPath, candidate, { defaultRef, upstreams }) => {
+  if (candidate.reason !== "prunable") {
+    return true;
+  }
+  if (candidate.branch.length === 0 || defaultRef === null) {
+    return false;
+  }
+  try {
+    const mergedIntoDefault = await git.isAncestor(rootPath, candidate.branch, defaultRef);
+    if (mergedIntoDefault === true) {
+      return true;
+    }
+    if (upstreamStateOf(upstreams, candidate.branch).kind === "gone") {
+      return await git.hasEquivalentCommits(rootPath, candidate.branch, defaultRef) === true;
+    }
+  } catch {}
+  return false;
+};
+var executeClean = ({
+  git,
+  fs,
+  context,
+  candidates,
+  cleanOptions
+}) => withRepoLock(context.commonDir, async () => {
+  try {
+    const fresh = await loadRepoContext(git, fs, context.rootPath);
+    const freshCandidates = await buildCleanCandidates(git, fs, fresh, cleanOptions.ext);
+    const freshByPath = new Map(freshCandidates.map((candidate) => [candidate.path, candidate]));
+    const stillValid = candidates.flatMap((candidate) => {
+      const freshCandidate = freshByPath.get(candidate.path);
+      return freshCandidate === undefined ? [] : [freshCandidate];
+    });
+    const [defaultRef, upstreams] = await Promise.all([
+      git.resolveDefaultBranchRef(fresh.rootPath),
+      git.upstreamStates(fresh.rootPath)
+    ]);
+    const removed = [];
+    const warnings = [];
+    for (const candidate of stillValid) {
+      const branchSafe = await canDeletePrunableBranch(git, fresh.rootPath, candidate, {
+        defaultRef,
+        upstreams
+      });
+      const deleteBranch = cleanOptions.withBranch && branchSafe;
+      if (cleanOptions.withBranch && candidate.reason === "prunable" && candidate.branch.length > 0 && !branchSafe) {
+        warnings.push(`Keeping branch "${candidate.branch}": prunable worktree is not confirmed merged or gone.`);
+      }
+      const outcome = await removeCandidate({
+        git,
+        rootPath: fresh.rootPath,
+        candidate,
+        deleteBranch,
+        worktrees: fresh.worktrees
+      });
+      if (outcome === "removed") {
+        removed.push(candidate.branch);
+      } else if (outcome === "nested") {
+        warnings.push(`Skipped ${candidate.path}: still contains a registered worktree.`);
+      }
+    }
+    return ok({
+      data: { candidates: [...candidates], removed },
+      ...warnings.length === 0 ? {} : { warnings }
+    });
+  } catch (error) {
+    throw new Error(`Failed to clean worktrees: ${messageOf(error)}`, {
+      cause: error
+    });
+  }
+});
+export {
+  clean
+};

package/dist/cli-23z98dw1.js

@@ -0,0 +1,116 @@
+import {
+  messageOf
+} from "./cli-qrxgkskr.js";
+import {
+  withRepoLock
+} from "./cli-rcw5adqd.js";
+import {
+  loadRepoContext,
+  nestedWorktrees,
+  worktreeDirtyState
+} from "./cli-7jg5qqs9.js";
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_USAGE_ERROR,
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail
+} from "./cli-2bhb9p0x.js";
+
+// src/commands/rm.ts
+var EXT_DEPRECATION_WARNING = "--ext is deprecated and no longer required: hop rm can now remove external worktrees without it.";
+var lockedRejection = (branch, lockReason) => fail(EXIT_SAFE_REJECTION, `Worktree for "${branch}" is locked by git${lockReason === null ? "" : ` (${lockReason})`}. hop never unlocks worktrees automatically — run "git worktree unlock" yourself first if you're sure.`);
+var turnedPrunableRejection = (branch) => fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal (git now reports it prunable). Refresh the picker and retry.`);
+var stalePrunableWarning = ({ path, prunableReason }) => `Worktree at ${path} no longer exists${prunableReason === null ? "" : ` (${prunableReason})`}; removed its stale registration — if it had been moved by hand, the moved copy is no longer linked to this repository.`;
+var resolveTarget = (worktrees, branch, expectedPath) => {
+  const matches = worktrees.filter((wt) => wt.branch === branch);
+  if (expectedPath !== undefined) {
+    const target = matches.find((wt) => wt.path === expectedPath);
+    return target === undefined ? {
+      rejection: fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal. Refresh the picker and retry.`)
+    } : { target };
+  }
+  if (matches.length > 1) {
+    return {
+      rejection: fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is checked out at ${matches.length} worktrees (${matches.map((wt) => wt.path).join(", ")}). Refusing to guess which one to remove.`)
+    };
+  }
+  const [target] = matches;
+  return target === undefined ? {} : { target };
+};
+var nestedWorktreeRejection = (branch, targetPath, worktrees) => {
+  const nested = nestedWorktrees(worktrees, targetPath);
+  if (nested.length === 0) {
+    return null;
+  }
+  const listing = nested.map((wt) => `  ${wt.path}${wt.branch === null ? "" : ` (${wt.branch})`}`).join(`
+`);
+  return fail(EXIT_SAFE_REJECTION, `Worktree for "${branch}" still contains ${nested.length} registered worktree(s) — refusing to remove it, since that would destroy their files too. Remove these first, then retry:
+${listing}`);
+};
+var targetSafetyRejection = async ({ git, fs, context, options }, target) => {
+  const nestedRejection = nestedWorktreeRejection(options.branch, target.path, context.worktrees);
+  if (nestedRejection !== null) {
+    return nestedRejection;
+  }
+  if (target.locked) {
+    return lockedRejection(options.branch, target.lockReason);
+  }
+  if (target.prunable && options.allowPrunable === false) {
+    return turnedPrunableRejection(options.branch);
+  }
+  if (!options.force && await worktreeDirtyState(git, fs, context.worktrees, target) === true) {
+    return fail(EXIT_SAFE_REJECTION, `Worktree for "${options.branch}" has uncommitted or untracked changes. Use --force to remove anyway.`);
+  }
+  return null;
+};
+var validateRemoval = async (check) => {
+  const { context, options } = check;
+  const resolved = resolveTarget(context.worktrees, options.branch, options.expectedPath);
+  if (resolved.rejection !== undefined) {
+    return { ok: false, rejection: resolved.rejection };
+  }
+  const { target } = resolved;
+  if (target === undefined) {
+    return {
+      ok: false,
+      rejection: fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`)
+    };
+  }
+  if (target.kind === "root") {
+    return { ok: false, rejection: fail(EXIT_USAGE_ERROR, "Cannot remove the root clone.") };
+  }
+  const rejection = await targetSafetyRejection(check, target);
+  return rejection === null ? { ok: true, target } : { ok: false, rejection };
+};
+var withExtWarning = (ext, result) => ext ? {
+  ...result,
+  warnings: [...result.warnings ?? [], EXT_DEPRECATION_WARNING]
+} : result;
+var removeWorktree = async (git, fs, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const validation = await validateRemoval({ git, fs, context, options });
+  if (!validation.ok) {
+    return validation.rejection;
+  }
+  return withRepoLock(context.commonDir, async () => {
+    try {
+      const fresh = await loadRepoContext(git, fs, options.cwd);
+      const freshValidation = await validateRemoval({ git, fs, context: fresh, options });
+      if (!freshValidation.ok) {
+        return freshValidation.rejection;
+      }
+      const { target } = freshValidation;
+      await git.removeWorktree(context.rootPath, target.path, options.force);
+      return ok({
+        data: { branch: options.branch, path: target.path },
+        ...target.prunable ? { warnings: [stalePrunableWarning(target)] } : {}
+      });
+    } catch (error) {
+      return fail(EXIT_SAFE_REJECTION, `Failed to remove worktree: ${messageOf(error)}`);
+    }
+  });
+};
+var rm2 = async (git, fs, options) => withExtWarning(options.ext, await removeWorktree(git, fs, options));
+
+export { rm2 };

package/dist/cli-2bhb9p0x.js

@@ -0,0 +1,19 @@
+// src/domain/result.ts
+var EXIT_SUCCESS = 0;
+var EXIT_GENERAL_ERROR = 1;
+var EXIT_USAGE_ERROR = 2;
+var EXIT_SAFE_REJECTION = 3;
+var EXIT_CANCELLED = 130;
+var ok = (fields = {}) => ({
+  ok: true,
+  exitCode: EXIT_SUCCESS,
+  ...fields
+});
+var fail = (exitCode, errorMessage, warnings) => ({
+  ok: false,
+  exitCode,
+  errorMessage,
+  ...warnings === undefined || warnings.length === 0 ? {} : { warnings }
+});
+
+export { EXIT_SUCCESS, EXIT_GENERAL_ERROR, EXIT_USAGE_ERROR, EXIT_SAFE_REJECTION, EXIT_CANCELLED, ok, fail };

package/dist/cli-3ya15je0.js

@@ -0,0 +1,114 @@
+import {
+  describeFatalError
+} from "./cli-qrxgkskr.js";
+import {
+  reportResult
+} from "./cli-dbzx9nzg.js";
+import {
+  fail
+} from "./cli-2bhb9p0x.js";
+
+// src/cli-dispatch.ts
+var normalizeCliArgs = (rawArgs, argv0, isCompiledBinary) => isCompiledBinary && rawArgs.length === 1 && rawArgs[0] === argv0 ? [] : rawArgs;
+var isRunningAsCompiledBinary = () => typeof Bun !== "undefined" && Bun.main.startsWith("/$bunfs/");
+var isUpdateRequest = (rawArgs) => rawArgs[0] === "--update";
+var HELP_FLAGS = new Set(["--help", "-h", "help"]);
+var UPDATE_HELP_FLAGS = new Set(["--help", "-h"]);
+var isHelpRequest = (rawArgs) => rawArgs.length > 0 && (HELP_FLAGS.has(rawArgs[0] ?? "") || isUpdateRequest(rawArgs) && rawArgs.slice(1).some((token) => UPDATE_HELP_FLAGS.has(token)));
+var isVersionRequest = (rawArgs) => rawArgs[0] === "--version";
+var dispatchCliArgs = (rawArgs, reservedNames) => {
+  const [first, ...rest] = rawArgs;
+  if (first === "--") {
+    return { kind: "jump", args: rest };
+  }
+  if (first !== undefined && reservedNames.includes(first)) {
+    return { kind: "reserved", name: first, args: rest };
+  }
+  return { kind: "jump", args: rawArgs };
+};
+
+// src/cli-fatal.ts
+var wantsJson = (args) => args.some((arg) => arg === "--json" || arg.startsWith("--json="));
+var reportFatalError = (command, json, error) => {
+  const fatal = describeFatalError(error);
+  const result = fail(fatal.exitCode, `hop: ${fatal.message}`);
+  reportResult(command, result, json);
+};
+// package.json
+var package_default = {
+  name: "@n-seiji/nuthatch",
+  version: "0.1.7",
+  description: "git worktree manager (hop)",
+  homepage: "https://github.com/n-seiji/nuthatch#readme",
+  bugs: {
+    url: "https://github.com/n-seiji/nuthatch/issues"
+  },
+  license: "GPL-3.0-only",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/n-seiji/nuthatch.git"
+  },
+  bin: {
+    hop: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "shell"
+  ],
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "bun build ./src/cli.ts --outdir dist --target node --format esm --splitting",
+    typecheck: "tsc --noEmit",
+    lint: "oxlint .",
+    "lint:fix": "oxlint . --fix",
+    format: "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    test: "bun test"
+  },
+  dependencies: {
+    valibot: "^1.4.2"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    oxfmt: "^0.66.0",
+    oxlint: "^1.81.0",
+    typescript: "^5.6.0"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/infra/executable.ts
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+var isExecutableFile = async (path) => {
+  try {
+    const stats = await stat(path);
+    if (!stats.isFile()) {
+      return false;
+    }
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var firstExecutable = async (candidates) => {
+  const probes = candidates.map(async (candidate) => await isExecutableFile(candidate) ? candidate : null);
+  for (const probe of probes) {
+    const found = await probe;
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+};
+
+export { normalizeCliArgs, isRunningAsCompiledBinary, isUpdateRequest, isHelpRequest, isVersionRequest, dispatchCliArgs, wantsJson, reportFatalError, firstExecutable, VERSION };