@cestoliv/wt 0.1.0-pr1.f38ce15

package/README.md

@@ -0,0 +1,116 @@
+# wt
+
+A fast, interactive TUI for managing git worktrees.
+
+Browse, create, open, and delete worktrees without leaving the terminal. Fuzzy search across branches, auto-open your IDE, and run setup commands on new worktrees — all from one tool.
+
+## Install
+
+```bash
+npm install -g @cestoliv/wt
+```
+
+Requires Node.js 20+ and Git. The command is `wt`.
+
+### Update
+
+```bash
+npm install -g @cestoliv/wt
+```
+
+### Pre-release builds
+
+Add the `publish-dev` label to a PR to publish that branch as a unique,
+pinned prerelease version (e.g. `0.1.0-pr12.abc1234`). The exact install
+command is posted as a comment on the PR. There is no rolling `dev` channel —
+each build is a distinct version you install explicitly.
+
+## Quick Start
+
+```bash
+# Inside any git repo
+wt                  # Browse worktrees
+wt create my-feat   # Create a new worktree and open it in your IDE
+wt config           # Edit config in $EDITOR
+```
+
+## Usage
+
+### Browse worktrees — `wt`
+
+Launches an interactive list of worktrees with fuzzy search.
+
+```
+MY-PROJECT
+  ▶ main           ~/dev/my-project
+      fix: resolve auth bug (2h ago)
+    feat/dashboard  ~/dev/my-project-feat-dashboard
+      wip: add chart component (1d ago)
+
+↕ navigate · Enter open · D delete · C create · Q quit
+```
+
+| Key     | Action                          |
+| ------- | ------------------------------- |
+| `↑` `↓` | Navigate                        |
+| `Enter` | Open worktree in IDE            |
+| `D`     | Delete worktree (with confirm)  |
+| `C`     | Create new worktree (repo mode) |
+| `Q`     | Quit                            |
+
+Type to fuzzy-filter branches instantly.
+
+**Repo mode** (inside a git repo): shows worktrees for that repo.
+**Global mode** (outside a repo): shows worktrees across all registered repos.
+
+### Create a worktree — `wt create [branch]`
+
+```bash
+wt create feat/login    # Create from base branch (origin/main by default)
+wt create               # Prompts for branch name
+```
+
+What happens:
+
+1. Creates a worktree as a sibling directory: `../my-project-feat-login`
+2. Runs configured setup commands (e.g., `npm install`)
+3. Opens the worktree in your IDE
+
+Run outside a repo to pick from registered repos via an interactive picker.
+
+### Edit config — `wt config`
+
+Opens the config file in `$EDITOR`.
+
+## Configuration
+
+Config is stored at `~/Library/Preferences/wt-nodejs/config.json` (macOS).
+
+```json
+{
+  "ide": "code",
+  "ide_open_args": ["-n"],
+  "base_branch": "origin/main",
+  "worktree_path": "../",
+  "setup_commands": ["npm install"],
+  "repo_overrides": {
+    "/path/to/special-repo": {
+      "base_branch": "origin/develop",
+      "setup_commands": ["pnpm install", "pnpm build"]
+    }
+  }
+}
+```
+
+| Key              | Default         | Description                                   |
+| ---------------- | --------------- | --------------------------------------------- |
+| `ide`            | `"zed"`         | Editor to open worktrees with                 |
+| `ide_open_args`  | `["-n"]`        | Extra args passed to the IDE command          |
+| `base_branch`    | `"origin/main"` | Branch new worktrees are created from         |
+| `worktree_path`  | `"../"`         | Where worktrees are placed (relative to repo) |
+| `setup_commands` | `[]`            | Commands to run in new worktrees              |
+| `repo_overrides` | `{}`            | Per-repo overrides for any of the above       |
+
+## License
+
+MIT

package/dist/chunk-25JVZOCI.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+import {
+  createStore,
+  getGlobalConfig
+} from "./chunk-HIGP6FSR.js";
+
+// src/lib/git.ts
+import { execFileSync } from "child_process";
+import { realpathSync } from "fs";
+import path from "path";
+function getRepoRoot(cwd = process.cwd()) {
+  try {
+    const realCwd = realpathSync(cwd);
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: realCwd,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    throw new Error("Not in a git repository");
+  }
+}
+function listWorktrees(repoRoot, cwd = process.cwd()) {
+  const realRepoRoot = realpathSync(repoRoot);
+  const realCwd = realpathSync(cwd);
+  const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+    cwd: realRepoRoot,
+    encoding: "utf8"
+  });
+  const worktrees = parseWorktreeList(output, realRepoRoot, realCwd);
+  const script = worktrees.map(
+    (wt) => `(cd ${JSON.stringify(wt.path)} 2>/dev/null && git log -1 --format='%s' 2>/dev/null) || echo ''`
+  ).join('; echo "---SEP---"; ');
+  let commits = [];
+  try {
+    const batchOutput = execFileSync("sh", ["-c", script], {
+      encoding: "utf8",
+      timeout: 8e3
+    });
+    commits = batchOutput.split("---SEP---").map((s) => s.trim());
+  } catch {
+  }
+  return worktrees.map((wt, i) => ({
+    ...wt,
+    lastCommit: commits[i] ?? ""
+  }));
+}
+function parseWorktreeList(output, repoRoot, cwd) {
+  return output.trim().split("\n\n").map((block) => {
+    const lines = block.trim().split("\n");
+    const wtPath = lines[0].slice("worktree ".length);
+    const branchLine = lines.find((l) => l.startsWith("branch "));
+    const branch = branchLine ? branchLine.replace("branch refs/heads/", "") : "(detached)";
+    return {
+      path: wtPath,
+      branch,
+      isCurrent: cwd === wtPath || cwd.startsWith(wtPath + path.sep),
+      repoRoot
+    };
+  });
+}
+function addWorktree(repoRoot, worktreePath, branch, baseBranch) {
+  if (baseBranch) {
+    execFileSync(
+      "git",
+      ["worktree", "add", "-b", branch, worktreePath, baseBranch],
+      {
+        cwd: repoRoot
+      }
+    );
+  } else {
+    execFileSync("git", ["worktree", "add", worktreePath, branch], {
+      cwd: repoRoot
+    });
+  }
+}
+function removeWorktree(repoRoot, worktreePath, force = false) {
+  execFileSync(
+    "git",
+    ["worktree", "remove", ...force ? ["--force"] : [], worktreePath],
+    { cwd: repoRoot, stdio: "pipe" }
+  );
+}
+function listWorktreeDirtyFiles(worktreePath) {
+  try {
+    const out = execFileSync("git", ["status", "--short"], {
+      cwd: worktreePath,
+      encoding: "utf8"
+    });
+    return out.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function branchExists(repoRoot, branch) {
+  try {
+    const local = execFileSync("git", ["branch", "--list", branch], {
+      cwd: repoRoot,
+      encoding: "utf8"
+    }).trim();
+    if (local) return true;
+    const remote = execFileSync(
+      "git",
+      ["ls-remote", "--heads", "origin", branch],
+      {
+        cwd: repoRoot,
+        encoding: "utf8",
+        timeout: 8e3
+      }
+    ).trim();
+    return remote.length > 0;
+  } catch {
+    return false;
+  }
+}
+function resolveWorktreePath(repoRoot, worktreePath, branch) {
+  const repoName = path.basename(repoRoot);
+  const safeBranch = branch.replace(/\//g, "-");
+  const resolved = path.resolve(
+    repoRoot,
+    worktreePath,
+    `${repoName}-${safeBranch}`
+  );
+  const expectedParent = path.resolve(repoRoot, worktreePath);
+  if (!resolved.startsWith(expectedParent + path.sep) && resolved !== expectedParent) {
+    throw new Error(
+      `Branch name "${branch}" would resolve outside the expected worktree directory`
+    );
+  }
+  return resolved;
+}
+
+// src/lib/ide.ts
+import { spawn } from "child_process";
+function buildIdeCommand(ide, ideOpenArgs, worktreePath) {
+  return { cmd: ide, args: [...ideOpenArgs, worktreePath] };
+}
+function openIde(ide, ideOpenArgs, worktreePath) {
+  return new Promise((resolve) => {
+    if (!ide) {
+      resolve(false);
+      return;
+    }
+    const { cmd, args } = buildIdeCommand(ide, ideOpenArgs, worktreePath);
+    const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+    child.on("spawn", () => {
+      child.unref();
+      resolve(true);
+    });
+    child.on("error", (err) => {
+      process.stderr.write(
+        `
+Warning: could not open "${ide}": ${err.message}
+`
+      );
+      resolve(false);
+    });
+  });
+}
+
+// src/lib/registry.ts
+function registerRepo(repoPath, store = createStore()) {
+  const { repos } = getGlobalConfig(store);
+  if (!repos.includes(repoPath)) {
+    store.set("repos", [...repos, repoPath]);
+  }
+}
+function getRegisteredRepos(store = createStore()) {
+  return getGlobalConfig(store).repos;
+}
+
+// src/lib/tui.ts
+import path2 from "path";
+import Fuse from "fuse.js";
+import pc from "picocolors";
+var cachedFuse = null;
+function filterItems(items, query) {
+  if (!query) return items;
+  if (!cachedFuse || cachedFuse.items !== items) {
+    cachedFuse = {
+      items,
+      fuse: new Fuse(items, { keys: ["branch"], threshold: 0.4 })
+    };
+  }
+  return cachedFuse.fuse.search(query).map((r) => r.item);
+}
+function groupByRepo(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const existing = map.get(item.repoRoot) ?? [];
+    map.set(item.repoRoot, [...existing, item]);
+  }
+  return map;
+}
+function shortenPath(p) {
+  const home = process.env.HOME ?? "";
+  return home && p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+function renderList(items, selectedIndex, query, mode) {
+  const lines = [];
+  if (mode === "global") {
+    lines.push(
+      pc.dim("\u2139 Not in a git repository \u2014 showing all registered worktrees")
+    );
+    lines.push("");
+  }
+  lines.push(pc.cyan(`> ${query}_`));
+  lines.push("");
+  const groups = groupByRepo(items);
+  let i = 0;
+  for (const [repoPath, groupItems] of groups) {
+    lines.push(pc.bold(path2.basename(repoPath).toUpperCase()));
+    for (const item of groupItems) {
+      const cursor = i === selectedIndex ? pc.cyan("\u25B6") : " ";
+      const branchLabel = item.isCurrent ? pc.dim(`${item.branch} (current)`) : pc.white(item.branch);
+      const pathLabel = pc.dim(shortenPath(item.path));
+      lines.push(`  ${cursor} ${branchLabel}  ${pathLabel}`);
+      if (item.lastCommit) {
+        lines.push(`      ${pc.dim(item.lastCommit)}`);
+      }
+      i++;
+    }
+  }
+  lines.push("");
+  const createHint = mode === "repo" ? " \xB7 C create" : "";
+  lines.push(
+    pc.dim(`\u2195 navigate \xB7 Enter open \xB7 D delete${createHint} \xB7 Q quit`)
+  );
+  return lines.join("\n");
+}
+function setupRawMode() {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+}
+function cleanupRawMode() {
+  process.stdin.setRawMode(false);
+  process.stdin.pause();
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+function renderRepoPicker(repos, selectedIndex, query) {
+  const lines = [];
+  lines.push(pc.dim("\u2139 Not in a git repository \u2014 select a repo to create in"));
+  lines.push("");
+  lines.push(pc.cyan(`> ${query}_`));
+  lines.push("");
+  for (let i = 0; i < repos.length; i++) {
+    const cursor = i === selectedIndex ? pc.cyan("\u25B6") : " ";
+    lines.push(
+      `  ${cursor} ${pc.bold(path2.basename(repos[i]).toUpperCase())}  ${pc.dim(shortenPath(repos[i]))}`
+    );
+  }
+  lines.push("");
+  lines.push(pc.dim("\u2195 navigate \xB7 Enter select \xB7 Q quit"));
+  return lines.join("\n");
+}
+async function runRepoPicker(repos) {
+  const filterRepos = (all, q) => q ? all.filter(
+    (p) => path2.basename(p).toLowerCase().includes(q.toLowerCase())
+  ) : all;
+  let query = "";
+  let selectedIndex = 0;
+  let filtered = repos;
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(renderRepoPicker(filtered, selectedIndex, query));
+  };
+  setupRawMode();
+  render();
+  return new Promise((resolve, reject) => {
+    let listenerActive = false;
+    const attachListener = () => {
+      if (!listenerActive) {
+        process.stdin.on("data", onData);
+        listenerActive = true;
+      }
+    };
+    const detachListener = () => {
+      process.stdin.removeListener("data", onData);
+      listenerActive = false;
+    };
+    const onData = (key) => {
+      try {
+        if (key === "" || key === "q" || key === "Q" || key === "\x1B") {
+          detachListener();
+          cleanupRawMode();
+          resolve(null);
+        } else if (key === "\x1B[A") {
+          selectedIndex = Math.max(0, selectedIndex - 1);
+          render();
+        } else if (key === "\x1B[B") {
+          selectedIndex = Math.min(filtered.length - 1, selectedIndex + 1);
+          render();
+        } else if (key === "\r") {
+          const repo = filtered[selectedIndex];
+          if (repo) {
+            detachListener();
+            cleanupRawMode();
+            resolve(repo);
+          }
+        } else if (key === "\x7F") {
+          query = query.slice(0, -1);
+          filtered = filterRepos(repos, query);
+          selectedIndex = 0;
+          render();
+        } else if (key.length === 1 && key >= " ") {
+          query += key;
+          filtered = filterRepos(repos, query);
+          selectedIndex = 0;
+          render();
+        }
+      } catch (err) {
+        detachListener();
+        cleanupRawMode();
+        reject(err);
+      }
+    };
+    attachListener();
+  });
+}
+function renderBranchInput(repoName, branch, error) {
+  const lines = [];
+  lines.push(pc.bold(`Repo: ${repoName}`));
+  lines.push("");
+  lines.push(`Branch: ${pc.cyan(`${branch}_`)}`);
+  if (error) {
+    lines.push("");
+    lines.push(pc.red(error));
+  }
+  lines.push("");
+  lines.push(pc.dim("Enter confirm \xB7 Esc cancel"));
+  return lines.join("\n");
+}
+async function runBranchInput(repoRoot) {
+  let branch = "";
+  let error;
+  const repoName = path2.basename(repoRoot);
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(renderBranchInput(repoName, branch, error));
+  };
+  setupRawMode();
+  render();
+  return new Promise((resolve, reject) => {
+    const onData = (key) => {
+      try {
+        if (key === "" || key === "\x1B") {
+          process.stdin.removeListener("data", onData);
+          cleanupRawMode();
+          resolve(null);
+        } else if (key === "\r") {
+          if (!branch) {
+            error = "Branch name is required";
+            render();
+          } else {
+            process.stdin.removeListener("data", onData);
+            cleanupRawMode();
+            resolve(branch);
+          }
+        } else if (key === "\x7F") {
+          branch = branch.slice(0, -1);
+          error = void 0;
+          render();
+        } else if (key.length === 1 && key >= " ") {
+          branch += key;
+          error = void 0;
+          render();
+        }
+      } catch (err) {
+        process.stdin.removeListener("data", onData);
+        cleanupRawMode();
+        reject(err);
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function runInteractiveList(allItems, mode, handlers) {
+  let query = "";
+  let selectedIndex = 0;
+  let filtered = allItems;
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(renderList(filtered, selectedIndex, query, mode));
+  };
+  setupRawMode();
+  render();
+  return new Promise((resolve, reject) => {
+    let listenerActive = false;
+    const attachListener = () => {
+      if (!listenerActive) {
+        process.stdin.on("data", onData);
+        listenerActive = true;
+      }
+    };
+    const detachListener = () => {
+      process.stdin.removeListener("data", onData);
+      listenerActive = false;
+    };
+    const onData = async (key) => {
+      try {
+        if (key === "" || key === "q" || key === "Q" || key === "\x1B") {
+          detachListener();
+          cleanupRawMode();
+          resolve();
+        } else if (key === "\x1B[A") {
+          selectedIndex = Math.max(0, selectedIndex - 1);
+          render();
+        } else if (key === "\x1B[B") {
+          selectedIndex = Math.min(filtered.length - 1, selectedIndex + 1);
+          render();
+        } else if (key === "\r") {
+          const item = filtered[selectedIndex];
+          if (item) {
+            detachListener();
+            cleanupRawMode();
+            handlers.onOpen(item);
+            resolve();
+          }
+        } else if (key === "d" || key === "D") {
+          const item = filtered[selectedIndex];
+          if (item) {
+            if (item.isCurrent) {
+              process.stdout.write(
+                pc.red("\nCannot delete the worktree you are currently in.\n")
+              );
+              return;
+            }
+            detachListener();
+            cleanupRawMode();
+            const confirmed = await handlers.onDelete(item);
+            if (confirmed) {
+              allItems = allItems.filter((w) => w !== item);
+              filtered = filtered.filter((w) => w !== item);
+            }
+            selectedIndex = Math.min(
+              selectedIndex,
+              Math.max(0, filtered.length - 1)
+            );
+            setupRawMode();
+            attachListener();
+            render();
+          }
+        } else if (key === "c" || key === "C") {
+          if (mode === "repo") {
+            detachListener();
+            cleanupRawMode();
+            await handlers.onCreate();
+            resolve();
+          } else {
+            process.stdout.write(
+              pc.dim("\ncd into a repo first to create a worktree.\n")
+            );
+          }
+        } else if (key === "\x7F") {
+          query = query.slice(0, -1);
+          filtered = filterItems(allItems, query);
+          selectedIndex = 0;
+          render();
+        } else if (key.length === 1 && key >= " ") {
+          query += key;
+          filtered = filterItems(allItems, query);
+          selectedIndex = 0;
+          render();
+        }
+      } catch (err) {
+        detachListener();
+        cleanupRawMode();
+        reject(err);
+      }
+    };
+    attachListener();
+  });
+}
+
+export {
+  getRepoRoot,
+  listWorktrees,
+  addWorktree,
+  removeWorktree,
+  listWorktreeDirtyFiles,
+  branchExists,
+  resolveWorktreePath,
+  openIde,
+  registerRepo,
+  getRegisteredRepos,
+  runRepoPicker,
+  runBranchInput,
+  runInteractiveList
+};

package/dist/chunk-HIGP6FSR.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+// src/lib/config.ts
+import Conf from "conf";
+var DEFAULT_CONFIG = {
+  worktree_path: "../",
+  base_branch: "origin/main",
+  setup_commands: [],
+  ide: "zed",
+  ide_open_args: ["-n"],
+  repos: [],
+  repo_overrides: {}
+};
+function createStore(cwd) {
+  return new Conf({
+    projectName: "wt",
+    defaults: DEFAULT_CONFIG,
+    ...cwd ? { cwd } : {}
+  });
+}
+function getGlobalConfig(store = createStore()) {
+  return store.store;
+}
+function getEffectiveConfig(repoPath, store = createStore()) {
+  const {
+    repos: _repos,
+    repo_overrides,
+    ...repoFields
+  } = getGlobalConfig(store);
+  const override = repo_overrides[repoPath] ?? {};
+  return { ...repoFields, ...override };
+}
+
+export {
+  createStore,
+  getGlobalConfig,
+  getEffectiveConfig
+};

package/dist/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+var program = new Command();
+program.name("wt").description("Git worktree manager").version("0.1.0-pr1.f38ce15").action(async () => {
+  const { runList } = await import("./list-Q7CFJ66L.js");
+  await runList();
+});
+program.command("create [branch]").description("Create a new worktree").action(async (branch) => {
+  const { createWorktree } = await import("./create-42OYRFQF.js");
+  await createWorktree(branch);
+});
+program.command("config").description("Open the config file in $EDITOR").action(async () => {
+  const { openConfig } = await import("./config-FRLXDMRY.js");
+  openConfig();
+});
+await program.parseAsync(process.argv);

package/dist/config-FRLXDMRY.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import {
+  createStore
+} from "./chunk-HIGP6FSR.js";
+
+// src/commands/config.ts
+import { spawn } from "child_process";
+function getConfigPath(store = createStore()) {
+  return store.path;
+}
+function openConfig(store = createStore()) {
+  const configPath = store.path;
+  console.log(`Config: ${configPath}`);
+  const editor = process.env.EDITOR ?? "nano";
+  const child = spawn(editor, [configPath], { stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(`Failed to open editor: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("close", (code) => process.exit(code ?? 0));
+}
+export {
+  getConfigPath,
+  openConfig
+};

package/dist/create-42OYRFQF.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import {
+  addWorktree,
+  branchExists,
+  getRegisteredRepos,
+  getRepoRoot,
+  openIde,
+  registerRepo,
+  resolveWorktreePath,
+  runBranchInput,
+  runRepoPicker
+} from "./chunk-25JVZOCI.js";
+import {
+  createStore,
+  getEffectiveConfig
+} from "./chunk-HIGP6FSR.js";
+
+// src/commands/create.ts
+import { existsSync } from "fs";
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/setup.ts
+import { spawn } from "child_process";
+async function runSetupCommands(commands, cwd) {
+  for (const command of commands) {
+    const result = await runCommand(command, cwd);
+    if (!result.success) {
+      return {
+        success: false,
+        failedCommand: command,
+        exitCode: result.exitCode
+      };
+    }
+  }
+  return { success: true };
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, { cwd, stdio: "inherit", shell: true });
+    child.on("error", () => {
+      resolve({ success: false, exitCode: void 0 });
+    });
+    child.on("close", (code) => {
+      resolve({ success: code === 0, exitCode: code ?? void 0 });
+    });
+  });
+}
+
+// src/commands/create.ts
+async function createWorktree(branch, options = {}) {
+  const {
+    cwd = process.cwd(),
+    store = createStore(),
+    repoPicker = runRepoPicker,
+    branchInput = runBranchInput
+  } = options;
+  let repoRoot;
+  try {
+    repoRoot = getRepoRoot(cwd);
+  } catch {
+    const repos = getRegisteredRepos(store);
+    if (repos.length === 0) {
+      console.error(
+        pc.red(
+          "No repos registered. cd into a repo and run wt create to get started."
+        )
+      );
+      return;
+    }
+    if (!process.stdin.isTTY) {
+      console.error(
+        pc.red(
+          "Interactive repo picker requires a TTY. Please run this command in an interactive terminal."
+        )
+      );
+      process.exit(1);
+    }
+    const picked = await repoPicker(repos);
+    if (!picked) return;
+    repoRoot = picked;
+    if (!branch) {
+      const entered = await branchInput(repoRoot);
+      if (!entered) return;
+      branch = entered;
+    }
+  }
+  if (!repoRoot) return;
+  if (!branch) {
+    const input = await clack.text({
+      message: "Branch name:",
+      validate: (v) => !v || v.length === 0 ? "Required" : void 0
+    });
+    if (clack.isCancel(input)) return;
+    branch = input;
+  }
+  registerRepo(repoRoot, store);
+  const config = getEffectiveConfig(repoRoot, store);
+  const worktreePath = resolveWorktreePath(
+    repoRoot,
+    config.worktree_path,
+    branch
+  );
+  if (existsSync(worktreePath)) {
+    throw new Error(`Worktree path already exists: ${worktreePath}`);
+  }
+  const exists = branchExists(repoRoot, branch);
+  if (exists) {
+    addWorktree(repoRoot, worktreePath, branch);
+  } else {
+    addWorktree(repoRoot, worktreePath, branch, config.base_branch);
+  }
+  console.log(pc.green(`\u2713 Created worktree at ${worktreePath}`));
+  if (config.setup_commands.length > 0) {
+    console.log(pc.dim("Running setup commands..."));
+    const result = await runSetupCommands(config.setup_commands, worktreePath);
+    if (!result.success) {
+      console.error(
+        pc.red(
+          `\u2717 Setup failed: ${result.failedCommand} (exit code ${result.exitCode})`
+        )
+      );
+      console.error(pc.dim(`Worktree left at ${worktreePath} for inspection`));
+      process.exit(1);
+    }
+  }
+  if (config.ide) {
+    const opened = await openIde(
+      config.ide,
+      config.ide_open_args,
+      worktreePath
+    );
+    if (opened) {
+      console.log(pc.green(`\u2713 Opened ${config.ide}`));
+    }
+  }
+}
+export {
+  createWorktree
+};

package/dist/list-Q7CFJ66L.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import {
+  getRegisteredRepos,
+  getRepoRoot,
+  listWorktreeDirtyFiles,
+  listWorktrees,
+  openIde,
+  registerRepo,
+  removeWorktree,
+  runInteractiveList
+} from "./chunk-25JVZOCI.js";
+import {
+  createStore,
+  getEffectiveConfig
+} from "./chunk-HIGP6FSR.js";
+
+// src/commands/list.ts
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+async function prepareListItems(options = {}) {
+  const { cwd = process.cwd(), store = createStore() } = options;
+  let repoRoot = null;
+  try {
+    repoRoot = getRepoRoot(cwd);
+  } catch {
+  }
+  if (repoRoot) {
+    registerRepo(repoRoot, store);
+    const items2 = listWorktrees(repoRoot, cwd);
+    return { items: items2, mode: "repo", repoRoot };
+  }
+  const repos = getRegisteredRepos(store);
+  const items = repos.flatMap((repo) => {
+    try {
+      return listWorktrees(repo, cwd);
+    } catch {
+      return [];
+    }
+  });
+  return { items, mode: "global", repoRoot: null };
+}
+async function runList(options = {}) {
+  const { store = createStore(), cwd = process.cwd() } = options;
+  const { items, mode, repoRoot } = await prepareListItems({ cwd, store });
+  if (items.length === 0 && mode === "global") {
+    console.log(
+      pc.dim(
+        "No repos registered. Run `wt create` inside a repo to get started."
+      )
+    );
+    return;
+  }
+  await runInteractiveList(items, mode, {
+    onOpen: (item) => {
+      const config = getEffectiveConfig(item.repoRoot, store);
+      openIde(config.ide, config.ide_open_args, item.path);
+    },
+    onDelete: async (item) => {
+      const confirmed = await clack.confirm({
+        message: `Remove worktree ${pc.bold(item.branch)}? This cannot be undone.`
+      });
+      if (clack.isCancel(confirmed) || !confirmed) return false;
+      try {
+        removeWorktree(item.repoRoot, item.path);
+        console.log(pc.green(`\u2713 Removed ${item.branch}`));
+        return true;
+      } catch (err) {
+        const msg = String(err);
+        if (msg.includes("modified or untracked files")) {
+          const dirty = listWorktreeDirtyFiles(item.path);
+          if (dirty.length > 0) {
+            clack.log.warn(
+              `Worktree has uncommitted changes:
+${dirty.map((f) => `  ${f}`).join("\n")}`
+            );
+          }
+          const force = await clack.confirm({
+            message: `Force delete ${pc.bold(item.branch)}? All changes will be lost.`
+          });
+          if (clack.isCancel(force) || !force) return false;
+          try {
+            removeWorktree(item.repoRoot, item.path, true);
+            console.log(pc.green(`\u2713 Force-removed ${item.branch}`));
+            return true;
+          } catch (err2) {
+            console.error(pc.red(`\u2717 Failed to force-remove: ${String(err2)}`));
+            return false;
+          }
+        }
+        console.error(pc.red(`\u2717 Failed to remove: ${msg}`));
+        return false;
+      }
+    },
+    onCreate: async () => {
+      if (repoRoot) {
+        const { createWorktree } = await import("./create-42OYRFQF.js");
+        await createWorktree(void 0, { cwd: repoRoot, store });
+      }
+    }
+  });
+}
+export {
+  prepareListItems,
+  runList
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@cestoliv/wt",
+  "version": "0.1.0-pr1.f38ce15",
+  "description": "Fast, interactive TUI to browse, create, open, and delete git worktrees across repos.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cestoliv/worktrees.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "bin": {
+    "wt": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsup && chmod +x dist/cli.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write ."
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "fuse.js": "^7.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  }
+}