worktree-launcher 1.0.0

package/README.md

@@ -0,0 +1,120 @@
+# worktree-launcher (wt)
+
+CLI tool to streamline git worktrees with AI coding assistants (Claude Code / Codex).
+
+## Installation
+
+```bash
+npm install -g worktree-launcher
+```
+
+Or for local development:
+
+```bash
+git clone <repo>
+cd worktree-launcher
+npm install
+npm run build
+npm link
+```
+
+## Commands
+
+### `wt new <branch-name>`
+
+Create a new worktree and launch your AI assistant.
+
+```bash
+wt new feature-auth
+```
+
+This will:
+1. Create a new branch (if it doesn't exist)
+2. Create a worktree at `../<repo-name>-<branch-name>/`
+3. Copy all `.env*` files from the main repo
+4. Show an interactive selector to choose Claude Code or Codex
+5. Launch the selected AI assistant in the new worktree
+
+**Options:**
+- `-i, --install` - Run package manager install after creating worktree
+- `-s, --skip-launch` - Create worktree without launching AI assistant
+
+**Examples:**
+```bash
+wt new feature-auth              # Create and launch AI
+wt new feature-auth --install    # Also run npm/yarn/pnpm install
+wt new feature-auth --skip-launch # Just create the worktree
+```
+
+### `wt list` (or `wt ls`)
+
+List all worktrees for the current repository.
+
+```bash
+wt list
+```
+
+Shows:
+- Worktree paths
+- Branch names
+- Status (active, merged, local only, detached)
+
+### `wt clean`
+
+Interactively remove worktrees for merged or deleted branches.
+
+```bash
+wt clean
+```
+
+This will:
+1. Find worktrees where the branch was merged or deleted
+2. Show an interactive checkbox to select which to remove
+3. Remove selected worktrees
+
+### `wt remove <name>` (or `wt rm`)
+
+Remove a specific worktree.
+
+```bash
+wt remove feature-auth
+wt rm feature-auth --force
+```
+
+**Options:**
+- `-f, --force` - Force removal even with uncommitted changes
+
+## Worktree Location
+
+Worktrees are created as siblings to your main repository:
+
+```
+/Users/you/code/
+├── myproject/               # Main repo
+├── myproject-feature-auth/  # Worktree for feature-auth branch
+└── myproject-fix-bug/       # Worktree for fix-bug branch
+```
+
+## Env Files
+
+The following env files are automatically copied to new worktrees:
+- `.env`
+- `.env.local`
+- `.env.development`
+- `.env.development.local`
+- `.env.test`
+- `.env.test.local`
+- `.env.production`
+- `.env.production.local`
+
+Template files (`.env.example`, `.env.sample`) are not copied.
+
+## Requirements
+
+- Node.js 18+
+- Git
+- Claude Code or Codex CLI installed and in PATH
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// 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;
+  const child = spawn(tool, [], {
+    cwd,
+    stdio: "inherit",
+    // Detach so the CLI can exit
+    detached: true
+  });
+  child.unref();
+}
+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"));
+    process.exit(1);
+  }
+  const mainRepoPath = await getGitRoot();
+  const worktrees = await listWorktrees();
+  if (worktrees.length === 0) {
+    console.log(chalk2.yellow("No worktrees found"));
+    return;
+  }
+  console.log(chalk2.cyan(`
+Worktrees for: ${chalk2.bold(path5.basename(mainRepoPath))}
+`));
+  console.log(
+    chalk2.dim("\u2500".repeat(100))
+  );
+  console.log(
+    chalk2.bold(padEnd("Path", 50)) + chalk2.bold(padEnd("Branch", 25)) + chalk2.bold("Status")
+  );
+  console.log(
+    chalk2.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";
+    console.log(
+      padEnd(isMain ? chalk2.bold(displayPath) : displayPath, 50) + padEnd(displayBranch, 25) + status
+    );
+  }
+  console.log(chalk2.dim("\u2500".repeat(100)));
+  console.log(chalk2.dim(`
+Total: ${worktrees.length} worktree(s)`));
+}
+async function getWorktreeStatus(branch, detached, isMain) {
+  if (isMain) {
+    return chalk2.blue("main");
+  }
+  if (detached) {
+    return chalk2.yellow("detached");
+  }
+  if (!branch) {
+    return chalk2.dim("unknown");
+  }
+  const existsOnRemote = await remoteBranchExists(branch);
+  const isMerged = await isBranchMerged(branch);
+  if (isMerged) {
+    return chalk2.green("merged") + chalk2.dim(" (can clean)");
+  }
+  if (!existsOnRemote) {
+    return chalk2.yellow("local only");
+  }
+  return chalk2.green("active");
+}
+function padEnd(str, length) {
+  const visibleLength = str.replace(/\x1B\[[0-9;]*m/g, "").length;
+  const padding = Math.max(0, length - visibleLength);
+  return str + " ".repeat(padding);
+}
+function shortenPath(p, maxLength) {
+  if (p.length <= maxLength) return p;
+  const parts = p.split(path5.sep);
+  let result = parts[parts.length - 1];
+  for (let i = parts.length - 2; i >= 0; i--) {
+    const newResult = path5.join(parts[i], result);
+    if (newResult.length > maxLength - 3) {
+      return "..." + path5.sep + result;
+    }
+    result = newResult;
+  }
+  return result;
+}
+
+// src/commands/clean.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+import path6 from "path";
+async function cleanCommand() {
+  if (!await isGitRepo()) {
+    console.error(chalk3.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const mainRepoPath = await getGitRoot();
+  const pruneSpinner = ora2("Pruning stale references...").start();
+  await pruneWorktrees();
+  pruneSpinner.succeed("Pruned stale references");
+  const worktrees = await listWorktrees();
+  const spinner = ora2("Checking worktree status...").start();
+  const staleWorktrees = [];
+  for (const wt of worktrees) {
+    if (wt.path === mainRepoPath) continue;
+    if (wt.detached || wt.bare || !wt.branch) continue;
+    const merged = await isBranchMerged(wt.branch);
+    if (merged) {
+      staleWorktrees.push({ ...wt, reason: "merged" });
+      continue;
+    }
+    const existsOnRemote = await remoteBranchExists(wt.branch);
+    if (!existsOnRemote) {
+      staleWorktrees.push({ ...wt, reason: "local-only" });
+    }
+  }
+  spinner.stop();
+  if (staleWorktrees.length === 0) {
+    console.log(chalk3.green("\n\u2713 No stale worktrees found"));
+    return;
+  }
+  console.log(chalk3.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");
+    return {
+      name: `${path6.basename(wt.path)} (${wt.branch}) - ${reasonText}`,
+      value: wt,
+      checked: wt.reason === "merged"
+      // Pre-select merged branches
+    };
+  });
+  const selected = await selectMultiple(
+    "Select worktrees to remove:",
+    choices
+  );
+  if (selected.length === 0) {
+    console.log(chalk3.yellow("\nNo worktrees selected for removal"));
+    return;
+  }
+  const confirmed = await confirm(
+    `Remove ${selected.length} worktree(s)?`,
+    true
+  );
+  if (!confirmed) {
+    console.log(chalk3.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();
+    try {
+      await removeWorktree(wt.path, false);
+      removeSpinner.succeed(chalk3.green(`Removed ${path6.basename(wt.path)}`));
+      removed++;
+    } catch (error) {
+      try {
+        await removeWorktree(wt.path, true);
+        removeSpinner.succeed(chalk3.green(`Removed ${path6.basename(wt.path)} (forced)`));
+        removed++;
+      } catch (forceError) {
+        removeSpinner.fail(chalk3.red(`Failed to remove ${path6.basename(wt.path)}: ${forceError.message}`));
+        failed++;
+      }
+    }
+  }
+  console.log("");
+  if (removed > 0) {
+    console.log(chalk3.green(`\u2713 Removed ${removed} worktree(s)`));
+  }
+  if (failed > 0) {
+    console.log(chalk3.red(`\u2717 Failed to remove ${failed} worktree(s)`));
+  }
+}
+
+// src/commands/remove.ts
+import chalk4 from "chalk";
+import ora3 from "ora";
+import path7 from "path";
+async function removeCommand(identifier, options) {
+  if (!await isGitRepo()) {
+    console.error(chalk4.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const mainRepoPath = await getGitRoot();
+  const spinner = ora3("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'));
+    process.exit(1);
+  }
+  spinner.stop();
+  if (worktree.path === mainRepoPath) {
+    console.error(chalk4.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)"}`));
+  if (!options.force) {
+    const confirmed = await confirm("\nRemove this worktree?", false);
+    if (!confirmed) {
+      console.log(chalk4.yellow("Cancelled"));
+      return;
+    }
+  }
+  const removeSpinner = ora3("Removing worktree...").start();
+  try {
+    await removeWorktree(worktree.path, false);
+    removeSpinner.succeed(chalk4.green(`Removed worktree: ${path7.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)}`));
+      } catch (forceError) {
+        removeSpinner.fail(chalk4.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"));
+      process.exit(1);
+    }
+  }
+}
+
+// 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.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,
+    skipLaunch: options.skipLaunch
+  });
+});
+program.command("list").alias("ls").description("List all worktrees for the current repository").action(async () => {
+  await listCommand();
+});
+program.command("clean").description("Remove worktrees for merged or deleted branches").action(async () => {
+  await cleanCommand();
+});
+program.command("remove <name>").alias("rm").description("Remove a specific worktree").option("-f, --force", "Force removal even if there are uncommitted changes").action(async (name, options) => {
+  await removeCommand(name, {
+    force: options.force
+  });
+});
+program.parse();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "worktree-launcher",
+  "version": "1.0.0",
+  "description": "CLI tool to streamline git worktrees with AI coding assistants",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "wt": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "worktree",
+    "cli",
+    "claude",
+    "codex",
+    "ai"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "glob": "^10.4.5",
+    "inquirer": "^9.3.7",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.17.9",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ]
+}