@aku11i/phantom 0.4.0 → 0.6.0

package/dist/phantom.js

@@ -3,9 +3,12 @@
 // src/bin/phantom.ts
 import { argv, exit } from "node:process";
 
-// src/cli/handlers/create.ts
+// src/cli/handlers/attach.ts
 import { parseArgs } from "node:util";
 
+// src/core/git/libs/get-git-root.ts
+import { dirname, resolve } from "node:path";
+
 // src/core/git/executor.ts
 import { execFile as execFileCallback } from "node:child_process";
 import { promisify } from "node:util";
@@ -41,8 +44,15 @@ async function executeGitCommandInDirectory(directory, args2) {
 
 // src/core/git/libs/get-git-root.ts
 async function getGitRoot() {
-  const { stdout } = await executeGitCommand(["rev-parse", "--show-toplevel"]);
-  return stdout;
+  const { stdout } = await executeGitCommand(["rev-parse", "--git-common-dir"]);
+  if (stdout.endsWith("/.git") || stdout === ".git") {
+    return resolve(process.cwd(), dirname(stdout));
+  }
+  const { stdout: toplevel } = await executeGitCommand([
+    "rev-parse",
+    "--show-toplevel"
+  ]);
+  return toplevel;
 }
 
 // src/core/types/result.ts
@@ -82,6 +92,12 @@ var GitOperationError = class extends WorktreeError {
     this.name = "GitOperationError";
   }
 };
+var BranchNotFoundError = class extends WorktreeError {
+  constructor(branchName) {
+    super(`Branch '${branchName}' not found`);
+    this.name = "BranchNotFoundError";
+  }
+};
 
 // src/core/worktree/validate.ts
 import fs from "node:fs/promises";
@@ -126,33 +142,17 @@ async function validateWorktreeDoesNotExist(gitRoot, name) {
     };
   }
 }
-async function validatePhantomDirectoryExists(gitRoot) {
-  const phantomDir = getPhantomDirectory(gitRoot);
-  try {
-    await fs.access(phantomDir);
-    return true;
-  } catch {
-    return false;
+function validateWorktreeName(name) {
+  if (!name || name.trim() === "") {
+    return err(new Error("Phantom name cannot be empty"));
   }
-}
-async function listValidWorktrees(gitRoot) {
-  const phantomDir = getPhantomDirectory(gitRoot);
-  if (!await validatePhantomDirectoryExists(gitRoot)) {
-    return [];
+  if (name.includes("/")) {
+    return err(new Error("Phantom name cannot contain slashes"));
   }
-  try {
-    const entries = await fs.readdir(phantomDir);
-    const validWorktrees = [];
-    for (const entry of entries) {
-      const result = await validateWorktreeExists(gitRoot, entry);
-      if (result.exists) {
-        validWorktrees.push(entry);
-      }
-    }
-    return validWorktrees;
-  } catch {
-    return [];
+  if (name.startsWith(".")) {
+    return err(new Error("Phantom name cannot start with a dot"));
   }
+  return ok(void 0);
 }
 
 // src/core/process/spawn.ts
@@ -191,24 +191,24 @@ var ProcessSpawnError = class extends ProcessError {
 
 // src/core/process/spawn.ts
 async function spawnProcess(config) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const { command: command2, args: args2 = [], options = {} } = config;
     const childProcess = nodeSpawn(command2, args2, {
       stdio: "inherit",
       ...options
     });
     childProcess.on("error", (error) => {
-      resolve(err(new ProcessSpawnError(command2, error.message)));
+      resolve2(err(new ProcessSpawnError(command2, error.message)));
     });
     childProcess.on("exit", (code, signal) => {
       if (signal) {
-        resolve(err(new ProcessSignalError(signal)));
+        resolve2(err(new ProcessSignalError(signal)));
       } else {
         const exitCode = code ?? 0;
         if (exitCode === 0) {
-          resolve(ok({ exitCode }));
+          resolve2(ok({ exitCode }));
         } else {
-          resolve(err(new ProcessExecutionError(command2, exitCode)));
+          resolve2(err(new ProcessExecutionError(command2, exitCode)));
         }
       }
     });
@@ -255,43 +255,68 @@ async function shellInWorktree(gitRoot, worktreeName) {
   });
 }
 
-// src/core/worktree/create.ts
-import fs2 from "node:fs/promises";
+// src/core/worktree/attach.ts
+import { existsSync } from "node:fs";
 
-// src/core/git/libs/add-worktree.ts
-async function addWorktree(options) {
-  const { path, branch, commitish = "HEAD" } = options;
-  await executeGitCommand(["worktree", "add", path, "-b", branch, commitish]);
+// src/core/git/libs/attach-worktree.ts
+async function attachWorktree(gitRoot, worktreePath, branchName) {
+  try {
+    await executeGitCommand(["worktree", "add", worktreePath, branchName], {
+      cwd: gitRoot
+    });
+    return ok(void 0);
+  } catch (error) {
+    return err(
+      error instanceof Error ? error : new Error(`Failed to attach worktree: ${String(error)}`)
+    );
+  }
 }
 
-// src/core/worktree/create.ts
-async function createWorktree(gitRoot, name, options = {}) {
-  const { branch = name, commitish = "HEAD" } = options;
-  const worktreesPath = getPhantomDirectory(gitRoot);
-  const worktreePath = getWorktreePath(gitRoot, name);
+// src/core/git/libs/branch-exists.ts
+async function branchExists(gitRoot, branchName) {
   try {
-    await fs2.access(worktreesPath);
-  } catch {
-    await fs2.mkdir(worktreesPath, { recursive: true });
+    await executeGitCommand(
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
+      { cwd: gitRoot }
+    );
+    return ok(true);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error) {
+      const execError = error;
+      if (execError.code === 1) {
+        return ok(false);
+      }
+    }
+    return err(
+      new Error(
+        `Failed to check branch existence: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
   }
-  const validation = await validateWorktreeDoesNotExist(gitRoot, name);
-  if (validation.exists) {
+}
+
+// src/core/worktree/attach.ts
+async function attachWorktreeCore(gitRoot, name) {
+  const validation = validateWorktreeName(name);
+  if (isErr(validation)) {
+    return validation;
+  }
+  const worktreePath = getWorktreePath(gitRoot, name);
+  if (existsSync(worktreePath)) {
     return err(new WorktreeAlreadyExistsError(name));
   }
-  try {
-    await addWorktree({
-      path: worktreePath,
-      branch,
-      commitish
-    });
-    return ok({
-      message: `Created worktree '${name}' at ${worktreePath}`,
-      path: worktreePath
-    });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return err(new GitOperationError("worktree add", errorMessage));
+  const branchCheckResult = await branchExists(gitRoot, name);
+  if (isErr(branchCheckResult)) {
+    return err(branchCheckResult.error);
+  }
+  if (!branchCheckResult.value) {
+    return err(new BranchNotFoundError(name));
+  }
+  const attachResult = await attachWorktree(gitRoot, worktreePath, name);
+  if (isErr(attachResult)) {
+    return err(attachResult.error);
   }
+  return ok(worktreePath);
 }
 
 // src/cli/output.ts
@@ -302,6 +327,9 @@ var output = {
   error: (message) => {
     console.error(message);
   },
+  warn: (message) => {
+    console.warn(message);
+  },
   table: (data) => {
     console.table(data);
   },
@@ -326,9 +354,295 @@ function exitWithError(message, exitCode = exitCodes.generalError) {
   process.exit(exitCode);
 }
 
+// src/cli/handlers/attach.ts
+async function attachHandler(args2) {
+  const { positionals, values } = parseArgs({
+    args: args2,
+    strict: true,
+    allowPositionals: true,
+    options: {
+      shell: {
+        type: "boolean",
+        short: "s"
+      },
+      exec: {
+        type: "string",
+        short: "e"
+      }
+    }
+  });
+  if (positionals.length === 0) {
+    exitWithError(
+      "Missing required argument: branch name",
+      exitCodes.validationError
+    );
+  }
+  const [branchName] = positionals;
+  if (values.shell && values.exec) {
+    exitWithError(
+      "Cannot use both --shell and --exec options",
+      exitCodes.validationError
+    );
+  }
+  const gitRoot = await getGitRoot();
+  const result = await attachWorktreeCore(gitRoot, branchName);
+  if (isErr(result)) {
+    const error = result.error;
+    if (error instanceof WorktreeAlreadyExistsError) {
+      exitWithError(error.message, exitCodes.validationError);
+    }
+    if (error instanceof BranchNotFoundError) {
+      exitWithError(error.message, exitCodes.notFound);
+    }
+    exitWithError(error.message, exitCodes.generalError);
+  }
+  const worktreePath = result.value;
+  output.log(`Attached phantom: ${branchName}`);
+  if (values.shell) {
+    const shellResult = await shellInWorktree(gitRoot, branchName);
+    if (isErr(shellResult)) {
+      exitWithError(shellResult.error.message, exitCodes.generalError);
+    }
+  } else if (values.exec) {
+    const execResult = await execInWorktree(
+      gitRoot,
+      branchName,
+      values.exec.split(" ")
+    );
+    if (isErr(execResult)) {
+      exitWithError(execResult.error.message, exitCodes.generalError);
+    }
+  }
+}
+
+// src/cli/handlers/create.ts
+import { parseArgs as parseArgs2 } from "node:util";
+
+// src/core/config/loader.ts
+import fs2 from "node:fs/promises";
+import path from "node:path";
+
+// src/core/utils/type-guards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/config/validate.ts
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(`Invalid phantom.config.json: ${message}`);
+    this.name = "ConfigValidationError";
+  }
+};
+function validateConfig(config) {
+  if (!isObject(config)) {
+    return err(new ConfigValidationError("Configuration must be an object"));
+  }
+  const cfg = config;
+  if (cfg.postCreate !== void 0) {
+    if (!isObject(cfg.postCreate)) {
+      return err(new ConfigValidationError("postCreate must be an object"));
+    }
+    const postCreate = cfg.postCreate;
+    if (postCreate.copyFiles !== void 0) {
+      if (!Array.isArray(postCreate.copyFiles)) {
+        return err(
+          new ConfigValidationError("postCreate.copyFiles must be an array")
+        );
+      }
+      if (!postCreate.copyFiles.every((f) => typeof f === "string")) {
+        return err(
+          new ConfigValidationError(
+            "postCreate.copyFiles must contain only strings"
+          )
+        );
+      }
+    }
+  }
+  return ok(config);
+}
+
+// src/core/config/loader.ts
+var ConfigNotFoundError = class extends Error {
+  constructor() {
+    super("phantom.config.json not found");
+    this.name = "ConfigNotFoundError";
+  }
+};
+var ConfigParseError = class extends Error {
+  constructor(message) {
+    super(`Failed to parse phantom.config.json: ${message}`);
+    this.name = "ConfigParseError";
+  }
+};
+async function loadConfig(gitRoot) {
+  const configPath = path.join(gitRoot, "phantom.config.json");
+  try {
+    const content = await fs2.readFile(configPath, "utf-8");
+    try {
+      const parsed = JSON.parse(content);
+      const validationResult = validateConfig(parsed);
+      if (!validationResult.ok) {
+        return err(validationResult.error);
+      }
+      return ok(validationResult.value);
+    } catch (error) {
+      return err(
+        new ConfigParseError(
+          error instanceof Error ? error.message : String(error)
+        )
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return err(new ConfigNotFoundError());
+    }
+    throw error;
+  }
+}
+
+// src/core/process/tmux.ts
+async function isInsideTmux() {
+  return process.env.TMUX !== void 0;
+}
+async function executeTmuxCommand(options) {
+  const { direction, command: command2, cwd, env } = options;
+  const tmuxArgs = [];
+  switch (direction) {
+    case "new":
+      tmuxArgs.push("new-window");
+      break;
+    case "vertical":
+      tmuxArgs.push("split-window", "-v");
+      break;
+    case "horizontal":
+      tmuxArgs.push("split-window", "-h");
+      break;
+  }
+  if (cwd) {
+    tmuxArgs.push("-c", cwd);
+  }
+  if (env) {
+    for (const [key, value] of Object.entries(env)) {
+      tmuxArgs.push("-e", `${key}=${value}`);
+    }
+  }
+  tmuxArgs.push(command2);
+  const result = await spawnProcess({
+    command: "tmux",
+    args: tmuxArgs
+  });
+  return result;
+}
+
+// src/core/worktree/create.ts
+import fs3 from "node:fs/promises";
+
+// src/core/git/libs/add-worktree.ts
+async function addWorktree(options) {
+  const { path: path3, branch, commitish = "HEAD" } = options;
+  await executeGitCommand(["worktree", "add", path3, "-b", branch, commitish]);
+}
+
+// src/core/worktree/file-copier.ts
+import { copyFile, mkdir, stat } from "node:fs/promises";
+import path2 from "node:path";
+var FileCopyError = class extends Error {
+  file;
+  constructor(file, message) {
+    super(`Failed to copy ${file}: ${message}`);
+    this.name = "FileCopyError";
+    this.file = file;
+  }
+};
+async function copyFiles(sourceDir, targetDir, files) {
+  const copiedFiles = [];
+  const skippedFiles = [];
+  for (const file of files) {
+    const sourcePath = path2.join(sourceDir, file);
+    const targetPath = path2.join(targetDir, file);
+    try {
+      const stats = await stat(sourcePath);
+      if (!stats.isFile()) {
+        skippedFiles.push(file);
+        continue;
+      }
+      const targetDirPath = path2.dirname(targetPath);
+      await mkdir(targetDirPath, { recursive: true });
+      await copyFile(sourcePath, targetPath);
+      copiedFiles.push(file);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        skippedFiles.push(file);
+      } else {
+        return err(
+          new FileCopyError(
+            file,
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+      }
+    }
+  }
+  return ok({ copiedFiles, skippedFiles });
+}
+
+// src/core/worktree/create.ts
+async function createWorktree(gitRoot, name, options = {}) {
+  const nameValidation = validateWorktreeName(name);
+  if (isErr(nameValidation)) {
+    return nameValidation;
+  }
+  const { branch = name, commitish = "HEAD" } = options;
+  const worktreesPath = getPhantomDirectory(gitRoot);
+  const worktreePath = getWorktreePath(gitRoot, name);
+  try {
+    await fs3.access(worktreesPath);
+  } catch {
+    await fs3.mkdir(worktreesPath, { recursive: true });
+  }
+  const validation = await validateWorktreeDoesNotExist(gitRoot, name);
+  if (validation.exists) {
+    return err(new WorktreeAlreadyExistsError(name));
+  }
+  try {
+    await addWorktree({
+      path: worktreePath,
+      branch,
+      commitish
+    });
+    let copiedFiles;
+    let skippedFiles;
+    let copyError;
+    if (options.copyFiles && options.copyFiles.length > 0) {
+      const copyResult = await copyFiles(
+        gitRoot,
+        worktreePath,
+        options.copyFiles
+      );
+      if (isOk(copyResult)) {
+        copiedFiles = copyResult.value.copiedFiles;
+        skippedFiles = copyResult.value.skippedFiles;
+      } else {
+        copyError = copyResult.error.message;
+      }
+    }
+    return ok({
+      message: `Created worktree '${name}' at ${worktreePath}`,
+      path: worktreePath,
+      copiedFiles,
+      skippedFiles,
+      copyError
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return err(new GitOperationError("worktree add", errorMessage));
+  }
+}
+
 // src/cli/handlers/create.ts
 async function createHandler(args2) {
-  const { values, positionals } = parseArgs({
+  const { values, positionals } = parseArgs2({
     args: args2,
     options: {
       shell: {
@@ -338,6 +652,26 @@ async function createHandler(args2) {
       exec: {
         type: "string",
         short: "x"
+      },
+      tmux: {
+        type: "boolean",
+        short: "t"
+      },
+      "tmux-vertical": {
+        type: "boolean"
+      },
+      "tmux-v": {
+        type: "boolean"
+      },
+      "tmux-horizontal": {
+        type: "boolean"
+      },
+      "tmux-h": {
+        type: "boolean"
+      },
+      "copy-file": {
+        type: "string",
+        multiple: true
       }
     },
     strict: true,
@@ -352,20 +686,61 @@ async function createHandler(args2) {
   const worktreeName = positionals[0];
   const openShell = values.shell ?? false;
   const execCommand = values.exec;
-  if (openShell && execCommand) {
+  const copyFileOptions = values["copy-file"];
+  const tmuxOption = values.tmux || values["tmux-vertical"] || values["tmux-v"] || values["tmux-horizontal"] || values["tmux-h"];
+  let tmuxDirection;
+  if (values.tmux) {
+    tmuxDirection = "new";
+  } else if (values["tmux-vertical"] || values["tmux-v"]) {
+    tmuxDirection = "vertical";
+  } else if (values["tmux-horizontal"] || values["tmux-h"]) {
+    tmuxDirection = "horizontal";
+  }
+  if ([openShell, execCommand !== void 0, tmuxOption].filter(Boolean).length > 1) {
+    exitWithError(
+      "Cannot use --shell, --exec, and --tmux options together",
+      exitCodes.validationError
+    );
+  }
+  if (tmuxOption && !await isInsideTmux()) {
     exitWithError(
-      "Cannot use --shell and --exec together",
+      "The --tmux option can only be used inside a tmux session",
       exitCodes.validationError
     );
   }
   try {
     const gitRoot = await getGitRoot();
-    const result = await createWorktree(gitRoot, worktreeName);
+    let filesToCopy = [];
+    const configResult = await loadConfig(gitRoot);
+    if (isOk(configResult)) {
+      if (configResult.value.postCreate?.copyFiles) {
+        filesToCopy = [...configResult.value.postCreate.copyFiles];
+      }
+    } else {
+      if (configResult.error instanceof ConfigValidationError) {
+        output.warn(`Configuration warning: ${configResult.error.message}`);
+      } else if (configResult.error instanceof ConfigParseError) {
+        output.warn(`Configuration warning: ${configResult.error.message}`);
+      }
+    }
+    if (copyFileOptions && copyFileOptions.length > 0) {
+      const cliFiles = Array.isArray(copyFileOptions) ? copyFileOptions : [copyFileOptions];
+      filesToCopy = [.../* @__PURE__ */ new Set([...filesToCopy, ...cliFiles])];
+    }
+    const result = await createWorktree(gitRoot, worktreeName, {
+      copyFiles: filesToCopy.length > 0 ? filesToCopy : void 0
+    });
     if (isErr(result)) {
       const exitCode = result.error instanceof WorktreeAlreadyExistsError ? exitCodes.validationError : exitCodes.generalError;
       exitWithError(result.error.message, exitCode);
     }
     output.log(result.value.message);
+    if (result.value.copyError) {
+      output.error(
+        `
+Warning: Failed to copy some files: ${result.value.copyError}`
+      );
+    }
     if (execCommand && isOk(result)) {
       output.log(
         `
@@ -398,6 +773,28 @@ Entering worktree '${worktreeName}' at ${result.value.path}`
       }
       process.exit(shellResult.value.exitCode ?? 0);
     }
+    if (tmuxDirection && isOk(result)) {
+      output.log(
+        `
+Opening worktree '${worktreeName}' in tmux ${tmuxDirection === "new" ? "window" : "pane"}...`
+      );
+      const shell = process.env.SHELL || "/bin/sh";
+      const tmuxResult = await executeTmuxCommand({
+        direction: tmuxDirection,
+        command: shell,
+        cwd: result.value.path,
+        env: {
+          PHANTOM: "1",
+          PHANTOM_NAME: worktreeName,
+          PHANTOM_PATH: result.value.path
+        }
+      });
+      if (isErr(tmuxResult)) {
+        output.error(tmuxResult.error.message);
+        const exitCode = "exitCode" in tmuxResult.error ? tmuxResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
+        exitWithError("", exitCode);
+      }
+    }
     exitWithSuccess();
   } catch (error) {
     exitWithError(
@@ -408,7 +805,67 @@ Entering worktree '${worktreeName}' at ${result.value.path}`
 }
 
 // src/cli/handlers/delete.ts
-import { parseArgs as parseArgs2 } from "node:util";
+import { parseArgs as parseArgs3 } from "node:util";
+
+// src/core/git/libs/list-worktrees.ts
+async function listWorktrees(gitRoot) {
+  const { stdout } = await executeGitCommand([
+    "worktree",
+    "list",
+    "--porcelain"
+  ]);
+  const worktrees = [];
+  let currentWorktree = {};
+  const lines = stdout.split("\n").filter((line) => line.length > 0);
+  for (const line of lines) {
+    if (line.startsWith("worktree ")) {
+      if (currentWorktree.path) {
+        worktrees.push(currentWorktree);
+      }
+      currentWorktree = {
+        path: line.substring("worktree ".length),
+        isLocked: false,
+        isPrunable: false
+      };
+    } else if (line.startsWith("HEAD ")) {
+      currentWorktree.head = line.substring("HEAD ".length);
+    } else if (line.startsWith("branch ")) {
+      const fullBranch = line.substring("branch ".length);
+      currentWorktree.branch = fullBranch.startsWith("refs/heads/") ? fullBranch.substring("refs/heads/".length) : fullBranch;
+    } else if (line === "detached") {
+      currentWorktree.branch = "(detached HEAD)";
+    } else if (line === "locked") {
+      currentWorktree.isLocked = true;
+    } else if (line === "prunable") {
+      currentWorktree.isPrunable = true;
+    }
+  }
+  if (currentWorktree.path) {
+    worktrees.push(currentWorktree);
+  }
+  return worktrees;
+}
+
+// src/core/git/libs/get-current-worktree.ts
+async function getCurrentWorktree(gitRoot) {
+  try {
+    const { stdout: currentPath } = await executeGitCommand([
+      "rev-parse",
+      "--show-toplevel"
+    ]);
+    const currentPathTrimmed = currentPath.trim();
+    const worktrees = await listWorktrees(gitRoot);
+    const currentWorktree = worktrees.find(
+      (wt) => wt.path === currentPathTrimmed
+    );
+    if (!currentWorktree || currentWorktree.path === gitRoot) {
+      return null;
+    }
+    return currentWorktree.branch;
+  } catch {
+    return null;
+  }
+}
 
 // src/core/worktree/delete.ts
 async function getWorktreeStatus(worktreePath) {
@@ -498,27 +955,49 @@ ${message}`;
 
 // src/cli/handlers/delete.ts
 async function deleteHandler(args2) {
-  const { values, positionals } = parseArgs2({
+  const { values, positionals } = parseArgs3({
     args: args2,
     options: {
       force: {
         type: "boolean",
         short: "f"
+      },
+      current: {
+        type: "boolean"
       }
     },
     strict: true,
     allowPositionals: true
   });
-  if (positionals.length === 0) {
+  const deleteCurrent = values.current ?? false;
+  if (positionals.length === 0 && !deleteCurrent) {
     exitWithError(
-      "Please provide a worktree name to delete",
+      "Please provide a worktree name to delete or use --current to delete the current worktree",
+      exitCodes.validationError
+    );
+  }
+  if (positionals.length > 0 && deleteCurrent) {
+    exitWithError(
+      "Cannot specify both a worktree name and --current option",
       exitCodes.validationError
     );
   }
-  const worktreeName = positionals[0];
   const forceDelete = values.force ?? false;
   try {
     const gitRoot = await getGitRoot();
+    let worktreeName;
+    if (deleteCurrent) {
+      const currentWorktree = await getCurrentWorktree(gitRoot);
+      if (!currentWorktree) {
+        exitWithError(
+          "Not in a worktree directory. The --current option can only be used from within a worktree.",
+          exitCodes.validationError
+        );
+      }
+      worktreeName = currentWorktree;
+    } else {
+      worktreeName = positionals[0];
+    }
     const result = await deleteWorktree(gitRoot, worktreeName, {
       force: forceDelete
     });
@@ -537,9 +1016,9 @@ async function deleteHandler(args2) {
 }
 
 // src/cli/handlers/exec.ts
-import { parseArgs as parseArgs3 } from "node:util";
+import { parseArgs as parseArgs4 } from "node:util";
 async function execHandler(args2) {
-  const { positionals } = parseArgs3({
+  const { positionals } = parseArgs4({
     args: args2,
     options: {},
     strict: true,
@@ -569,20 +1048,9 @@ async function execHandler(args2) {
 }
 
 // src/cli/handlers/list.ts
-import { parseArgs as parseArgs4 } from "node:util";
+import { parseArgs as parseArgs5 } from "node:util";
 
 // src/core/worktree/list.ts
-async function getWorktreeBranch(worktreePath) {
-  try {
-    const { stdout } = await executeGitCommandInDirectory(worktreePath, [
-      "branch",
-      "--show-current"
-    ]);
-    return stdout || "(detached HEAD)";
-  } catch {
-    return "unknown";
-  }
-}
 async function getWorktreeStatus2(worktreePath) {
   try {
     const { stdout } = await executeGitCommandInDirectory(worktreePath, [
@@ -594,36 +1062,30 @@ async function getWorktreeStatus2(worktreePath) {
     return true;
   }
 }
-async function getWorktreeInfo(gitRoot, name) {
-  const worktreePath = getWorktreePath(gitRoot, name);
-  const [branch, isClean] = await Promise.all([
-    getWorktreeBranch(worktreePath),
-    getWorktreeStatus2(worktreePath)
-  ]);
-  return {
-    name,
-    path: worktreePath,
-    branch,
-    isClean
-  };
-}
-async function listWorktrees(gitRoot) {
-  if (!await validatePhantomDirectoryExists(gitRoot)) {
-    return ok({
-      worktrees: [],
-      message: "No worktrees found (worktrees directory doesn't exist)"
-    });
-  }
-  const worktreeNames = await listValidWorktrees(gitRoot);
-  if (worktreeNames.length === 0) {
-    return ok({
-      worktrees: [],
-      message: "No worktrees found"
-    });
-  }
+async function listWorktrees2(gitRoot) {
   try {
+    const gitWorktrees = await listWorktrees(gitRoot);
+    const phantomDir = getPhantomDirectory(gitRoot);
+    const phantomWorktrees = gitWorktrees.filter(
+      (worktree) => worktree.path.startsWith(phantomDir)
+    );
+    if (phantomWorktrees.length === 0) {
+      return ok({
+        worktrees: [],
+        message: "No worktrees found"
+      });
+    }
     const worktrees = await Promise.all(
-      worktreeNames.map((name) => getWorktreeInfo(gitRoot, name))
+      phantomWorktrees.map(async (gitWorktree) => {
+        const name = gitWorktree.path.substring(phantomDir.length + 1);
+        const isClean = await getWorktreeStatus2(gitWorktree.path);
+        return {
+          name,
+          path: gitWorktree.path,
+          branch: gitWorktree.branch || "(detached HEAD)",
+          isClean
+        };
+      })
     );
     return ok({
       worktrees
@@ -636,7 +1098,7 @@ async function listWorktrees(gitRoot) {
 
 // src/cli/handlers/list.ts
 async function listHandler(args2 = []) {
-  parseArgs4({
+  parseArgs5({
     args: args2,
     options: {},
     strict: true,
@@ -644,7 +1106,7 @@ async function listHandler(args2 = []) {
   });
   try {
     const gitRoot = await getGitRoot();
-    const result = await listWorktrees(gitRoot);
+    const result = await listWorktrees2(gitRoot);
     if (isErr(result)) {
       exitWithError("Failed to list worktrees", exitCodes.generalError);
     }
@@ -670,9 +1132,9 @@ async function listHandler(args2 = []) {
 }
 
 // src/cli/handlers/shell.ts
-import { parseArgs as parseArgs5 } from "node:util";
+import { parseArgs as parseArgs6 } from "node:util";
 async function shellHandler(args2) {
-  const { positionals } = parseArgs5({
+  const { positionals } = parseArgs6({
     args: args2,
     options: {},
     strict: true,
@@ -711,13 +1173,13 @@ async function shellHandler(args2) {
 }
 
 // src/cli/handlers/version.ts
-import { parseArgs as parseArgs6 } from "node:util";
+import { parseArgs as parseArgs7 } from "node:util";
 
 // package.json
 var package_default = {
   name: "@aku11i/phantom",
   packageManager: "pnpm@10.8.1",
-  version: "0.4.0",
+  version: "0.6.0",
   description: "A powerful CLI tool for managing Git worktrees for parallel development",
   keywords: [
     "git",
@@ -746,12 +1208,14 @@ var package_default = {
     start: "node ./src/bin/phantom.ts",
     phantom: "node ./src/bin/phantom.ts",
     build: "node build.ts",
-    "type-check": "tsgo --noEmit",
-    test: "node --test --experimental-strip-types --experimental-test-module-mocks src/**/*.test.ts",
+    typecheck: "tsgo --noEmit",
+    test: 'node --test --experimental-strip-types --experimental-test-module-mocks "src/**/*.test.js"',
+    "test:coverage": 'node --experimental-test-coverage --test --experimental-strip-types --experimental-test-module-mocks "src/**/*.test.js"',
+    "test:file": "node --test --experimental-strip-types --experimental-test-module-mocks",
     lint: "biome check .",
     fix: "biome check --write .",
-    ready: "pnpm fix && pnpm type-check && pnpm test",
-    "ready:check": "pnpm lint && pnpm type-check && pnpm test",
+    ready: "pnpm fix && pnpm typecheck && pnpm test",
+    "ready:check": "pnpm lint && pnpm typecheck && pnpm test",
     prepublishOnly: "pnpm ready:check && pnpm build"
   },
   engines: {
@@ -778,7 +1242,7 @@ function getVersion() {
 
 // src/cli/handlers/version.ts
 function versionHandler(args2 = []) {
-  parseArgs6({
+  parseArgs7({
     args: args2,
     options: {},
     strict: true,
@@ -790,7 +1254,7 @@ function versionHandler(args2 = []) {
 }
 
 // src/cli/handlers/where.ts
-import { parseArgs as parseArgs7 } from "node:util";
+import { parseArgs as parseArgs8 } from "node:util";
 
 // src/core/worktree/where.ts
 async function whereWorktree(gitRoot, name) {
@@ -805,7 +1269,7 @@ async function whereWorktree(gitRoot, name) {
 
 // src/cli/handlers/where.ts
 async function whereHandler(args2) {
-  const { positionals } = parseArgs7({
+  const { positionals } = parseArgs8({
     args: args2,
     options: {},
     strict: true,
@@ -835,9 +1299,14 @@ async function whereHandler(args2) {
 var commands = [
   {
     name: "create",
-    description: "Create a new worktree [--shell | --exec <command>]",
+    description: "Create a new worktree [--shell | --exec <command> | --tmux | --tmux-vertical | --tmux-horizontal] [--copy-file <file>]...",
     handler: createHandler
   },
+  {
+    name: "attach",
+    description: "Attach to an existing branch [--shell | --exec <command>]",
+    handler: attachHandler
+  },
   {
     name: "list",
     description: "List all worktrees",