worktree-launcher 1.2.1 → 1.3.0

package/dist/index.js

@@ -1,82 +1,436 @@
 #!/usr/bin/env node
-import {
-  confirm,
-  findWorktree,
-  getGitRoot,
-  isBranchMerged,
-  isGitRepo,
-  isToolAvailable,
-  launchAITool,
-  listWorktrees,
-  newCommand,
-  pruneWorktrees,
-  remoteBranchExists,
-  removeWorktree,
-  selectAITool,
-  selectMultiple
-} from "./chunk-KGMGW33P.js";
 
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/list.ts
+// 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";
-async function listCommand() {
+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 worktrees2 = [];
+  let current = {};
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) {
+        worktrees2.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) {
+    worktrees2.push(current);
+  }
+  return worktrees2;
+}
+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(mainRepoPath2, branchName) {
+  validateBranchName(branchName);
+  const repoName = path.basename(mainRepoPath2);
+  const safeBranchName = branchName.replace(/\//g, "-");
+  return path.join(path.dirname(mainRepoPath2), `${repoName}-${safeBranchName}`);
+}
+async function findWorktree(identifier) {
+  const worktrees2 = await listWorktrees();
+  return worktrees2.find(
+    (wt) => wt.branch === identifier || wt.path === identifier || path.basename(wt.path) === identifier || wt.path.endsWith(identifier)
+  );
+}
+async function pushBranch(branchName, cwd) {
+  const args = ["push", "-u", "origin", branchName];
+  await execFileAsync("git", args, cwd ? { cwd } : void 0);
+}
+
+// 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 worktrees = await listWorktrees();
-  if (worktrees.length === 0) {
-    console.log(chalk.yellow("No worktrees found"));
+  const mainRepoPath2 = await getGitRoot();
+  const repoName = path4.basename(mainRepoPath2);
+  const worktreePath = getWorktreePath(mainRepoPath2, 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);
+  }
+  if (options.push) {
+    const pushSpinner = ora("Pushing branch to remote...").start();
+    try {
+      await pushBranch(branchName, worktreePath);
+      pushSpinner.succeed(chalk.green(`Pushed ${branchName} to origin`));
+    } catch (error) {
+      pushSpinner.fail(chalk.yellow(`Could not push: ${error.message}`));
+    }
+  }
+  const envSpinner = ora("Copying .env files...").start();
+  try {
+    const copiedFiles = await copyEnvFiles(mainRepoPath2, 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(`
-Worktrees for: ${chalk.bold(path.basename(mainRepoPath))}
+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"));
+    process.exit(1);
+  }
+  const mainRepoPath2 = await getGitRoot();
+  const worktrees2 = await listWorktrees();
+  if (worktrees2.length === 0) {
+    console.log(chalk2.yellow("No worktrees found"));
+    return;
+  }
+  console.log(chalk2.cyan(`
+Worktrees for: ${chalk2.bold(path5.basename(mainRepoPath2))}
 `));
   console.log(
-    chalk.dim("\u2500".repeat(100))
+    chalk2.dim("\u2500".repeat(100))
   );
   console.log(
-    chalk.bold(padEnd("Path", 50)) + chalk.bold(padEnd("Branch", 25)) + chalk.bold("Status")
+    chalk2.bold(padEnd("Path", 50)) + chalk2.bold(padEnd("Branch", 25)) + chalk2.bold("Status")
   );
   console.log(
-    chalk.dim("\u2500".repeat(100))
+    chalk2.dim("\u2500".repeat(100))
   );
-  for (const wt of worktrees) {
-    const isMain = wt.path === mainRepoPath;
+  for (const wt of worktrees2) {
+    const isMain = wt.path === mainRepoPath2;
     const status = await getWorktreeStatus(wt.branch, wt.detached, isMain);
     const displayPath = shortenPath(wt.path, 48);
-    const displayBranch = wt.detached ? chalk.yellow("(detached)") : wt.branch || "N/A";
+    const displayBranch = wt.detached ? chalk2.yellow("(detached)") : wt.branch || "N/A";
     console.log(
-      padEnd(isMain ? chalk.bold(displayPath) : displayPath, 50) + padEnd(displayBranch, 25) + status
+      padEnd(isMain ? chalk2.bold(displayPath) : displayPath, 50) + padEnd(displayBranch, 25) + status
     );
   }
-  console.log(chalk.dim("\u2500".repeat(100)));
-  console.log(chalk.dim(`
-Total: ${worktrees.length} worktree(s)`));
+  console.log(chalk2.dim("\u2500".repeat(100)));
+  console.log(chalk2.dim(`
+Total: ${worktrees2.length} worktree(s)`));
 }
 async function getWorktreeStatus(branch, detached, isMain) {
   if (isMain) {
-    return chalk.blue("main");
+    return chalk2.blue("main");
   }
   if (detached) {
-    return chalk.yellow("detached");
+    return chalk2.yellow("detached");
   }
   if (!branch) {
-    return chalk.dim("unknown");
+    return chalk2.dim("unknown");
   }
   const existsOnRemote = await remoteBranchExists(branch);
   const isMerged = await isBranchMerged(branch);
   if (isMerged) {
-    return chalk.green("merged") + chalk.dim(" (can clean)");
+    return chalk2.green("merged") + chalk2.dim(" (can clean)");
   }
   if (!existsOnRemote) {
-    return chalk.yellow("local only");
+    return chalk2.yellow("local only");
   }
-  return chalk.green("active");
+  return chalk2.green("active");
 }
 function padEnd(str, length) {
   const visibleLength = str.replace(/\x1B\[[0-9;]*m/g, "").length;
@@ -85,12 +439,12 @@ function padEnd(str, length) {
 }
 function shortenPath(p, maxLength) {
   if (p.length <= maxLength) return p;
-  const parts = p.split(path.sep);
+  const parts = p.split(path5.sep);
   let result = parts[parts.length - 1];
   for (let i = parts.length - 2; i >= 0; i--) {
-    const newResult = path.join(parts[i], result);
+    const newResult = path5.join(parts[i], result);
     if (newResult.length > maxLength - 3) {
-      return "..." + path.sep + result;
+      return "..." + path5.sep + result;
     }
     result = newResult;
   }
@@ -98,23 +452,23 @@ function shortenPath(p, maxLength) {
 }
 
 // src/commands/clean.ts
-import chalk2 from "chalk";
-import ora from "ora";
-import path2 from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import path6 from "path";
 async function cleanCommand() {
   if (!await isGitRepo()) {
-    console.error(chalk2.red("Error: Not a git repository"));
+    console.error(chalk3.red("Error: Not a git repository"));
     process.exit(1);
   }
-  const mainRepoPath = await getGitRoot();
-  const pruneSpinner = ora("Pruning stale references...").start();
+  const mainRepoPath2 = await getGitRoot();
+  const pruneSpinner = ora2("Pruning stale references...").start();
   await pruneWorktrees();
   pruneSpinner.succeed("Pruned stale references");
-  const worktrees = await listWorktrees();
-  const spinner = ora("Checking worktree status...").start();
+  const worktrees2 = await listWorktrees();
+  const spinner = ora2("Checking worktree status...").start();
   const staleWorktrees = [];
-  for (const wt of worktrees) {
-    if (wt.path === mainRepoPath) continue;
+  for (const wt of worktrees2) {
+    if (wt.path === mainRepoPath2) continue;
     if (wt.detached || wt.bare || !wt.branch) continue;
     const merged = await isBranchMerged(wt.branch);
     if (merged) {
@@ -128,16 +482,16 @@ async function cleanCommand() {
   }
   spinner.stop();
   if (staleWorktrees.length === 0) {
-    console.log(chalk2.green("\n\u2713 No stale worktrees found"));
+    console.log(chalk3.green("\n\u2713 No stale worktrees found"));
     return;
   }
-  console.log(chalk2.yellow(`
+  console.log(chalk3.yellow(`
 Found ${staleWorktrees.length} potentially stale worktree(s):
 `));
   const choices = staleWorktrees.map((wt) => {
-    const reasonText = wt.reason === "merged" ? chalk2.green("merged") : chalk2.yellow("local only");
+    const reasonText = wt.reason === "merged" ? chalk3.green("merged") : chalk3.yellow("local only");
     return {
-      name: `${path2.basename(wt.path)} (${wt.branch}) - ${reasonText}`,
+      name: `${path6.basename(wt.path)} (${wt.branch}) - ${reasonText}`,
       value: wt,
       checked: wt.reason === "merged"
       // Pre-select merged branches
@@ -148,7 +502,7 @@ Found ${staleWorktrees.length} potentially stale worktree(s):
     choices
   );
   if (selected.length === 0) {
-    console.log(chalk2.yellow("\nNo worktrees selected for removal"));
+    console.log(chalk3.yellow("\nNo worktrees selected for removal"));
     return;
   }
   const confirmed = await confirm(
@@ -156,275 +510,360 @@ Found ${staleWorktrees.length} potentially stale worktree(s):
     true
   );
   if (!confirmed) {
-    console.log(chalk2.yellow("Cancelled"));
+    console.log(chalk3.yellow("Cancelled"));
     return;
   }
   console.log("");
   let removed = 0;
   let failed = 0;
   for (const wt of selected) {
-    const removeSpinner = ora(`Removing ${path2.basename(wt.path)}...`).start();
+    const removeSpinner = ora2(`Removing ${path6.basename(wt.path)}...`).start();
     try {
       await removeWorktree(wt.path, false);
-      removeSpinner.succeed(chalk2.green(`Removed ${path2.basename(wt.path)}`));
+      removeSpinner.succeed(chalk3.green(`Removed ${path6.basename(wt.path)}`));
       removed++;
     } catch (error) {
       try {
         await removeWorktree(wt.path, true);
-        removeSpinner.succeed(chalk2.green(`Removed ${path2.basename(wt.path)} (forced)`));
+        removeSpinner.succeed(chalk3.green(`Removed ${path6.basename(wt.path)} (forced)`));
         removed++;
       } catch (forceError) {
-        removeSpinner.fail(chalk2.red(`Failed to remove ${path2.basename(wt.path)}: ${forceError.message}`));
+        removeSpinner.fail(chalk3.red(`Failed to remove ${path6.basename(wt.path)}: ${forceError.message}`));
         failed++;
       }
     }
   }
   console.log("");
   if (removed > 0) {
-    console.log(chalk2.green(`\u2713 Removed ${removed} worktree(s)`));
+    console.log(chalk3.green(`\u2713 Removed ${removed} worktree(s)`));
   }
   if (failed > 0) {
-    console.log(chalk2.red(`\u2717 Failed to remove ${failed} worktree(s)`));
+    console.log(chalk3.red(`\u2717 Failed to remove ${failed} worktree(s)`));
   }
 }
 
 // src/commands/remove.ts
-import chalk3 from "chalk";
-import ora2 from "ora";
-import path3 from "path";
+import chalk4 from "chalk";
+import ora3 from "ora";
+import path7 from "path";
 async function removeCommand(identifier, options) {
   if (!await isGitRepo()) {
-    console.error(chalk3.red("Error: Not a git repository"));
+    console.error(chalk4.red("Error: Not a git repository"));
     process.exit(1);
   }
-  const mainRepoPath = await getGitRoot();
-  const spinner = ora2("Finding worktree...").start();
+  const mainRepoPath2 = await getGitRoot();
+  const spinner = ora3("Finding worktree...").start();
   const worktree = await findWorktree(identifier);
   if (!worktree) {
-    spinner.fail(chalk3.red(`Worktree not found: ${identifier}`));
-    console.log(chalk3.dim('\nTip: Run "wt list" to see available worktrees'));
+    spinner.fail(chalk4.red(`Worktree not found: ${identifier}`));
+    console.log(chalk4.dim('\nTip: Run "wt list" to see available worktrees'));
     process.exit(1);
   }
   spinner.stop();
-  if (worktree.path === mainRepoPath) {
-    console.error(chalk3.red("\nError: Cannot remove the main worktree"));
+  if (worktree.path === mainRepoPath2) {
+    console.error(chalk4.red("\nError: Cannot remove the main worktree"));
     process.exit(1);
   }
-  console.log(chalk3.cyan("\nWorktree to remove:"));
-  console.log(chalk3.dim(`  Path:   ${worktree.path}`));
-  console.log(chalk3.dim(`  Branch: ${worktree.branch || "(detached)"}`));
+  console.log(chalk4.cyan("\nWorktree to remove:"));
+  console.log(chalk4.dim(`  Path:   ${worktree.path}`));
+  console.log(chalk4.dim(`  Branch: ${worktree.branch || "(detached)"}`));
   if (!options.force) {
     const confirmed = await confirm("\nRemove this worktree?", false);
     if (!confirmed) {
-      console.log(chalk3.yellow("Cancelled"));
+      console.log(chalk4.yellow("Cancelled"));
       return;
     }
   }
-  const removeSpinner = ora2("Removing worktree...").start();
+  const removeSpinner = ora3("Removing worktree...").start();
   try {
     await removeWorktree(worktree.path, false);
-    removeSpinner.succeed(chalk3.green(`Removed worktree: ${path3.basename(worktree.path)}`));
+    removeSpinner.succeed(chalk4.green(`Removed worktree: ${path7.basename(worktree.path)}`));
   } catch (error) {
     if (options.force) {
       try {
         await removeWorktree(worktree.path, true);
-        removeSpinner.succeed(chalk3.green(`Removed worktree (forced): ${path3.basename(worktree.path)}`));
+        removeSpinner.succeed(chalk4.green(`Removed worktree (forced): ${path7.basename(worktree.path)}`));
       } catch (forceError) {
-        removeSpinner.fail(chalk3.red(`Failed to remove worktree: ${forceError.message}`));
+        removeSpinner.fail(chalk4.red(`Failed to remove worktree: ${forceError.message}`));
         process.exit(1);
       }
     } else {
-      removeSpinner.fail(chalk3.red(`Failed to remove worktree: ${error.message}`));
-      console.log(chalk3.dim("\nTip: Use --force to force removal"));
+      removeSpinner.fail(chalk4.red(`Failed to remove worktree: ${error.message}`));
+      console.log(chalk4.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");
-}
+import blessed from "blessed";
+import path8 from "path";
+var screen;
+var worktreeList;
+var statusBar;
+var helpBar;
+var mainRepoPath;
+var worktrees = [];
+var selectedIndex = 0;
 async function interactiveCommand() {
   if (!await isGitRepo()) {
-    console.error(chalk4.red("Error: Not a git repository"));
+    console.error("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
-      });
+  mainRepoPath = await getGitRoot();
+  const repoName = path8.basename(mainRepoPath);
+  screen = blessed.screen({
+    smartCSR: true,
+    title: `wt - ${repoName}`
+  });
+  blessed.box({
+    parent: screen,
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    content: ` Worktrees: ${repoName}`,
+    style: {
+      fg: "white",
+      bg: "blue",
+      bold: true
     }
-    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
+  });
+  worktreeList = blessed.list({
+    parent: screen,
+    top: 1,
+    left: 0,
+    width: "100%",
+    height: "100%-3",
+    keys: true,
+    vi: true,
+    mouse: true,
+    style: {
+      selected: {
+        bg: "blue",
+        fg: "white"
+      },
+      item: {
+        fg: "white"
       }
-    ]);
-    if (selected === "quit") {
-      console.log(chalk4.dim("\nGoodbye.\n"));
-      break;
+    },
+    scrollbar: {
+      ch: " ",
+      style: { bg: "grey" }
     }
-    if (selected === "new") {
-      await handleNewWorktree(mainRepoPath);
-      continue;
+  });
+  statusBar = blessed.box({
+    parent: screen,
+    bottom: 1,
+    left: 0,
+    width: "100%",
+    height: 1,
+    content: "",
+    style: {
+      fg: "yellow",
+      bg: "black"
+    }
+  });
+  helpBar = blessed.box({
+    parent: screen,
+    bottom: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    content: " [n]ew  [d]elete  [c]laude  [x]codex  [p]ush  [Enter]cd  [q]uit",
+    style: {
+      fg: "black",
+      bg: "white"
     }
-    await handleWorktreeActions(selected, mainRepoPath);
+  });
+  await refreshWorktrees();
+  worktreeList.on("select", (_item, index) => {
+    selectedIndex = index;
+    showPath();
+  });
+  screen.key(["q", "C-c"], () => {
+    screen.destroy();
+    process.exit(0);
+  });
+  screen.key(["n"], async () => {
+    await createNewWorktree();
+  });
+  screen.key(["d"], async () => {
+    await deleteSelected();
+  });
+  screen.key(["c"], async () => {
+    await launchAI("claude");
+  });
+  screen.key(["x"], async () => {
+    await launchAI("codex");
+  });
+  screen.key(["p"], async () => {
+    await pushSelected();
+  });
+  screen.key(["enter"], () => {
+    const wt = worktrees[selectedIndex];
+    if (wt) {
+      screen.destroy();
+      console.log(`
+cd "${wt.path}"
+`);
+      process.exit(0);
+    }
+  });
+  screen.key(["r"], async () => {
+    await refreshWorktrees();
+  });
+  worktreeList.focus();
+  screen.render();
+}
+async function refreshWorktrees() {
+  setStatus("Loading...");
+  worktrees = await listWorktrees();
+  const items = worktrees.map((wt) => {
+    const isMain = wt.path === mainRepoPath;
+    const dirName = path8.basename(wt.path);
+    const branch = wt.branch || "(detached)";
+    const status = isMain ? "[main]" : "";
+    return ` ${dirName.padEnd(40)} ${branch.padEnd(25)} ${status}`;
+  });
+  worktreeList.setItems(items);
+  worktreeList.select(selectedIndex);
+  showPath();
+  screen.render();
+}
+function showPath() {
+  const wt = worktrees[selectedIndex];
+  if (wt) {
+    setStatus(wt.path);
+  } else {
+    setStatus("");
   }
 }
-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;
-      }
+function setStatus(msg) {
+  statusBar.setContent(` ${msg}`);
+  screen.render();
+}
+async function createNewWorktree() {
+  const input = blessed.textbox({
+    parent: screen,
+    top: "center",
+    left: "center",
+    width: 50,
+    height: 3,
+    border: { type: "line" },
+    style: {
+      fg: "white",
+      bg: "black",
+      border: { fg: "blue" }
+    },
+    label: " Branch name ",
+    inputOnFocus: true
+  });
+  input.focus();
+  screen.render();
+  input.on("submit", async (value) => {
+    input.destroy();
+    if (!value || !value.trim()) {
+      await refreshWorktrees();
+      return;
     }
-  ]);
-  if (!branchName.trim()) return;
-  const { newCommand: newCommand2 } = await import("./new-DHGI74HT.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" });
+    const branchName = value.trim();
+    try {
+      validateBranchName(branchName);
+    } catch (e) {
+      setStatus(`Error: ${e.message}`);
+      return;
+    }
+    setStatus(`Creating ${branchName}...`);
+    try {
+      const worktreePath = getWorktreePath(mainRepoPath, branchName);
+      await createWorktree(worktreePath, branchName);
+      await copyEnvFiles(mainRepoPath, worktreePath);
+      setStatus(`Created ${branchName}`);
+      await refreshWorktrees();
+    } catch (e) {
+      setStatus(`Error: ${e.message}`);
+    }
+  });
+  input.on("cancel", () => {
+    input.destroy();
+    refreshWorktrees();
+  });
+  input.readInput();
+}
+async function deleteSelected() {
+  const wt = worktrees[selectedIndex];
+  if (!wt) return;
+  if (wt.path === mainRepoPath) {
+    setStatus("Cannot delete main worktree");
+    return;
   }
-  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
+  const dirName = path8.basename(wt.path);
+  const confirm2 = blessed.question({
+    parent: screen,
+    top: "center",
+    left: "center",
+    width: 40,
+    height: 5,
+    border: { type: "line" },
+    style: {
+      fg: "white",
+      bg: "black",
+      border: { fg: "red" }
     }
-  ]);
-  switch (action) {
-    case "cd":
-      console.log(chalk4.green(`
-To open this worktree, run:`));
-      console.log(chalk4.cyan(`  cd "${wt.path}"
-`));
+  });
+  confirm2.ask(`Delete ${dirName}?`, async (err, yes) => {
+    confirm2.destroy();
+    if (yes) {
+      setStatus(`Deleting ${dirName}...`);
       try {
-        await execFileAsync("pbcopy", [], { input: wt.path });
-        console.log(chalk4.dim("(Path copied to clipboard)\n"));
+        await removeWorktree(wt.path, false);
+        setStatus(`Deleted ${dirName}`);
       } 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 removeWorktree(wt.path, true);
+          setStatus(`Deleted ${dirName} (forced)`);
+        } catch (e) {
+          setStatus(`Error: ${e.message}`);
         }
-        await pause();
       }
-      break;
-    case "back":
-    default:
-      break;
+      if (selectedIndex > 0) selectedIndex--;
+      await refreshWorktrees();
+    } else {
+      await refreshWorktrees();
+    }
+  });
+}
+async function launchAI(tool) {
+  const wt = worktrees[selectedIndex];
+  if (!wt) return;
+  const available = await isToolAvailable(tool);
+  if (!available) {
+    setStatus(`${tool} is not installed`);
+    return;
   }
+  setStatus(`Launching ${tool}...`);
+  launchAITool({ cwd: wt.path, tool });
+  setStatus(`${tool} launched in ${path8.basename(wt.path)}`);
 }
-async function pause() {
-  await inquirer.prompt([
-    {
-      type: "input",
-      name: "continue",
-      message: "Press Enter to continue..."
-    }
-  ]);
+async function pushSelected() {
+  const wt = worktrees[selectedIndex];
+  if (!wt || !wt.branch) {
+    setStatus("No branch to push");
+    return;
+  }
+  setStatus(`Pushing ${wt.branch}...`);
+  try {
+    await pushBranch(wt.branch, wt.path);
+    setStatus(`Pushed ${wt.branch} to origin`);
+  } catch (e) {
+    setStatus(`Error: ${e.message}`);
+  }
 }
 
 // src/index.ts
 var program = new Command();
-program.name("wt").description("CLI tool to streamline git worktrees with AI coding assistants").version("1.2.1").action(async () => {
+program.name("wt").description("CLI tool to streamline git worktrees with AI coding assistants").version("1.3.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").option("-p, --push", "Push branch to remote (visible on GitHub)").action(async (branchName, options) => {