@n-seiji/nuthatch 0.1.5 → 0.2.0

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 と同じ |
 
@@ -145,27 +145,27 @@ install script は `hop` を `~/.local/bin` に置き (`HOP_INSTALL_DIR` で
 ### 更新
 
 ```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 が一致した場合に限る — 不一致なら
+何も置換しない。それ以外のインストールでは、何も実行せず、リクエストも送らず、
+更新方法を 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 |
 
@@ -151,27 +151,27 @@ 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 --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. 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-dkrfmz85.js

@@ -0,0 +1,207 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  upstreamStateOf
+} from "./cli-btqjpf1q.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  loadRepoContext,
+  nestedWorktrees,
+  worktreeDirtyState
+} from "./cli-fqz7emfm.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");
+  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-9y31xrsx.js

@@ -0,0 +1,187 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  loadRepoContext,
+  isWorktreeDirty,
+  resolveBranchCheckout
+} from "./cli-fqz7emfm.js";
+import {
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
+
+// src/commands/root-holder-swap.ts
+var holderRejection = (branch, holderPath, reason) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is already checked out at ${holderPath}, and it ${reason}. Not swapping — cd there instead of using hop root.`);
+var prunableHolderRejection = (branch, holderPath) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is held by a stale worktree registration at ${holderPath} (git reports it prunable). Not swapping — if that worktree was moved, re-link it with "git worktree repair <new path>"; otherwise drop the registration first ("hop rm ${branch}" or "git worktree prune").`);
+var multipleHoldersRejection = (branch, holders) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is checked out at ${holders.length} worktrees at once (${holders.map((holder) => holder.path).join(", ")}). Not swapping — hop won't guess which one to detach.`);
+var resolveHolderSwap = async ({
+  git,
+  fresh,
+  target,
+  switchOptions,
+  policy
+}) => {
+  if (target === "-") {
+    return pass(null);
+  }
+  const freshHolders = fresh.worktrees.filter((wt) => wt.branch === target && wt.kind !== "root");
+  if (freshHolders.length > 1) {
+    return reject(multipleHoldersRejection(target, freshHolders));
+  }
+  const [freshHolder] = freshHolders;
+  if (freshHolder === undefined) {
+    return pass(null);
+  }
+  if (policy.expectedPath !== undefined && freshHolder.path !== policy.expectedPath) {
+    return reject(holderRejection(target, freshHolder.path, `changed from the picker selection at ${policy.expectedPath}`));
+  }
+  if (freshHolder.kind === "external" && !policy.allowExternal) {
+    return reject(holderRejection(target, freshHolder.path, "is external and requires confirmation before it can be put into detached HEAD"));
+  }
+  if (switchOptions.createBranch === true) {
+    return reject(holderRejection(target, freshHolder.path, "wasn't visible when hop checked existing local branches (e.g. it has no commits yet, or was created after that check)"));
+  }
+  if (freshHolder.locked) {
+    return reject(holderRejection(target, freshHolder.path, `is locked by git${freshHolder.lockReason === null ? "" : ` (${freshHolder.lockReason})`}`));
+  }
+  if (freshHolder.prunable) {
+    return reject(prunableHolderRejection(target, freshHolder.path));
+  }
+  const holderDirty = await isWorktreeDirty(git, fresh.worktrees, freshHolder.path);
+  if (holderDirty) {
+    return reject(holderRejection(target, freshHolder.path, "has uncommitted or untracked changes"));
+  }
+  await git.detachHead(freshHolder.path);
+  return pass({ path: freshHolder.path, branch: target });
+};
+
+// src/commands/root.ts
+var root2 = async (git, fs, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  if (options.target === undefined) {
+    return ok({
+      path: context.rootPath,
+      data: {
+        branch: rootBranchOf(context),
+        switched: false,
+        detachedHolder: null
+      }
+    });
+  }
+  const dirtyRejection = await dirtyRootRejection(git, context);
+  if (dirtyRejection !== null) {
+    return dirtyRejection;
+  }
+  if (options.target === "-") {
+    return switchAndReport({
+      git,
+      fs,
+      context,
+      target: "-",
+      switchOptions: {},
+      holderPolicy: { allowExternal: true }
+    });
+  }
+  const checkout = await resolveBranchCheckout(git, context.rootPath, options.target, options.track);
+  if (!checkout.ok) {
+    return checkout.rejection;
+  }
+  return switchAndReport({
+    git,
+    fs,
+    context,
+    target: options.target,
+    switchOptions: checkout.value,
+    holderPolicy: {
+      allowExternal: options.allowExternalHolderSwap ?? true,
+      ...options.expectedHolderPath === undefined ? {} : { expectedPath: options.expectedHolderPath }
+    }
+  });
+};
+var rootBranchOf = ({ worktrees }) => worktrees.find((wt) => wt.kind === "root")?.branch ?? null;
+var dirtyRootRejection = async (git, context) => {
+  const dirty = await isWorktreeDirty(git, context.worktrees, context.rootPath);
+  if (!dirty) {
+    return null;
+  }
+  return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
+};
+var rollBackSwitch = async (git, { rootPath, previousBranch, detachedHolder }) => {
+  const warnings = [];
+  if (previousBranch !== null) {
+    try {
+      await git.switchBranch(rootPath, previousBranch, {});
+    } catch {
+      warnings.push(`Could not restore ${rootPath} to its original branch (${previousBranch})`);
+    }
+  }
+  if (detachedHolder !== null) {
+    try {
+      await git.switchBranch(detachedHolder.path, detachedHolder.branch, {});
+    } catch {
+      warnings.push(`Could not restore ${detachedHolder.path} to its original branch (${detachedHolder.branch}); it remains in detached HEAD`);
+    }
+  }
+  return warnings;
+};
+var switchAndReport = ({
+  git,
+  fs,
+  context,
+  target,
+  switchOptions,
+  holderPolicy
+}) => withRepoLock(context.commonDir, async () => {
+  let detachedHolder = null;
+  let previousBranch = null;
+  try {
+    const fresh = await loadRepoContext(git, fs, context.rootPath);
+    previousBranch = rootBranchOf(fresh);
+    const stillDirty = await dirtyRootRejection(git, fresh);
+    if (stillDirty !== null) {
+      return stillDirty;
+    }
+    const holderSwap = await resolveHolderSwap({
+      git,
+      fresh,
+      target,
+      switchOptions,
+      policy: holderPolicy
+    });
+    if (!holderSwap.ok) {
+      return holderSwap.rejection;
+    }
+    detachedHolder = holderSwap.value;
+    await git.switchBranch(fresh.rootPath, target, switchOptions);
+    let resolvedBranch = target;
+    if (target === "-") {
+      const afterSwitch = await loadRepoContext(git, fs, fresh.rootPath);
+      resolvedBranch = rootBranchOf(afterSwitch);
+    }
+    return ok({
+      path: fresh.rootPath,
+      data: {
+        branch: resolvedBranch,
+        switched: true,
+        detachedHolder: detachedHolder?.path ?? null
+      },
+      warnings: detachedHolder === null ? [] : [`Put ${detachedHolder.path} into detached HEAD`]
+    });
+  } catch (error) {
+    const warnings = await rollBackSwitch(git, {
+      rootPath: context.rootPath,
+      previousBranch,
+      detachedHolder
+    });
+    return fail(EXIT_SAFE_REJECTION, `Failed to switch root: ${messageOf(error)}`, warnings);
+  }
+});
+
+export { root2 };

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