@soprog_/cdwt 0.1.0

package/dist/cli.js

@@ -0,0 +1,1787 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import pc2 from "picocolors";
+
+// src/errors.ts
+var CdwtError = class extends Error {
+  constructor(message, code = 1) {
+    super(message);
+    this.code = code;
+    this.name = "CdwtError";
+  }
+  code;
+};
+
+// src/commands/install.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import pc from "picocolors";
+
+// src/core/rc-file.ts
+function appendLineIfMissing(existing, line2) {
+  const target = line2.trim();
+  if (target === "") return { contents: existing, changed: false };
+  for (const rawLine of existing.split("\n")) {
+    if (rawLine.trim() === target) {
+      return { contents: existing, changed: false };
+    }
+  }
+  if (existing === "") {
+    return { contents: `${target}
+`, changed: true };
+  }
+  const separator = existing.endsWith("\n") ? "" : "\n";
+  return { contents: `${existing}${separator}${target}
+`, changed: true };
+}
+
+// src/commands/install.ts
+var SHELL_FILE = "cdwt.zsh";
+var SHELL_FUNCTION = `cdwt() {
+  local destination
+  case "\${1-}" in
+    -h|--help)
+      command cdwt "$@"
+      return $?
+      ;;
+  esac
+  if ! destination="$(command cdwt "$@")"; then
+    return $?
+  fi
+  if [[ -z "$destination" ]]; then
+    return 1
+  fi
+  cd "$destination" || return $?
+}
+`;
+var RC_LINE = 'source "$HOME/.local/share/cdwt/cdwt.zsh"';
+async function runInstall(options) {
+  const { console } = options;
+  const shareDir = path.join(options.home, ".local", "share", "cdwt");
+  const shellFile = path.join(shareDir, SHELL_FILE);
+  await mkdir(shareDir, { recursive: true });
+  await writeFile(shellFile, SHELL_FUNCTION, { mode: 420 });
+  const rcFile = options.rcFile ?? path.join(options.home, ".zshrc");
+  const existing = await fileExists(rcFile) ? await readFile(rcFile, "utf8") : "";
+  const result = appendLineIfMissing(existing, RC_LINE);
+  if (result.changed) {
+    await writeFile(rcFile, result.contents);
+  }
+  console.outln(`${pc.green("\u2713")} installed shell wrapper to ${shellFile}`);
+  console.outln(
+    `${pc.green("\u2713")} ${result.changed ? "added" : "kept"} \`source\` line in ${rcFile}`
+  );
+  console.outln("");
+  console.outln("Reload your shell with one of:");
+  console.outln(`  exec zsh -l`);
+  console.outln(`  source "${rcFile}"`);
+  return 0;
+}
+async function fileExists(file) {
+  try {
+    const s = await stat(file);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+function defaultHome() {
+  return process.env["HOME"] ?? homedir();
+}
+
+// src/commands/select.ts
+import { homedir as homedir2 } from "os";
+
+// src/core/paths.ts
+import path2 from "path";
+function displayPath({
+  path: target,
+  mainWorktree,
+  mainParent,
+  home
+}) {
+  if (target === mainWorktree) return ".";
+  if (mainWorktree && target.startsWith(`${mainWorktree}/`)) {
+    return `./${target.slice(mainWorktree.length + 1)}`;
+  }
+  if (mainParent && target.startsWith(`${mainParent}/`)) {
+    return `../${target.slice(mainParent.length + 1)}`;
+  }
+  if (home && target.startsWith(`${home}/`)) {
+    return `~/${target.slice(home.length + 1)}`;
+  }
+  return target;
+}
+function slugifyBranch(branch) {
+  let slug = branch.replace(/[/ ]/g, "-").replace(/[^A-Za-z0-9._-]/g, "-");
+  slug = slug.replace(/^-+/, "").replace(/-+$/, "");
+  if (slug === "") return "worktree";
+  return slug;
+}
+function makeBranchPath(branch, mainWorktree, repoName) {
+  const parent = path2.dirname(mainWorktree);
+  return `${parent}/${repoName}-${slugifyBranch(branch)}`;
+}
+function makePrPath(prNumber, mainWorktree, repoName) {
+  const parent = path2.dirname(mainWorktree);
+  return `${parent}/${repoName}-pr-${prNumber}`;
+}
+
+// src/core/sections.ts
+function deriveBranchesWithWorktree(repo) {
+  const set = /* @__PURE__ */ new Set();
+  for (const wt of repo.worktrees) {
+    if (wt.branch && wt.path !== repo.mainWorktree) {
+      set.add(wt.branch);
+    }
+  }
+  return set;
+}
+function buildSections({
+  repo,
+  prs,
+  localBranches,
+  home
+}) {
+  const lines = [];
+  const branchesWithWorktree = deriveBranchesWithWorktree(repo);
+  const prBranches = /* @__PURE__ */ new Set();
+  const rootMarker = repo.mainWorktree === repo.currentPath ? " [current]" : "";
+  lines.push(
+    line({
+      kind: "worktree",
+      section: "main",
+      name: `${repo.repoName}${rootMarker}`,
+      shortPath: ".",
+      fullPath: repo.mainWorktree,
+      destination: repo.mainWorktree,
+      branch: repo.mainWorktreeBranch ?? ""
+    })
+  );
+  for (const wt of repo.worktrees) {
+    if (wt.path === repo.mainWorktree) continue;
+    const label = worktreeLabel(wt, repo.currentPath);
+    lines.push(
+      line({
+        kind: "worktree",
+        section: "wt",
+        name: label,
+        shortPath: displayPath({
+          path: wt.path,
+          mainWorktree: repo.mainWorktree,
+          mainParent: repo.mainParent,
+          home
+        }),
+        fullPath: wt.path,
+        destination: wt.path,
+        branch: wt.branch ?? ""
+      })
+    );
+  }
+  for (const pr of prs) {
+    prBranches.add(pr.branch);
+    const existingWorktreePath = findNonMainWorktreePathForBranch(
+      repo.worktrees,
+      pr.branch,
+      repo.mainWorktree
+    );
+    const targetPath = existingWorktreePath ?? makePrPath(pr.number, repo.mainWorktree, repo.repoName);
+    lines.push(
+      line({
+        kind: "pr",
+        section: "pr",
+        name: `#${pr.number} ${pr.title}`,
+        shortPath: displayPath({
+          path: targetPath,
+          mainWorktree: repo.mainWorktree,
+          mainParent: repo.mainParent,
+          home
+        }),
+        fullPath: targetPath,
+        destination: targetPath,
+        branch: pr.branch,
+        prNumber: pr.number
+      })
+    );
+  }
+  for (const branch of localBranches) {
+    if (branchesWithWorktree.has(branch)) continue;
+    if (prBranches.has(branch)) continue;
+    const targetPath = makeBranchPath(branch, repo.mainWorktree, repo.repoName);
+    lines.push(
+      line({
+        kind: "branch",
+        section: "br",
+        name: branch,
+        shortPath: displayPath({
+          path: targetPath,
+          mainWorktree: repo.mainWorktree,
+          mainParent: repo.mainParent,
+          home
+        }),
+        fullPath: targetPath,
+        destination: targetPath,
+        branch
+      })
+    );
+  }
+  return lines;
+}
+function line(input) {
+  return {
+    kind: input.kind,
+    section: input.section,
+    name: input.name,
+    shortPath: input.shortPath,
+    fullPath: input.fullPath,
+    destination: input.destination,
+    branch: input.branch,
+    prNumber: input.prNumber ?? null
+  };
+}
+function worktreeLabel(wt, currentPath) {
+  const baseLabel = wt.branch ? wt.branch : wt.head ? `detached@${wt.head.slice(0, 7)}` : "detached";
+  const marker = wt.path === currentPath ? " [current]" : "";
+  return `${baseLabel}${marker}`;
+}
+function findNonMainWorktreePathForBranch(worktrees, branch, mainWorktree) {
+  for (const wt of worktrees) {
+    if (wt.path === mainWorktree) continue;
+    if (wt.branch === branch) return wt.path;
+  }
+  return null;
+}
+
+// src/io/config-loader.ts
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import path3 from "path";
+
+// src/core/config.ts
+var ConfigError = class extends Error {
+  constructor(message, file) {
+    super(message);
+    this.file = file;
+    this.name = "ConfigError";
+  }
+  file;
+};
+function emptyConfig() {
+  return { copyIgnored: { paths: [], patterns: [] } };
+}
+function parseConfig(json, file) {
+  if (json === null || typeof json !== "object" || Array.isArray(json)) {
+    throw new ConfigError("config root must be an object", file);
+  }
+  const root = json;
+  const copyRaw = root["copyIgnored"];
+  if (copyRaw === void 0) {
+    return { copyIgnored: {} };
+  }
+  if (copyRaw === null || typeof copyRaw !== "object" || Array.isArray(copyRaw)) {
+    throw new ConfigError("copyIgnored must be an object", file);
+  }
+  const copy = copyRaw;
+  const out = { copyIgnored: {} };
+  if ("paths" in copy) {
+    out.copyIgnored.paths = readStringArray(copy["paths"], "copyIgnored.paths", file);
+  }
+  if ("patterns" in copy) {
+    out.copyIgnored.patterns = readStringArray(copy["patterns"], "copyIgnored.patterns", file);
+  }
+  return out;
+}
+function readStringArray(value, key, file) {
+  if (!Array.isArray(value)) {
+    throw new ConfigError(`${key} must be an array`, file);
+  }
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new ConfigError(`${key} must contain only strings`, file);
+    }
+  }
+  return [...value];
+}
+function mergeConfigs(configs) {
+  const merged = emptyConfig();
+  for (const config of configs) {
+    if (config.copyIgnored.paths !== void 0) {
+      merged.copyIgnored.paths = [...config.copyIgnored.paths];
+    }
+    if (config.copyIgnored.patterns !== void 0) {
+      merged.copyIgnored.patterns = [...config.copyIgnored.patterns];
+    }
+  }
+  return merged;
+}
+
+// src/io/config-loader.ts
+async function discoverConfigFiles({
+  cwd,
+  mainWorktree,
+  home,
+  override,
+  debug
+}) {
+  if (override !== void 0) {
+    const exists = await fileExists2(override);
+    debug?.(`config override path=${override} exists=${exists}`);
+    if (!exists) {
+      throw new CdwtError(`config file not found: ${override}`);
+    }
+    return [override];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  const homeFile = path3.join(home, ".cdwt", "settings.json");
+  const homeExists = await fileExists2(homeFile);
+  debug?.(`config check path=${homeFile} hit=${homeExists}`);
+  if (homeExists) {
+    seen.add(homeFile);
+    files.push(homeFile);
+  }
+  let scan = cwd;
+  if (scan !== mainWorktree && !scan.startsWith(`${mainWorktree}/`)) {
+    scan = mainWorktree;
+  }
+  const dirs = [];
+  while (true) {
+    dirs.push(scan);
+    if (scan === "/" || scan === "") break;
+    scan = path3.dirname(scan);
+  }
+  for (let i = dirs.length - 1; i >= 0; i--) {
+    const file = path3.join(dirs[i], ".cdwt", "settings.json");
+    if (seen.has(file)) continue;
+    const exists = await fileExists2(file);
+    debug?.(`config check path=${file} hit=${exists}`);
+    if (exists) {
+      seen.add(file);
+      files.push(file);
+    }
+  }
+  debug?.(`config discovery complete: found ${files.length} file(s): [${files.join(", ")}]`);
+  return files;
+}
+async function readMergedConfig(files) {
+  const parsed = [];
+  for (const file of files) {
+    let raw;
+    try {
+      raw = await readFile2(file, "utf8");
+    } catch (err) {
+      throw new CdwtError(`failed to read config: ${file} (${err.message})`);
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch (err) {
+      throw new CdwtError(`invalid JSON in ${file}: ${err.message}`);
+    }
+    try {
+      parsed.push(parseConfig(json, file));
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        throw new CdwtError(`invalid config: ${file} (${err.message})`);
+      }
+      throw err;
+    }
+  }
+  return mergeConfigs(parsed);
+}
+async function fileExists2(file) {
+  try {
+    const s = await stat2(file);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/io/exec.ts
+import { spawn } from "child_process";
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const t0 = Date.now();
+    const stdio = options.inheritStdio ? ["inherit", process.stderr, "inherit"] : ["pipe", "pipe", "pipe"];
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio
+    });
+    if (options.inheritStdio) {
+      child.on("error", reject);
+      child.on("close", (exitCode2) => {
+        const code = exitCode2 ?? 0;
+        const elapsed = Date.now() - t0;
+        options.onDebug?.(
+          `exec [inherited] ${command} ${args.join(" ")} cwd=${options.cwd ?? "."} exit=${code} +${elapsed}ms`
+        );
+        resolve({ stdout: "", stderr: "", exitCode: code });
+      });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.on("close", (exitCode2) => {
+      const code = exitCode2 ?? 0;
+      const elapsed = Date.now() - t0;
+      options.onDebug?.(
+        `exec ${command} ${args.join(" ")} cwd=${options.cwd ?? "."} exit=${code} stdout=${stdout.length}B stderr=${stderr.length}B +${elapsed}ms`
+      );
+      resolve({ stdout, stderr, exitCode: code });
+    });
+    if (options.input !== void 0) {
+      child.stdin?.write(options.input);
+      child.stdin?.end();
+    }
+  });
+}
+
+// src/io/gh.ts
+async function isGhAvailable() {
+  const result = await run("which", ["gh"]);
+  return result.exitCode === 0;
+}
+async function listPullRequests(cwd, limit = 100) {
+  const result = await run(
+    "gh",
+    ["pr", "list", "--limit", String(limit), "--json", "number,title,headRefName"],
+    { cwd }
+  );
+  if (result.exitCode !== 0) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const item of parsed) {
+    if (!isGhPrItem(item)) continue;
+    out.push({ number: item.number, branch: item.headRefName, title: item.title });
+  }
+  return out;
+}
+async function checkoutPr(cwd, prNumber) {
+  const result = await run("gh", ["pr", "checkout", String(prNumber)], {
+    cwd,
+    inheritStdio: true
+  });
+  return result.exitCode === 0;
+}
+function isGhPrItem(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v["number"] === "number" && typeof v["title"] === "string" && typeof v["headRefName"] === "string";
+}
+
+// src/io/git.ts
+import path4 from "path";
+import { realpath } from "fs/promises";
+
+// src/core/git-parse.ts
+function parseWorktreeList(output) {
+  const worktrees = [];
+  let current = null;
+  const flush = () => {
+    if (current && current.path) {
+      worktrees.push({ ...current });
+    }
+    current = null;
+  };
+  for (const rawLine of output.split("\n")) {
+    const line2 = rawLine.replace(/\r$/, "");
+    if (line2 === "") {
+      flush();
+      continue;
+    }
+    if (line2.startsWith("worktree ")) {
+      flush();
+      current = { path: line2.slice("worktree ".length), branch: null, head: null };
+      continue;
+    }
+    if (!current) continue;
+    if (line2.startsWith("branch ")) {
+      const ref = line2.slice("branch ".length);
+      current.branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+    } else if (line2.startsWith("HEAD ")) {
+      current.head = line2.slice("HEAD ".length);
+    }
+  }
+  flush();
+  return worktrees;
+}
+
+// src/io/git.ts
+var _gitDebug;
+function setGitDebug(fn) {
+  _gitDebug = fn;
+}
+async function loadGitContext(cwd) {
+  let realCwd;
+  try {
+    realCwd = await realpath(cwd);
+  } catch {
+    throw new CdwtError(`invalid working directory: ${cwd}`);
+  }
+  const root = await runGit(["rev-parse", "--show-toplevel"], { cwd: realCwd });
+  if (root.exitCode !== 0) {
+    throw new CdwtError("not inside a git worktree");
+  }
+  const commonDirResult = await runGit(["rev-parse", "--git-common-dir"], { cwd: realCwd });
+  if (commonDirResult.exitCode !== 0) {
+    throw new CdwtError("failed to resolve git common dir");
+  }
+  let commonDir = commonDirResult.stdout.trim();
+  if (!path4.isAbsolute(commonDir)) {
+    commonDir = await realpath(path4.resolve(realCwd, commonDir));
+  }
+  return {
+    cwd: realCwd,
+    gitRoot: root.stdout.trim(),
+    gitCommonDir: commonDir,
+    expectedMainWorktree: path4.dirname(commonDir)
+  };
+}
+async function listWorktrees(cwd) {
+  const result = await runGit(["worktree", "list", "--porcelain"], { cwd });
+  if (result.exitCode !== 0) {
+    throw new CdwtError("failed to list git worktrees");
+  }
+  return parseWorktreeList(result.stdout);
+}
+async function symbolicRef(cwd, ref) {
+  const result = await runGit(["symbolic-ref", "--quiet", "--short", ref], { cwd });
+  return result.exitCode === 0 ? result.stdout.trim() : null;
+}
+async function listLocalBranches(cwd) {
+  const result = await runGit(["for-each-ref", "--format=%(refname:short)", "refs/heads"], {
+    cwd
+  });
+  if (result.exitCode !== 0) return [];
+  return result.stdout.split("\n").filter((line2) => line2.length > 0);
+}
+async function listRemoteBranches(cwd) {
+  const result = await runGit(
+    ["for-each-ref", "--format=%(refname:short)", "refs/remotes/origin"],
+    { cwd }
+  );
+  if (result.exitCode !== 0) return [];
+  return result.stdout.split("\n").filter((line2) => line2.length > 0 && line2 !== "origin/HEAD").map((line2) => line2.replace(/^origin\//, ""));
+}
+async function branchExists(cwd, branch) {
+  const result = await runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+    cwd
+  });
+  return result.exitCode === 0;
+}
+async function checkRefFormat(cwd, branch) {
+  const result = await runGit(["check-ref-format", "--branch", branch], { cwd });
+  return result.exitCode === 0;
+}
+async function isGitIgnored(cwd, relativePath) {
+  const result = await runGit(["check-ignore", "-q", "--", relativePath], { cwd });
+  return result.exitCode === 0;
+}
+async function listIgnoredFilesMatching(cwd, pathspecs) {
+  if (pathspecs.length === 0) return [];
+  const result = await runGit(
+    ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", ...pathspecs],
+    { cwd }
+  );
+  if (result.exitCode !== 0) return [];
+  return result.stdout.split("\0").filter((p) => p.length > 0);
+}
+async function runGitInherited(args, cwd) {
+  const result = await run("git", args, { cwd, inheritStdio: true, ..._gitDebug && { onDebug: _gitDebug } });
+  return result.exitCode;
+}
+async function addWorktreeForBranch(cwd, destination, branch) {
+  const code = await runGitInherited(["worktree", "add", destination, branch], cwd);
+  if (code !== 0) {
+    throw new CdwtError(`git worktree add failed for ${branch} (exit ${code})`);
+  }
+}
+async function addWorktreeNewBranch(cwd, destination, branch, baseRef) {
+  const code = await runGitInherited(["worktree", "add", "-b", branch, destination, baseRef], cwd);
+  if (code !== 0) {
+    throw new CdwtError(`git worktree add -b ${branch} from ${baseRef} failed (exit ${code})`);
+  }
+}
+async function addWorktreeDetached(cwd, destination) {
+  const code = await runGitInherited(["worktree", "add", "--detach", destination], cwd);
+  if (code !== 0) {
+    throw new CdwtError(`git worktree add --detach failed at ${destination} (exit ${code})`);
+  }
+}
+async function removeWorktree(cwd, target) {
+  const result = await run("git", ["worktree", "remove", target], { cwd, ..._gitDebug && { onDebug: _gitDebug } });
+  return { exitCode: result.exitCode, stderr: result.stderr };
+}
+async function removeWorktreeForceRaw(cwd, target) {
+  const result = await run("git", ["worktree", "remove", "--force", target], {
+    cwd,
+    ..._gitDebug && { onDebug: _gitDebug }
+  });
+  return { exitCode: result.exitCode, stderr: result.stderr };
+}
+async function removeWorktreeForce(cwd, target, console) {
+  const result = await removeWorktreeForceRaw(cwd, target);
+  if (result.exitCode === 0) return;
+  if (result.stderr) console.err(result.stderr);
+  console.errln(
+    `cdwt: warning: failed to remove orphan worktree at ${target}; clean up with: git worktree remove --force "${target}"`
+  );
+}
+async function runGit(args, options) {
+  return run("git", args, { cwd: options.cwd, ..._gitDebug && { onDebug: _gitDebug } });
+}
+
+// src/io/repo-context.ts
+import path5 from "path";
+
+// src/core/default-branch.ts
+var FALLBACK_CANDIDATES = ["main", "master"];
+function resolveDefaultBranch(input) {
+  let branch = null;
+  if (input.remoteHead) {
+    branch = input.remoteHead.startsWith("origin/") ? input.remoteHead.slice("origin/".length) : input.remoteHead;
+  }
+  if (!branch && input.mainWorktreeBranch) {
+    branch = input.mainWorktreeBranch;
+  }
+  if (!branch) {
+    for (const candidate of FALLBACK_CANDIDATES) {
+      if (input.localBranches.has(candidate) || input.remoteBranches.has(candidate)) {
+        branch = candidate;
+        break;
+      }
+    }
+  }
+  if (!branch) {
+    return { branch: null, ref: null };
+  }
+  if (input.localBranches.has(branch)) {
+    return { branch, ref: branch };
+  }
+  if (input.remoteBranches.has(branch)) {
+    return { branch, ref: `origin/${branch}` };
+  }
+  if (input.worktreeBranches.has(branch)) {
+    return { branch, ref: branch };
+  }
+  return { branch, ref: null };
+}
+
+// src/io/repo-context.ts
+async function loadRepoContext(cwd) {
+  const git = await loadGitContext(cwd);
+  const worktrees = await listWorktrees(git.cwd);
+  const main2 = worktrees.find((wt) => wt.path === git.expectedMainWorktree);
+  if (!main2) {
+    throw new CdwtError("failed to detect the main worktree");
+  }
+  const mainParent = path5.dirname(main2.path);
+  const repoName = path5.basename(main2.path);
+  const [remoteHead, localBranches, remoteBranches] = await Promise.all([
+    symbolicRef(git.cwd, "refs/remotes/origin/HEAD"),
+    listLocalBranches(git.cwd),
+    listRemoteBranches(git.cwd)
+  ]);
+  const worktreeBranches = /* @__PURE__ */ new Set();
+  for (const wt of worktrees) {
+    if (wt.branch) worktreeBranches.add(wt.branch);
+  }
+  const { branch, ref } = resolveDefaultBranch({
+    remoteHead,
+    mainWorktreeBranch: main2.branch,
+    localBranches: new Set(localBranches),
+    remoteBranches: new Set(remoteBranches),
+    worktreeBranches
+  });
+  return {
+    mainWorktree: main2.path,
+    mainParent,
+    repoName,
+    defaultBranch: branch,
+    defaultBranchRef: ref,
+    mainWorktreeBranch: main2.branch,
+    worktrees,
+    cwd: git.cwd,
+    currentPath: git.gitRoot
+  };
+}
+
+// src/ui/fzf.ts
+import { spawn as spawn2 } from "child_process";
+async function isFzfAvailable() {
+  const result = await run("which", ["fzf"]);
+  return result.exitCode === 0;
+}
+function runFzf({ args, input }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("fzf", args, {
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    let stdout = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ exitCode: code ?? 0, stdout }));
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
+// src/ui/format.ts
+var FIELD_SEP = "";
+var TAG_WIDTH = 11;
+var NAME_WIDTH = 44;
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var BOLD = `${ESC}1m`;
+var FG_GREEN = `${ESC}32m`;
+var FG_YELLOW = `${ESC}33m`;
+var FG_CYAN = `${ESC}36m`;
+var FG_MAGENTA = `${ESC}35m`;
+var FG_GRAY = `${ESC}90m`;
+var STYLES = {
+  main: { label: "main", glyph: "\u2605", color: `${BOLD}${FG_GREEN}` },
+  wt: { label: "worktree", glyph: "\u25CF", color: FG_CYAN },
+  br: { label: "branch", glyph: "\u25CB", color: FG_YELLOW },
+  pr: { label: "PR", glyph: "\u25C6", color: FG_MAGENTA }
+};
+function renderLine(line2) {
+  const style = STYLES[line2.section];
+  const tag = pad(`[${style.label}]`, TAG_WIDTH);
+  const paddedName = pad(line2.name, NAME_WIDTH);
+  const head = `${style.color}${style.glyph} ${tag} ${paddedName}${RESET}`;
+  const pathHint = `${FG_GRAY}${line2.shortPath}${RESET}`;
+  const visible = `${head} ${pathHint}`;
+  return `${visible}${FIELD_SEP}${line2.shortPath}${FIELD_SEP}${line2.fullPath}`;
+}
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function sectionLabel(section) {
+  return STYLES[section].label;
+}
+function pad(value, width) {
+  return value.length >= width ? value : value + " ".repeat(width - value.length);
+}
+
+// src/ui/selector.ts
+var FILTER_ORDER = ["all", "wt", "br", "pr"];
+function filterLabel(filter) {
+  return filter === "all" ? "all" : sectionLabel(filter);
+}
+var FILTER_CYCLE_LABEL = `${FILTER_ORDER.map(filterLabel).join(" / ")}`;
+var COMMAND_SENTINEL = "__CDWT_CMD__";
+var FOOTER = "\u21B5 go   esc cancel   tab filter   ctrl-d delete   / commands   ? help";
+var HELP_BODY = [
+  "shortcuts",
+  "  enter            go to highlighted entry",
+  "  esc              cancel",
+  `  tab / shift-tab  cycle filter (${FILTER_CYCLE_LABEL})`,
+  "  ctrl-d           delete the highlighted worktree",
+  "  /                open the slash command palette",
+  "  ?                this help",
+  "",
+  "row legend",
+  "  \u2605 [main]      default-branch worktree (enter = jump)",
+  "  \u25CF [worktree]  existing linked worktree (enter = jump)",
+  "  \u25CB [branch]    local branch without a worktree (enter = create then jump)",
+  "  \u25C6 [PR]        GitHub PR (enter = checkout into a worktree then jump)"
+];
+async function selectInteractive(allLines, options) {
+  if (allLines.length === 0) return { kind: "cancelled" };
+  const useFzf = options.useFzf ?? await isFzfAvailable();
+  options.console.debug(
+    `selector mode=${useFzf ? "fzf" : "prompt"} totalLines=${allLines.length} initialFilter=${options.initialFilter ?? "all"}`
+  );
+  if (useFzf) {
+    return selectWithFzf(allLines, options);
+  }
+  return selectWithPrompt(allLines, options);
+}
+async function selectWithFzf(allLines, options) {
+  const runFzf2 = options.fzfRunner ?? runFzf;
+  let filter = options.initialFilter ?? "all";
+  const prompt = options.prompt ?? "> ";
+  const footer = options.footer ?? FOOTER;
+  while (true) {
+    const visible = applyFilter(allLines, filter);
+    if (visible.length === 0) {
+      filter = "all";
+      continue;
+    }
+    const inputLines = visible.map((line2) => renderLine(line2));
+    const lookup = new Map(visible.map((line2) => [stripAnsi(renderLine(line2)), line2]));
+    const header = filter === "all" ? "" : `filter: ${filterLabel(filter)}`;
+    const result = await runFzf2({
+      args: [
+        `--prompt=${prompt}`,
+        "--print-query",
+        `--delimiter=${FIELD_SEP}`,
+        "--nth=1",
+        // Field 1 carries the colored "glyph + [tag] + name + dim path" row,
+        // fields 2/3 are data-only (preview / cd target). --with-nth=1 keeps
+        // the visible row tidy; --ansi makes fzf interpret the color codes
+        // and strip them when matching/printing.
+        "--with-nth=1",
+        "--ansi",
+        "--expect=tab,btab,?,ctrl-d",
+        "--height=70%",
+        "--reverse",
+        "--layout=reverse",
+        "--info=inline-right",
+        "--header-first",
+        `--header=${header}`,
+        `--footer=${footer}`,
+        "--preview",
+        'if [ -n "{3}" ]; then printf "%s\\n" {3}; fi',
+        "--preview-window=down:3:wrap",
+        // `/` leaves the picker. `become` replaces fzf with a printf that
+        // writes the sentinel; we dispatch into command-mode from the caller.
+        `--bind=/:become(printf '%s\\n' '${COMMAND_SENTINEL}')`
+      ],
+      input: inputLines.join("\n")
+    });
+    options.console.debug(
+      `fzf returned exit=${result.exitCode} stdoutBytes=${result.stdout.length}`
+    );
+    if (containsCommandSentinel(result.stdout)) {
+      return { kind: "command-mode" };
+    }
+    const outcome = parsePickerOutput(result.stdout, result.exitCode);
+    options.console.debug(
+      `fzf parsed key=${JSON.stringify(outcome.key)} query=${JSON.stringify(outcome.query)} selected=${outcome.selected ? "yes" : "no"}`
+    );
+    if (outcome.cancelled) return { kind: "cancelled" };
+    if (outcome.key === "tab") {
+      filter = nextFilter(filter, 1);
+      continue;
+    }
+    if (outcome.key === "btab") {
+      filter = nextFilter(filter, -1);
+      continue;
+    }
+    if (outcome.key === "?") {
+      await runHelpOverlay(runFzf2);
+      continue;
+    }
+    if (outcome.key === "ctrl-d") {
+      if (outcome.selected) {
+        const line2 = lookup.get(stripAnsi(outcome.selected));
+        if (line2) return { kind: "delete-target", line: line2 };
+      }
+      continue;
+    }
+    if (outcome.selected) {
+      const line2 = lookup.get(stripAnsi(outcome.selected));
+      if (line2) return { kind: "selected", line: line2 };
+    }
+    return { kind: "cancelled" };
+  }
+}
+function containsCommandSentinel(stdout) {
+  return stdout.split("\n").some((line2) => line2 === COMMAND_SENTINEL);
+}
+function parsePickerOutput(stdout, exitCode2) {
+  if (exitCode2 !== 0 && stdout === "") {
+    return { cancelled: true, query: "", key: "", selected: "" };
+  }
+  const lines = stdout.replace(/\n$/, "").split("\n");
+  return {
+    cancelled: false,
+    query: lines[0] ?? "",
+    key: lines[1] ?? "",
+    selected: lines[2] ?? ""
+  };
+}
+function applyFilter(lines, filter) {
+  if (filter === "all") return [...lines];
+  return lines.filter((l) => sectionMatches(l.section, filter));
+}
+function sectionMatches(section, filter) {
+  return section === filter;
+}
+function nextFilter(current, step) {
+  const idx = FILTER_ORDER.indexOf(current);
+  const next = (idx + step + FILTER_ORDER.length) % FILTER_ORDER.length;
+  return FILTER_ORDER[next];
+}
+async function runHelpOverlay(runFzf2) {
+  await runFzf2({
+    args: [
+      "--prompt=help> ",
+      "--height=70%",
+      "--reverse",
+      "--layout=reverse",
+      "--info=hidden",
+      "--header-first",
+      "--header=press esc to close",
+      "--no-sort",
+      "--disabled"
+    ],
+    input: HELP_BODY.join("\n")
+  });
+}
+var MAX_PROMPT_RETRIES = 5;
+async function selectWithPrompt(allLines, options) {
+  const console = options.console;
+  let filter = options.initialFilter ?? "all";
+  for (let attempt = 0; attempt < MAX_PROMPT_RETRIES; attempt++) {
+    const visible = applyFilter(allLines, filter);
+    if (visible.length === 0) {
+      filter = "all";
+      continue;
+    }
+    console.errln("");
+    if (filter !== "all") console.errln(`(filter: ${filterLabel(filter)})`);
+    visible.forEach(
+      (line2, idx) => console.errln(
+        `${String(idx + 1).padStart(2)}) ${renderLine(line2).split(FIELD_SEP)[0] ?? line2.name}`
+      )
+    );
+    console.errln(
+      "type number to go, d <number> to delete, /<command> for slash mode, blank to cancel"
+    );
+    const answer = await console.ask("> ");
+    if (answer === null) return { kind: "cancelled" };
+    const trimmed = answer.trim();
+    if (trimmed === "") return { kind: "cancelled" };
+    if (trimmed.startsWith("/")) {
+      return { kind: "command-mode", initialInput: trimmed };
+    }
+    if (trimmed === "tab") {
+      filter = nextFilter(filter, 1);
+      continue;
+    }
+    if (trimmed === "?") {
+      console.errln(HELP_BODY.join("\n"));
+      continue;
+    }
+    const deleteMatch = /^d\s+(\d+)$/i.exec(trimmed);
+    if (deleteMatch) {
+      const n2 = Number.parseInt(deleteMatch[1], 10);
+      if (!Number.isFinite(n2) || n2 < 1 || n2 > visible.length) {
+        console.errln("cdwt: invalid selection");
+        continue;
+      }
+      return { kind: "delete-target", line: visible[n2 - 1] };
+    }
+    const n = Number.parseInt(trimmed, 10);
+    if (!Number.isFinite(n) || n < 1 || n > visible.length) {
+      console.errln("cdwt: invalid selection");
+      continue;
+    }
+    return { kind: "selected", line: visible[n - 1] };
+  }
+  console.errln("cdwt: too many invalid attempts; aborting");
+  return { kind: "cancelled" };
+}
+
+// src/commands/slash-commands.ts
+var NEW_CMD = {
+  name: "new",
+  aliases: ["n"],
+  description: "create a worktree from the default branch",
+  argHint: "<branch>",
+  async execute(rawArgs, host) {
+    const branch = rawArgs.trim() === "" ? void 0 : rawArgs.trim();
+    const code = await host.createNewWorktree(branch);
+    return { kind: "exit", code };
+  }
+};
+var MAIN_CMD = {
+  name: "main",
+  aliases: ["home"],
+  description: "jump to the main worktree",
+  execute(_rawArgs, host) {
+    host.printMainDestination();
+    return Promise.resolve({ kind: "exit", code: 0 });
+  }
+};
+var PR_CMD = {
+  name: "pr",
+  aliases: [],
+  description: "load and filter pull requests",
+  async execute(_rawArgs, host) {
+    await host.loadPrs();
+    return { kind: "continue" };
+  }
+};
+var REFRESH_CMD = {
+  name: "refresh",
+  aliases: ["reload", "r"],
+  description: "reload worktrees, branches, and PRs",
+  async execute(_rawArgs, host) {
+    await host.refresh();
+    return { kind: "continue" };
+  }
+};
+var HELP_CMD = {
+  name: "help",
+  aliases: ["h", "?"],
+  description: "show command help",
+  execute(_rawArgs, host) {
+    host.console.errln(buildHelpText(SLASH_COMMANDS));
+    return Promise.resolve({ kind: "continue" });
+  }
+};
+var SLASH_COMMANDS = [
+  NEW_CMD,
+  MAIN_CMD,
+  PR_CMD,
+  REFRESH_CMD,
+  HELP_CMD
+];
+function findCommand(name) {
+  if (name === "") return null;
+  return SLASH_COMMANDS.find((c) => c.name === name || c.aliases.includes(name)) ?? null;
+}
+function parseCommandLine(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const body = trimmed.slice(1).trim();
+  if (body === "") return null;
+  const [head, ...rest] = body.split(/\s+/);
+  if (head === void 0 || head === "") return null;
+  const command = findCommand(head);
+  if (!command) return null;
+  return { command, args: rest.join(" ") };
+}
+function buildHelpText(commands) {
+  const rows = commands.map((cmd) => {
+    const aliases = cmd.aliases.map((a) => `/${a}`).join(", ");
+    const left = `/${cmd.name}${cmd.argHint ? ` ${cmd.argHint}` : ""}`;
+    const aliasPart = aliases ? `  (${aliases})` : "";
+    return `  ${left.padEnd(20)} ${cmd.description}${aliasPart}`;
+  });
+  return ["slash commands", ...rows].join("\n");
+}
+
+// src/ui/command-mode.ts
+var PROMPT = "cmd> ";
+async function runCommandMode(options) {
+  if (options.initialInput !== void 0) {
+    const parsed = parseCommandLine(options.initialInput);
+    if (parsed) {
+      return resolveArgs(parsed.command, parsed.args, options);
+    }
+    options.console.errln(`cdwt: unknown command: ${options.initialInput.trim()}`);
+  }
+  const useFzf = options.useFzf ?? await isFzfAvailable();
+  if (useFzf) return runWithFzf(options);
+  return runWithPrompt(options);
+}
+var MAX_PROMPT_RETRIES2 = 5;
+async function runWithPrompt(options) {
+  const { console, registry } = options;
+  for (let attempt = 0; attempt < MAX_PROMPT_RETRIES2; attempt++) {
+    console.errln("");
+    registry.forEach((cmd, idx) => console.errln(formatPaletteRow(cmd, idx + 1)));
+    console.errln(
+      "type number to pick, /<name> [args] to dispatch directly, blank to cancel"
+    );
+    const answer = await console.ask(PROMPT);
+    if (answer === null) return { kind: "cancelled" };
+    const trimmed = answer.trim();
+    if (trimmed === "") return { kind: "cancelled" };
+    if (trimmed.startsWith("/")) {
+      const parsed = parseCommandLine(trimmed);
+      if (parsed) return resolveArgs(parsed.command, parsed.args, options);
+      console.errln(`cdwt: unknown command: ${trimmed}`);
+      continue;
+    }
+    const n = Number.parseInt(trimmed, 10);
+    if (!Number.isFinite(n) || n < 1 || n > registry.length) {
+      console.errln("cdwt: invalid selection");
+      continue;
+    }
+    const command = registry[n - 1];
+    return resolveArgs(command, "", options);
+  }
+  console.errln("cdwt: too many invalid attempts; aborting");
+  return { kind: "cancelled" };
+}
+async function runWithFzf(options) {
+  const runFzf2 = options.fzfRunner ?? runFzf;
+  const { registry, console } = options;
+  const inputLines = registry.map((cmd) => renderPaletteLine(cmd));
+  const lookup = new Map(inputLines.map((line2, idx) => [line2, registry[idx]]));
+  const result = await runFzf2({
+    args: [
+      `--prompt=${PROMPT}`,
+      "--print-query",
+      `--delimiter=${FIELD_SEP}`,
+      "--nth=1",
+      "--height=40%",
+      "--reverse",
+      "--layout=reverse",
+      "--info=inline-right",
+      "--header=pick a command"
+    ],
+    input: inputLines.join("\n")
+  });
+  if (result.exitCode !== 0 && result.stdout === "") {
+    return { kind: "cancelled" };
+  }
+  const lines = result.stdout.replace(/\n$/, "").split("\n");
+  const query = lines[0] ?? "";
+  const selected = lines[1] ?? "";
+  if (query.startsWith("/")) {
+    const parsed = parseCommandLine(query);
+    if (parsed) return resolveArgs(parsed.command, parsed.args, options);
+    console.errln(`cdwt: unknown command: ${query.trim()}`);
+    return { kind: "cancelled" };
+  }
+  const command = selected ? lookup.get(selected) : void 0;
+  if (!command) return { kind: "cancelled" };
+  return resolveArgs(command, "", options);
+}
+async function resolveArgs(command, rawArgs, options) {
+  if (command.argHint && rawArgs.trim() === "") {
+    const answer = await options.console.ask(`/${command.name} ${command.argHint}> `);
+    if (answer === null || answer.trim() === "") return { kind: "cancelled" };
+    return { kind: "command", command, args: answer.trim() };
+  }
+  return { kind: "command", command, args: rawArgs };
+}
+function renderPaletteLine(cmd) {
+  const left = `/${cmd.name}${cmd.argHint ? ` ${cmd.argHint}` : ""}`;
+  return `${left.padEnd(20)}${FIELD_SEP}${cmd.description}`;
+}
+function formatPaletteRow(cmd, n) {
+  const left = `/${cmd.name}${cmd.argHint ? ` ${cmd.argHint}` : ""}`;
+  return `${String(n).padStart(2)}) ${left.padEnd(20)} ${cmd.description}`;
+}
+
+// src/commands/actions.ts
+import { stat as stat4 } from "fs/promises";
+
+// src/io/copy-files.ts
+import { cp, mkdir as mkdir2, stat as stat3 } from "fs/promises";
+import path7 from "path";
+
+// src/core/copy.ts
+import path6 from "path";
+var UnsafeCopyPathError = class extends Error {
+  constructor(value) {
+    super(`refusing unsafe copy path: ${value}`);
+    this.value = value;
+    this.name = "UnsafeCopyPathError";
+  }
+  value;
+};
+function validateCopyPath(relativePath) {
+  if (relativePath === "" || relativePath.startsWith("/") || relativePath.includes("/../") || relativePath.startsWith("../") || relativePath === "..") {
+    throw new UnsafeCopyPathError(relativePath);
+  }
+}
+function patternsToPathspecs(patterns) {
+  const specs = [];
+  for (const p of patterns) {
+    if (p.includes("/")) {
+      specs.push(`:(glob)${p}`);
+    } else {
+      specs.push(`:(glob)**/${p}`);
+    }
+  }
+  return specs;
+}
+function copyPatternMatchesPath(relativePath, patterns) {
+  const base = path6.basename(relativePath);
+  for (const pattern of patterns) {
+    validateCopyPath(pattern);
+    if (pattern.includes("/")) {
+      if (fnmatch(relativePath, pattern)) return true;
+      continue;
+    }
+    if (fnmatch(base, pattern)) return true;
+    if (relativePath === pattern) return true;
+    if (relativePath.startsWith(`${pattern}/`)) return true;
+    if (relativePath.endsWith(`/${pattern}`)) return true;
+    if (relativePath.includes(`/${pattern}/`)) return true;
+  }
+  return false;
+}
+function fnmatch(input, pattern) {
+  let regex = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      regex += ".*";
+      while (pattern[i + 1] === "*") i++;
+    } else if (ch === "?") {
+      regex += ".";
+    } else if (ch === "[") {
+      const close = pattern.indexOf("]", i + 1);
+      if (close === -1) {
+        regex += "\\[";
+      } else {
+        regex += pattern.slice(i, close + 1);
+        i = close;
+      }
+    } else if (/[.+^${}()|\\]/.test(ch)) {
+      regex += `\\${ch}`;
+    } else {
+      regex += ch;
+    }
+  }
+  regex += "$";
+  return new RegExp(regex).test(input);
+}
+
+// src/io/copy-files.ts
+async function copyConfiguredIgnoredPaths(options) {
+  const { source, destination, config, console } = options;
+  const t0Total = Date.now();
+  console.debug(
+    `copyConfiguredIgnoredPaths start source=${source} destination=${destination} paths=[${config.copyIgnored.paths.join(",")}] patterns=[${config.copyIgnored.patterns.join(",")}]`
+  );
+  let timeInIsIgnored = 0;
+  let timeInCp = 0;
+  let copiedCount = 0;
+  let skippedCount = 0;
+  for (const relative of config.copyIgnored.paths) {
+    validateCopyPath(relative);
+    await copyOneIgnoredPath(source, destination, relative, console, {
+      onTimeIgnored: (ms) => {
+        timeInIsIgnored += ms;
+      },
+      onTimeCp: (ms) => {
+        timeInCp += ms;
+      },
+      onCopied: () => {
+        copiedCount++;
+      },
+      onSkipped: () => {
+        skippedCount++;
+      }
+    });
+  }
+  if (config.copyIgnored.patterns.length === 0) {
+    console.debug(
+      `copyConfiguredIgnoredPaths done (no patterns) elapsed=${Date.now() - t0Total}ms copied=${copiedCount} skipped=${skippedCount}`
+    );
+    return;
+  }
+  const pathspecs = patternsToPathspecs(config.copyIgnored.patterns);
+  const t0Ls = Date.now();
+  const ignored = await listIgnoredFilesMatching(source, pathspecs);
+  const lsElapsed = Date.now() - t0Ls;
+  console.debug(`git ls-files (targeted) returned ${ignored.length} entries in ${lsElapsed}ms`);
+  const matched = ignored.filter((f) => copyPatternMatchesPath(f, config.copyIgnored.patterns));
+  console.debug(`pattern filter: ${matched.length} of ${ignored.length} entries matched`);
+  for (const relative of matched) {
+    await copyOnePath(source, destination, relative, console, {
+      onTimeCp: (ms) => {
+        timeInCp += ms;
+      },
+      onCopied: () => {
+        copiedCount++;
+      }
+    });
+  }
+  const totalElapsed = Date.now() - t0Total;
+  console.debug(
+    `copyConfiguredIgnoredPaths done elapsed=${totalElapsed}ms copied=${copiedCount} skipped=${skippedCount} timeInIsIgnored=${timeInIsIgnored}ms timeInCp=${timeInCp}ms other=${totalElapsed - timeInIsIgnored - timeInCp}ms`
+  );
+}
+async function copyOneIgnoredPath(source, destination, relative, console, timers) {
+  validateCopyPath(relative);
+  const sourceItem = path7.join(source, relative);
+  const destinationItem = path7.join(destination, relative);
+  const sourceStat = await safeStat(sourceItem);
+  if (!sourceStat) {
+    console.debug(`copy skip (not found): ${relative}`);
+    return;
+  }
+  const t0Ignored = Date.now();
+  const ignored = await isGitIgnored(source, relative);
+  const ignoredElapsed = Date.now() - t0Ignored;
+  timers.onTimeIgnored(ignoredElapsed);
+  if (!ignored) {
+    console.debug(`copy skip (not git-ignored, isGitIgnored took ${ignoredElapsed}ms): ${relative}`);
+    timers.onSkipped();
+    console.errln(`cdwt: copy path is not ignored by git, skipping: ${relative}`);
+    return;
+  }
+  const sizeInfo = sourceStat.isDirectory() ? "dir" : `${sourceStat.size}B`;
+  console.debug(
+    `copy ${relative} (${sizeInfo}) isGitIgnored=${ignoredElapsed}ms`
+  );
+  await mkdir2(path7.dirname(destinationItem), { recursive: true });
+  const t0Cp = Date.now();
+  await cp(sourceItem, destinationItem, {
+    recursive: sourceStat.isDirectory(),
+    preserveTimestamps: true,
+    force: true
+  });
+  const cpElapsed = Date.now() - t0Cp;
+  timers.onTimeCp(cpElapsed);
+  timers.onCopied();
+  console.debug(`copy done ${relative} cp=${cpElapsed}ms`);
+}
+async function copyOnePath(source, destination, relative, console, timers) {
+  validateCopyPath(relative);
+  const sourceItem = path7.join(source, relative);
+  const destinationItem = path7.join(destination, relative);
+  const sourceStat = await safeStat(sourceItem);
+  if (!sourceStat) {
+    console.debug(`copy skip (not found): ${relative}`);
+    return;
+  }
+  const sizeInfo = sourceStat.isDirectory() ? "dir" : `${sourceStat.size}B`;
+  console.debug(`copy ${relative} (${sizeInfo})`);
+  await mkdir2(path7.dirname(destinationItem), { recursive: true });
+  const t0Cp = Date.now();
+  await cp(sourceItem, destinationItem, {
+    recursive: sourceStat.isDirectory(),
+    preserveTimestamps: true,
+    force: true
+  });
+  const cpElapsed = Date.now() - t0Cp;
+  timers.onTimeCp(cpElapsed);
+  timers.onCopied();
+  console.debug(`copy done ${relative} cp=${cpElapsed}ms`);
+}
+async function safeStat(target) {
+  try {
+    return await stat3(target);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/actions.ts
+var EXIT_CANCELLED = 130;
+var MAX_BRANCH_PROMPT_RETRIES = 5;
+function printDestination(console, target) {
+  console.outln(target);
+}
+async function deleteWorktreeAction(ctx, target) {
+  if (target === ctx.repo.mainWorktree) {
+    throw new CdwtError("refusing to delete the default branch worktree");
+  }
+  if (!await ctx.console.confirm(`Delete worktree at "${target}"? [y/N] `)) {
+    ctx.console.debug(`delete cancelled by user for ${target}`);
+    return { kind: "cancelled" };
+  }
+  ctx.console.debug(`attempting git worktree remove for ${target}`);
+  const result = await removeWorktree(ctx.repo.mainWorktree, target);
+  ctx.console.debug(
+    `git worktree remove exit=${result.exitCode} stderr=${result.stderr.length}B`
+  );
+  if (result.exitCode === 0) {
+    ctx.console.debug(`delete succeeded (clean) for ${target}`);
+    return { kind: "deleted" };
+  }
+  if (result.stderr) ctx.console.errln(result.stderr.trimEnd());
+  ctx.console.debug(`worktree is dirty, prompting for force delete`);
+  if (!await ctx.console.confirm(`Worktree has uncommitted changes. Force delete? [y/N] `)) {
+    ctx.console.debug(`force delete cancelled by user for ${target}`);
+    return { kind: "cancelled" };
+  }
+  ctx.console.debug(`attempting force remove for ${target}`);
+  const force = await removeWorktreeForceRaw(ctx.repo.mainWorktree, target);
+  ctx.console.debug(`force remove exit=${force.exitCode} stderr=${force.stderr.length}B`);
+  if (force.exitCode !== 0) {
+    if (force.stderr) ctx.console.errln(force.stderr.trimEnd());
+    throw new CdwtError(
+      `git worktree remove --force failed for ${target} (exit ${force.exitCode})`
+    );
+  }
+  ctx.console.debug(`force delete succeeded for ${target}`);
+  return { kind: "deleted" };
+}
+async function createWorktreeForBranchAction(ctx, branch, target) {
+  await assertDestinationFree(target);
+  await addWorktreeForBranch(ctx.repo.cwd, target, branch);
+  await copyConfiguredIgnoredPaths({
+    source: ctx.repo.mainWorktree,
+    destination: target,
+    config: ctx.config,
+    console: ctx.console
+  });
+  printDestination(ctx.console, target);
+  return 0;
+}
+async function createNewWorktreeAction(ctx, branchArg) {
+  const ref = ctx.repo.defaultBranchRef;
+  if (!ref) throw new CdwtError("failed to detect the default branch");
+  const branch = branchArg !== void 0 && branchArg !== "" ? await validateNewBranch(ctx, branchArg) : await readNewBranchName(ctx);
+  if (branch === null) return EXIT_CANCELLED;
+  const target = makeBranchPath(branch, ctx.repo.mainWorktree, ctx.repo.repoName);
+  await assertDestinationFree(target);
+  await addWorktreeNewBranch(ctx.repo.cwd, target, branch, ref);
+  await copyConfiguredIgnoredPaths({
+    source: ctx.repo.mainWorktree,
+    destination: target,
+    config: ctx.config,
+    console: ctx.console
+  });
+  printDestination(ctx.console, target);
+  return 0;
+}
+async function createPrWorktreeAction(ctx, prNumber, target) {
+  await assertDestinationFree(target);
+  await addWorktreeDetached(ctx.repo.cwd, target);
+  const ok = await checkoutPr(target, prNumber);
+  if (!ok) {
+    await removeWorktreeForce(ctx.repo.cwd, target, ctx.console);
+    throw new CdwtError(`failed to checkout PR #${prNumber}`);
+  }
+  await copyConfiguredIgnoredPaths({
+    source: ctx.repo.mainWorktree,
+    destination: target,
+    config: ctx.config,
+    console: ctx.console
+  });
+  printDestination(ctx.console, target);
+  return 0;
+}
+async function validateNewBranch(ctx, raw) {
+  const branch = raw.trim();
+  if (branch === "") return null;
+  if (!await checkRefFormat(ctx.repo.cwd, branch)) {
+    ctx.console.errln(`cdwt: invalid branch name: ${branch}`);
+    return null;
+  }
+  if (await branchExists(ctx.repo.cwd, branch)) {
+    ctx.console.errln(`cdwt: branch already exists: ${branch}`);
+    return null;
+  }
+  if (ctx.branchesWithWorktree.has(branch)) {
+    ctx.console.errln(`cdwt: branch already has a worktree: ${branch}`);
+    return null;
+  }
+  return branch;
+}
+async function readNewBranchName(ctx) {
+  for (let attempt = 0; attempt < MAX_BRANCH_PROMPT_RETRIES; attempt++) {
+    const raw = await ctx.console.ask("New branch name: ");
+    if (raw === null) return null;
+    const branch = raw.trim();
+    if (branch === "") return null;
+    const validated = await validateNewBranch(ctx, branch);
+    if (validated !== null) return validated;
+  }
+  ctx.console.errln(`cdwt: too many invalid branch name attempts; aborting`);
+  return null;
+}
+async function assertDestinationFree(target) {
+  try {
+    await stat4(target);
+  } catch {
+    return;
+  }
+  throw new CdwtError(`destination already exists: ${target}`);
+}
+
+// src/commands/select.ts
+async function runSelect(options) {
+  const { console } = options;
+  setGitDebug((msg) => console.debug(msg));
+  console.debug(`runSelect start cwd=${options.cwd}`);
+  const repo = await loadRepoContext(options.cwd);
+  console.debug(
+    `repo context: mainWorktree=${repo.mainWorktree} defaultBranchRef=${repo.defaultBranchRef ?? "null"} worktrees=${repo.worktrees.length}`
+  );
+  if (options.defaultBranchOnly) {
+    printDestination(console, repo.mainWorktree);
+    return 0;
+  }
+  const configFiles = await discoverConfigFiles({
+    cwd: repo.cwd,
+    mainWorktree: repo.mainWorktree,
+    home: options.home,
+    override: options.configOverride,
+    debug: (msg) => console.debug(msg)
+  });
+  const config = await readMergedConfig(configFiles);
+  console.debug(
+    `merged config: patterns=[${config.copyIgnored.patterns.join(",")}] paths=[${config.copyIgnored.paths.join(",")}]`
+  );
+  if (options.newBranch !== void 0) {
+    const ctx = {
+      repo,
+      config,
+      branchesWithWorktree: deriveBranchesWithWorktree(repo),
+      console
+    };
+    const branchArg = options.newBranch === true ? void 0 : options.newBranch;
+    return createNewWorktreeAction(ctx, branchArg);
+  }
+  const localBranches = await listLocalBranches(repo.cwd);
+  console.debug(`localBranches=${localBranches.length}`);
+  let prs = [];
+  let prsLoaded = false;
+  if (options.prFilter) {
+    prs = await loadPrs(options.cwd, console);
+    prsLoaded = true;
+  }
+  const state = {
+    repo,
+    prs,
+    prsLoaded,
+    localBranches,
+    lines: buildSections({ repo, prs, localBranches, home: options.home })
+  };
+  if (state.lines.length === 0) {
+    throw new CdwtError("no worktree or branch candidates found");
+  }
+  let initialFilter = options.prFilter ? "pr" : void 0;
+  while (true) {
+    const ctx = {
+      repo: state.repo,
+      config,
+      branchesWithWorktree: deriveBranchesWithWorktree(state.repo),
+      console
+    };
+    const outcome = await selectInteractive(state.lines, {
+      console,
+      ...initialFilter ? { initialFilter } : {},
+      ...options.selectorOptions
+    });
+    initialFilter = void 0;
+    switch (outcome.kind) {
+      case "cancelled":
+        return EXIT_CANCELLED;
+      case "command-mode": {
+        const code = await enterCommandMode(state, ctx, options, outcome.initialInput);
+        if (code !== void 0) return code;
+        continue;
+      }
+      case "delete-target": {
+        const code = await handleDeleteTarget(state, ctx, options, outcome.line);
+        if (code !== void 0) return code;
+        continue;
+      }
+      case "selected":
+        return dispatchSelected(state, ctx, options, outcome.line);
+    }
+  }
+}
+async function dispatchSelected(_state, ctx, options, selected) {
+  options.console.debug(
+    `selected: kind=${selected.kind} branch="${selected.branch}" destination="${selected.destination}"`
+  );
+  switch (selected.kind) {
+    case "worktree":
+      printDestination(options.console, selected.destination);
+      return 0;
+    case "branch":
+      return createWorktreeForBranchAction(ctx, selected.branch, selected.destination);
+    case "pr": {
+      if (selected.prNumber === null) throw new CdwtError("missing PR number");
+      if (ctx.branchesWithWorktree.has(selected.branch)) {
+        printDestination(options.console, selected.destination);
+        return 0;
+      }
+      return createPrWorktreeAction(ctx, selected.prNumber, selected.destination);
+    }
+  }
+}
+async function enterCommandMode(state, ctx, options, initialInput) {
+  const cmdOptions = {
+    console: options.console,
+    registry: SLASH_COMMANDS,
+    ...options.selectorOptions?.useFzf !== void 0 ? { useFzf: options.selectorOptions.useFzf } : {},
+    ...options.selectorOptions?.fzfRunner ? { fzfRunner: options.selectorOptions.fzfRunner } : {},
+    ...initialInput !== void 0 ? { initialInput } : {}
+  };
+  const picked = await runCommandMode(cmdOptions);
+  if (picked.kind === "cancelled") return void 0;
+  const host = makeCommandHost(state, ctx, options);
+  const result = await picked.command.execute(picked.args, host);
+  if (result.kind === "exit") return result.code;
+  return void 0;
+}
+function makeCommandHost(state, ctx, options) {
+  return {
+    console: options.console,
+    printMainDestination() {
+      printDestination(options.console, state.repo.mainWorktree);
+    },
+    createNewWorktree(branch) {
+      return createNewWorktreeAction(ctx, branch);
+    },
+    async loadPrs() {
+      if (state.prsLoaded) return;
+      state.prs = await loadPrs(options.cwd, options.console);
+      state.prsLoaded = true;
+      rebuildLines(state, options.home);
+    },
+    async refresh() {
+      await refresh(state, options);
+    }
+  };
+}
+async function handleDeleteTarget(state, ctx, options, target) {
+  if (target.section === "main") {
+    options.console.errln("cdwt: refusing to delete the default branch worktree");
+    return void 0;
+  }
+  if (target.section !== "wt") {
+    options.console.errln(
+      `cdwt: ctrl-d only deletes worktree entries (got [${sectionLabel(target.section)}])`
+    );
+    return void 0;
+  }
+  const result = await deleteWorktreeAction(ctx, target.destination);
+  if (result.kind === "cancelled") return void 0;
+  await refresh(state, options);
+  if (state.lines.filter((l) => l.section === "wt").length === 0) {
+    printDestination(options.console, state.repo.mainWorktree);
+    return 0;
+  }
+  return void 0;
+}
+async function refresh(state, options) {
+  state.repo = await loadRepoContext(options.cwd);
+  state.localBranches = await listLocalBranches(state.repo.cwd);
+  if (state.prsLoaded) {
+    state.prs = await loadPrs(options.cwd, options.console);
+  }
+  rebuildLines(state, options.home);
+}
+function rebuildLines(state, home) {
+  state.lines = buildSections({
+    repo: state.repo,
+    prs: state.prs,
+    localBranches: state.localBranches,
+    home
+  });
+}
+async function loadPrs(cwd, console) {
+  const t0 = Date.now();
+  const ghAvailable = await isGhAvailable();
+  console.debug(`gh available=${ghAvailable}`);
+  if (!ghAvailable) return [];
+  const prs = await listPullRequests(cwd);
+  console.debug(`listed ${prs.length} PRs in ${Date.now() - t0}ms`);
+  return prs;
+}
+function defaultHome2() {
+  return process.env["HOME"] ?? homedir2();
+}
+
+// src/io/console.ts
+import { createInterface } from "readline/promises";
+var YES = /^y(es)?$/i;
+var _startTime = Date.now();
+function createDefaultConsole(streams = {}) {
+  const stdin = streams.stdin ?? process.stdin;
+  const stdout = streams.stdout ?? process.stdout;
+  const stderr = streams.stderr ?? process.stderr;
+  const isInteractive = Boolean(stdin.isTTY);
+  const verbose = streams.verbose ?? false;
+  const console = {
+    out: (chunk) => stdout.write(chunk),
+    outln: (message = "") => stdout.write(`${message}
+`),
+    err: (chunk) => stderr.write(chunk),
+    errln: (message = "") => stderr.write(`${message}
+`),
+    debug(message) {
+      if (!verbose) return;
+      const elapsed = Date.now() - _startTime;
+      stderr.write(`[cdwt verbose +${elapsed}ms] ${message}
+`);
+    },
+    isInteractive,
+    async ask(prompt) {
+      if (!isInteractive) return null;
+      const rl = createInterface({ input: stdin, output: stderr, terminal: true });
+      try {
+        return await rl.question(prompt);
+      } catch {
+        return null;
+      } finally {
+        rl.close();
+      }
+    },
+    async confirm(prompt) {
+      const answer = await this.ask(prompt);
+      if (answer === null) return false;
+      return YES.test(answer.trim());
+    }
+  };
+  return console;
+}
+
+// src/cli.ts
+function buildProgram(consoleFactory) {
+  const program = new Command();
+  const state = { exitCode: 0 };
+  program.name("cdwt").description(
+    "Interactive git worktree switcher. Prints the destination path on stdout; use the bundled zsh wrapper (installed via `cdwt install`) so the shell can `cd` into it."
+  ).version("0.1.0").option("-v, --verbose", "write timestamped diagnostic logs to stderr");
+  program.option("--default-branch", "print the path of the default branch worktree and exit").option("--pr", "open the picker pre-filtered to PRs (loads `gh pr list` immediately)").option(
+    "--new [branch]",
+    "create a new worktree from the default branch and cd into it (prompts for name if omitted)"
+  ).option(
+    "--config <file>",
+    "use only the given settings file (overrides .cdwt/settings.json discovery)"
+  ).action(async (opts) => {
+    const verbose = Boolean(opts.verbose ?? program.opts().verbose);
+    const console = consoleFactory(verbose);
+    state.exitCode = await runSelect({
+      defaultBranchOnly: Boolean(opts.defaultBranch),
+      prFilter: Boolean(opts.pr),
+      ...opts.new !== void 0 ? { newBranch: opts.new } : {},
+      cwd: process.cwd(),
+      configOverride: opts.config ?? process.env["CDWT_CONFIG"],
+      home: defaultHome2(),
+      console
+    });
+  });
+  program.command("install").description("install the zsh shell wrapper to ~/.local/share/cdwt and update ~/.zshrc").option("--rc <file>", "rc file to update (default: $HOME/.zshrc)").action(async (opts) => {
+    const verbose = Boolean(opts.verbose ?? program.opts().verbose);
+    const console = consoleFactory(verbose);
+    state.exitCode = await runInstall({
+      home: defaultHome(),
+      rcFile: opts.rc,
+      console
+    });
+  });
+  return { program, state };
+}
+async function main() {
+  const { program, state } = buildProgram((verbose) => createDefaultConsole({ verbose }));
+  const errorConsole = createDefaultConsole();
+  try {
+    await program.parseAsync(process.argv);
+    return state.exitCode;
+  } catch (error) {
+    if (error instanceof CdwtError) {
+      errorConsole.errln(`${pc2.red("cdwt:")} ${error.message}`);
+      return error.code;
+    }
+    errorConsole.errln(`${pc2.red("cdwt:")} ${error.message}`);
+    return 1;
+  }
+}
+var exitCode = await main();
+process.exit(exitCode);
+export {
+  buildProgram
+};
+//# sourceMappingURL=cli.js.map