@aku11i/phantom 0.3.0 → 0.5.0

package/dist/phantom.js

@@ -1,493 +1,877 @@
 #!/usr/bin/env node
 
 // src/bin/phantom.ts
-import { argv, exit as exit6 } from "node:process";
+import { argv, exit } from "node:process";
 
-// src/commands/create.ts
-import { access as access2, mkdir } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { exit as exit3 } from "node:process";
+// src/cli/handlers/attach.ts
+import { parseArgs } from "node:util";
 
-// src/git/libs/add-worktree.ts
-import { exec } from "node:child_process";
+// 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";
-var execAsync = promisify(exec);
-async function addWorktree(options) {
-  const { path, branch, commitish = "HEAD" } = options;
-  await execAsync(`git worktree add "${path}" -b "${branch}" ${commitish}`);
+var execFile = promisify(execFileCallback);
+async function executeGitCommand(args2, options = {}) {
+  try {
+    const result = await execFile("git", args2, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      encoding: "utf8"
+    });
+    return {
+      stdout: result.stdout.trim(),
+      stderr: result.stderr.trim()
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && "stdout" in error && "stderr" in error) {
+      const execError = error;
+      if (execError.stderr?.trim()) {
+        throw new Error(execError.stderr.trim());
+      }
+      return {
+        stdout: execError.stdout?.trim() || "",
+        stderr: execError.stderr?.trim() || ""
+      };
+    }
+    throw error;
+  }
+}
+async function executeGitCommandInDirectory(directory, args2) {
+  return executeGitCommand(["-C", directory, ...args2], {});
 }
 
-// src/git/libs/get-git-root.ts
-import { exec as exec2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var execAsync2 = promisify2(exec2);
+// src/core/git/libs/get-git-root.ts
 async function getGitRoot() {
-  const { stdout } = await execAsync2("git rev-parse --show-toplevel");
-  return stdout.trim();
+  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/commands/shell.ts
-import { spawn } from "node:child_process";
-import { exit as exit2 } from "node:process";
+// src/core/types/result.ts
+var ok = (value) => ({
+  ok: true,
+  value
+});
+var err = (error) => ({
+  ok: false,
+  error
+});
+var isOk = (result) => result.ok;
+var isErr = (result) => !result.ok;
 
-// src/commands/where.ts
-import { access } from "node:fs/promises";
-import { join } from "node:path";
-import { exit } from "node:process";
-async function whereWorktree(name) {
-  if (!name) {
-    return { success: false, message: "Error: worktree name required" };
+// src/core/worktree/errors.ts
+var WorktreeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorktreeError";
+  }
+};
+var WorktreeNotFoundError = class extends WorktreeError {
+  constructor(name) {
+    super(`Worktree '${name}' not found`);
+    this.name = "WorktreeNotFoundError";
+  }
+};
+var WorktreeAlreadyExistsError = class extends WorktreeError {
+  constructor(name) {
+    super(`Worktree '${name}' already exists`);
+    this.name = "WorktreeAlreadyExistsError";
   }
+};
+var GitOperationError = class extends WorktreeError {
+  constructor(operation, details) {
+    super(`Git ${operation} failed: ${details}`);
+    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";
+
+// src/core/paths.ts
+import { join } from "node:path";
+function getPhantomDirectory(gitRoot) {
+  return join(gitRoot, ".git", "phantom", "worktrees");
+}
+function getWorktreePath(gitRoot, name) {
+  return join(getPhantomDirectory(gitRoot), name);
+}
+
+// src/core/worktree/validate.ts
+async function validateWorktreeExists(gitRoot, name) {
+  const worktreePath = getWorktreePath(gitRoot, name);
   try {
-    const gitRoot = await getGitRoot();
-    const worktreesPath = join(gitRoot, ".git", "phantom", "worktrees");
-    const worktreePath = join(worktreesPath, name);
-    try {
-      await access(worktreePath);
-    } catch {
-      return {
-        success: false,
-        message: `Error: Worktree '${name}' does not exist`
-      };
-    }
+    await fs.access(worktreePath);
     return {
-      success: true,
+      exists: true,
       path: worktreePath
     };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+  } catch {
     return {
-      success: false,
-      message: `Error locating worktree: ${errorMessage}`
+      exists: false,
+      message: `Worktree '${name}' does not exist`
     };
   }
 }
-async function whereHandler(args2) {
-  const name = args2[0];
-  const result = await whereWorktree(name);
-  if (!result.success) {
-    console.error(result.message);
-    exit(1);
+async function validateWorktreeDoesNotExist(gitRoot, name) {
+  const worktreePath = getWorktreePath(gitRoot, name);
+  try {
+    await fs.access(worktreePath);
+    return {
+      exists: true,
+      message: `Worktree '${name}' already exists`
+    };
+  } catch {
+    return {
+      exists: false,
+      path: worktreePath
+    };
+  }
+}
+function validateWorktreeName(name) {
+  if (!name || name.trim() === "") {
+    return err(new Error("Phantom name cannot be empty"));
+  }
+  if (name.includes("/")) {
+    return err(new Error("Phantom name cannot contain slashes"));
+  }
+  if (name.startsWith(".")) {
+    return err(new Error("Phantom name cannot start with a dot"));
   }
-  console.log(result.path);
+  return ok(void 0);
 }
 
-// src/commands/shell.ts
-async function shellInWorktree(worktreeName) {
-  if (!worktreeName) {
-    return { success: false, message: "Error: worktree name required" };
+// src/core/process/spawn.ts
+import {
+  spawn as nodeSpawn
+} from "node:child_process";
+
+// src/core/process/errors.ts
+var ProcessError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "ProcessError";
+    this.exitCode = exitCode;
   }
-  const worktreeResult = await whereWorktree(worktreeName);
-  if (!worktreeResult.success) {
-    return { success: false, message: worktreeResult.message };
+};
+var ProcessExecutionError = class extends ProcessError {
+  constructor(command2, exitCode) {
+    super(`Command '${command2}' failed with exit code ${exitCode}`, exitCode);
+    this.name = "ProcessExecutionError";
   }
-  const worktreePath = worktreeResult.path;
-  const shell = process.env.SHELL || "/bin/sh";
-  return new Promise((resolve) => {
-    const childProcess = spawn(shell, [], {
-      cwd: worktreePath,
+};
+var ProcessSignalError = class extends ProcessError {
+  constructor(signal) {
+    const exitCode = 128 + (signal === "SIGTERM" ? 15 : 1);
+    super(`Command terminated by signal: ${signal}`, exitCode);
+    this.name = "ProcessSignalError";
+  }
+};
+var ProcessSpawnError = class extends ProcessError {
+  constructor(command2, details) {
+    super(`Error executing command '${command2}': ${details}`);
+    this.name = "ProcessSpawnError";
+  }
+};
+
+// src/core/process/spawn.ts
+async function spawnProcess(config) {
+  return new Promise((resolve2) => {
+    const { command: command2, args: args2 = [], options = {} } = config;
+    const childProcess = nodeSpawn(command2, args2, {
       stdio: "inherit",
-      env: {
-        ...process.env,
-        // Add environment variable to indicate we're in a worktree
-        WORKTREE_NAME: worktreeName,
-        WORKTREE_PATH: worktreePath
-      }
+      ...options
     });
     childProcess.on("error", (error) => {
-      resolve({
-        success: false,
-        message: `Error starting shell: ${error.message}`
-      });
+      resolve2(err(new ProcessSpawnError(command2, error.message)));
     });
     childProcess.on("exit", (code, signal) => {
       if (signal) {
-        resolve({
-          success: false,
-          message: `Shell terminated by signal: ${signal}`,
-          exitCode: 128 + (signal === "SIGTERM" ? 15 : 1)
-        });
+        resolve2(err(new ProcessSignalError(signal)));
       } else {
         const exitCode = code ?? 0;
-        resolve({
-          success: exitCode === 0,
-          exitCode
-        });
+        if (exitCode === 0) {
+          resolve2(ok({ exitCode }));
+        } else {
+          resolve2(err(new ProcessExecutionError(command2, exitCode)));
+        }
       }
     });
   });
 }
-async function shellHandler(args2) {
-  if (args2.length < 1) {
-    console.error("Usage: phantom shell <worktree-name>");
-    exit2(1);
-  }
-  const worktreeName = args2[0];
-  const worktreeResult = await whereWorktree(worktreeName);
-  if (!worktreeResult.success) {
-    console.error(worktreeResult.message);
-    exit2(1);
-  }
-  console.log(`Entering worktree '${worktreeName}' at ${worktreeResult.path}`);
-  console.log("Type 'exit' to return to your original directory\n");
-  const result = await shellInWorktree(worktreeName);
-  if (!result.success) {
-    if (result.message) {
-      console.error(result.message);
+
+// src/core/process/exec.ts
+async function execInWorktree(gitRoot, worktreeName, command2) {
+  const validation = await validateWorktreeExists(gitRoot, worktreeName);
+  if (!validation.exists) {
+    return err(new WorktreeNotFoundError(worktreeName));
+  }
+  const worktreePath = validation.path;
+  const [cmd, ...args2] = command2;
+  return spawnProcess({
+    command: cmd,
+    args: args2,
+    options: {
+      cwd: worktreePath
     }
-    exit2(result.exitCode ?? 1);
+  });
+}
+
+// src/core/process/shell.ts
+async function shellInWorktree(gitRoot, worktreeName) {
+  const validation = await validateWorktreeExists(gitRoot, worktreeName);
+  if (!validation.exists) {
+    return err(new WorktreeNotFoundError(worktreeName));
   }
-  exit2(result.exitCode ?? 0);
+  const worktreePath = validation.path;
+  const shell = process.env.SHELL || "/bin/sh";
+  return spawnProcess({
+    command: shell,
+    args: [],
+    options: {
+      cwd: worktreePath,
+      env: {
+        ...process.env,
+        PHANTOM: "1",
+        PHANTOM_NAME: worktreeName,
+        PHANTOM_PATH: worktreePath
+      }
+    }
+  });
 }
 
-// src/commands/create.ts
-async function createWorktree(name) {
-  if (!name) {
-    return { success: false, message: "Error: worktree name required" };
+// src/core/worktree/attach.ts
+import { existsSync } from "node:fs";
+
+// 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/git/libs/branch-exists.ts
+async function branchExists(gitRoot, branchName) {
   try {
-    const gitRoot = await getGitRoot();
-    const worktreesPath = join2(gitRoot, ".git", "phantom", "worktrees");
-    const worktreePath = join2(worktreesPath, name);
-    try {
-      await access2(worktreesPath);
-    } catch {
-      await 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);
+      }
     }
-    try {
-      await access2(worktreePath);
-      return {
-        success: false,
-        message: `Error: worktree '${name}' already exists`
-      };
-    } catch {
+    return err(
+      new Error(
+        `Failed to check branch existence: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+// 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));
+  }
+  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
+var output = {
+  log: (message) => {
+    console.log(message);
+  },
+  error: (message) => {
+    console.error(message);
+  },
+  table: (data) => {
+    console.table(data);
+  },
+  processOutput: (proc) => {
+    proc.stdout?.pipe(process.stdout);
+    proc.stderr?.pipe(process.stderr);
+  }
+};
+
+// src/cli/errors.ts
+var exitCodes = {
+  success: 0,
+  generalError: 1,
+  notFound: 2,
+  validationError: 3
+};
+function exitWithSuccess() {
+  process.exit(exitCodes.success);
+}
+function exitWithError(message, exitCode = exitCodes.generalError) {
+  output.error(message);
+  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/worktree/create.ts
+import fs2 from "node:fs/promises";
+
+// 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/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 fs2.access(worktreesPath);
+  } catch {
+    await fs2.mkdir(worktreesPath, { recursive: true });
+  }
+  const validation = await validateWorktreeDoesNotExist(gitRoot, name);
+  if (validation.exists) {
+    return err(new WorktreeAlreadyExistsError(name));
+  }
+  try {
     await addWorktree({
       path: worktreePath,
-      branch: name,
-      commitish: "HEAD"
+      branch,
+      commitish
     });
-    return {
-      success: true,
+    return ok({
       message: `Created worktree '${name}' at ${worktreePath}`,
       path: worktreePath
-    };
+    });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: `Error creating worktree: ${errorMessage}`
-    };
+    return err(new GitOperationError("worktree add", errorMessage));
   }
 }
+
+// src/cli/handlers/create.ts
 async function createHandler(args2) {
-  const name = args2[0];
-  const openShell = args2.includes("--shell");
-  const result = await createWorktree(name);
-  if (!result.success) {
-    console.error(result.message);
-    exit3(1);
-  }
-  console.log(result.message);
-  if (openShell && result.path) {
-    console.log(`
-Entering worktree '${name}' at ${result.path}`);
-    console.log("Type 'exit' to return to your original directory\n");
-    const shellResult = await shellInWorktree(name);
-    if (!shellResult.success) {
-      if (shellResult.message) {
-        console.error(shellResult.message);
+  const { values, positionals } = parseArgs2({
+    args: args2,
+    options: {
+      shell: {
+        type: "boolean",
+        short: "s"
+      },
+      exec: {
+        type: "string",
+        short: "x"
       }
-      exit3(shellResult.exitCode ?? 1);
-    }
-    exit3(shellResult.exitCode ?? 0);
+    },
+    strict: true,
+    allowPositionals: true
+  });
+  if (positionals.length === 0) {
+    exitWithError(
+      "Please provide a name for the new worktree",
+      exitCodes.validationError
+    );
   }
-}
-
-// src/commands/delete.ts
-import { exec as exec3 } from "node:child_process";
-import { access as access3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
-import { exit as exit4 } from "node:process";
-import { promisify as promisify3 } from "node:util";
-var execAsync3 = promisify3(exec3);
-async function deleteWorktree(name, options = {}) {
-  if (!name) {
-    return { success: false, message: "Error: worktree name required" };
+  const worktreeName = positionals[0];
+  const openShell = values.shell ?? false;
+  const execCommand = values.exec;
+  if (openShell && execCommand) {
+    exitWithError(
+      "Cannot use --shell and --exec together",
+      exitCodes.validationError
+    );
   }
-  const { force = false } = options;
   try {
     const gitRoot = await getGitRoot();
-    const worktreesPath = join3(gitRoot, ".git", "phantom", "worktrees");
-    const worktreePath = join3(worktreesPath, name);
-    try {
-      await access3(worktreePath);
-    } catch {
-      return {
-        success: false,
-        message: `Error: Worktree '${name}' does not exist`
-      };
+    const result = await createWorktree(gitRoot, worktreeName);
+    if (isErr(result)) {
+      const exitCode = result.error instanceof WorktreeAlreadyExistsError ? exitCodes.validationError : exitCodes.generalError;
+      exitWithError(result.error.message, exitCode);
     }
-    let hasUncommittedChanges = false;
-    let changedFiles = 0;
-    try {
-      const { stdout } = await execAsync3("git status --porcelain", {
-        cwd: worktreePath
-      });
-      const changes = stdout.trim();
-      if (changes) {
-        hasUncommittedChanges = true;
-        changedFiles = changes.split("\n").length;
+    output.log(result.value.message);
+    if (execCommand && isOk(result)) {
+      output.log(
+        `
+Executing command in worktree '${worktreeName}': ${execCommand}`
+      );
+      const shell = process.env.SHELL || "/bin/sh";
+      const execResult = await execInWorktree(gitRoot, worktreeName, [
+        shell,
+        "-c",
+        execCommand
+      ]);
+      if (isErr(execResult)) {
+        output.error(execResult.error.message);
+        const exitCode = "exitCode" in execResult.error ? execResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
+        exitWithError("", exitCode);
       }
-    } catch {
-      hasUncommittedChanges = false;
+      process.exit(execResult.value.exitCode ?? 0);
+    }
+    if (openShell && isOk(result)) {
+      output.log(
+        `
+Entering worktree '${worktreeName}' at ${result.value.path}`
+      );
+      output.log("Type 'exit' to return to your original directory\n");
+      const shellResult = await shellInWorktree(gitRoot, worktreeName);
+      if (isErr(shellResult)) {
+        output.error(shellResult.error.message);
+        const exitCode = "exitCode" in shellResult.error ? shellResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
+        exitWithError("", exitCode);
+      }
+      process.exit(shellResult.value.exitCode ?? 0);
     }
-    if (hasUncommittedChanges && !force) {
+    exitWithSuccess();
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
+  }
+}
+
+// src/cli/handlers/delete.ts
+import { parseArgs as parseArgs3 } from "node:util";
+
+// src/core/worktree/delete.ts
+async function getWorktreeStatus(worktreePath) {
+  try {
+    const { stdout } = await executeGitCommandInDirectory(worktreePath, [
+      "status",
+      "--porcelain"
+    ]);
+    if (stdout) {
       return {
-        success: false,
-        message: `Error: Worktree '${name}' has uncommitted changes (${changedFiles} files). Use --force to delete anyway.`,
         hasUncommittedChanges: true,
-        changedFiles
+        changedFiles: stdout.split("\n").length
       };
     }
+  } catch {
+  }
+  return {
+    hasUncommittedChanges: false,
+    changedFiles: 0
+  };
+}
+async function removeWorktree(gitRoot, worktreePath, force = false) {
+  try {
+    await executeGitCommand(["worktree", "remove", worktreePath], {
+      cwd: gitRoot
+    });
+  } catch (error) {
     try {
-      await execAsync3(`git worktree remove "${worktreePath}"`, {
-        cwd: gitRoot
-      });
-    } catch (error) {
-      try {
-        await execAsync3(`git worktree remove --force "${worktreePath}"`, {
-          cwd: gitRoot
-        });
-      } catch {
-        return {
-          success: false,
-          message: `Error: Failed to remove worktree '${name}'`
-        };
-      }
-    }
-    const branchName = `phantom/worktrees/${name}`;
-    try {
-      await execAsync3(`git branch -D "${branchName}"`, {
+      await executeGitCommand(["worktree", "remove", "--force", worktreePath], {
         cwd: gitRoot
       });
     } catch {
+      throw new Error("Failed to remove worktree");
     }
-    let message = `Deleted worktree '${name}' and its branch '${branchName}'`;
-    if (hasUncommittedChanges) {
-      message = `Warning: Worktree '${name}' had uncommitted changes (${changedFiles} files)
+  }
+}
+async function deleteBranch(gitRoot, branchName) {
+  try {
+    await executeGitCommand(["branch", "-D", branchName], { cwd: gitRoot });
+    return ok(true);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return err(new GitOperationError("branch delete", errorMessage));
+  }
+}
+async function deleteWorktree(gitRoot, name, options = {}) {
+  const { force = false } = options;
+  const validation = await validateWorktreeExists(gitRoot, name);
+  if (!validation.exists) {
+    return err(new WorktreeNotFoundError(name));
+  }
+  const worktreePath = validation.path;
+  const status = await getWorktreeStatus(worktreePath);
+  if (status.hasUncommittedChanges && !force) {
+    return err(
+      new WorktreeError(
+        `Worktree '${name}' has uncommitted changes (${status.changedFiles} files). Use --force to delete anyway.`
+      )
+    );
+  }
+  try {
+    await removeWorktree(gitRoot, worktreePath, force);
+    const branchName = name;
+    const branchResult = await deleteBranch(gitRoot, branchName);
+    let message;
+    if (isOk(branchResult)) {
+      message = `Deleted worktree '${name}' and its branch '${branchName}'`;
+    } else {
+      message = `Deleted worktree '${name}'`;
+      message += `
+Note: Branch '${branchName}' could not be deleted: ${branchResult.error.message}`;
+    }
+    if (status.hasUncommittedChanges) {
+      message = `Warning: Worktree '${name}' had uncommitted changes (${status.changedFiles} files)
 ${message}`;
     }
-    return {
-      success: true,
+    return ok({
       message,
-      hasUncommittedChanges,
-      changedFiles: hasUncommittedChanges ? changedFiles : void 0
-    };
+      hasUncommittedChanges: status.hasUncommittedChanges,
+      changedFiles: status.hasUncommittedChanges ? status.changedFiles : void 0
+    });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: `Error deleting worktree: ${errorMessage}`
-    };
-  }
-}
-async function deleteHandler(args2) {
-  const forceIndex = args2.indexOf("--force");
-  const force = forceIndex !== -1;
-  const filteredArgs = args2.filter((arg) => arg !== "--force");
-  const name = filteredArgs[0];
-  const result = await deleteWorktree(name, { force });
-  if (!result.success) {
-    console.error(result.message);
-    exit4(1);
+    return err(new GitOperationError("worktree remove", errorMessage));
   }
-  console.log(result.message);
 }
 
-// src/commands/exec.ts
-import { spawn as spawn2 } from "node:child_process";
-import { exit as exit5 } from "node:process";
-async function execInWorktree(worktreeName, command2) {
-  if (!worktreeName) {
-    return { success: false, message: "Error: worktree name required" };
-  }
-  if (!command2 || command2.length === 0) {
-    return { success: false, message: "Error: command required" };
-  }
-  const worktreeResult = await whereWorktree(worktreeName);
-  if (!worktreeResult.success) {
-    return { success: false, message: worktreeResult.message };
-  }
-  const worktreePath = worktreeResult.path;
-  const [cmd, ...args2] = command2;
-  return new Promise((resolve) => {
-    const childProcess = spawn2(cmd, args2, {
-      cwd: worktreePath,
-      stdio: "inherit"
-    });
-    childProcess.on("error", (error) => {
-      resolve({
-        success: false,
-        message: `Error executing command: ${error.message}`
-      });
-    });
-    childProcess.on("exit", (code, signal) => {
-      if (signal) {
-        resolve({
-          success: false,
-          message: `Command terminated by signal: ${signal}`,
-          exitCode: 128 + (signal === "SIGTERM" ? 15 : 1)
-        });
-      } else {
-        const exitCode = code ?? 0;
-        resolve({
-          success: exitCode === 0,
-          exitCode
-        });
+// src/cli/handlers/delete.ts
+async function deleteHandler(args2) {
+  const { values, positionals } = parseArgs3({
+    args: args2,
+    options: {
+      force: {
+        type: "boolean",
+        short: "f"
       }
-    });
+    },
+    strict: true,
+    allowPositionals: true
   });
-}
-async function execHandler(args2) {
-  if (args2.length < 2) {
-    console.error("Usage: phantom exec <worktree-name> <command> [args...]");
-    exit5(1);
-  }
-  const worktreeName = args2[0];
-  const command2 = args2.slice(1);
-  const result = await execInWorktree(worktreeName, command2);
-  if (!result.success) {
-    if (result.message) {
-      console.error(result.message);
+  if (positionals.length === 0) {
+    exitWithError(
+      "Please provide a worktree name to delete",
+      exitCodes.validationError
+    );
+  }
+  const worktreeName = positionals[0];
+  const forceDelete = values.force ?? false;
+  try {
+    const gitRoot = await getGitRoot();
+    const result = await deleteWorktree(gitRoot, worktreeName, {
+      force: forceDelete
+    });
+    if (isErr(result)) {
+      const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.validationError : result.error instanceof WorktreeError && result.error.message.includes("uncommitted changes") ? exitCodes.validationError : exitCodes.generalError;
+      exitWithError(result.error.message, exitCode);
     }
-    exit5(result.exitCode ?? 1);
+    output.log(result.value.message);
+    exitWithSuccess();
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
   }
-  exit5(result.exitCode ?? 0);
 }
 
-// src/commands/list.ts
-import { exec as exec4 } from "node:child_process";
-import { access as access4, readdir } from "node:fs/promises";
-import { join as join4 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-var execAsync4 = promisify4(exec4);
-async function listWorktrees() {
+// src/cli/handlers/exec.ts
+import { parseArgs as parseArgs4 } from "node:util";
+async function execHandler(args2) {
+  const { positionals } = parseArgs4({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: true
+  });
+  if (positionals.length < 2) {
+    exitWithError(
+      "Usage: phantom exec <worktree-name> <command> [args...]",
+      exitCodes.validationError
+    );
+  }
+  const [worktreeName, ...commandArgs] = positionals;
   try {
     const gitRoot = await getGitRoot();
-    const worktreesPath = join4(gitRoot, ".git", "phantom", "worktrees");
-    try {
-      await access4(worktreesPath);
-    } catch {
-      return {
-        success: true,
-        worktrees: [],
-        message: "No worktrees found (worktrees directory doesn't exist)"
-      };
+    const result = await execInWorktree(gitRoot, worktreeName, commandArgs);
+    if (isErr(result)) {
+      const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.notFound : result.error.exitCode || exitCodes.generalError;
+      exitWithError(result.error.message, exitCode);
     }
-    let worktreeNames;
-    try {
-      const entries = await readdir(worktreesPath);
-      const validEntries = await Promise.all(
-        entries.map(async (entry) => {
-          try {
-            const entryPath = join4(worktreesPath, entry);
-            await access4(entryPath);
-            return entry;
-          } catch {
-            return null;
-          }
-        })
-      );
-      worktreeNames = validEntries.filter(
-        (entry) => entry !== null
-      );
-    } catch {
-      return {
-        success: true,
-        worktrees: [],
-        message: "No worktrees found (unable to read worktrees directory)"
+    process.exit(result.value.exitCode);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
+  }
+}
+
+// src/cli/handlers/list.ts
+import { parseArgs as parseArgs5 } 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 (worktreeNames.length === 0) {
-      return {
-        success: true,
+  }
+  if (currentWorktree.path) {
+    worktrees.push(currentWorktree);
+  }
+  return worktrees;
+}
+
+// src/core/worktree/list.ts
+async function getWorktreeStatus2(worktreePath) {
+  try {
+    const { stdout } = await executeGitCommandInDirectory(worktreePath, [
+      "status",
+      "--porcelain"
+    ]);
+    return !stdout;
+  } catch {
+    return true;
+  }
+}
+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(async (name) => {
-        const worktreePath = join4(worktreesPath, name);
-        let branch = "unknown";
-        try {
-          const { stdout } = await execAsync4("git branch --show-current", {
-            cwd: worktreePath
-          });
-          branch = stdout.trim() || "detached HEAD";
-        } catch {
-          branch = "unknown";
-        }
-        let status = "clean";
-        let changedFiles;
-        try {
-          const { stdout } = await execAsync4("git status --porcelain", {
-            cwd: worktreePath
-          });
-          const changes = stdout.trim();
-          if (changes) {
-            status = "dirty";
-            changedFiles = changes.split("\n").length;
-          }
-        } catch {
-          status = "clean";
-        }
+      phantomWorktrees.map(async (gitWorktree) => {
+        const name = gitWorktree.path.substring(phantomDir.length + 1);
+        const isClean = await getWorktreeStatus2(gitWorktree.path);
         return {
           name,
-          branch,
-          status,
-          changedFiles
+          path: gitWorktree.path,
+          branch: gitWorktree.branch || "(detached HEAD)",
+          isClean
         };
       })
     );
-    return {
-      success: true,
+    return ok({
       worktrees
-    };
+    });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: `Error listing worktrees: ${errorMessage}`
-    };
+    throw new Error(`Failed to list worktrees: ${errorMessage}`);
   }
 }
-async function listHandler() {
-  const result = await listWorktrees();
-  if (!result.success) {
-    console.error(result.message);
-    return;
+
+// src/cli/handlers/list.ts
+async function listHandler(args2 = []) {
+  parseArgs5({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: false
+  });
+  try {
+    const gitRoot = await getGitRoot();
+    const result = await listWorktrees2(gitRoot);
+    if (isErr(result)) {
+      exitWithError("Failed to list worktrees", exitCodes.generalError);
+    }
+    const { worktrees, message } = result.value;
+    if (worktrees.length === 0) {
+      output.log(message || "No worktrees found.");
+      process.exit(exitCodes.success);
+    }
+    const maxNameLength = Math.max(...worktrees.map((wt) => wt.name.length));
+    for (const worktree of worktrees) {
+      const paddedName = worktree.name.padEnd(maxNameLength + 2);
+      const branchInfo = worktree.branch ? `(${worktree.branch})` : "";
+      const status = !worktree.isClean ? " [dirty]" : "";
+      output.log(`${paddedName} ${branchInfo}${status}`);
+    }
+    process.exit(exitCodes.success);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
   }
-  if (!result.worktrees || result.worktrees.length === 0) {
-    console.log(result.message || "No worktrees found");
-    return;
+}
+
+// src/cli/handlers/shell.ts
+import { parseArgs as parseArgs6 } from "node:util";
+async function shellHandler(args2) {
+  const { positionals } = parseArgs6({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: true
+  });
+  if (positionals.length === 0) {
+    exitWithError(
+      "Usage: phantom shell <worktree-name>",
+      exitCodes.validationError
+    );
   }
-  console.log("Worktrees:");
-  for (const worktree of result.worktrees) {
-    const statusText = worktree.status === "clean" ? "[clean]" : `[dirty: ${worktree.changedFiles} files]`;
-    console.log(
-      `  ${worktree.name.padEnd(20)} (branch: ${worktree.branch.padEnd(20)}) ${statusText}`
+  const worktreeName = positionals[0];
+  try {
+    const gitRoot = await getGitRoot();
+    const validation = await validateWorktreeExists(gitRoot, worktreeName);
+    if (!validation.exists) {
+      exitWithError(
+        validation.message || `Worktree '${worktreeName}' not found`,
+        exitCodes.generalError
+      );
+    }
+    output.log(`Entering worktree '${worktreeName}' at ${validation.path}`);
+    output.log("Type 'exit' to return to your original directory\n");
+    const result = await shellInWorktree(gitRoot, worktreeName);
+    if (isErr(result)) {
+      const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.notFound : result.error.exitCode || exitCodes.generalError;
+      exitWithError(result.error.message, exitCode);
+    }
+    process.exit(result.value.exitCode);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
     );
   }
-  console.log(`
-Total: ${result.worktrees.length} worktrees`);
 }
 
+// src/cli/handlers/version.ts
+import { parseArgs as parseArgs7 } from "node:util";
+
 // package.json
 var package_default = {
   name: "@aku11i/phantom",
   packageManager: "pnpm@10.8.1",
-  version: "0.3.0",
+  version: "0.5.0",
   description: "A powerful CLI tool for managing Git worktrees for parallel development",
   keywords: [
     "git",
@@ -516,12 +900,12 @@ var package_default = {
     start: "node ./src/bin/phantom.ts",
     phantom: "node ./src/bin/phantom.ts",
     build: "node build.ts",
-    "type-check": "tsc --noEmit",
+    typecheck: "tsgo --noEmit",
     test: "node --test --experimental-strip-types --experimental-test-module-mocks src/**/*.test.ts",
     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: {
@@ -535,27 +919,84 @@ var package_default = {
   devDependencies: {
     "@biomejs/biome": "^1.9.4",
     "@types/node": "^22.15.29",
+    "@typescript/native-preview": "7.0.0-dev.20250602.1",
     esbuild: "^0.25.5",
     typescript: "^5.8.3"
   }
 };
 
-// src/commands/version.ts
+// src/core/version.ts
 function getVersion() {
   return package_default.version;
 }
-function versionHandler() {
+
+// src/cli/handlers/version.ts
+function versionHandler(args2 = []) {
+  parseArgs7({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: false
+  });
   const version = getVersion();
-  console.log(`Phantom v${version}`);
+  output.log(`Phantom v${version}`);
+  exitWithSuccess();
+}
+
+// src/cli/handlers/where.ts
+import { parseArgs as parseArgs8 } from "node:util";
+
+// src/core/worktree/where.ts
+async function whereWorktree(gitRoot, name) {
+  const validation = await validateWorktreeExists(gitRoot, name);
+  if (!validation.exists) {
+    return err(new WorktreeNotFoundError(name));
+  }
+  return ok({
+    path: validation.path
+  });
+}
+
+// src/cli/handlers/where.ts
+async function whereHandler(args2) {
+  const { positionals } = parseArgs8({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: true
+  });
+  if (positionals.length === 0) {
+    exitWithError("Please provide a worktree name", exitCodes.validationError);
+  }
+  const worktreeName = positionals[0];
+  try {
+    const gitRoot = await getGitRoot();
+    const result = await whereWorktree(gitRoot, worktreeName);
+    if (isErr(result)) {
+      exitWithError(result.error.message, exitCodes.notFound);
+    }
+    output.log(result.value.path);
+    exitWithSuccess();
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
+  }
 }
 
 // src/bin/phantom.ts
 var commands = [
   {
     name: "create",
-    description: "Create a new worktree [--shell to open shell]",
+    description: "Create a new worktree [--shell | --exec <command>]",
     handler: createHandler
   },
+  {
+    name: "attach",
+    description: "Attach to an existing branch [--shell | --exec <command>]",
+    handler: attachHandler
+  },
   {
     name: "list",
     description: "List all worktrees",
@@ -617,18 +1058,18 @@ function findCommand(args2, commands2) {
 var args = argv.slice(2);
 if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
   printHelp(commands);
-  exit6(0);
+  exit(0);
 }
 if (args[0] === "--version" || args[0] === "-v") {
   versionHandler();
-  exit6(0);
+  exit(0);
 }
 var { command, remainingArgs } = findCommand(args, commands);
 if (!command || !command.handler) {
   console.error(`Error: Unknown command '${args.join(" ")}'
 `);
   printHelp(commands);
-  exit6(1);
+  exit(1);
 }
 try {
   await command.handler(remainingArgs);
@@ -637,6 +1078,6 @@ try {
     "Error:",
     error instanceof Error ? error.message : String(error)
   );
-  exit6(1);
+  exit(1);
 }
 //# sourceMappingURL=phantom.js.map