@n-seiji/nuthatch 0.1.5 → 0.2.0

package/dist/cli-b0tk5wcx.js

@@ -0,0 +1,86 @@
+// 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 { REFS_HEADS_PREFIX, parsePorcelain };

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-fqz7emfm.js

@@ -0,0 +1,88 @@
+import {
+  parsePorcelain
+} from "./cli-b0tk5wcx.js";
+import {
+  EXIT_USAGE_ERROR,
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
+import {
+  isWithin,
+  classifyWorktreePath
+} from "./cli-a56b2ar0.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 nestedWorktrees = (worktrees, path) => worktrees.filter((wt) => wt.path !== path && !wt.prunable && isWithin(path, wt.path));
+var isWorktreeDirty = (git, worktrees, path) => git.isDirty(path, nestedWorktrees(worktrees, path).map((wt) => wt.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 reject(fail(EXIT_USAGE_ERROR, `Branch "${branch}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`));
+    }
+    if (resolution.kind === "track") {
+      track = resolution.ref;
+    }
+  }
+  return pass({ 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-mfz1rx2x.js

@@ -0,0 +1,87 @@
+import {
+  describeFatalError
+} from "./cli-ph0gp56k.js";
+import {
+  reportResult
+} from "./cli-dbzx9nzg.js";
+import {
+  fail
+} from "./cli-77yanq37.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.2.0",
+  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"
+  ],
+  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.72.0",
+    oxlint: "^1.81.0",
+    typescript: "^5.6.0"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+export { normalizeCliArgs, isRunningAsCompiledBinary, isUpdateRequest, isHelpRequest, isVersionRequest, dispatchCliArgs, wantsJson, reportFatalError, VERSION };

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