@n-seiji/nuthatch 0.1.5 → 0.2.1

package/dist/cli-btqjpf1q.js

@@ -0,0 +1,35 @@
+import {
+  REFS_HEADS_PREFIX
+} from "./cli-b0tk5wcx.js";
+
+// src/domain/upstream.ts
+var NONE = { kind: "none" };
+var FIELD_SEPARATOR = "\x00";
+var UPSTREAM_FORMAT = "%(refname)%00%(upstream)%00%(upstream:track,nobracket)";
+var countOf = (track, word) => {
+  const match = new RegExp(`${word} (?<count>\\d+)`, "u").exec(track);
+  return match?.groups?.count === undefined ? 0 : Number(match.groups.count);
+};
+var parseTrack = (upstream, track) => {
+  if (upstream.length === 0) {
+    return NONE;
+  }
+  if (track === "gone") {
+    return { kind: "gone" };
+  }
+  return { kind: "tracking", ahead: countOf(track, "ahead"), behind: countOf(track, "behind") };
+};
+var parseUpstreamStates = (output) => {
+  const states = new Map;
+  for (const line of output.split(`
+`)) {
+    const [refname = "", upstream = "", track = ""] = line.split(FIELD_SEPARATOR);
+    if (refname.startsWith(REFS_HEADS_PREFIX)) {
+      states.set(refname.slice(REFS_HEADS_PREFIX.length), parseTrack(upstream, track.trim()));
+    }
+  }
+  return states;
+};
+var upstreamStateOf = (states, branch) => states.get(branch) ?? NONE;
+
+export { UPSTREAM_FORMAT, parseUpstreamStates, upstreamStateOf };

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

package/dist/cli-fhta3tr8.js

@@ -0,0 +1,126 @@
+// 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("");
+};
+
+// src/domain/ansi.ts
+var ESC = "\x1B";
+var SGR = {
+  bold: `${ESC}[1m`,
+  dim: `${ESC}[2m`,
+  inverse: `${ESC}[7m`,
+  red: `${ESC}[31m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  magenta: `${ESC}[35m`,
+  cyan: `${ESC}[36m`
+};
+var SGR_RESET = `${ESC}[0m`;
+
+export { graphemes, displayWidth, padToWidth, truncateToWidth, truncateToWidthKeepingTail, ESC, SGR, SGR_RESET };

package/dist/cli-hz0r7zw8.js

@@ -0,0 +1,194 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  refArgumentRejection,
+  loadRepoContext,
+  isWorktreeDirty,
+  resolveBranchCheckout
+} from "./cli-y8vsqre6.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) => {
+  if (options.target !== undefined && options.target !== "-") {
+    const refRejection = refArgumentRejection(options.target, options.track);
+    if (refRejection !== null) {
+      return refRejection;
+    }
+  }
+  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-ph0gp56k.js

@@ -0,0 +1,54 @@
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_SAFE_REJECTION
+} from "./cli-77yanq37.js";
+import {
+  absoluteCandidates,
+  splitPathEnv
+} from "./cli-s5qcjcwk.js";
+
+// src/domain/git-executable.ts
+var GIT_EXECUTABLE_OVERRIDE_ENV = "HOP_GIT";
+var GIT_NOT_FOUND_ERROR_CODE = "HOP_GIT_NOT_FOUND";
+var GIT_NOT_FOUND_HINT = `Install git, or set ${GIT_EXECUTABLE_OVERRIDE_ENV} to its absolute path.`;
+var GIT_FALLBACK_BIN_DIRS = [
+  "/opt/homebrew/bin",
+  "/usr/local/bin",
+  "/usr/bin",
+  "/bin"
+];
+var gitExecutableCandidates = (input) => {
+  const override = input.override?.trim() ?? "";
+  if (override.length > 0) {
+    return [override];
+  }
+  return absoluteCandidates([...splitPathEnv(input.path), ...GIT_FALLBACK_BIN_DIRS], "git");
+};
+var gitNotFoundMessage = (candidates) => `git executable not found. Looked in: ${candidates.join(", ")}. ${GIT_NOT_FOUND_HINT}`;
+
+// src/domain/fatal-error.ts
+var fieldsOf = (error) => typeof error === "object" && error !== null ? error : {};
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var trimmedStringOf = (value) => typeof value === "string" ? value.trim() : "";
+var isSpawnFailure = (fields) => fields.code === "ENOENT" && typeof fields.syscall === "string" && fields.syscall.startsWith("spawn");
+var isGitFailure = (fields) => typeof fields.code === "number" || typeof fields.signal === "string" && fields.signal !== "";
+var describeFatalError = (error) => {
+  const fields = fieldsOf(error);
+  if (isSpawnFailure(fields)) {
+    const binary = trimmedStringOf(fields.path) || "git";
+    return {
+      message: `failed to run ${binary}: no such executable. ${GIT_NOT_FOUND_HINT}`,
+      exitCode: EXIT_GENERAL_ERROR
+    };
+  }
+  if (isGitFailure(fields)) {
+    const stderr = trimmedStringOf(fields.stderr);
+    return {
+      message: stderr.length > 0 ? stderr : messageOf(error),
+      exitCode: EXIT_SAFE_REJECTION
+    };
+  }
+  return { message: messageOf(error), exitCode: EXIT_GENERAL_ERROR };
+};
+
+export { GIT_EXECUTABLE_OVERRIDE_ENV, GIT_NOT_FOUND_ERROR_CODE, gitExecutableCandidates, gitNotFoundMessage, messageOf, describeFatalError };