@n-seiji/nuthatch 0.1.5 → 0.2.1

package/{shell/init.zsh → dist/init-167d1bbs.js}

@@ -1,9 +1,15 @@
-# nuthatch shell integration for zsh.
+// src/commands/init.ts
+var ZSH_TEMPLATE = `# nuthatch shell integration for zsh.
 # Usage: eval "$(hop init zsh)"
-#
-# This file is a reference copy of the template embedded in
-# src/commands/init.ts (renderInit). Keep the two in sync.
 hop() {
+  # stdout is not a terminal (e.g. inside p=$(hop ...)): a cd here would only
+  # affect the capturing subshell and leave the caller with an empty string,
+  # so just print the path.
+  if [[ ! -t 1 ]]; then
+    command hop "$@"
+    return $?
+  fi
+
   if [[ "$1" == "-" ]]; then
     cd - > /dev/null || return $?
     return 0
@@ -28,6 +34,13 @@ hop() {
     --*) should_cd=0 ;;
   esac
 
+  # Nothing to cd into: run hop with the terminal as its stdout, so a listing
+  # keeps its colors (hop only colors stdout when it is a terminal).
+  if [[ $should_cd -eq 0 ]]; then
+    command hop "$@"
+    return $?
+  fi
+
   # "status" is a zsh read-only special parameter (mirrors $?); using it as a
   # local name fails with "read-only variable: status". Use "rc" instead, and
   # declare it before the command substitution so the exit code isn't
@@ -44,3 +57,8 @@ hop() {
 
   return $rc
 }
+`;
+var renderInit = () => ZSH_TEMPLATE;
+export {
+  renderInit
+};

package/dist/jump-1zkraat1.js

@@ -0,0 +1,108 @@
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  withRepoLock
+} from "./cli-wcnyhk4w.js";
+import {
+  refArgumentRejection,
+  loadRepoContext,
+  resolveBranchCheckout
+} from "./cli-y8vsqre6.js";
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail
+} from "./cli-77yanq37.js";
+
+// src/commands/jump.ts
+import { join } from "node:path";
+
+// src/domain/sanitize.ts
+var MAX_DIR_NAME_LENGTH = 200;
+var HASH_LENGTH = 8;
+var HEX_RADIX = 16;
+var FULL_HASH_HEX_LENGTH = 8;
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var shortHash = (input) => {
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0;i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return (hash >>> 0).toString(HEX_RADIX).padStart(FULL_HASH_HEX_LENGTH, "0").slice(0, HASH_LENGTH);
+};
+var baseName = (branch) => branch.replaceAll("/", "__");
+var truncate = (name, maxLength) => name.length > maxLength ? name.slice(0, maxLength) : name;
+var sanitizeBranchName = (branch, isTaken) => {
+  const base = truncate(baseName(branch), MAX_DIR_NAME_LENGTH);
+  if (!isTaken(base)) {
+    return base;
+  }
+  const hash = shortHash(branch);
+  let candidate = `${truncate(base, MAX_DIR_NAME_LENGTH - hash.length - 1)}-${hash}`;
+  let suffix = 1;
+  while (isTaken(candidate)) {
+    const withSuffix = `${hash}-${suffix}`;
+    candidate = `${truncate(base, MAX_DIR_NAME_LENGTH - withSuffix.length - 1)}-${withSuffix}`;
+    suffix++;
+  }
+  return candidate;
+};
+
+// src/commands/jump.ts
+var existingWorktreeResult = (branch, path) => ok({ path, data: { branch, created: false } });
+var jump = async (git, fs, options) => {
+  if (options.target === "-") {
+    const previous = process.env.OLDPWD;
+    if (previous === undefined || previous.length === 0) {
+      return fail(EXIT_GENERAL_ERROR, "No previous worktree recorded (OLDPWD is unset).");
+    }
+    return ok({
+      path: previous,
+      data: { branch: options.target, created: false }
+    });
+  }
+  const refRejection = refArgumentRejection(options.target, options.track);
+  if (refRejection !== null) {
+    return refRejection;
+  }
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const existing = context.worktrees.find((wt) => wt.branch === options.target);
+  if (existing !== undefined) {
+    return existingWorktreeResult(options.target, existing.path);
+  }
+  if (!options.create) {
+    return fail(EXIT_SAFE_REJECTION, `No worktree for branch "${options.target}". Re-run with --create to create it.`);
+  }
+  const checkout = await resolveBranchCheckout(git, context.rootPath, options.target, options.track);
+  if (!checkout.ok) {
+    return checkout.rejection;
+  }
+  const managedDirNames = await fs.listDirNames(context.managedRoot);
+  const existingDirNames = new Set(managedDirNames.map((name) => name.toLowerCase()));
+  const dirName = sanitizeBranchName(options.target, (candidate) => existingDirNames.has(candidate.toLowerCase()));
+  const targetPath = join(context.managedRoot, dirName);
+  return withRepoLock(context.commonDir, async () => {
+    try {
+      const fresh = await loadRepoContext(git, fs, options.cwd);
+      const racedExisting = fresh.worktrees.find((wt) => wt.branch === options.target);
+      if (racedExisting !== undefined) {
+        return existingWorktreeResult(options.target, racedExisting.path);
+      }
+      await fs.mkdir(context.managedRoot);
+      await git.addWorktree(context.rootPath, targetPath, options.target, checkout.value);
+      return ok({
+        path: targetPath,
+        data: { branch: options.target, created: true }
+      });
+    } catch (error) {
+      return fail(EXIT_SAFE_REJECTION, `Failed to create worktree: ${messageOf(error)}`);
+    }
+  });
+};
+export {
+  jump
+};

package/dist/ls-3hyjf60d.js

@@ -0,0 +1,34 @@
+import {
+  upstreamStateOf
+} from "./cli-btqjpf1q.js";
+import {
+  loadRepoContext,
+  worktreeDirtyState
+} from "./cli-y8vsqre6.js";
+import {
+  ok
+} from "./cli-77yanq37.js";
+
+// src/commands/ls.ts
+var ls = async (git, fs, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const upstreams = git.upstreamStates(context.rootPath);
+  const entries = await Promise.all(context.worktrees.map(async (wt) => {
+    const [dirtyState, states] = await Promise.all([
+      worktreeDirtyState(git, fs, context.worktrees, wt),
+      upstreams
+    ]);
+    const upstream = wt.branch === null ? null : upstreamStateOf(states, wt.branch);
+    const tracking = upstream?.kind === "tracking" ? upstream : null;
+    return {
+      ...wt,
+      dirty: dirtyState ?? false,
+      ahead: tracking?.ahead ?? null,
+      behind: tracking?.behind ?? null
+    };
+  }));
+  return ok({ data: entries });
+};
+export {
+  ls
+};

package/dist/render-ls-x4hpnsvy.js

@@ -0,0 +1,149 @@
+import {
+  displayWidth,
+  padToWidth,
+  truncateToWidth,
+  truncateToWidthKeepingTail,
+  SGR,
+  SGR_RESET
+} from "./cli-fhta3tr8.js";
+import {
+  colorEnabled
+} from "./cli-26d2drt6.js";
+import {
+  reportResult
+} from "./cli-dbzx9nzg.js";
+import {
+  shortenHome
+} from "./cli-s5qcjcwk.js";
+import {
+  isWithinOrSelf
+} from "./cli-a56b2ar0.js";
+
+// src/render-ls.ts
+var cell = (text, tone = "plain") => ({ text, tone });
+var paint = (value, color) => !color || value.tone === "plain" ? value.text : `${SGR[value.tone]}${value.text}${SGR_RESET}`;
+var SHORT_SHA_LENGTH = 7;
+var MIN_PATH_WIDTH = 12;
+var MAX_BRANCH_WIDTH = 32;
+var COLUMN_GAP = "  ";
+var MARKER_WIDTH = 2;
+var KIND_ORDER = { root: 0, managed: 1, external: 2 };
+var KIND_CELLS = {
+  root: cell("root", "magenta"),
+  managed: cell("managed", "cyan"),
+  external: cell("external", "yellow")
+};
+var compareEntries = (a, b) => {
+  const kindDiff = KIND_ORDER[a.kind] - KIND_ORDER[b.kind];
+  if (kindDiff !== 0) {
+    return kindDiff;
+  }
+  if (a.branch === null || b.branch === null) {
+    return (a.branch === null ? 1 : 0) - (b.branch === null ? 1 : 0);
+  }
+  return a.branch.localeCompare(b.branch);
+};
+var branchCell = (entry) => {
+  if (entry.branch !== null) {
+    return cell(truncateToWidth(entry.branch, MAX_BRANCH_WIDTH), "bold");
+  }
+  const sha = entry.head?.slice(0, SHORT_SHA_LENGTH) ?? "";
+  return cell(entry.bare ? "(bare)" : `(detached ${sha})`, "dim");
+};
+var stateCell = (entry) => {
+  if (entry.prunable) {
+    return cell("✗ missing", "red");
+  }
+  if (entry.locked) {
+    return cell("⊘ locked", "red");
+  }
+  if (entry.bare) {
+    return cell("- bare", "dim");
+  }
+  return entry.dirty ? cell("● changes", "yellow") : cell("✓ clean", "green");
+};
+var syncCells = (entry) => {
+  if (entry.ahead === null || entry.behind === null) {
+    return [cell("-", "dim")];
+  }
+  if (entry.ahead === 0 && entry.behind === 0) {
+    return [cell("=", "dim")];
+  }
+  const cells = [];
+  if (entry.ahead > 0) {
+    cells.push(cell(`↑${entry.ahead}`, "green"));
+  }
+  if (entry.behind > 0) {
+    cells.push(cell(`↓${entry.behind}`, "red"));
+  }
+  return cells;
+};
+var currentPath = (entries, cwd) => entries.filter((entry) => isWithinOrSelf(entry.path, cwd)).reduce((best, entry) => best === null || entry.path.length > best.length ? entry.path : best, null);
+var summaryLine = (entries) => {
+  const parts = [`${entries.length} worktree${entries.length === 1 ? "" : "s"}`];
+  const counts = [
+    [entries.filter((entry) => entry.dirty).length, "with changes"],
+    [entries.filter((entry) => (entry.ahead ?? 0) > 0).length, "ahead"],
+    [entries.filter((entry) => entry.kind === "external").length, "external"],
+    [entries.filter((entry) => entry.locked || entry.prunable).length, "locked or missing"]
+  ];
+  for (const [count, label] of counts) {
+    if (count > 0) {
+      parts.push(`${count} ${label}`);
+    }
+  }
+  return parts.join(" · ");
+};
+var HEADERS = ["BRANCH", "STATE", "REMOTE", "KIND"];
+var buildRow = (entry, current, home) => ({
+  marker: entry.path === current ? cell("@", "green") : cell(" "),
+  columns: [[branchCell(entry)], [stateCell(entry)], syncCells(entry), [KIND_CELLS[entry.kind]]],
+  path: shortenHome(entry.path, home)
+});
+var cellsWidth = (cells) => displayWidth(cells.map((part) => part.text).join(" "));
+var renderCells = (cells, width, color) => {
+  const text = cells.map((part) => paint(part, color)).join(" ");
+  return text + " ".repeat(Math.max(0, width - cellsWidth(cells)));
+};
+var formatLsTable = (entries, options) => {
+  const sorted = entries.toSorted(compareEntries);
+  const current = currentPath(sorted, options.cwd);
+  const rows = sorted.map((entry) => buildRow(entry, current, options.home));
+  const widths = HEADERS.map((header, index) => Math.max(displayWidth(header), ...rows.map((row) => cellsWidth(row.columns[index] ?? []))));
+  const fixedWidth = MARKER_WIDTH + widths.reduce((total, width) => total + width + COLUMN_GAP.length, 0);
+  const pathWidth = options.width === null ? null : Math.max(MIN_PATH_WIDTH, options.width - fixedWidth);
+  const fitPath = (path) => pathWidth === null ? path : truncateToWidthKeepingTail(path, pathWidth);
+  const header = `  ${HEADERS.map((title, index) => padToWidth(title, widths[index] ?? 0)).join(COLUMN_GAP)}${COLUMN_GAP}PATH`;
+  const lines = [paint(cell(header, "dim"), options.color)];
+  for (const row of rows) {
+    const columns = row.columns.map((cells, index) => renderCells(cells, widths[index] ?? 0, options.color));
+    const path = paint(cell(fitPath(row.path), "dim"), options.color);
+    lines.push(`${paint(row.marker, options.color)} ${columns.join(COLUMN_GAP)}${COLUMN_GAP}${path}`);
+  }
+  const summary = cell(summaryLine(sorted), "dim");
+  lines.push("", paint(summary, options.color));
+  return `${lines.join(`
+`)}
+`;
+};
+var reportLs = (result, json) => {
+  if (json || !result.ok || result.data === undefined) {
+    reportResult("ls", result, json);
+    return;
+  }
+  const color = colorEnabled(process.stdout);
+  process.stdout.write(formatLsTable(result.data, {
+    color,
+    width: process.stdout.isTTY === true ? process.stdout.columns ?? null : null,
+    home: process.env["HOME"] ?? "",
+    cwd: process.cwd()
+  }));
+  for (const warning of result.warnings ?? []) {
+    process.stderr.write(`warning: ${warning}
+`);
+  }
+  process.exitCode = result.exitCode;
+};
+export {
+  reportLs
+};

package/dist/rm-eg3j8ae1.js

@@ -0,0 +1,7 @@
+import {
+  rm2
+} from "./cli-9n04gsq1.js";
+import"./cli-ph0gp56k.js";
+export {
+  rm2 as rm
+};

package/dist/root-49vcb8x2.js

@@ -0,0 +1,7 @@
+import {
+  root2
+} from "./cli-hz0r7zw8.js";
+import"./cli-ph0gp56k.js";
+export {
+  root2 as root
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@n-seiji/nuthatch",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "description": "git worktree manager (hop)",
   "homepage": "https://github.com/n-seiji/nuthatch#readme",
   "bugs": {
@@ -15,15 +15,14 @@
     "hop": "dist/cli.js"
   },
   "files": [
-    "dist",
-    "shell"
+    "dist"
   ],
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "bun build ./src/cli.ts --outfile dist/cli.js --target node --format esm",
+    "build": "bun build ./src/cli.ts --outdir dist --target node --format esm --splitting",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint .",
     "lint:fix": "oxlint . --fix",
@@ -32,12 +31,11 @@
     "test": "bun test"
   },
   "dependencies": {
-    "citty": "^0.1.6",
     "valibot": "^1.4.2"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "oxfmt": "^0.66.0",
+    "oxfmt": "^0.72.0",
     "oxlint": "^1.81.0",
     "typescript": "^5.6.0"
   },