@aku11i/phantom 0.2.0 → 0.4.0

package/dist/phantom.js

@@ -1,537 +1,879 @@
 #!/usr/bin/env node
 
 // src/bin/phantom.ts
-import { argv, exit as exit6 } from "node:process";
+import { argv, exit } from "node:process";
 
-// src/gardens/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/create.ts
+import { parseArgs } from "node:util";
 
-// src/git/libs/add-worktree.ts
-import { exec } from "node:child_process";
+// 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", "--show-toplevel"]);
+  return stdout;
 }
 
-// src/phantom/command/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/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";
+  }
+};
 
-// src/gardens/commands/where.ts
-import { access } from "node:fs/promises";
+// src/core/worktree/validate.ts
+import fs from "node:fs/promises";
+
+// src/core/paths.ts
 import { join } from "node:path";
-import { exit } from "node:process";
-async function whereGarden(name) {
-  if (!name) {
-    return { success: false, message: "Error: garden name required" };
+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 {
+    await fs.access(worktreePath);
+    return {
+      exists: true,
+      path: worktreePath
+    };
+  } catch {
+    return {
+      exists: false,
+      message: `Worktree '${name}' does not exist`
+    };
   }
+}
+async function validateWorktreeDoesNotExist(gitRoot, name) {
+  const worktreePath = getWorktreePath(gitRoot, name);
   try {
-    const gitRoot = await getGitRoot();
-    const gardensPath = join(gitRoot, ".git", "phantom", "gardens");
-    const gardenPath = join(gardensPath, name);
-    try {
-      await access(gardenPath);
-    } catch {
-      return {
-        success: false,
-        message: `Error: Garden '${name}' does not exist`
-      };
-    }
+    await fs.access(worktreePath);
     return {
-      success: true,
-      path: gardenPath
+      exists: true,
+      message: `Worktree '${name}' already exists`
     };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+  } catch {
     return {
-      success: false,
-      message: `Error locating garden: ${errorMessage}`
+      exists: false,
+      path: worktreePath
     };
   }
 }
-async function gardensWhereHandler(args2) {
-  const name = args2[0];
-  const result = await whereGarden(name);
-  if (!result.success) {
-    console.error(result.message);
-    exit(1);
+async function validatePhantomDirectoryExists(gitRoot) {
+  const phantomDir = getPhantomDirectory(gitRoot);
+  try {
+    await fs.access(phantomDir);
+    return true;
+  } catch {
+    return false;
   }
-  console.log(result.path);
 }
+async function listValidWorktrees(gitRoot) {
+  const phantomDir = getPhantomDirectory(gitRoot);
+  if (!await validatePhantomDirectoryExists(gitRoot)) {
+    return [];
+  }
+  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 [];
+  }
+}
+
+// src/core/process/spawn.ts
+import {
+  spawn as nodeSpawn
+} from "node:child_process";
 
-// src/phantom/command/shell.ts
-async function shellInGarden(gardenName) {
-  if (!gardenName) {
-    return { success: false, message: "Error: garden name required" };
+// src/core/process/errors.ts
+var ProcessError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "ProcessError";
+    this.exitCode = exitCode;
   }
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    return { success: false, message: gardenResult.message };
+};
+var ProcessExecutionError = class extends ProcessError {
+  constructor(command2, exitCode) {
+    super(`Command '${command2}' failed with exit code ${exitCode}`, exitCode);
+    this.name = "ProcessExecutionError";
   }
-  const gardenPath = gardenResult.path;
-  const shell = process.env.SHELL || "/bin/sh";
+};
+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((resolve) => {
-    const childProcess = spawn(shell, [], {
-      cwd: gardenPath,
+    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 phantom garden
-        PHANTOM_GARDEN: gardenName,
-        PHANTOM_GARDEN_PATH: gardenPath
-      }
+      ...options
     });
     childProcess.on("error", (error) => {
-      resolve({
-        success: false,
-        message: `Error starting shell: ${error.message}`
-      });
+      resolve(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)
-        });
+        resolve(err(new ProcessSignalError(signal)));
       } else {
         const exitCode = code ?? 0;
-        resolve({
-          success: exitCode === 0,
-          exitCode
-        });
+        if (exitCode === 0) {
+          resolve(ok({ exitCode }));
+        } else {
+          resolve(err(new ProcessExecutionError(command2, exitCode)));
+        }
       }
     });
   });
 }
-async function shellHandler(args2) {
-  if (args2.length < 1) {
-    console.error("Usage: phantom shell <garden-name>");
-    exit2(1);
-  }
-  const gardenName = args2[0];
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    console.error(gardenResult.message);
-    exit2(1);
-  }
-  console.log(`Entering garden '${gardenName}' at ${gardenResult.path}`);
-  console.log("Type 'exit' to return to your original directory\n");
-  const result = await shellInGarden(gardenName);
-  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/gardens/commands/create.ts
-async function createGarden(name) {
-  if (!name) {
-    return { success: false, message: "Error: garden name required" };
+// 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 { 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 {
-    const gitRoot = await getGitRoot();
-    const gardensPath = join2(gitRoot, ".git", "phantom", "gardens");
-    const worktreePath = join2(gardensPath, name);
-    try {
-      await access2(gardensPath);
-    } catch {
-      await mkdir(gardensPath, { recursive: true });
-    }
-    try {
-      await access2(worktreePath);
-      return {
-        success: false,
-        message: `Error: garden '${name}' already exists`
-      };
-    } catch {
-    }
     await addWorktree({
       path: worktreePath,
-      branch: name,
-      commitish: "HEAD"
+      branch,
+      commitish
     });
-    return {
-      success: true,
-      message: `Created garden '${name}' at ${worktreePath}`,
+    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 garden: ${errorMessage}`
-    };
+    return err(new GitOperationError("worktree add", errorMessage));
   }
 }
-async function gardensCreateHandler(args2) {
-  const name = args2[0];
-  const openShell = args2.includes("--shell");
-  const result = await createGarden(name);
-  if (!result.success) {
-    console.error(result.message);
-    exit3(1);
-  }
-  console.log(result.message);
-  if (openShell && result.path) {
-    console.log(`
-Entering garden '${name}' at ${result.path}`);
-    console.log("Type 'exit' to return to your original directory\n");
-    const shellResult = await shellInGarden(name);
-    if (!shellResult.success) {
-      if (shellResult.message) {
-        console.error(shellResult.message);
-      }
-      exit3(shellResult.exitCode ?? 1);
-    }
-    exit3(shellResult.exitCode ?? 0);
+
+// 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/gardens/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 deleteGarden(name, options = {}) {
-  if (!name) {
-    return { success: false, message: "Error: garden name required" };
+// src/cli/handlers/create.ts
+async function createHandler(args2) {
+  const { values, positionals } = parseArgs({
+    args: args2,
+    options: {
+      shell: {
+        type: "boolean",
+        short: "s"
+      },
+      exec: {
+        type: "string",
+        short: "x"
+      }
+    },
+    strict: true,
+    allowPositionals: true
+  });
+  if (positionals.length === 0) {
+    exitWithError(
+      "Please provide a name for the new worktree",
+      exitCodes.validationError
+    );
+  }
+  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 gardensPath = join3(gitRoot, ".git", "phantom", "gardens");
-    const gardenPath = join3(gardensPath, name);
-    try {
-      await access3(gardenPath);
-    } catch {
-      return {
-        success: false,
-        message: `Error: Garden '${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: gardenPath
-      });
-      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 (hasUncommittedChanges && !force) {
+    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);
+    }
+    exitWithSuccess();
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
+  }
+}
+
+// src/cli/handlers/delete.ts
+import { parseArgs as parseArgs2 } 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: Garden '${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 "${gardenPath}"`, {
-        cwd: gitRoot
-      });
-    } catch (error) {
-      try {
-        await execAsync3(`git worktree remove --force "${gardenPath}"`, {
-          cwd: gitRoot
-        });
-      } catch {
-        return {
-          success: false,
-          message: `Error: Failed to remove worktree for garden '${name}'`
-        };
-      }
-    }
-    const branchName = `phantom/gardens/${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 garden '${name}' and its branch '${branchName}'`;
-    if (hasUncommittedChanges) {
-      message = `Warning: Garden '${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 garden: ${errorMessage}`
-    };
+    return err(new GitOperationError("worktree remove", errorMessage));
   }
 }
-async function gardensDeleteHandler(args2) {
-  const forceIndex = args2.indexOf("--force");
-  const force = forceIndex !== -1;
-  const filteredArgs = args2.filter((arg) => arg !== "--force");
-  const name = filteredArgs[0];
-  const result = await deleteGarden(name, { force });
-  if (!result.success) {
-    console.error(result.message);
-    exit4(1);
+
+// src/cli/handlers/delete.ts
+async function deleteHandler(args2) {
+  const { values, positionals } = parseArgs2({
+    args: args2,
+    options: {
+      force: {
+        type: "boolean",
+        short: "f"
+      }
+    },
+    strict: true,
+    allowPositionals: true
+  });
+  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);
+    }
+    output.log(result.value.message);
+    exitWithSuccess();
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
   }
-  console.log(result.message);
 }
 
-// src/gardens/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 listGardens() {
+// src/cli/handlers/exec.ts
+import { parseArgs as parseArgs3 } from "node:util";
+async function execHandler(args2) {
+  const { positionals } = parseArgs3({
+    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 gardensPath = join4(gitRoot, ".git", "phantom", "gardens");
-    try {
-      await access4(gardensPath);
-    } catch {
-      return {
-        success: true,
-        gardens: [],
-        message: "No gardens found (gardens directory doesn't exist)"
-      };
-    }
-    let gardenNames;
-    try {
-      const entries = await readdir(gardensPath);
-      const validEntries = await Promise.all(
-        entries.map(async (entry) => {
-          try {
-            const entryPath = join4(gardensPath, entry);
-            await access4(entryPath);
-            return entry;
-          } catch {
-            return null;
-          }
-        })
-      );
-      gardenNames = validEntries.filter(
-        (entry) => entry !== null
-      );
-    } catch {
-      return {
-        success: true,
-        gardens: [],
-        message: "No gardens found (unable to read gardens directory)"
-      };
+    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);
     }
-    if (gardenNames.length === 0) {
-      return {
-        success: true,
-        gardens: [],
-        message: "No gardens found"
-      };
-    }
-    const gardens = await Promise.all(
-      gardenNames.map(async (name) => {
-        const gardenPath = join4(gardensPath, name);
-        let branch = "unknown";
-        try {
-          const { stdout } = await execAsync4("git branch --show-current", {
-            cwd: gardenPath
-          });
-          branch = stdout.trim() || "detached HEAD";
-        } catch {
-          branch = "unknown";
-        }
-        let status = "clean";
-        let changedFiles;
-        try {
-          const { stdout } = await execAsync4("git status --porcelain", {
-            cwd: gardenPath
-          });
-          const changes = stdout.trim();
-          if (changes) {
-            status = "dirty";
-            changedFiles = changes.split("\n").length;
-          }
-        } catch {
-          status = "clean";
-        }
-        return {
-          name,
-          branch,
-          status,
-          changedFiles
-        };
-      })
+    process.exit(result.value.exitCode);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
     );
-    return {
-      success: true,
-      gardens
-    };
+  }
+}
+
+// src/cli/handlers/list.ts
+import { parseArgs as parseArgs4 } 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, [
+      "status",
+      "--porcelain"
+    ]);
+    return !stdout;
+  } catch {
+    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"
+    });
+  }
+  try {
+    const worktrees = await Promise.all(
+      worktreeNames.map((name) => getWorktreeInfo(gitRoot, name))
+    );
+    return ok({
+      worktrees
+    });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      message: `Error listing gardens: ${errorMessage}`
-    };
+    throw new Error(`Failed to list worktrees: ${errorMessage}`);
   }
 }
-async function gardensListHandler() {
-  const result = await listGardens();
-  if (!result.success) {
-    console.error(result.message);
-    return;
+
+// src/cli/handlers/list.ts
+async function listHandler(args2 = []) {
+  parseArgs4({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: false
+  });
+  try {
+    const gitRoot = await getGitRoot();
+    const result = await listWorktrees(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.gardens || result.gardens.length === 0) {
-    console.log(result.message || "No gardens found");
-    return;
+}
+
+// src/cli/handlers/shell.ts
+import { parseArgs as parseArgs5 } from "node:util";
+async function shellHandler(args2) {
+  const { positionals } = parseArgs5({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: true
+  });
+  if (positionals.length === 0) {
+    exitWithError(
+      "Usage: phantom shell <worktree-name>",
+      exitCodes.validationError
+    );
   }
-  console.log("Gardens:");
-  for (const garden of result.gardens) {
-    const statusText = garden.status === "clean" ? "[clean]" : `[dirty: ${garden.changedFiles} files]`;
-    console.log(
-      `  ${garden.name.padEnd(20)} (branch: ${garden.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.gardens.length} gardens`);
 }
 
-// src/phantom/command/exec.ts
-import { spawn as spawn2 } from "node:child_process";
-import { exit as exit5 } from "node:process";
-async function execInGarden(gardenName, command2) {
-  if (!gardenName) {
-    return { success: false, message: "Error: garden name required" };
-  }
-  if (!command2 || command2.length === 0) {
-    return { success: false, message: "Error: command required" };
+// src/cli/handlers/version.ts
+import { parseArgs as parseArgs6 } from "node:util";
+
+// package.json
+var package_default = {
+  name: "@aku11i/phantom",
+  packageManager: "pnpm@10.8.1",
+  version: "0.4.0",
+  description: "A powerful CLI tool for managing Git worktrees for parallel development",
+  keywords: [
+    "git",
+    "worktree",
+    "cli",
+    "phantom",
+    "workspace",
+    "development",
+    "parallel"
+  ],
+  homepage: "https://github.com/aku11i/phantom#readme",
+  bugs: {
+    url: "https://github.com/aku11i/phantom/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/aku11i/phantom.git"
+  },
+  license: "MIT",
+  author: "aku11i",
+  type: "module",
+  bin: {
+    phantom: "./dist/phantom.js"
+  },
+  scripts: {
+    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",
+    lint: "biome check .",
+    fix: "biome check --write .",
+    ready: "pnpm fix && pnpm type-check && pnpm test",
+    "ready:check": "pnpm lint && pnpm type-check && pnpm test",
+    prepublishOnly: "pnpm ready:check && pnpm build"
+  },
+  engines: {
+    node: ">=22.0.0"
+  },
+  files: [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  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"
   }
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    return { success: false, message: gardenResult.message };
+};
+
+// src/core/version.ts
+function getVersion() {
+  return package_default.version;
+}
+
+// src/cli/handlers/version.ts
+function versionHandler(args2 = []) {
+  parseArgs6({
+    args: args2,
+    options: {},
+    strict: true,
+    allowPositionals: false
+  });
+  const version = getVersion();
+  output.log(`Phantom v${version}`);
+  exitWithSuccess();
+}
+
+// src/cli/handlers/where.ts
+import { parseArgs as parseArgs7 } 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));
   }
-  const gardenPath = gardenResult.path;
-  const [cmd, ...args2] = command2;
-  return new Promise((resolve) => {
-    const childProcess = spawn2(cmd, args2, {
-      cwd: gardenPath,
-      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
-        });
-      }
-    });
+  return ok({
+    path: validation.path
   });
 }
-async function execHandler(args2) {
-  if (args2.length < 2) {
-    console.error("Usage: phantom exec <garden-name> <command> [args...]");
-    exit5(1);
-  }
-  const gardenName = args2[0];
-  const command2 = args2.slice(1);
-  const result = await execInGarden(gardenName, command2);
-  if (!result.success) {
-    if (result.message) {
-      console.error(result.message);
+
+// src/cli/handlers/where.ts
+async function whereHandler(args2) {
+  const { positionals } = parseArgs7({
+    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);
     }
-    exit5(result.exitCode ?? 1);
+    output.log(result.value.path);
+    exitWithSuccess();
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : String(error),
+      exitCodes.generalError
+    );
   }
-  exit5(result.exitCode ?? 0);
 }
 
 // src/bin/phantom.ts
 var commands = [
   {
-    name: "garden",
-    description: "Manage git worktrees (gardens)",
-    subcommands: [
-      {
-        name: "create",
-        description: "Create a new worktree (garden) [--shell to open shell]",
-        handler: gardensCreateHandler
-      },
-      {
-        name: "list",
-        description: "List all gardens",
-        handler: gardensListHandler
-      },
-      {
-        name: "where",
-        description: "Output the path of a specific garden",
-        handler: gardensWhereHandler
-      },
-      {
-        name: "delete",
-        description: "Delete a garden (use --force for dirty gardens)",
-        handler: gardensDeleteHandler
-      }
-    ]
+    name: "create",
+    description: "Create a new worktree [--shell | --exec <command>]",
+    handler: createHandler
+  },
+  {
+    name: "list",
+    description: "List all worktrees",
+    handler: listHandler
+  },
+  {
+    name: "where",
+    description: "Output the path of a specific worktree",
+    handler: whereHandler
+  },
+  {
+    name: "delete",
+    description: "Delete a worktree (use --force for uncommitted changes)",
+    handler: deleteHandler
   },
   {
     name: "exec",
-    description: "Execute a command in a garden directory",
+    description: "Execute a command in a worktree directory",
     handler: execHandler
   },
   {
     name: "shell",
-    description: "Open interactive shell in a garden directory",
+    description: "Open interactive shell in a worktree directory",
     handler: shellHandler
+  },
+  {
+    name: "version",
+    description: "Display phantom version",
+    handler: versionHandler
   }
 ];
-function printHelp(commands2, prefix = "") {
+function printHelp(commands2) {
   console.log("Usage: phantom <command> [options]\n");
   console.log("Commands:");
   for (const cmd of commands2) {
-    console.log(`  ${prefix}${cmd.name.padEnd(20)} ${cmd.description}`);
-    if (cmd.subcommands) {
-      for (const subcmd of cmd.subcommands) {
-        console.log(`    ${subcmd.name.padEnd(18)} ${subcmd.description}`);
-      }
-    }
+    console.log(`  ${cmd.name.padEnd(12)} ${cmd.description}`);
   }
 }
 function findCommand(args2, commands2) {
@@ -557,14 +899,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();
+  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);
@@ -573,6 +919,6 @@ try {
     "Error:",
     error instanceof Error ? error.message : String(error)
   );
-  exit6(1);
+  exit(1);
 }
 //# sourceMappingURL=phantom.js.map