@n-seiji/nuthatch 0.1.5 → 0.1.7

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

package/dist/cli-71jgs14h.js

@@ -0,0 +1,112 @@
+// src/domain/display-width.ts
+var WIDTH_ZERO = 0;
+var WIDTH_NARROW = 1;
+var WIDTH_WIDE = 2;
+var segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+var ZERO_WIDTH_JOINER = 8205;
+var VARIATION_SELECTOR_TEXT = 65038;
+var VARIATION_SELECTOR_EMOJI = 65039;
+var ZERO_WIDTH_CODE_POINTS = new Set([
+  ZERO_WIDTH_JOINER,
+  VARIATION_SELECTOR_TEXT,
+  VARIATION_SELECTOR_EMOJI
+]);
+var isCombiningMark = (codePoint) => /\p{M}/u.test(String.fromCodePoint(codePoint));
+var HANGUL_JAMO_START = 4352;
+var HANGUL_JAMO_END = 4447;
+var CJK_RADICALS_START = 11904;
+var CJK_SYMBOLS_END = 12350;
+var HIRAGANA_START = 12353;
+var CJK_COMPATIBILITY_END = 13311;
+var CJK_EXT_A_START = 13312;
+var CJK_EXT_A_END = 19903;
+var CJK_UNIFIED_START = 19968;
+var CJK_UNIFIED_END = 40959;
+var YI_SYLLABLES_START = 40960;
+var YI_SYLLABLES_END = 42191;
+var HANGUL_SYLLABLES_START = 44032;
+var HANGUL_SYLLABLES_END = 55203;
+var CJK_COMPAT_IDEOGRAPHS_START = 63744;
+var CJK_COMPAT_IDEOGRAPHS_END = 64255;
+var CJK_COMPAT_FORMS_START = 65072;
+var CJK_COMPAT_FORMS_END = 65103;
+var FULLWIDTH_FORMS_START = 65280;
+var FULLWIDTH_FORMS_END = 65376;
+var FULLWIDTH_SIGNS_START = 65504;
+var FULLWIDTH_SIGNS_END = 65510;
+var EMOJI_MISC_START = 127744;
+var EMOJI_MISC_END = 128591;
+var EMOJI_TRANSPORT_START = 128640;
+var EMOJI_TRANSPORT_END = 129535;
+var CJK_EXT_B_START = 131072;
+var CJK_EXT_B_END = 262141;
+var WIDE_RANGES = [
+  [HANGUL_JAMO_START, HANGUL_JAMO_END],
+  [CJK_RADICALS_START, CJK_SYMBOLS_END],
+  [HIRAGANA_START, CJK_COMPATIBILITY_END],
+  [CJK_EXT_A_START, CJK_EXT_A_END],
+  [CJK_UNIFIED_START, CJK_UNIFIED_END],
+  [YI_SYLLABLES_START, YI_SYLLABLES_END],
+  [HANGUL_SYLLABLES_START, HANGUL_SYLLABLES_END],
+  [CJK_COMPAT_IDEOGRAPHS_START, CJK_COMPAT_IDEOGRAPHS_END],
+  [CJK_COMPAT_FORMS_START, CJK_COMPAT_FORMS_END],
+  [FULLWIDTH_FORMS_START, FULLWIDTH_FORMS_END],
+  [FULLWIDTH_SIGNS_START, FULLWIDTH_SIGNS_END],
+  [EMOJI_MISC_START, EMOJI_MISC_END],
+  [EMOJI_TRANSPORT_START, EMOJI_TRANSPORT_END],
+  [CJK_EXT_B_START, CJK_EXT_B_END]
+];
+var isWide = (codePoint) => WIDE_RANGES.some(([start, end]) => codePoint >= start && codePoint <= end);
+var codePointWidth = (codePoint) => {
+  if (ZERO_WIDTH_CODE_POINTS.has(codePoint) || isCombiningMark(codePoint)) {
+    return WIDTH_ZERO;
+  }
+  return isWide(codePoint) ? WIDTH_WIDE : WIDTH_NARROW;
+};
+var graphemeWidth = (grapheme) => {
+  const codePoints = Array.from(grapheme, (char) => char.codePointAt(0)).filter((codePoint) => codePoint !== undefined);
+  return codePoints.reduce((max, codePoint) => Math.max(max, codePointWidth(codePoint)), WIDTH_ZERO);
+};
+var graphemes = (value) => Array.from(segmenter.segment(value), (entry) => entry.segment);
+var displayWidth = (value) => graphemes(value).reduce((total, grapheme) => total + graphemeWidth(grapheme), WIDTH_ZERO);
+var padToWidth = (value, width) => {
+  const current = displayWidth(value);
+  return current >= width ? value : value + " ".repeat(width - current);
+};
+var DEFAULT_ELLIPSIS = "…";
+var takeWithinWidth = (clusters, budget) => {
+  const taken = [];
+  let usedWidth = WIDTH_ZERO;
+  for (const grapheme of clusters) {
+    const nextWidth = usedWidth + graphemeWidth(grapheme);
+    if (nextWidth > budget) {
+      break;
+    }
+    taken.push(grapheme);
+    usedWidth = nextWidth;
+  }
+  return taken;
+};
+var truncateToWidth = (value, width, ellipsis = DEFAULT_ELLIPSIS) => {
+  if (displayWidth(value) <= width) {
+    return value;
+  }
+  const budget = width - displayWidth(ellipsis);
+  if (budget < WIDTH_ZERO) {
+    return "";
+  }
+  return takeWithinWidth(graphemes(value), budget).join("") + ellipsis;
+};
+var truncateToWidthKeepingTail = (value, width, ellipsis = DEFAULT_ELLIPSIS) => {
+  if (displayWidth(value) <= width) {
+    return value;
+  }
+  const budget = width - displayWidth(ellipsis);
+  if (budget < WIDTH_ZERO) {
+    return "";
+  }
+  const keptFromEnd = takeWithinWidth(graphemes(value).toReversed(), budget);
+  return ellipsis + keptFromEnd.toReversed().join("");
+};
+
+export { graphemes, displayWidth, padToWidth, truncateToWidth, truncateToWidthKeepingTail };

package/dist/cli-7jg5qqs9.js

@@ -0,0 +1,88 @@
+import {
+  isWithin,
+  classifyWorktreePath,
+  parsePorcelain
+} from "./cli-g72ra4e5.js";
+import {
+  EXIT_USAGE_ERROR,
+  fail
+} from "./cli-2bhb9p0x.js";
+
+// src/infra/repo.ts
+import { basename, dirname, join } from "node:path";
+
+// src/domain/tracking.ts
+var resolveTrackingRef = (branch, remotes) => {
+  if (remotes.includes("origin")) {
+    return { kind: "track", ref: `origin/${branch}` };
+  }
+  const [first, second] = remotes;
+  if (first === undefined) {
+    return { kind: "none" };
+  }
+  if (second !== undefined) {
+    return { kind: "ambiguous" };
+  }
+  return { kind: "track", ref: `${first}/${branch}` };
+};
+
+// src/infra/repo.ts
+var loadRepoContext = async (git, fs, cwd) => {
+  const [commonDir, porcelainOut] = await Promise.all([
+    git.commonDir(cwd),
+    git.listWorktreesPorcelain(cwd)
+  ]);
+  const parsed = parsePorcelain(porcelainOut);
+  const [firstEntry] = parsed;
+  if (firstEntry === undefined) {
+    throw new Error("git worktree list returned no entries");
+  }
+  const rootPath = await realpathOrRaw(fs, firstEntry.path);
+  const managedRoot = join(dirname(rootPath), "_worktree", basename(rootPath));
+  const worktrees = await Promise.all(parsed.map(async (entry) => {
+    const resolvedPath = await realpathOrRaw(fs, entry.path);
+    return {
+      ...entry,
+      path: resolvedPath,
+      kind: classifyWorktreePath(resolvedPath, rootPath, managedRoot)
+    };
+  }));
+  return { rootPath, managedRoot, commonDir, worktrees };
+};
+var nestedWorktreePaths = (worktrees, path) => nestedWorktrees(worktrees, path).map((wt) => wt.path);
+var nestedWorktrees = (worktrees, path) => worktrees.filter((wt) => wt.path !== path && !wt.prunable && isWithin(path, wt.path));
+var isWorktreeDirty = (git, worktrees, path) => git.isDirty(path, nestedWorktreePaths(worktrees, path));
+var worktreeDirtyState = async (git, fs, worktrees, wt) => {
+  if (wt.bare || wt.prunable || !await fs.exists(wt.path)) {
+    return null;
+  }
+  return isWorktreeDirty(git, worktrees, wt.path);
+};
+var resolveBranchCheckout = async (git, rootPath, branch, explicitTrack) => {
+  const localBranches = await git.listBranches(rootPath);
+  const createBranch = !localBranches.includes(branch);
+  let track = explicitTrack;
+  if (createBranch && track === undefined) {
+    const remotes = await git.remotesWithBranch(rootPath, branch);
+    const resolution = resolveTrackingRef(branch, remotes);
+    if (resolution.kind === "ambiguous") {
+      return {
+        ok: false,
+        rejection: fail(EXIT_USAGE_ERROR, `Branch "${branch}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`)
+      };
+    }
+    if (resolution.kind === "track") {
+      track = resolution.ref;
+    }
+  }
+  return { ok: true, options: { createBranch, ...track === undefined ? {} : { track } } };
+};
+var realpathOrRaw = async (fs, path) => {
+  try {
+    return await fs.realpath(path);
+  } catch {
+    return path;
+  }
+};
+
+export { loadRepoContext, nestedWorktrees, isWorktreeDirty, worktreeDirtyState, resolveBranchCheckout };

package/dist/cli-dbzx9nzg.js

@@ -0,0 +1,40 @@
+// src/render.ts
+var PLAIN_JSON_INDENT = 2;
+var render = (command, result, json) => {
+  if (json) {
+    const envelope = {
+      schemaVersion: 1,
+      command,
+      data: result.ok ? result.data : undefined,
+      warnings: result.warnings ?? []
+    };
+    process.stdout.write(`${JSON.stringify(envelope)}
+`);
+    if (!result.ok && result.errorMessage !== undefined) {
+      process.stderr.write(`${result.errorMessage}
+`);
+    }
+    return;
+  }
+  if (result.path !== undefined) {
+    process.stdout.write(`${result.path}
+`);
+  } else if (result.ok && result.data !== undefined) {
+    process.stdout.write(`${JSON.stringify(result.data, null, PLAIN_JSON_INDENT)}
+`);
+  }
+  for (const warning of result.warnings ?? []) {
+    process.stderr.write(`warning: ${warning}
+`);
+  }
+  if (!result.ok && result.errorMessage !== undefined) {
+    process.stderr.write(`${result.errorMessage}
+`);
+  }
+};
+var reportResult = (command, result, json) => {
+  render(command, result, json);
+  process.exitCode = result.exitCode;
+};
+
+export { render, reportResult };