@n-seiji/nuthatch 0.1.5 → 0.2.0

package/dist/cli-r39xsdym.js

@@ -0,0 +1,103 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  loadRepoContext,
+  nestedWorktrees,
+  worktreeDirtyState
+} from "./cli-fqz7emfm.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 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-s5qcjcwk.js

@@ -0,0 +1,25 @@
+// src/domain/posix-path.ts
+var withoutTrailingSlash = (path) => path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+var shortenHome = (path, home) => {
+  if (home === "" || home === "/") {
+    return path;
+  }
+  if (path === home) {
+    return "~";
+  }
+  return path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+};
+var parentDir = (path) => {
+  const trimmed = withoutTrailingSlash(path);
+  const index = trimmed.lastIndexOf("/");
+  if (index === -1) {
+    return ".";
+  }
+  return index === 0 ? "/" : trimmed.slice(0, index);
+};
+var absoluteCandidates = (dirs, name) => [
+  ...new Set(dirs.map((entry) => entry.trim()).filter((entry) => entry.startsWith("/")).map((dir) => `${dir.endsWith("/") ? dir.slice(0, -1) : dir}/${name}`))
+];
+var splitPathEnv = (pathEnv) => (pathEnv ?? "").split(":");
+
+export { shortenHome, parentDir, absoluteCandidates, splitPathEnv };