worktree-launcher 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktree-launcher",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "CLI tool for managing git worktrees with AI coding assistants",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,6 +33,8 @@
   "author": "mertdeveci5",
   "license": "MIT",
   "dependencies": {
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.11.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "glob": "^10.4.5",
@@ -40,6 +42,7 @@
     "ora": "^8.1.0"
   },
   "devDependencies": {
+    "@types/blessed": "^0.1.27",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.17.9",
     "tsup": "^8.3.5",

package/dist/chunk-KGMGW33P.js

@@ -1,386 +0,0 @@
-// 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)
-  );
-}
-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 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);
-  }
-  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(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/new-DHGI74HT.js

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