@n-seiji/nuthatch 0.1.4 → 0.1.7

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

package/dist/cli-g72ra4e5.js

@@ -0,0 +1,104 @@
+// src/domain/classify.ts
+var isWithin = (parent, child) => {
+  if (parent === child) {
+    return false;
+  }
+  const parentWithSlash = parent.endsWith("/") ? parent : `${parent}/`;
+  return child.startsWith(parentWithSlash);
+};
+var classifyWorktreePath = (path, rootPath, managedRoot) => {
+  if (path === rootPath) {
+    return "root";
+  }
+  if (path === managedRoot || isWithin(managedRoot, path)) {
+    return "managed";
+  }
+  return "external";
+};
+
+// src/domain/porcelain.ts
+var REFS_HEADS_PREFIX = "refs/heads/";
+var branchNameFromRef = (ref) => ref.startsWith(REFS_HEADS_PREFIX) ? ref.slice(REFS_HEADS_PREFIX.length) : ref;
+var parseRecord = (lines) => {
+  let path = null;
+  let head = null;
+  let branch = null;
+  let detached = false;
+  let bare = false;
+  let locked = false;
+  let lockReason = null;
+  let prunable = false;
+  let prunableReason = null;
+  for (const line of lines.filter((candidate) => candidate.length > 0)) {
+    const spaceIndex = line.indexOf(" ");
+    const key = spaceIndex === -1 ? line : line.slice(0, spaceIndex);
+    const value = spaceIndex === -1 ? "" : line.slice(spaceIndex + 1);
+    switch (key) {
+      case "worktree": {
+        path = value;
+        break;
+      }
+      case "HEAD": {
+        head = value;
+        break;
+      }
+      case "branch": {
+        branch = branchNameFromRef(value);
+        break;
+      }
+      case "detached": {
+        detached = true;
+        break;
+      }
+      case "bare": {
+        bare = true;
+        break;
+      }
+      case "locked": {
+        locked = true;
+        lockReason = value.length > 0 ? value : null;
+        break;
+      }
+      case "prunable": {
+        prunable = true;
+        prunableReason = value.length > 0 ? value : null;
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  if (path === null) {
+    return null;
+  }
+  return {
+    path,
+    head,
+    branch,
+    detached,
+    bare,
+    locked,
+    lockReason,
+    prunable,
+    prunableReason
+  };
+};
+var parsePorcelain = (output) => {
+  if (output.length === 0) {
+    return [];
+  }
+  const trimmed = output.endsWith("\x00") ? output.slice(0, -1) : output;
+  const records = trimmed.split("\x00\x00");
+  const result = [];
+  for (const record of records.filter((candidate) => candidate.length > 0)) {
+    const lines = record.split("\x00");
+    const parsed = parseRecord(lines);
+    if (parsed !== null) {
+      result.push(parsed);
+    }
+  }
+  return result;
+};
+
+export { isWithin, classifyWorktreePath, REFS_HEADS_PREFIX, parsePorcelain };