@n-seiji/nuthatch 0.1.5 → 0.2.1

package/README.ja.md

@@ -40,8 +40,8 @@ hop -- <branch>    # 予約コマンドと被る branch 名をエスケープ
 hop --help         # usage を表示 (-h / hop help でも同じ)
 
 hop --version          # hop の version を表示
-hop --update           # 最新リリースへ、インストールした方法のまま更新
-hop --update --check   # --update が何をするかを報告するだけ — 何も変更しない
+hop --update           # standalone バイナリを最新リリースへ置換 (それ以外は更新方法を表示)
+hop --update --check   # 更新があるかを報告するだけ — 何も変更しない
 ```
 
 同じ branch が複数の worktree で checkout されている場合、branch だけを指定する
@@ -92,7 +92,7 @@ action を選ぶ間も一覧が見え続ける。横に並べられない幅 (
 | `Tab`, `→`, `Ctrl+L`, `Ctrl+F` | 選択中の候補の action panel を開く (ここで cd / 削除 / root 切替) |
 | `Ctrl+X` | 選択中の worktree を削除 (常に先に y/N を確認) |
 | `Ctrl+R` | root clone を選択中の branch へ切替 (`external` は先に y/N を確認) |
-| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K`/`Ctrl+J` | 選択を移動 (矢印・emacs・vim キーがすべて併用可) |
+| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K` | 選択を移動 (矢印・emacs・vim キーがすべて併用可) |
 | `Esc` | 静かにキャンセル — exit 0、stdout は空のまま (shell wrapper は cd しない) |
 | `Ctrl+C` | 割り込みとしてキャンセル — exit 130、実際の SIGINT と同じ |
 
@@ -142,30 +142,40 @@ install script は `hop` を `~/.local/bin` に置き (`HOP_INSTALL_DIR` で
 には `HOP_VERSION=vX.Y.Z` を使う。Linux arm64 はビルド済みバイナリが
 まだないため、npm install を使う。
 
+v0.2.0 より後のリリースのバイナリにはビルド来歴 (build provenance) の attestation
+が付く。ダウンロードしたバイナリを手動で検証するには:
+
+```sh
+gh attestation verify ./hop-darwin-arm64 --repo n-seiji/nuthatch \
+  --signer-workflow github.com/n-seiji/nuthatch/.github/workflows/release.yml
+```
+
+`install.sh` は attestation を確認せず、SHA-256 だけを検証する。
+
 ### 更新
 
 ```sh
-hop --update          # 最新リリースへ、インストールした方法のまま更新
-hop --update --check  # 報告だけ: current / latest / method / 実行されるコマンド
+hop --update          # standalone バイナリを最新リリースへ置換
+hop --update --check  # 報告だけ: current / latest / インストール方法 / すべきこと
 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 --update` が置換するのは `install.sh` で入れたバイナリだけで、置き場の
+ディレクトリに書き込めて (バイナリと checksum のダウンロードの前に確認する)、
+かつリリースに添付された `.sha256` と SHA-256 が一致した場合に限る — 不一致なら
+何も置換しない (確認するのは SHA-256 のみで、attestation は見ない)。それ以外のインストールでは、何も実行せず、リクエストも送らず、
+更新方法を 1 行表示して終了する (exit 1):
+
+| インストール方法 | 更新方法 |
+|---|---|
+| `install.sh` (`~/.local/bin` のバイナリ) | `hop --update`、または `install.sh` を再実行 |
+| mise | `mise upgrade` |
+| npm / bun / pnpm / yarn の global | `npm i -g @n-seiji/nuthatch@latest` (または使っているパッケージマネージャの同等コマンド) |
+| Homebrew・Nix・aqua・proto・ソースチェックアウト・その他のツール | そのツール自身の upgrade コマンド |
+
+`hop --update --check` はどのインストール方法でも使え、同じ案内を報告する。
+hop がネットワークに出るのは GitHub の固定アドレスへの HTTPS リクエストだけで、
+タイムアウトとサイズ上限つき。
 
 ## トラブルシューティング
 

package/README.md

@@ -42,8 +42,8 @@ hop -- <branch>    # escape a branch name that collides with a reserved command
 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
+hop --update           # replace a standalone binary with the latest release (other installs: prints how to update)
+hop --update --check   # only report whether an update is available — changes nothing
 ```
 
 If Git reports the same branch checked out in multiple worktrees, the
@@ -100,7 +100,7 @@ below the list instead.
 | `Tab`, `→`, `Ctrl+L`, `Ctrl+F` | Open the action panel for the selected candidate (cd / delete / switch root here) |
 | `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) |
+| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K` | 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) |
 | `Ctrl+C` | Cancel like an interrupt — exit 130, same as a real SIGINT |
 
@@ -148,30 +148,40 @@ 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.
 
+Release binaries from releases after v0.2.0 carry a build-provenance
+attestation. To verify a downloaded binary by hand:
+
+```sh
+gh attestation verify ./hop-darwin-arm64 --repo n-seiji/nuthatch \
+  --signer-workflow github.com/n-seiji/nuthatch/.github/workflows/release.yml
+```
+
+`install.sh` does not check it; it verifies the SHA-256 only.
+
 ### 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 --update          # replace a standalone binary with the latest release
+hop --update --check  # just report: current, latest, how hop was installed, what to do
 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.
+`hop --update` only replaces the binary that `install.sh` installs, and only if
+its directory is writable (checked before the binary or its checksum is
+downloaded) and its SHA-256 matches the `.sha256` attached to the release; on a
+mismatch nothing is replaced (SHA-256 only; attestations are not checked). For any other install it runs nothing, makes no
+request, and prints one line saying how to update it (exit 1):
+
+| Installed with | Update with |
+|---|---|
+| `install.sh` (binary in `~/.local/bin`) | `hop --update`, or re-run `install.sh` |
+| mise | `mise upgrade` |
+| npm / bun / pnpm / yarn global | `npm i -g @n-seiji/nuthatch@latest` (or your package manager's equivalent) |
+| Homebrew, Nix, aqua, proto, a source checkout, any other tool | that tool's own upgrade command |
+
+`hop --update --check` works for every install and reports the same hint. The
+only network traffic is HTTPS requests to fixed GitHub addresses, each with a
+timeout and a size cap.
 
 ## Troubleshooting
 

package/dist/clean-rn2476my.js

@@ -0,0 +1,217 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  upstreamStateOf
+} from "./cli-btqjpf1q.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  isOptionLikeRef,
+  loadRepoContext,
+  nestedWorktrees,
+  worktreeDirtyState
+} from "./cli-y8vsqre6.js";
+import {
+  EXIT_USAGE_ERROR,
+  ok,
+  fail
+} from "./cli-77yanq37.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") && !(wt.branch !== null && isOptionLikeRef(wt.branch)));
+  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 branchMergeFacts = async (git, rootPath, branch, { defaultRef, upstreams }) => {
+  const upstreamGone = upstreamStateOf(upstreams, branch).kind === "gone";
+  const mergedIntoDefault = defaultRef === null ? "unknown" : await git.isAncestor(rootPath, branch, defaultRef);
+  const allCommitsReachableFromDefault = defaultRef === null || mergedIntoDefault === true || !upstreamGone ? "unknown" : await git.hasEquivalentCommits(rootPath, branch, defaultRef);
+  return {
+    prunable: false,
+    upstreamGone,
+    mergedIntoDefault,
+    allCommitsReachableFromDefault
+  };
+};
+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 facts = await branchMergeFacts(git, rootPath, wt.branch, {
+    defaultRef,
+    upstreams
+  });
+  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, facts) => {
+  if (candidate.reason !== "prunable") {
+    return true;
+  }
+  if (candidate.branch.length === 0) {
+    return false;
+  }
+  try {
+    const branchFacts = await branchMergeFacts(git, rootPath, candidate.branch, facts);
+    return classifyGarbage({ ...branchFacts, clean: true }) !== null;
+  } 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-26d2drt6.js

@@ -0,0 +1,30 @@
+// src/infra/term.ts
+import { createInterface } from "node:readline";
+var colorEnabled = (stream) => stream.isTTY === true && (process.env["NO_COLOR"] ?? "") === "";
+var createTermPort = () => ({
+  isTTY() {
+    return process.stderr.isTTY === true && process.stdin.isTTY === true;
+  },
+  logStderr(message) {
+    process.stderr.write(`${message}
+`);
+  },
+  confirm(message) {
+    return new Promise((resolve) => {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stderr,
+        terminal: false
+      });
+      rl.question(`${message} [y/N] `, (answer) => {
+        rl.close();
+        resolve(answer.trim().toLowerCase() === "y");
+      });
+      rl.once("close", () => {
+        resolve(false);
+      });
+    });
+  }
+});
+
+export { colorEnabled, createTermPort };

package/dist/cli-77yanq37.js

@@ -0,0 +1,21 @@
+// 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 }
+});
+var pass = (value) => ({ ok: true, value });
+var reject = (rejection) => ({ ok: false, rejection });
+
+export { EXIT_SUCCESS, EXIT_GENERAL_ERROR, EXIT_USAGE_ERROR, EXIT_SAFE_REJECTION, EXIT_CANCELLED, ok, fail, pass, reject };

package/dist/cli-9n04gsq1.js

@@ -0,0 +1,108 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  optionLikeRefRejection,
+  loadRepoContext,
+  nestedWorktrees,
+  worktreeDirtyState
+} from "./cli-y8vsqre6.js";
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_USAGE_ERROR,
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
+
+// src/commands/rm.ts
+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 ? reject(fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal. Refresh the picker and retry.`)) : pass(target);
+  }
+  if (matches.length > 1) {
+    return reject(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 ? reject(fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${branch}".`)) : pass(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.ok) {
+    return resolved;
+  }
+  const target = resolved.value;
+  if (target.kind === "root") {
+    return reject(fail(EXIT_USAGE_ERROR, "Cannot remove the root clone."));
+  }
+  const rejection = await targetSafetyRejection(check, target);
+  return rejection === null ? resolved : reject(rejection);
+};
+var removeWorktree = async (git, fs, options) => {
+  const refRejection = optionLikeRefRejection("branch", options.branch);
+  if (refRejection !== null) {
+    return refRejection;
+  }
+  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.value;
+      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 = (git, fs, options) => removeWorktree(git, fs, options);
+
+export { rm2 };

package/dist/cli-a56b2ar0.js

@@ -0,0 +1,20 @@
+// src/domain/classify.ts
+var isWithin = (parent, child) => {
+  if (parent === child) {
+    return false;
+  }
+  const parentWithSlash = parent.endsWith("/") ? parent : `${parent}/`;
+  return child.startsWith(parentWithSlash);
+};
+var isWithinOrSelf = (parent, child) => parent === child || isWithin(parent, child);
+var classifyWorktreePath = (path, rootPath, managedRoot) => {
+  if (path === rootPath) {
+    return "root";
+  }
+  if (path === managedRoot || isWithin(managedRoot, path)) {
+    return "managed";
+  }
+  return "external";
+};
+
+export { isWithin, isWithinOrSelf, classifyWorktreePath };

package/dist/cli-b0tk5wcx.js

@@ -0,0 +1,86 @@
+// src/domain/porcelain.ts
+var REFS_HEADS_PREFIX = "refs/heads/";
+var branchNameFromRef = (ref) => ref.startsWith(REFS_HEADS_PREFIX) ? ref.slice(REFS_HEADS_PREFIX.length) : ref;
+var parseRecord = (lines) => {
+  let path = null;
+  let head = null;
+  let branch = null;
+  let detached = false;
+  let bare = false;
+  let locked = false;
+  let lockReason = null;
+  let prunable = false;
+  let prunableReason = null;
+  for (const line of lines.filter((candidate) => candidate.length > 0)) {
+    const spaceIndex = line.indexOf(" ");
+    const key = spaceIndex === -1 ? line : line.slice(0, spaceIndex);
+    const value = spaceIndex === -1 ? "" : line.slice(spaceIndex + 1);
+    switch (key) {
+      case "worktree": {
+        path = value;
+        break;
+      }
+      case "HEAD": {
+        head = value;
+        break;
+      }
+      case "branch": {
+        branch = branchNameFromRef(value);
+        break;
+      }
+      case "detached": {
+        detached = true;
+        break;
+      }
+      case "bare": {
+        bare = true;
+        break;
+      }
+      case "locked": {
+        locked = true;
+        lockReason = value.length > 0 ? value : null;
+        break;
+      }
+      case "prunable": {
+        prunable = true;
+        prunableReason = value.length > 0 ? value : null;
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  if (path === null) {
+    return null;
+  }
+  return {
+    path,
+    head,
+    branch,
+    detached,
+    bare,
+    locked,
+    lockReason,
+    prunable,
+    prunableReason
+  };
+};
+var parsePorcelain = (output) => {
+  if (output.length === 0) {
+    return [];
+  }
+  const trimmed = output.endsWith("\x00") ? output.slice(0, -1) : output;
+  const records = trimmed.split("\x00\x00");
+  const result = [];
+  for (const record of records.filter((candidate) => candidate.length > 0)) {
+    const lines = record.split("\x00");
+    const parsed = parseRecord(lines);
+    if (parsed !== null) {
+      result.push(parsed);
+    }
+  }
+  return result;
+};
+
+export { REFS_HEADS_PREFIX, parsePorcelain };