worktree-launcher 1.0.2 → 1.1.0

package/README.md

@@ -36,8 +36,32 @@ npm install -g worktree-launcher
 
 Requires Node.js 18+ and git.
 
+## Interactive Mode
+
+Run `wt` with no arguments to enter interactive mode:
+
+```bash
+wt
+```
+
+This shows a navigable list of all worktrees where you can:
+- Select a worktree to see actions
+- Launch an AI assistant in any worktree
+- Delete worktrees
+- Create new worktrees
+
+Use arrow keys to navigate and Enter to select.
+
 ## Commands
 
+### wt
+
+Run with no arguments for interactive mode.
+
+```bash
+wt
+```
+
 ### wt new
 
 Create a new worktree and optionally launch an AI assistant.
@@ -108,15 +132,15 @@ A typical development workflow:
 # 1. Start in your main repository
 cd ~/code/myproject
 
-# 2. Create a worktree for a new feature
+# 2. Open interactive mode to see all worktrees
+wt
+
+# 3. Or create a worktree directly
 wt new feature-user-auth
 # Select Claude Code or Codex from the prompt
 # AI assistant launches in the new worktree
 
-# 3. Work on the feature, commit, push, create PR
-
-# 4. Back in main repo, check your worktrees
-wt list
+# 4. Work on the feature, commit, push, create PR
 
 # 5. After PR is merged, clean up
 wt clean

package/dist/chunk-U3OPVTLP.js

@@ -0,0 +1,373 @@
+// src/commands/new.ts
+import chalk from "chalk";
+import ora from "ora";
+import path4 from "path";
+
+// src/utils/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import path from "path";
+var execFileAsync = promisify(execFile);
+async function isGitRepo() {
+  try {
+    await execFileAsync("git", ["rev-parse", "--git-dir"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitRoot() {
+  const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+  return stdout.trim();
+}
+async function branchExists(branchName) {
+  try {
+    await execFileAsync("git", ["rev-parse", "--verify", branchName]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function remoteBranchExists(branchName) {
+  try {
+    const { stdout } = await execFileAsync("git", ["branch", "-r"]);
+    const remoteBranches = stdout.split("\n").map((b) => b.trim());
+    return remoteBranches.some(
+      (b) => b === `origin/${branchName}` || b.endsWith(`/${branchName}`)
+    );
+  } catch {
+    return false;
+  }
+}
+async function getDefaultBranch() {
+  try {
+    const { stdout } = await execFileAsync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    return stdout.trim().replace("refs/remotes/origin/", "");
+  } catch {
+    if (await branchExists("main")) return "main";
+    if (await branchExists("master")) return "master";
+    return "main";
+  }
+}
+async function createWorktree(worktreePath, branchName) {
+  validateBranchName(branchName);
+  const exists = await branchExists(branchName);
+  if (exists) {
+    await execFileAsync("git", ["worktree", "add", "--", worktreePath, branchName]);
+  } else {
+    await execFileAsync("git", ["worktree", "add", "-b", branchName, "--", worktreePath]);
+  }
+}
+async function listWorktrees() {
+  const { stdout } = await execFileAsync("git", ["worktree", "list", "--porcelain"]);
+  const worktrees = [];
+  let current = {};
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) {
+        worktrees.push(current);
+      }
+      current = {
+        path: line.substring(9),
+        bare: false,
+        detached: false
+      };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.substring(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.substring(7).replace("refs/heads/", "");
+    } else if (line === "bare") {
+      current.bare = true;
+    } else if (line === "detached") {
+      current.detached = true;
+    }
+  }
+  if (current.path) {
+    worktrees.push(current);
+  }
+  return worktrees;
+}
+async function removeWorktree(worktreePath, force = false) {
+  const args = ["worktree", "remove"];
+  if (force) args.push("--force");
+  args.push(worktreePath);
+  await execFileAsync("git", args);
+}
+async function pruneWorktrees() {
+  await execFileAsync("git", ["worktree", "prune"]);
+}
+async function isBranchMerged(branchName) {
+  try {
+    const defaultBranch = await getDefaultBranch();
+    const { stdout } = await execFileAsync("git", ["branch", "--merged", defaultBranch]);
+    const mergedBranches = stdout.split("\n").map((b) => b.trim().replace("* ", ""));
+    return mergedBranches.includes(branchName);
+  } catch {
+    return false;
+  }
+}
+function validateBranchName(branchName) {
+  if (!branchName || branchName.trim() === "") {
+    throw new Error("Branch name cannot be empty");
+  }
+  if (branchName.startsWith("-")) {
+    throw new Error("Branch name cannot start with -");
+  }
+  if (branchName.includes("..")) {
+    throw new Error("Branch name cannot contain ..");
+  }
+  if (branchName.length > 250) {
+    throw new Error("Branch name too long (max 250 characters)");
+  }
+}
+function getWorktreePath(mainRepoPath, branchName) {
+  validateBranchName(branchName);
+  const repoName = path.basename(mainRepoPath);
+  const safeBranchName = branchName.replace(/\//g, "-");
+  return path.join(path.dirname(mainRepoPath), `${repoName}-${safeBranchName}`);
+}
+async function findWorktree(identifier) {
+  const worktrees = await listWorktrees();
+  return worktrees.find(
+    (wt) => wt.branch === identifier || wt.path === identifier || path.basename(wt.path) === identifier || wt.path.endsWith(identifier)
+  );
+}
+
+// src/utils/env.ts
+import { glob } from "glob";
+import { copyFile } from "fs/promises";
+import path2 from "path";
+async function findEnvFiles(sourceDir) {
+  const files = await glob(".env*", {
+    cwd: sourceDir,
+    dot: true,
+    nodir: true
+  });
+  return files.filter((file) => {
+    if (file !== ".env" && !file.startsWith(".env.")) return false;
+    if (file.endsWith(".example") || file.endsWith(".sample") || file.endsWith(".template")) return false;
+    return true;
+  });
+}
+async function copyEnvFiles(sourceDir, destDir) {
+  const envFiles = await findEnvFiles(sourceDir);
+  const copied = [];
+  for (const file of envFiles) {
+    try {
+      await copyFile(path2.join(sourceDir, file), path2.join(destDir, file));
+      copied.push(file);
+    } catch (error) {
+      console.warn(`Warning: Could not copy ${file}: ${error}`);
+    }
+  }
+  return copied;
+}
+
+// src/utils/launcher.ts
+import { spawn } from "child_process";
+import { access } from "fs/promises";
+import path3 from "path";
+import { constants } from "fs";
+function launchAITool(options) {
+  const { cwd, tool } = options;
+  spawn(tool, [], {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+}
+async function isToolAvailable(tool) {
+  return new Promise((resolve) => {
+    const child = spawn("which", [tool]);
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+    child.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function detectPackageManager(dir) {
+  const lockfiles = [
+    { file: "bun.lockb", manager: "bun" },
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" }
+  ];
+  for (const { file, manager } of lockfiles) {
+    try {
+      await access(path3.join(dir, file), constants.R_OK);
+      return manager;
+    } catch {
+    }
+  }
+  try {
+    await access(path3.join(dir, "package.json"), constants.R_OK);
+    return "npm";
+  } catch {
+    return null;
+  }
+}
+function runInstall(dir, packageManager) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(packageManager, ["install"], {
+      cwd: dir,
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${packageManager} install failed with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+
+// src/ui/selector.ts
+import inquirer from "inquirer";
+var AI_TOOLS = [
+  {
+    name: "Claude Code",
+    value: "claude",
+    description: "Anthropic's Claude coding assistant"
+  },
+  {
+    name: "Codex",
+    value: "codex",
+    description: "OpenAI's Codex coding assistant"
+  }
+];
+async function selectAITool() {
+  const { tool } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "tool",
+      message: "Select AI coding assistant:",
+      choices: AI_TOOLS.map((t) => ({
+        name: `${t.name} - ${t.description}`,
+        value: t.value,
+        short: t.name
+      }))
+    }
+  ]);
+  return tool;
+}
+async function confirm(message, defaultValue = true) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return confirmed;
+}
+async function selectMultiple(message, choices) {
+  const { selected } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "selected",
+      message,
+      choices
+    }
+  ]);
+  return selected;
+}
+
+// src/commands/new.ts
+async function newCommand(branchName, options) {
+  if (!await isGitRepo()) {
+    console.error(chalk.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const mainRepoPath = await getGitRoot();
+  const repoName = path4.basename(mainRepoPath);
+  const worktreePath = getWorktreePath(mainRepoPath, branchName);
+  console.log(chalk.cyan(`
+Creating worktree for branch: ${chalk.bold(branchName)}`));
+  console.log(chalk.dim(`Repository: ${repoName}`));
+  console.log(chalk.dim(`Worktree path: ${worktreePath}
+`));
+  const spinner = ora("Creating worktree...").start();
+  try {
+    await createWorktree(worktreePath, branchName);
+    spinner.succeed(chalk.green("Worktree created successfully"));
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to create worktree"));
+    console.error(chalk.red(error.message || error));
+    process.exit(1);
+  }
+  const envSpinner = ora("Copying .env files...").start();
+  try {
+    const copiedFiles = await copyEnvFiles(mainRepoPath, worktreePath);
+    if (copiedFiles.length > 0) {
+      envSpinner.succeed(chalk.green(`Copied ${copiedFiles.length} env file(s): ${copiedFiles.join(", ")}`));
+    } else {
+      envSpinner.info(chalk.yellow("No .env files found to copy"));
+    }
+  } catch (error) {
+    envSpinner.warn(chalk.yellow(`Warning: Could not copy env files: ${error.message}`));
+  }
+  if (options.install) {
+    const packageManager = await detectPackageManager(worktreePath);
+    if (packageManager) {
+      const installSpinner = ora(`Running ${packageManager} install...`).start();
+      try {
+        await runInstall(worktreePath, packageManager);
+        installSpinner.succeed(chalk.green(`${packageManager} install completed`));
+      } catch (error) {
+        installSpinner.fail(chalk.red(`${packageManager} install failed: ${error.message}`));
+      }
+    }
+  } else {
+    const packageManager = await detectPackageManager(worktreePath);
+    if (packageManager) {
+      console.log(chalk.dim(`
+Tip: Run '${packageManager} install' in the worktree, or use 'wt new --install' next time`));
+    }
+  }
+  if (options.skipLaunch) {
+    console.log(chalk.green(`
+\u2713 Worktree ready at: ${worktreePath}`));
+    console.log(chalk.dim(`  cd "${worktreePath}"`));
+    return;
+  }
+  console.log("");
+  const selectedTool = await selectAITool();
+  const toolAvailable = await isToolAvailable(selectedTool);
+  if (!toolAvailable) {
+    console.error(chalk.red(`
+Error: ${selectedTool} is not installed or not in PATH`));
+    console.log(chalk.dim(`Worktree is ready at: ${worktreePath}`));
+    console.log(chalk.dim(`You can manually launch your AI tool there.`));
+    process.exit(1);
+  }
+  console.log(chalk.cyan(`
+Launching ${selectedTool} in worktree...`));
+  launchAITool({
+    cwd: worktreePath,
+    tool: selectedTool
+  });
+  console.log(chalk.green(`
+\u2713 ${selectedTool} launched in: ${worktreePath}`));
+}
+
+export {
+  isGitRepo,
+  getGitRoot,
+  remoteBranchExists,
+  listWorktrees,
+  removeWorktree,
+  pruneWorktrees,
+  isBranchMerged,
+  findWorktree,
+  launchAITool,
+  isToolAvailable,
+  selectAITool,
+  confirm,
+  selectMultiple,
+  newCommand
+};

package/dist/index.js

@@ -1,423 +1,82 @@
 #!/usr/bin/env node
+import {
+  confirm,
+  findWorktree,
+  getGitRoot,
+  isBranchMerged,
+  isGitRepo,
+  isToolAvailable,
+  launchAITool,
+  listWorktrees,
+  newCommand,
+  pruneWorktrees,
+  remoteBranchExists,
+  removeWorktree,
+  selectAITool,
+  selectMultiple
+} from "./chunk-U3OPVTLP.js";
 
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/new.ts
+// src/commands/list.ts
 import chalk from "chalk";
-import ora from "ora";
-import path4 from "path";
-
-// src/utils/git.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
 import path from "path";
-var execFileAsync = promisify(execFile);
-async function isGitRepo() {
-  try {
-    await execFileAsync("git", ["rev-parse", "--git-dir"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getGitRoot() {
-  const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
-  return stdout.trim();
-}
-async function branchExists(branchName) {
-  try {
-    await execFileAsync("git", ["rev-parse", "--verify", branchName]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function remoteBranchExists(branchName) {
-  try {
-    const { stdout } = await execFileAsync("git", ["branch", "-r"]);
-    const remoteBranches = stdout.split("\n").map((b) => b.trim());
-    return remoteBranches.some(
-      (b) => b === `origin/${branchName}` || b.endsWith(`/${branchName}`)
-    );
-  } catch {
-    return false;
-  }
-}
-async function getDefaultBranch() {
-  try {
-    const { stdout } = await execFileAsync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"]);
-    return stdout.trim().replace("refs/remotes/origin/", "");
-  } catch {
-    if (await branchExists("main")) return "main";
-    if (await branchExists("master")) return "master";
-    return "main";
-  }
-}
-async function createWorktree(worktreePath, branchName) {
-  validateBranchName(branchName);
-  const exists = await branchExists(branchName);
-  if (exists) {
-    await execFileAsync("git", ["worktree", "add", "--", worktreePath, branchName]);
-  } else {
-    await execFileAsync("git", ["worktree", "add", "-b", branchName, "--", worktreePath]);
-  }
-}
-async function listWorktrees() {
-  const { stdout } = await execFileAsync("git", ["worktree", "list", "--porcelain"]);
-  const worktrees = [];
-  let current = {};
-  for (const line of stdout.split("\n")) {
-    if (line.startsWith("worktree ")) {
-      if (current.path) {
-        worktrees.push(current);
-      }
-      current = {
-        path: line.substring(9),
-        bare: false,
-        detached: false
-      };
-    } else if (line.startsWith("HEAD ")) {
-      current.head = line.substring(5);
-    } else if (line.startsWith("branch ")) {
-      current.branch = line.substring(7).replace("refs/heads/", "");
-    } else if (line === "bare") {
-      current.bare = true;
-    } else if (line === "detached") {
-      current.detached = true;
-    }
-  }
-  if (current.path) {
-    worktrees.push(current);
-  }
-  return worktrees;
-}
-async function removeWorktree(worktreePath, force = false) {
-  const args = ["worktree", "remove"];
-  if (force) args.push("--force");
-  args.push(worktreePath);
-  await execFileAsync("git", args);
-}
-async function pruneWorktrees() {
-  await execFileAsync("git", ["worktree", "prune"]);
-}
-async function isBranchMerged(branchName) {
-  try {
-    const defaultBranch = await getDefaultBranch();
-    const { stdout } = await execFileAsync("git", ["branch", "--merged", defaultBranch]);
-    const mergedBranches = stdout.split("\n").map((b) => b.trim().replace("* ", ""));
-    return mergedBranches.includes(branchName);
-  } catch {
-    return false;
-  }
-}
-function validateBranchName(branchName) {
-  if (!branchName || branchName.trim() === "") {
-    throw new Error("Branch name cannot be empty");
-  }
-  if (branchName.startsWith("-")) {
-    throw new Error("Branch name cannot start with -");
-  }
-  if (branchName.includes("..")) {
-    throw new Error("Branch name cannot contain ..");
-  }
-  if (branchName.length > 250) {
-    throw new Error("Branch name too long (max 250 characters)");
-  }
-}
-function getWorktreePath(mainRepoPath, branchName) {
-  validateBranchName(branchName);
-  const repoName = path.basename(mainRepoPath);
-  const safeBranchName = branchName.replace(/\//g, "-");
-  return path.join(path.dirname(mainRepoPath), `${repoName}-${safeBranchName}`);
-}
-async function findWorktree(identifier) {
-  const worktrees = await listWorktrees();
-  return worktrees.find(
-    (wt) => wt.branch === identifier || wt.path === identifier || path.basename(wt.path) === identifier || wt.path.endsWith(identifier)
-  );
-}
-
-// src/utils/env.ts
-import { glob } from "glob";
-import { copyFile } from "fs/promises";
-import path2 from "path";
-async function findEnvFiles(sourceDir) {
-  const files = await glob(".env*", {
-    cwd: sourceDir,
-    dot: true,
-    nodir: true
-  });
-  return files.filter((file) => {
-    if (file !== ".env" && !file.startsWith(".env.")) return false;
-    if (file.endsWith(".example") || file.endsWith(".sample") || file.endsWith(".template")) return false;
-    return true;
-  });
-}
-async function copyEnvFiles(sourceDir, destDir) {
-  const envFiles = await findEnvFiles(sourceDir);
-  const copied = [];
-  for (const file of envFiles) {
-    try {
-      await copyFile(path2.join(sourceDir, file), path2.join(destDir, file));
-      copied.push(file);
-    } catch (error) {
-      console.warn(`Warning: Could not copy ${file}: ${error}`);
-    }
-  }
-  return copied;
-}
-
-// src/utils/launcher.ts
-import { spawn } from "child_process";
-import { access } from "fs/promises";
-import path3 from "path";
-import { constants } from "fs";
-function launchAITool(options) {
-  const { cwd, tool } = options;
-  spawn(tool, [], {
-    cwd,
-    stdio: "inherit",
-    shell: true
-  });
-}
-async function isToolAvailable(tool) {
-  return new Promise((resolve) => {
-    const child = spawn("which", [tool]);
-    child.on("close", (code) => {
-      resolve(code === 0);
-    });
-    child.on("error", () => {
-      resolve(false);
-    });
-  });
-}
-async function detectPackageManager(dir) {
-  const lockfiles = [
-    { file: "bun.lockb", manager: "bun" },
-    { file: "pnpm-lock.yaml", manager: "pnpm" },
-    { file: "yarn.lock", manager: "yarn" },
-    { file: "package-lock.json", manager: "npm" }
-  ];
-  for (const { file, manager } of lockfiles) {
-    try {
-      await access(path3.join(dir, file), constants.R_OK);
-      return manager;
-    } catch {
-    }
-  }
-  try {
-    await access(path3.join(dir, "package.json"), constants.R_OK);
-    return "npm";
-  } catch {
-    return null;
-  }
-}
-function runInstall(dir, packageManager) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(packageManager, ["install"], {
-      cwd: dir,
-      stdio: "inherit"
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`${packageManager} install failed with code ${code}`));
-      }
-    });
-    child.on("error", reject);
-  });
-}
-
-// src/ui/selector.ts
-import inquirer from "inquirer";
-var AI_TOOLS = [
-  {
-    name: "Claude Code",
-    value: "claude",
-    description: "Anthropic's Claude coding assistant"
-  },
-  {
-    name: "Codex",
-    value: "codex",
-    description: "OpenAI's Codex coding assistant"
-  }
-];
-async function selectAITool() {
-  const { tool } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "tool",
-      message: "Select AI coding assistant:",
-      choices: AI_TOOLS.map((t) => ({
-        name: `${t.name} - ${t.description}`,
-        value: t.value,
-        short: t.name
-      }))
-    }
-  ]);
-  return tool;
-}
-async function confirm(message, defaultValue = true) {
-  const { confirmed } = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "confirmed",
-      message,
-      default: defaultValue
-    }
-  ]);
-  return confirmed;
-}
-async function selectMultiple(message, choices) {
-  const { selected } = await inquirer.prompt([
-    {
-      type: "checkbox",
-      name: "selected",
-      message,
-      choices
-    }
-  ]);
-  return selected;
-}
-
-// src/commands/new.ts
-async function newCommand(branchName, options) {
-  if (!await isGitRepo()) {
-    console.error(chalk.red("Error: Not a git repository"));
-    process.exit(1);
-  }
-  const mainRepoPath = await getGitRoot();
-  const repoName = path4.basename(mainRepoPath);
-  const worktreePath = getWorktreePath(mainRepoPath, branchName);
-  console.log(chalk.cyan(`
-Creating worktree for branch: ${chalk.bold(branchName)}`));
-  console.log(chalk.dim(`Repository: ${repoName}`));
-  console.log(chalk.dim(`Worktree path: ${worktreePath}
-`));
-  const spinner = ora("Creating worktree...").start();
-  try {
-    await createWorktree(worktreePath, branchName);
-    spinner.succeed(chalk.green("Worktree created successfully"));
-  } catch (error) {
-    spinner.fail(chalk.red("Failed to create worktree"));
-    console.error(chalk.red(error.message || error));
-    process.exit(1);
-  }
-  const envSpinner = ora("Copying .env files...").start();
-  try {
-    const copiedFiles = await copyEnvFiles(mainRepoPath, worktreePath);
-    if (copiedFiles.length > 0) {
-      envSpinner.succeed(chalk.green(`Copied ${copiedFiles.length} env file(s): ${copiedFiles.join(", ")}`));
-    } else {
-      envSpinner.info(chalk.yellow("No .env files found to copy"));
-    }
-  } catch (error) {
-    envSpinner.warn(chalk.yellow(`Warning: Could not copy env files: ${error.message}`));
-  }
-  if (options.install) {
-    const packageManager = await detectPackageManager(worktreePath);
-    if (packageManager) {
-      const installSpinner = ora(`Running ${packageManager} install...`).start();
-      try {
-        await runInstall(worktreePath, packageManager);
-        installSpinner.succeed(chalk.green(`${packageManager} install completed`));
-      } catch (error) {
-        installSpinner.fail(chalk.red(`${packageManager} install failed: ${error.message}`));
-      }
-    }
-  } else {
-    const packageManager = await detectPackageManager(worktreePath);
-    if (packageManager) {
-      console.log(chalk.dim(`
-Tip: Run '${packageManager} install' in the worktree, or use 'wt new --install' next time`));
-    }
-  }
-  if (options.skipLaunch) {
-    console.log(chalk.green(`
-\u2713 Worktree ready at: ${worktreePath}`));
-    console.log(chalk.dim(`  cd "${worktreePath}"`));
-    return;
-  }
-  console.log("");
-  const selectedTool = await selectAITool();
-  const toolAvailable = await isToolAvailable(selectedTool);
-  if (!toolAvailable) {
-    console.error(chalk.red(`
-Error: ${selectedTool} is not installed or not in PATH`));
-    console.log(chalk.dim(`Worktree is ready at: ${worktreePath}`));
-    console.log(chalk.dim(`You can manually launch your AI tool there.`));
-    process.exit(1);
-  }
-  console.log(chalk.cyan(`
-Launching ${selectedTool} in worktree...`));
-  launchAITool({
-    cwd: worktreePath,
-    tool: selectedTool
-  });
-  console.log(chalk.green(`
-\u2713 ${selectedTool} launched in: ${worktreePath}`));
-}
-
-// src/commands/list.ts
-import chalk2 from "chalk";
-import path5 from "path";
 async function listCommand() {
   if (!await isGitRepo()) {
-    console.error(chalk2.red("Error: Not a git repository"));
+    console.error(chalk.red("Error: Not a git repository"));
     process.exit(1);
   }
   const mainRepoPath = await getGitRoot();
   const worktrees = await listWorktrees();
   if (worktrees.length === 0) {
-    console.log(chalk2.yellow("No worktrees found"));
+    console.log(chalk.yellow("No worktrees found"));
     return;
   }
-  console.log(chalk2.cyan(`
-Worktrees for: ${chalk2.bold(path5.basename(mainRepoPath))}
+  console.log(chalk.cyan(`
+Worktrees for: ${chalk.bold(path.basename(mainRepoPath))}
 `));
   console.log(
-    chalk2.dim("\u2500".repeat(100))
+    chalk.dim("\u2500".repeat(100))
   );
   console.log(
-    chalk2.bold(padEnd("Path", 50)) + chalk2.bold(padEnd("Branch", 25)) + chalk2.bold("Status")
+    chalk.bold(padEnd("Path", 50)) + chalk.bold(padEnd("Branch", 25)) + chalk.bold("Status")
   );
   console.log(
-    chalk2.dim("\u2500".repeat(100))
+    chalk.dim("\u2500".repeat(100))
   );
   for (const wt of worktrees) {
     const isMain = wt.path === mainRepoPath;
     const status = await getWorktreeStatus(wt.branch, wt.detached, isMain);
     const displayPath = shortenPath(wt.path, 48);
-    const displayBranch = wt.detached ? chalk2.yellow("(detached)") : wt.branch || "N/A";
+    const displayBranch = wt.detached ? chalk.yellow("(detached)") : wt.branch || "N/A";
     console.log(
-      padEnd(isMain ? chalk2.bold(displayPath) : displayPath, 50) + padEnd(displayBranch, 25) + status
+      padEnd(isMain ? chalk.bold(displayPath) : displayPath, 50) + padEnd(displayBranch, 25) + status
     );
   }
-  console.log(chalk2.dim("\u2500".repeat(100)));
-  console.log(chalk2.dim(`
+  console.log(chalk.dim("\u2500".repeat(100)));
+  console.log(chalk.dim(`
 Total: ${worktrees.length} worktree(s)`));
 }
 async function getWorktreeStatus(branch, detached, isMain) {
   if (isMain) {
-    return chalk2.blue("main");
+    return chalk.blue("main");
   }
   if (detached) {
-    return chalk2.yellow("detached");
+    return chalk.yellow("detached");
   }
   if (!branch) {
-    return chalk2.dim("unknown");
+    return chalk.dim("unknown");
   }
   const existsOnRemote = await remoteBranchExists(branch);
   const isMerged = await isBranchMerged(branch);
   if (isMerged) {
-    return chalk2.green("merged") + chalk2.dim(" (can clean)");
+    return chalk.green("merged") + chalk.dim(" (can clean)");
   }
   if (!existsOnRemote) {
-    return chalk2.yellow("local only");
+    return chalk.yellow("local only");
   }
-  return chalk2.green("active");
+  return chalk.green("active");
 }
 function padEnd(str, length) {
   const visibleLength = str.replace(/\x1B\[[0-9;]*m/g, "").length;
@@ -426,12 +85,12 @@ function padEnd(str, length) {
 }
 function shortenPath(p, maxLength) {
   if (p.length <= maxLength) return p;
-  const parts = p.split(path5.sep);
+  const parts = p.split(path.sep);
   let result = parts[parts.length - 1];
   for (let i = parts.length - 2; i >= 0; i--) {
-    const newResult = path5.join(parts[i], result);
+    const newResult = path.join(parts[i], result);
     if (newResult.length > maxLength - 3) {
-      return "..." + path5.sep + result;
+      return "..." + path.sep + result;
     }
     result = newResult;
   }
@@ -439,20 +98,20 @@ function shortenPath(p, maxLength) {
 }
 
 // src/commands/clean.ts
-import chalk3 from "chalk";
-import ora2 from "ora";
-import path6 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+import path2 from "path";
 async function cleanCommand() {
   if (!await isGitRepo()) {
-    console.error(chalk3.red("Error: Not a git repository"));
+    console.error(chalk2.red("Error: Not a git repository"));
     process.exit(1);
   }
   const mainRepoPath = await getGitRoot();
-  const pruneSpinner = ora2("Pruning stale references...").start();
+  const pruneSpinner = ora("Pruning stale references...").start();
   await pruneWorktrees();
   pruneSpinner.succeed("Pruned stale references");
   const worktrees = await listWorktrees();
-  const spinner = ora2("Checking worktree status...").start();
+  const spinner = ora("Checking worktree status...").start();
   const staleWorktrees = [];
   for (const wt of worktrees) {
     if (wt.path === mainRepoPath) continue;
@@ -469,16 +128,16 @@ async function cleanCommand() {
   }
   spinner.stop();
   if (staleWorktrees.length === 0) {
-    console.log(chalk3.green("\n\u2713 No stale worktrees found"));
+    console.log(chalk2.green("\n\u2713 No stale worktrees found"));
     return;
   }
-  console.log(chalk3.yellow(`
+  console.log(chalk2.yellow(`
 Found ${staleWorktrees.length} potentially stale worktree(s):
 `));
   const choices = staleWorktrees.map((wt) => {
-    const reasonText = wt.reason === "merged" ? chalk3.green("merged") : chalk3.yellow("local only");
+    const reasonText = wt.reason === "merged" ? chalk2.green("merged") : chalk2.yellow("local only");
     return {
-      name: `${path6.basename(wt.path)} (${wt.branch}) - ${reasonText}`,
+      name: `${path2.basename(wt.path)} (${wt.branch}) - ${reasonText}`,
       value: wt,
       checked: wt.reason === "merged"
       // Pre-select merged branches
@@ -489,7 +148,7 @@ Found ${staleWorktrees.length} potentially stale worktree(s):
     choices
   );
   if (selected.length === 0) {
-    console.log(chalk3.yellow("\nNo worktrees selected for removal"));
+    console.log(chalk2.yellow("\nNo worktrees selected for removal"));
     return;
   }
   const confirmed = await confirm(
@@ -497,94 +156,277 @@ Found ${staleWorktrees.length} potentially stale worktree(s):
     true
   );
   if (!confirmed) {
-    console.log(chalk3.yellow("Cancelled"));
+    console.log(chalk2.yellow("Cancelled"));
     return;
   }
   console.log("");
   let removed = 0;
   let failed = 0;
   for (const wt of selected) {
-    const removeSpinner = ora2(`Removing ${path6.basename(wt.path)}...`).start();
+    const removeSpinner = ora(`Removing ${path2.basename(wt.path)}...`).start();
     try {
       await removeWorktree(wt.path, false);
-      removeSpinner.succeed(chalk3.green(`Removed ${path6.basename(wt.path)}`));
+      removeSpinner.succeed(chalk2.green(`Removed ${path2.basename(wt.path)}`));
       removed++;
     } catch (error) {
       try {
         await removeWorktree(wt.path, true);
-        removeSpinner.succeed(chalk3.green(`Removed ${path6.basename(wt.path)} (forced)`));
+        removeSpinner.succeed(chalk2.green(`Removed ${path2.basename(wt.path)} (forced)`));
         removed++;
       } catch (forceError) {
-        removeSpinner.fail(chalk3.red(`Failed to remove ${path6.basename(wt.path)}: ${forceError.message}`));
+        removeSpinner.fail(chalk2.red(`Failed to remove ${path2.basename(wt.path)}: ${forceError.message}`));
         failed++;
       }
     }
   }
   console.log("");
   if (removed > 0) {
-    console.log(chalk3.green(`\u2713 Removed ${removed} worktree(s)`));
+    console.log(chalk2.green(`\u2713 Removed ${removed} worktree(s)`));
   }
   if (failed > 0) {
-    console.log(chalk3.red(`\u2717 Failed to remove ${failed} worktree(s)`));
+    console.log(chalk2.red(`\u2717 Failed to remove ${failed} worktree(s)`));
   }
 }
 
 // src/commands/remove.ts
-import chalk4 from "chalk";
-import ora3 from "ora";
-import path7 from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import path3 from "path";
 async function removeCommand(identifier, options) {
   if (!await isGitRepo()) {
-    console.error(chalk4.red("Error: Not a git repository"));
+    console.error(chalk3.red("Error: Not a git repository"));
     process.exit(1);
   }
   const mainRepoPath = await getGitRoot();
-  const spinner = ora3("Finding worktree...").start();
+  const spinner = ora2("Finding worktree...").start();
   const worktree = await findWorktree(identifier);
   if (!worktree) {
-    spinner.fail(chalk4.red(`Worktree not found: ${identifier}`));
-    console.log(chalk4.dim('\nTip: Run "wt list" to see available worktrees'));
+    spinner.fail(chalk3.red(`Worktree not found: ${identifier}`));
+    console.log(chalk3.dim('\nTip: Run "wt list" to see available worktrees'));
     process.exit(1);
   }
   spinner.stop();
   if (worktree.path === mainRepoPath) {
-    console.error(chalk4.red("\nError: Cannot remove the main worktree"));
+    console.error(chalk3.red("\nError: Cannot remove the main worktree"));
     process.exit(1);
   }
-  console.log(chalk4.cyan("\nWorktree to remove:"));
-  console.log(chalk4.dim(`  Path:   ${worktree.path}`));
-  console.log(chalk4.dim(`  Branch: ${worktree.branch || "(detached)"}`));
+  console.log(chalk3.cyan("\nWorktree to remove:"));
+  console.log(chalk3.dim(`  Path:   ${worktree.path}`));
+  console.log(chalk3.dim(`  Branch: ${worktree.branch || "(detached)"}`));
   if (!options.force) {
     const confirmed = await confirm("\nRemove this worktree?", false);
     if (!confirmed) {
-      console.log(chalk4.yellow("Cancelled"));
+      console.log(chalk3.yellow("Cancelled"));
       return;
     }
   }
-  const removeSpinner = ora3("Removing worktree...").start();
+  const removeSpinner = ora2("Removing worktree...").start();
   try {
     await removeWorktree(worktree.path, false);
-    removeSpinner.succeed(chalk4.green(`Removed worktree: ${path7.basename(worktree.path)}`));
+    removeSpinner.succeed(chalk3.green(`Removed worktree: ${path3.basename(worktree.path)}`));
   } catch (error) {
     if (options.force) {
       try {
         await removeWorktree(worktree.path, true);
-        removeSpinner.succeed(chalk4.green(`Removed worktree (forced): ${path7.basename(worktree.path)}`));
+        removeSpinner.succeed(chalk3.green(`Removed worktree (forced): ${path3.basename(worktree.path)}`));
       } catch (forceError) {
-        removeSpinner.fail(chalk4.red(`Failed to remove worktree: ${forceError.message}`));
+        removeSpinner.fail(chalk3.red(`Failed to remove worktree: ${forceError.message}`));
         process.exit(1);
       }
     } else {
-      removeSpinner.fail(chalk4.red(`Failed to remove worktree: ${error.message}`));
-      console.log(chalk4.dim("\nTip: Use --force to force removal"));
+      removeSpinner.fail(chalk3.red(`Failed to remove worktree: ${error.message}`));
+      console.log(chalk3.dim("\nTip: Use --force to force removal"));
       process.exit(1);
     }
   }
 }
 
+// src/commands/interactive.ts
+import chalk4 from "chalk";
+import inquirer from "inquirer";
+import path4 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function getWorktreeStatus2(branch, isMain) {
+  if (isMain) return chalk4.blue("main");
+  if (!branch) return chalk4.dim("detached");
+  const merged = await isBranchMerged(branch);
+  if (merged) return chalk4.green("merged");
+  const onRemote = await remoteBranchExists(branch);
+  if (!onRemote) return chalk4.yellow("local");
+  return chalk4.green("active");
+}
+async function interactiveCommand() {
+  if (!await isGitRepo()) {
+    console.error(chalk4.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const mainRepoPath = await getGitRoot();
+  const repoName = path4.basename(mainRepoPath);
+  while (true) {
+    console.clear();
+    console.log(chalk4.cyan.bold(`
+  Worktrees: ${repoName}
+`));
+    const worktrees = await listWorktrees();
+    const choices = [];
+    for (const wt of worktrees) {
+      const isMain = wt.path === mainRepoPath;
+      const status = await getWorktreeStatus2(wt.branch, isMain);
+      const branchDisplay = wt.branch || "(detached)";
+      const dirName = path4.basename(wt.path);
+      choices.push({
+        name: `  ${dirName.padEnd(35)} ${branchDisplay.padEnd(25)} ${status}`,
+        value: wt,
+        short: dirName
+      });
+    }
+    choices.push({ name: chalk4.dim("\u2500".repeat(70)), value: "quit", short: "" });
+    choices.push({ name: chalk4.green("  + Create new worktree"), value: "new", short: "new" });
+    choices.push({ name: chalk4.dim("  q Quit"), value: "quit", short: "quit" });
+    const { selected } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selected",
+        message: "Select a worktree:",
+        choices,
+        pageSize: 15
+      }
+    ]);
+    if (selected === "quit") {
+      console.log(chalk4.dim("\nGoodbye.\n"));
+      break;
+    }
+    if (selected === "new") {
+      await handleNewWorktree(mainRepoPath);
+      continue;
+    }
+    await handleWorktreeActions(selected, mainRepoPath);
+  }
+}
+async function handleNewWorktree(mainRepoPath) {
+  const { branchName } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "branchName",
+      message: "Branch name:",
+      validate: (input) => {
+        if (!input.trim()) return "Branch name required";
+        if (input.startsWith("-")) return "Cannot start with -";
+        if (input.includes("..")) return "Cannot contain ..";
+        return true;
+      }
+    }
+  ]);
+  if (!branchName.trim()) return;
+  const { newCommand: newCommand2 } = await import("./new-KE3RQFLK.js");
+  await newCommand2(branchName.trim(), { skipLaunch: false });
+}
+async function handleWorktreeActions(wt, mainRepoPath) {
+  const isMain = wt.path === mainRepoPath;
+  const dirName = path4.basename(wt.path);
+  const actions = [
+    { name: "  Open in terminal (cd)", value: "cd" },
+    { name: "  Launch AI assistant", value: "launch" }
+  ];
+  if (!isMain) {
+    actions.push({ name: chalk4.red("  Delete worktree"), value: "delete" });
+  }
+  actions.push({ name: chalk4.dim("  Back"), value: "back" });
+  console.log(chalk4.cyan(`
+  ${dirName}`));
+  console.log(chalk4.dim(`  ${wt.path}
+`));
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "Action:",
+      choices: actions
+    }
+  ]);
+  switch (action) {
+    case "cd":
+      console.log(chalk4.green(`
+To open this worktree, run:`));
+      console.log(chalk4.cyan(`  cd "${wt.path}"
+`));
+      try {
+        await execFileAsync("pbcopy", [], { input: wt.path });
+        console.log(chalk4.dim("(Path copied to clipboard)\n"));
+      } catch {
+      }
+      await pause();
+      break;
+    case "launch":
+      const tool = await selectAITool();
+      const available = await isToolAvailable(tool);
+      if (!available) {
+        console.log(chalk4.red(`
+${tool} is not installed or not in PATH
+`));
+        await pause();
+        break;
+      }
+      console.log(chalk4.cyan(`
+Launching ${tool} in ${dirName}...`));
+      launchAITool({ cwd: wt.path, tool });
+      console.log(chalk4.green(`
+${tool} launched.
+`));
+      await pause();
+      break;
+    case "delete":
+      const { confirm: confirm2 } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `Delete ${dirName}?`,
+          default: false
+        }
+      ]);
+      if (confirm2) {
+        try {
+          await removeWorktree(wt.path, false);
+          console.log(chalk4.green(`
+Deleted ${dirName}
+`));
+        } catch {
+          try {
+            await removeWorktree(wt.path, true);
+            console.log(chalk4.green(`
+Deleted ${dirName} (forced)
+`));
+          } catch (e) {
+            console.log(chalk4.red(`
+Failed to delete: ${e.message}
+`));
+          }
+        }
+        await pause();
+      }
+      break;
+    case "back":
+    default:
+      break;
+  }
+}
+async function pause() {
+  await inquirer.prompt([
+    {
+      type: "input",
+      name: "continue",
+      message: "Press Enter to continue..."
+    }
+  ]);
+}
+
 // src/index.ts
 var program = new Command();
-program.name("wt").description("CLI tool to streamline git worktrees with AI coding assistants").version("1.0.0");
+program.name("wt").description("CLI tool to streamline git worktrees with AI coding assistants").version("1.1.0").action(async () => {
+  await interactiveCommand();
+});
 program.command("new <branch-name>").description("Create a new worktree and launch AI assistant").option("-i, --install", "Run package manager install after creating worktree").option("-s, --skip-launch", "Create worktree without launching AI assistant").action(async (branchName, options) => {
   await newCommand(branchName, {
     install: options.install,

package/dist/new-KE3RQFLK.js

@@ -0,0 +1,6 @@
+import {
+  newCommand
+} from "./chunk-U3OPVTLP.js";
+export {
+  newCommand
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktree-launcher",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "CLI tool for managing git worktrees with AI coding assistants",
   "type": "module",
   "main": "./dist/index.js",