@n-seiji/nuthatch 0.1.5 → 0.1.7

package/dist/cli-ygt2w4e1.js

@@ -0,0 +1,195 @@
+import {
+  messageOf
+} from "./cli-qrxgkskr.js";
+import {
+  withRepoLock
+} from "./cli-rcw5adqd.js";
+import {
+  loadRepoContext,
+  isWorktreeDirty,
+  resolveBranchCheckout
+} from "./cli-7jg5qqs9.js";
+import {
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail
+} from "./cli-2bhb9p0x.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 { detachedHolder: null };
+  }
+  const freshHolders = fresh.worktrees.filter((wt) => wt.branch === target && wt.kind !== "root");
+  if (freshHolders.length > 1) {
+    return { rejection: multipleHoldersRejection(target, freshHolders) };
+  }
+  const [freshHolder] = freshHolders;
+  if (freshHolder === undefined) {
+    return { detachedHolder: null };
+  }
+  if (policy.expectedPath !== undefined && freshHolder.path !== policy.expectedPath) {
+    return {
+      rejection: holderRejection(target, freshHolder.path, `changed from the picker selection at ${policy.expectedPath}`)
+    };
+  }
+  if (freshHolder.kind === "external" && !policy.allowExternal) {
+    return {
+      rejection: holderRejection(target, freshHolder.path, "is external and requires confirmation before it can be put into detached HEAD")
+    };
+  }
+  if (switchOptions.createBranch === true) {
+    return {
+      rejection: 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 {
+      rejection: holderRejection(target, freshHolder.path, `is locked by git${freshHolder.lockReason === null ? "" : ` (${freshHolder.lockReason})`}`)
+    };
+  }
+  if (freshHolder.prunable) {
+    return { rejection: prunableHolderRejection(target, freshHolder.path) };
+  }
+  const holderDirty = await isWorktreeDirty(git, fresh.worktrees, freshHolder.path);
+  if (holderDirty) {
+    return {
+      rejection: holderRejection(target, freshHolder.path, "has uncommitted or untracked changes")
+    };
+  }
+  await git.detachHead(freshHolder.path);
+  return { detachedHolder: { 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.options,
+    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 ("rejection" in holderSwap) {
+      return holderSwap.rejection;
+    }
+    ({ detachedHolder } = holderSwap);
+    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 };