@aku11i/phantom 0.9.0 → 1.1.0

package/dist/phantom.js

@@ -1,2338 +0,0 @@
-#!/usr/bin/env node
-
-// src/bin/phantom.ts
-import { argv, exit as exit2 } from "node:process";
-
-// 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";
-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/core/git/libs/get-git-root.ts
-async function getGitRoot() {
-  const { stdout: stdout2 } = await executeGitCommand(["rev-parse", "--git-common-dir"]);
-  if (stdout2.endsWith("/.git") || stdout2 === ".git") {
-    return resolve(process.cwd(), dirname(stdout2));
-  }
-  const { stdout: toplevel } = await executeGitCommand([
-    "rev-parse",
-    "--show-toplevel"
-  ]);
-  return toplevel;
-}
-
-// 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";
-  }
-};
-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 {
-    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 {
-    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"));
-  }
-  return ok(void 0);
-}
-
-// 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;
-  }
-};
-var ProcessExecutionError = class extends ProcessError {
-  constructor(command2, exitCode) {
-    super(`Command '${command2}' failed with exit code ${exitCode}`, exitCode);
-    this.name = "ProcessExecutionError";
-  }
-};
-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",
-      ...options
-    });
-    childProcess.on("error", (error) => {
-      resolve2(err(new ProcessSpawnError(command2, error.message)));
-    });
-    childProcess.on("exit", (code, signal) => {
-      if (signal) {
-        resolve2(err(new ProcessSignalError(signal)));
-      } else {
-        const exitCode = code ?? 0;
-        if (exitCode === 0) {
-          resolve2(ok({ exitCode }));
-        } else {
-          resolve2(err(new ProcessExecutionError(command2, exitCode)));
-        }
-      }
-    });
-  });
-}
-
-// src/core/process/exec.ts
-async function execInWorktree(gitRoot, worktreeName, command2, options = {}) {
-  const validation = await validateWorktreeExists(gitRoot, worktreeName);
-  if (!validation.exists) {
-    return err(new WorktreeNotFoundError(worktreeName));
-  }
-  const worktreePath = validation.path;
-  const [cmd, ...args2] = command2;
-  const stdio = options.interactive ? "inherit" : ["ignore", "inherit", "inherit"];
-  return spawnProcess({
-    command: cmd,
-    args: args2,
-    options: {
-      cwd: worktreePath,
-      stdio
-    }
-  });
-}
-
-// src/core/process/shell.ts
-async function shellInWorktree(gitRoot, worktreeName) {
-  const validation = await validateWorktreeExists(gitRoot, worktreeName);
-  if (!validation.exists) {
-    return err(new WorktreeNotFoundError(worktreeName));
-  }
-  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/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 {
-    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)}`
-      )
-    );
-  }
-}
-
-// 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);
-  },
-  warn: (message) => {
-    console.warn(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(" "),
-      { interactive: true }
-    );
-    if (isErr(execResult)) {
-      exitWithError(execResult.error.message, exitCodes.generalError);
-    }
-  }
-}
-
-// src/cli/handlers/completion.ts
-import { exit } from "node:process";
-var FISH_COMPLETION_SCRIPT = `# Fish completion for phantom
-# Place this in ~/.config/fish/completions/phantom.fish
-
-function __phantom_list_worktrees
-    phantom list --names 2>/dev/null
-end
-
-function __phantom_using_command
-    set -l cmd (commandline -opc)
-    set -l cmd_count (count $cmd)
-    if test $cmd_count -eq 1
-        # No subcommand yet, so any command can be used
-        if test (count $argv) -eq 0
-            return 0
-        else
-            return 1
-        end
-    else if test $cmd_count -ge 2
-        # Check if we're in the context of a specific command
-        if test (count $argv) -gt 0 -a "$argv[1]" = "$cmd[2]"
-            return 0
-        end
-    end
-    return 1
-end
-
-# Disable file completion for phantom
-complete -c phantom -f
-
-# Main commands
-complete -c phantom -n "__phantom_using_command" -a "create" -d "Create a new Git worktree (phantom)"
-complete -c phantom -n "__phantom_using_command" -a "attach" -d "Attach to an existing branch by creating a new worktree"
-complete -c phantom -n "__phantom_using_command" -a "list" -d "List all Git worktrees (phantoms)"
-complete -c phantom -n "__phantom_using_command" -a "where" -d "Output the filesystem path of a specific worktree"
-complete -c phantom -n "__phantom_using_command" -a "delete" -d "Delete a Git worktree (phantom)"
-complete -c phantom -n "__phantom_using_command" -a "exec" -d "Execute a command in a worktree directory"
-complete -c phantom -n "__phantom_using_command" -a "shell" -d "Open an interactive shell in a worktree directory"
-complete -c phantom -n "__phantom_using_command" -a "version" -d "Display phantom version information"
-complete -c phantom -n "__phantom_using_command" -a "completion" -d "Generate shell completion scripts"
-
-# Global options
-complete -c phantom -l help -d "Show help (-h)"
-complete -c phantom -l version -d "Show version (-v)"
-
-# create command options
-complete -c phantom -n "__phantom_using_command create" -l shell -d "Open an interactive shell in the new worktree after creation (-s)"
-complete -c phantom -n "__phantom_using_command create" -l exec -d "Execute a command in the new worktree after creation (-x)" -x
-complete -c phantom -n "__phantom_using_command create" -l tmux -d "Open the worktree in a new tmux window (-t)"
-complete -c phantom -n "__phantom_using_command create" -l tmux-vertical -d "Open the worktree in a vertical tmux pane"
-complete -c phantom -n "__phantom_using_command create" -l tmux-horizontal -d "Open the worktree in a horizontal tmux pane"
-complete -c phantom -n "__phantom_using_command create" -l copy-file -d "Copy specified files from the current worktree" -r
-
-# attach command options
-complete -c phantom -n "__phantom_using_command attach" -l shell -d "Open an interactive shell in the worktree after attaching (-s)"
-complete -c phantom -n "__phantom_using_command attach" -l exec -d "Execute a command in the worktree after attaching (-x)" -x
-
-# list command options
-complete -c phantom -n "__phantom_using_command list" -l fzf -d "Use fzf for interactive selection"
-complete -c phantom -n "__phantom_using_command list" -l names -d "Output only phantom names (for scripts and completion)"
-
-# where command options
-complete -c phantom -n "__phantom_using_command where" -l fzf -d "Use fzf for interactive selection"
-complete -c phantom -n "__phantom_using_command where" -a "(__phantom_list_worktrees)"
-
-# delete command options
-complete -c phantom -n "__phantom_using_command delete" -l force -d "Force deletion even if worktree has uncommitted changes (-f)"
-complete -c phantom -n "__phantom_using_command delete" -l current -d "Delete the current worktree"
-complete -c phantom -n "__phantom_using_command delete" -l fzf -d "Use fzf for interactive selection"
-complete -c phantom -n "__phantom_using_command delete" -a "(__phantom_list_worktrees)"
-
-# exec command - accept worktree names and then any command
-complete -c phantom -n "__phantom_using_command exec" -a "(__phantom_list_worktrees)"
-
-# shell command options
-complete -c phantom -n "__phantom_using_command shell" -l fzf -d "Use fzf for interactive selection"
-complete -c phantom -n "__phantom_using_command shell" -a "(__phantom_list_worktrees)"
-
-# completion command - shell names
-complete -c phantom -n "__phantom_using_command completion" -a "fish zsh" -d "Shell type"`;
-var ZSH_COMPLETION_SCRIPT = `#compdef phantom
-# Zsh completion for phantom
-# Place this in a directory in your $fpath (e.g., ~/.zsh/completions/)
-# Or load dynamically with: eval "$(phantom completion zsh)"
-
-# Only define the function, don't execute it
-_phantom() {
-    local -a commands
-    commands=(
-        'create:Create a new Git worktree (phantom)'
-        'attach:Attach to an existing branch by creating a new worktree'
-        'list:List all Git worktrees (phantoms)'
-        'where:Output the filesystem path of a specific worktree'
-        'delete:Delete a Git worktree (phantom)'
-        'exec:Execute a command in a worktree directory'
-        'shell:Open an interactive shell in a worktree directory'
-        'version:Display phantom version information'
-        'completion:Generate shell completion scripts'
-    )
-
-    _arguments -C \\
-        '--help[Show help (-h)]' \\
-        '--version[Show version (-v)]' \\
-        '1:command:->command' \\
-        '*::arg:->args'
-
-    case \${state} in
-        command)
-            _describe 'phantom command' commands
-            ;;
-        args)
-            case \${line[1]} in
-                create)
-                    _arguments \\
-                        '--shell[Open an interactive shell in the new worktree after creation (-s)]' \\
-                        '--exec[Execute a command in the new worktree after creation (-x)]:command:' \\
-                        '--tmux[Open the worktree in a new tmux window (-t)]' \\
-                        '--tmux-vertical[Open the worktree in a vertical tmux pane]' \\
-                        '--tmux-horizontal[Open the worktree in a horizontal tmux pane]' \\
-                        '*--copy-file[Copy specified files from the current worktree]:file:_files' \\
-                        '1:name:'
-                    ;;
-                attach)
-                    _arguments \\
-                        '--shell[Open an interactive shell in the worktree after attaching (-s)]' \\
-                        '--exec[Execute a command in the worktree after attaching (-x)]:command:' \\
-                        '1:worktree-name:' \\
-                        '2:branch-name:'
-                    ;;
-                list)
-                    _arguments \\
-                        '--fzf[Use fzf for interactive selection]' \\
-                        '--names[Output only phantom names (for scripts and completion)]'
-                    ;;
-                where|delete|shell)
-                    local worktrees
-                    worktrees=(\${(f)"$(phantom list --names 2>/dev/null)"})
-                    if [[ \${line[1]} == "where" || \${line[1]} == "shell" ]]; then
-                        _arguments \\
-                            '--fzf[Use fzf for interactive selection]' \\
-                            '1:worktree:(\${(q)worktrees[@]})'
-                    elif [[ \${line[1]} == "delete" ]]; then
-                        _arguments \\
-                            '--force[Force deletion even if worktree has uncommitted changes (-f)]' \\
-                            '--current[Delete the current worktree]' \\
-                            '--fzf[Use fzf for interactive selection]' \\
-                            '1:worktree:(\${(q)worktrees[@]})'
-                    fi
-                    ;;
-                exec)
-                    local worktrees
-                    worktrees=(\${(f)"$(phantom list --names 2>/dev/null)"})
-                    _arguments \\
-                        '1:worktree:(\${(q)worktrees[@]})' \\
-                        '*:command:_command_names'
-                    ;;
-                completion)
-                    _arguments \\
-                        '1:shell:(fish zsh)'
-                    ;;
-            esac
-            ;;
-    esac
-}
-
-# Register the completion function if loading dynamically
-if [[ -n \${ZSH_VERSION} ]]; then
-    autoload -Uz compinit && compinit -C
-    compdef _phantom phantom
-fi`;
-function completionHandler(args2) {
-  const shell = args2[0];
-  if (!shell) {
-    output.error("Usage: phantom completion <shell>");
-    output.error("Supported shells: fish, zsh");
-    exit(1);
-  }
-  switch (shell.toLowerCase()) {
-    case "fish":
-      console.log(FISH_COMPLETION_SCRIPT);
-      break;
-    case "zsh":
-      console.log(ZSH_COMPLETION_SCRIPT);
-      break;
-    default:
-      output.error(`Unsupported shell: ${shell}`);
-      output.error("Supported shells: fish, zsh");
-      exit(1);
-  }
-}
-
-// 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"
-          )
-        );
-      }
-    }
-    if (postCreate.commands !== void 0) {
-      if (!Array.isArray(postCreate.commands)) {
-        return err(
-          new ConfigValidationError("postCreate.commands must be an array")
-        );
-      }
-      if (!postCreate.commands.every((c) => typeof c === "string")) {
-        return err(
-          new ConfigValidationError(
-            "postCreate.commands 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 } = parseArgs2({
-    args: args2,
-    options: {
-      shell: {
-        type: "boolean",
-        short: "s"
-      },
-      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,
-    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;
-  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(
-      "The --tmux option can only be used inside a tmux session",
-      exitCodes.validationError
-    );
-  }
-  try {
-    const gitRoot = await getGitRoot();
-    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 (isOk(configResult) && configResult.value.postCreate?.commands) {
-      const commands2 = configResult.value.postCreate.commands;
-      output.log("\nRunning post-create commands...");
-      for (const command2 of commands2) {
-        output.log(`Executing: ${command2}`);
-        const shell = process.env.SHELL || "/bin/sh";
-        const cmdResult = await execInWorktree(gitRoot, worktreeName, [
-          shell,
-          "-c",
-          command2
-        ]);
-        if (isErr(cmdResult)) {
-          output.error(`Failed to execute command: ${cmdResult.error.message}`);
-          const exitCode = "exitCode" in cmdResult.error ? cmdResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
-          exitWithError(`Post-create command failed: ${command2}`, exitCode);
-        }
-        if (cmdResult.value.exitCode !== 0) {
-          exitWithError(
-            `Post-create command failed: ${command2}`,
-            cmdResult.value.exitCode
-          );
-        }
-      }
-    }
-    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],
-        { interactive: true }
-      );
-      if (isErr(execResult)) {
-        output.error(execResult.error.message);
-        const exitCode = "exitCode" in execResult.error ? execResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
-        exitWithError("", exitCode);
-      }
-      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 (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(
-      error instanceof Error ? error.message : String(error),
-      exitCodes.generalError
-    );
-  }
-}
-
-// src/cli/handlers/delete.ts
-import { parseArgs as parseArgs3 } from "node:util";
-
-// src/core/git/libs/list-worktrees.ts
-async function listWorktrees(gitRoot) {
-  const { stdout: stdout2 } = await executeGitCommand([
-    "worktree",
-    "list",
-    "--porcelain"
-  ]);
-  const worktrees = [];
-  let currentWorktree = {};
-  const lines = stdout2.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) {
-  try {
-    const { stdout: stdout2 } = await executeGitCommandInDirectory(worktreePath, [
-      "status",
-      "--porcelain"
-    ]);
-    if (stdout2) {
-      return {
-        hasUncommittedChanges: true,
-        changedFiles: stdout2.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 executeGitCommand(["worktree", "remove", "--force", worktreePath], {
-        cwd: gitRoot
-      });
-    } catch {
-      throw new Error("Failed to remove worktree");
-    }
-  }
-}
-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 ok({
-      message,
-      hasUncommittedChanges: status.hasUncommittedChanges,
-      changedFiles: status.hasUncommittedChanges ? status.changedFiles : void 0
-    });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return err(new GitOperationError("worktree remove", errorMessage));
-  }
-}
-
-// src/core/utils/fzf.ts
-import { spawn } from "node:child_process";
-async function selectWithFzf(items, options = {}) {
-  return new Promise((resolve2) => {
-    const args2 = [];
-    if (options.prompt) {
-      args2.push("--prompt", options.prompt);
-    }
-    if (options.header) {
-      args2.push("--header", options.header);
-    }
-    if (options.previewCommand) {
-      args2.push("--preview", options.previewCommand);
-    }
-    const fzf = spawn("fzf", args2, {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let result = "";
-    let errorOutput = "";
-    fzf.stdout.on("data", (data) => {
-      result += data.toString();
-    });
-    if (fzf.stderr) {
-      fzf.stderr.on("data", (data) => {
-        errorOutput += data.toString();
-      });
-    }
-    fzf.on("error", (error) => {
-      if (error.message.includes("ENOENT")) {
-        resolve2(
-          err(new Error("fzf command not found. Please install fzf first."))
-        );
-      } else {
-        resolve2(err(error));
-      }
-    });
-    fzf.on("close", (code) => {
-      if (code === 0) {
-        const selected = result.trim();
-        resolve2(ok(selected || null));
-      } else if (code === 1) {
-        resolve2(ok(null));
-      } else if (code === 130) {
-        resolve2(ok(null));
-      } else {
-        resolve2(err(new Error(`fzf exited with code ${code}: ${errorOutput}`)));
-      }
-    });
-    fzf.stdin.write(items.join("\n"));
-    fzf.stdin.end();
-  });
-}
-
-// src/core/worktree/list.ts
-async function getWorktreeStatus2(worktreePath) {
-  try {
-    const { stdout: stdout2 } = await executeGitCommandInDirectory(worktreePath, [
-      "status",
-      "--porcelain"
-    ]);
-    return !stdout2;
-  } 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(
-      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
-    });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to list worktrees: ${errorMessage}`);
-  }
-}
-
-// src/core/worktree/select.ts
-async function selectWorktreeWithFzf(gitRoot) {
-  const listResult = await listWorktrees2(gitRoot);
-  if (isErr(listResult)) {
-    return listResult;
-  }
-  const { worktrees } = listResult.value;
-  if (worktrees.length === 0) {
-    return {
-      ok: true,
-      value: null
-    };
-  }
-  const list = worktrees.map((wt) => {
-    const branchInfo = wt.branch ? `(${wt.branch})` : "";
-    const status = !wt.isClean ? " [dirty]" : "";
-    return `${wt.name} ${branchInfo}${status}`;
-  });
-  const fzfResult = await selectWithFzf(list, {
-    prompt: "Select worktree> ",
-    header: "Git Worktrees (Phantoms)"
-  });
-  if (isErr(fzfResult)) {
-    return fzfResult;
-  }
-  if (!fzfResult.value) {
-    return {
-      ok: true,
-      value: null
-    };
-  }
-  const selectedName = fzfResult.value.split(" ")[0];
-  const selectedWorktree = worktrees.find((wt) => wt.name === selectedName);
-  if (!selectedWorktree) {
-    return {
-      ok: false,
-      error: new Error("Selected worktree not found")
-    };
-  }
-  return {
-    ok: true,
-    value: {
-      name: selectedWorktree.name,
-      branch: selectedWorktree.branch,
-      isClean: selectedWorktree.isClean
-    }
-  };
-}
-
-// src/cli/handlers/delete.ts
-async function deleteHandler(args2) {
-  const { values, positionals } = parseArgs3({
-    args: args2,
-    options: {
-      force: {
-        type: "boolean",
-        short: "f"
-      },
-      current: {
-        type: "boolean"
-      },
-      fzf: {
-        type: "boolean",
-        default: false
-      }
-    },
-    strict: true,
-    allowPositionals: true
-  });
-  const deleteCurrent = values.current ?? false;
-  const useFzf = values.fzf ?? false;
-  if (positionals.length === 0 && !deleteCurrent && !useFzf) {
-    exitWithError(
-      "Please provide a worktree name to delete, use --current to delete the current worktree, or use --fzf for interactive selection",
-      exitCodes.validationError
-    );
-  }
-  if ((positionals.length > 0 || useFzf) && deleteCurrent) {
-    exitWithError(
-      "Cannot specify --current with a worktree name or --fzf option",
-      exitCodes.validationError
-    );
-  }
-  if (positionals.length > 0 && useFzf) {
-    exitWithError(
-      "Cannot specify both a worktree name and --fzf option",
-      exitCodes.validationError
-    );
-  }
-  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 if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
-      if (isErr(selectResult)) {
-        exitWithError(selectResult.error.message, exitCodes.generalError);
-      }
-      if (!selectResult.value) {
-        exitWithSuccess();
-      }
-      worktreeName = selectResult.value.name;
-    } else {
-      worktreeName = positionals[0];
-    }
-    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
-    );
-  }
-}
-
-// 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 result = await execInWorktree(
-      gitRoot,
-      worktreeName,
-      commandArgs,
-      { interactive: true }
-    );
-    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
-    );
-  }
-}
-
-// src/cli/handlers/list.ts
-import { parseArgs as parseArgs5 } from "node:util";
-async function listHandler(args2 = []) {
-  const { values } = parseArgs5({
-    args: args2,
-    options: {
-      fzf: {
-        type: "boolean",
-        default: false
-      },
-      names: {
-        type: "boolean",
-        default: false
-      }
-    },
-    strict: true,
-    allowPositionals: false
-  });
-  try {
-    const gitRoot = await getGitRoot();
-    if (values.fzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
-      if (isErr(selectResult)) {
-        exitWithError(selectResult.error.message, exitCodes.generalError);
-      }
-      if (selectResult.value) {
-        output.log(selectResult.value.name);
-      }
-    } else {
-      const result = await listWorktrees2(gitRoot);
-      if (isErr(result)) {
-        exitWithError("Failed to list worktrees", exitCodes.generalError);
-      }
-      const { worktrees, message } = result.value;
-      if (worktrees.length === 0) {
-        if (!values.names) {
-          output.log(message || "No worktrees found.");
-        }
-        process.exit(exitCodes.success);
-      }
-      if (values.names) {
-        for (const worktree of worktrees) {
-          output.log(worktree.name);
-        }
-      } else {
-        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
-    );
-  }
-}
-
-// src/cli/handlers/shell.ts
-import { parseArgs as parseArgs6 } from "node:util";
-async function shellHandler(args2) {
-  const { positionals, values } = parseArgs6({
-    args: args2,
-    options: {
-      fzf: {
-        type: "boolean",
-        default: false
-      }
-    },
-    strict: true,
-    allowPositionals: true
-  });
-  const useFzf = values.fzf ?? false;
-  if (positionals.length === 0 && !useFzf) {
-    exitWithError(
-      "Usage: phantom shell <worktree-name> or phantom shell --fzf",
-      exitCodes.validationError
-    );
-  }
-  if (positionals.length > 0 && useFzf) {
-    exitWithError(
-      "Cannot specify both a worktree name and --fzf option",
-      exitCodes.validationError
-    );
-  }
-  let worktreeName;
-  try {
-    const gitRoot = await getGitRoot();
-    if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
-      if (isErr(selectResult)) {
-        exitWithError(selectResult.error.message, exitCodes.generalError);
-      }
-      if (!selectResult.value) {
-        exitWithSuccess();
-      }
-      worktreeName = selectResult.value.name;
-    } else {
-      worktreeName = positionals[0];
-    }
-    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
-    );
-  }
-}
-
-// 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.9.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",
-    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 typecheck && pnpm test",
-    "ready:check": "pnpm lint && pnpm typecheck && 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"
-  }
-};
-
-// src/core/version.ts
-function getVersion() {
-  return package_default.version;
-}
-
-// src/cli/handlers/version.ts
-function versionHandler(args2 = []) {
-  parseArgs7({
-    args: args2,
-    options: {},
-    strict: true,
-    allowPositionals: false
-  });
-  const version = getVersion();
-  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, values } = parseArgs8({
-    args: args2,
-    options: {
-      fzf: {
-        type: "boolean",
-        default: false
-      }
-    },
-    strict: true,
-    allowPositionals: true
-  });
-  const useFzf = values.fzf ?? false;
-  if (positionals.length === 0 && !useFzf) {
-    exitWithError(
-      "Usage: phantom where <worktree-name> or phantom where --fzf",
-      exitCodes.validationError
-    );
-  }
-  if (positionals.length > 0 && useFzf) {
-    exitWithError(
-      "Cannot specify both a worktree name and --fzf option",
-      exitCodes.validationError
-    );
-  }
-  let worktreeName;
-  let gitRoot;
-  try {
-    gitRoot = await getGitRoot();
-  } catch (error) {
-    exitWithError(
-      error instanceof Error ? error.message : String(error),
-      exitCodes.generalError
-    );
-  }
-  if (useFzf) {
-    const selectResult = await selectWorktreeWithFzf(gitRoot);
-    if (isErr(selectResult)) {
-      exitWithError(selectResult.error.message, exitCodes.generalError);
-    }
-    if (!selectResult.value) {
-      exitWithSuccess();
-    }
-    worktreeName = selectResult.value.name;
-  } else {
-    worktreeName = positionals[0];
-  }
-  const result = await whereWorktree(gitRoot, worktreeName);
-  if (isErr(result)) {
-    exitWithError(result.error.message, exitCodes.notFound);
-  }
-  output.log(result.value.path);
-  exitWithSuccess();
-}
-
-// src/cli/help.ts
-import { stdout } from "node:process";
-var HelpFormatter = class {
-  width;
-  indent = "  ";
-  constructor() {
-    this.width = stdout.columns || 80;
-  }
-  formatMainHelp(commands2) {
-    const lines = [];
-    lines.push(this.bold("Phantom - Git Worktree Manager"));
-    lines.push("");
-    lines.push(
-      this.dim(
-        "A CLI tool for managing Git worktrees with enhanced functionality"
-      )
-    );
-    lines.push("");
-    lines.push(this.section("USAGE"));
-    lines.push(`${this.indent}phantom <command> [options]`);
-    lines.push("");
-    lines.push(this.section("COMMANDS"));
-    const maxNameLength = Math.max(...commands2.map((cmd) => cmd.name.length));
-    for (const cmd of commands2) {
-      const paddedName = cmd.name.padEnd(maxNameLength + 2);
-      lines.push(`${this.indent}${this.cyan(paddedName)}${cmd.description}`);
-    }
-    lines.push("");
-    lines.push(this.section("GLOBAL OPTIONS"));
-    const helpOption = "-h, --help";
-    const versionOption = "-v, --version";
-    const globalOptionWidth = Math.max(helpOption.length, versionOption.length) + 2;
-    lines.push(
-      `${this.indent}${this.cyan(helpOption.padEnd(globalOptionWidth))}Show help`
-    );
-    lines.push(
-      `${this.indent}${this.cyan(versionOption.padEnd(globalOptionWidth))}Show version`
-    );
-    lines.push("");
-    lines.push(
-      this.dim(
-        "Run 'phantom <command> --help' for more information on a command."
-      )
-    );
-    return lines.join("\n");
-  }
-  formatCommandHelp(help) {
-    const lines = [];
-    lines.push(this.bold(`phantom ${help.name}`));
-    lines.push(this.dim(help.description));
-    lines.push("");
-    lines.push(this.section("USAGE"));
-    lines.push(`${this.indent}${help.usage}`);
-    lines.push("");
-    if (help.options && help.options.length > 0) {
-      lines.push(this.section("OPTIONS"));
-      const maxOptionLength = Math.max(
-        ...help.options.map((opt) => this.formatOptionName(opt).length)
-      );
-      for (const option of help.options) {
-        const optionName = this.formatOptionName(option);
-        const paddedName = optionName.padEnd(maxOptionLength + 2);
-        const description = this.wrapText(
-          option.description,
-          maxOptionLength + 4
-        );
-        lines.push(`${this.indent}${this.cyan(paddedName)}${description[0]}`);
-        for (let i = 1; i < description.length; i++) {
-          lines.push(
-            `${this.indent}${" ".repeat(maxOptionLength + 2)}${description[i]}`
-          );
-        }
-        if (option.example) {
-          const exampleIndent = " ".repeat(maxOptionLength + 4);
-          lines.push(
-            `${this.indent}${exampleIndent}${this.dim(`Example: ${option.example}`)}`
-          );
-        }
-      }
-      lines.push("");
-    }
-    if (help.examples && help.examples.length > 0) {
-      lines.push(this.section("EXAMPLES"));
-      for (const example of help.examples) {
-        lines.push(`${this.indent}${this.dim(example.description)}`);
-        lines.push(`${this.indent}${this.indent}$ ${example.command}`);
-        lines.push("");
-      }
-    }
-    if (help.notes && help.notes.length > 0) {
-      lines.push(this.section("NOTES"));
-      for (const note of help.notes) {
-        const wrappedNote = this.wrapText(note, 2);
-        for (const line of wrappedNote) {
-          lines.push(`${this.indent}${line}`);
-        }
-      }
-      lines.push("");
-    }
-    return lines.join("\n");
-  }
-  formatOptionName(option) {
-    const parts = [];
-    if (option.short) {
-      parts.push(`-${option.short},`);
-    }
-    parts.push(`--${option.name}`);
-    if (option.type === "string") {
-      parts.push(option.multiple ? "<value>..." : "<value>");
-    }
-    return parts.join(" ");
-  }
-  wrapText(text, indent) {
-    const maxWidth = this.width - indent - 2;
-    const words = text.split(" ");
-    const lines = [];
-    let currentLine = "";
-    for (const word of words) {
-      if (currentLine.length + word.length + 1 > maxWidth) {
-        lines.push(currentLine);
-        currentLine = word;
-      } else {
-        currentLine = currentLine ? `${currentLine} ${word}` : word;
-      }
-    }
-    if (currentLine) {
-      lines.push(currentLine);
-    }
-    return lines;
-  }
-  section(text) {
-    return this.bold(text);
-  }
-  bold(text) {
-    return `\x1B[1m${text}\x1B[0m`;
-  }
-  dim(text) {
-    return `\x1B[2m${text}\x1B[0m`;
-  }
-  cyan(text) {
-    return `\x1B[36m${text}\x1B[0m`;
-  }
-};
-var helpFormatter = new HelpFormatter();
-
-// src/cli/help/attach.ts
-var attachHelp = {
-  name: "attach",
-  description: "Attach to an existing branch by creating a new worktree",
-  usage: "phantom attach <worktree-name> <branch-name> [options]",
-  options: [
-    {
-      name: "shell",
-      short: "s",
-      type: "boolean",
-      description: "Open an interactive shell in the worktree after attaching"
-    },
-    {
-      name: "exec",
-      short: "x",
-      type: "string",
-      description: "Execute a command in the worktree after attaching",
-      example: "--exec 'git pull'"
-    }
-  ],
-  examples: [
-    {
-      description: "Attach to an existing branch",
-      command: "phantom attach review-pr main"
-    },
-    {
-      description: "Attach to a remote branch and open a shell",
-      command: "phantom attach hotfix origin/hotfix-v1.2 --shell"
-    },
-    {
-      description: "Attach to a branch and pull latest changes",
-      command: "phantom attach staging origin/staging --exec 'git pull'"
-    }
-  ],
-  notes: [
-    "The branch must already exist (locally or remotely)",
-    "If attaching to a remote branch, it will be checked out locally",
-    "Only one of --shell or --exec options can be used at a time"
-  ]
-};
-
-// src/cli/help/completion.ts
-var completionHelp = {
-  name: "completion",
-  usage: "phantom completion <shell>",
-  description: "Generate shell completion scripts for fish or zsh",
-  examples: [
-    {
-      command: "phantom completion fish > ~/.config/fish/completions/phantom.fish",
-      description: "Generate and install Fish completion"
-    },
-    {
-      command: "phantom completion fish | source",
-      description: "Load Fish completion in current session"
-    },
-    {
-      command: "phantom completion zsh > ~/.zsh/completions/_phantom",
-      description: "Generate and install Zsh completion"
-    },
-    {
-      command: 'eval "$(phantom completion zsh)"',
-      description: "Load Zsh completion in current session"
-    }
-  ],
-  notes: [
-    "Supported shells: fish, zsh",
-    "After installing completions, you may need to restart your shell or source the completion file",
-    "For Fish: completions are loaded automatically from ~/.config/fish/completions/",
-    "For Zsh: ensure the completion file is in a directory in your $fpath"
-  ]
-};
-
-// src/cli/help/create.ts
-var createHelp = {
-  name: "create",
-  description: "Create a new Git worktree (phantom)",
-  usage: "phantom create <name> [options]",
-  options: [
-    {
-      name: "shell",
-      short: "s",
-      type: "boolean",
-      description: "Open an interactive shell in the new worktree after creation"
-    },
-    {
-      name: "exec",
-      short: "x",
-      type: "string",
-      description: "Execute a command in the new worktree after creation",
-      example: "--exec 'npm install'"
-    },
-    {
-      name: "tmux",
-      short: "t",
-      type: "boolean",
-      description: "Open the worktree in a new tmux window (requires being inside tmux)"
-    },
-    {
-      name: "tmux-vertical",
-      type: "boolean",
-      description: "Open the worktree in a vertical tmux pane (requires being inside tmux)"
-    },
-    {
-      name: "tmux-horizontal",
-      type: "boolean",
-      description: "Open the worktree in a horizontal tmux pane (requires being inside tmux)"
-    },
-    {
-      name: "copy-file",
-      type: "string",
-      multiple: true,
-      description: "Copy specified files from the current worktree to the new one. Can be used multiple times",
-      example: "--copy-file .env --copy-file config.local.json"
-    }
-  ],
-  examples: [
-    {
-      description: "Create a new worktree named 'feature-auth'",
-      command: "phantom create feature-auth"
-    },
-    {
-      description: "Create a worktree and open a shell in it",
-      command: "phantom create bugfix-123 --shell"
-    },
-    {
-      description: "Create a worktree and run npm install",
-      command: "phantom create new-feature --exec 'npm install'"
-    },
-    {
-      description: "Create a worktree in a new tmux window",
-      command: "phantom create experiment --tmux"
-    },
-    {
-      description: "Create a worktree and copy environment files",
-      command: "phantom create staging --copy-file .env --copy-file database.yml"
-    }
-  ],
-  notes: [
-    "The worktree name will be used as the branch name",
-    "Only one of --shell, --exec, or --tmux options can be used at a time",
-    "File copying can also be configured in phantom.config.json"
-  ]
-};
-
-// src/cli/help/delete.ts
-var deleteHelp = {
-  name: "delete",
-  description: "Delete a Git worktree (phantom)",
-  usage: "phantom delete <name> [options]",
-  options: [
-    {
-      name: "force",
-      short: "f",
-      type: "boolean",
-      description: "Force deletion even if the worktree has uncommitted or unpushed changes"
-    },
-    {
-      name: "--current",
-      type: "boolean",
-      description: "Delete the current worktree"
-    },
-    {
-      name: "--fzf",
-      type: "boolean",
-      description: "Use fzf for interactive selection"
-    }
-  ],
-  examples: [
-    {
-      description: "Delete a worktree",
-      command: "phantom delete feature-auth"
-    },
-    {
-      description: "Force delete a worktree with uncommitted changes",
-      command: "phantom delete experimental --force"
-    },
-    {
-      description: "Delete the current worktree",
-      command: "phantom delete --current"
-    },
-    {
-      description: "Delete a worktree with interactive fzf selection",
-      command: "phantom delete --fzf"
-    }
-  ],
-  notes: [
-    "By default, deletion will fail if the worktree has uncommitted changes",
-    "The associated branch will also be deleted if it's not checked out elsewhere",
-    "With --fzf, you can interactively select the worktree to delete"
-  ]
-};
-
-// src/cli/help/exec.ts
-var execHelp = {
-  name: "exec",
-  description: "Execute a command in a worktree directory",
-  usage: "phantom exec <worktree-name> <command> [args...]",
-  examples: [
-    {
-      description: "Run npm test in a worktree",
-      command: "phantom exec feature-auth npm test"
-    },
-    {
-      description: "Check git status in a worktree",
-      command: "phantom exec bugfix-123 git status"
-    },
-    {
-      description: "Run a complex command with arguments",
-      command: "phantom exec staging npm run build -- --production"
-    }
-  ],
-  notes: [
-    "The command is executed with the worktree directory as the working directory",
-    "All arguments after the worktree name are passed to the command",
-    "The exit code of the executed command is preserved"
-  ]
-};
-
-// src/cli/help/list.ts
-var listHelp = {
-  name: "list",
-  description: "List all Git worktrees (phantoms)",
-  usage: "phantom list [options]",
-  options: [
-    {
-      name: "--fzf",
-      type: "boolean",
-      description: "Use fzf for interactive selection"
-    },
-    {
-      name: "--names",
-      type: "boolean",
-      description: "Output only phantom names (for scripts and completion)"
-    }
-  ],
-  examples: [
-    {
-      description: "List all worktrees",
-      command: "phantom list"
-    },
-    {
-      description: "List worktrees with interactive fzf selection",
-      command: "phantom list --fzf"
-    },
-    {
-      description: "List only worktree names",
-      command: "phantom list --names"
-    }
-  ],
-  notes: [
-    "Shows all worktrees with their paths and associated branches",
-    "The main worktree is marked as '(bare)' if using a bare repository",
-    "With --fzf, outputs only the selected worktree name",
-    "Use --names for shell completion scripts and automation"
-  ]
-};
-
-// src/cli/help/shell.ts
-var shellHelp = {
-  name: "shell",
-  description: "Open an interactive shell in a worktree directory",
-  usage: "phantom shell <worktree-name> [options]",
-  options: [
-    {
-      name: "--fzf",
-      type: "boolean",
-      description: "Use fzf for interactive selection"
-    }
-  ],
-  examples: [
-    {
-      description: "Open a shell in a worktree",
-      command: "phantom shell feature-auth"
-    },
-    {
-      description: "Open a shell with interactive fzf selection",
-      command: "phantom shell --fzf"
-    }
-  ],
-  notes: [
-    "Uses your default shell from the SHELL environment variable",
-    "The shell starts with the worktree directory as the working directory",
-    "Type 'exit' to return to your original directory",
-    "With --fzf, you can interactively select the worktree to enter"
-  ]
-};
-
-// src/cli/help/version.ts
-var versionHelp = {
-  name: "version",
-  description: "Display phantom version information",
-  usage: "phantom version",
-  examples: [
-    {
-      description: "Show version",
-      command: "phantom version"
-    }
-  ],
-  notes: ["Also accessible via 'phantom --version' or 'phantom -v'"]
-};
-
-// src/cli/help/where.ts
-var whereHelp = {
-  name: "where",
-  description: "Output the filesystem path of a specific worktree",
-  usage: "phantom where <worktree-name> [options]",
-  options: [
-    {
-      name: "--fzf",
-      type: "boolean",
-      description: "Use fzf for interactive selection"
-    }
-  ],
-  examples: [
-    {
-      description: "Get the path of a worktree",
-      command: "phantom where feature-auth"
-    },
-    {
-      description: "Change directory to a worktree",
-      command: "cd $(phantom where staging)"
-    },
-    {
-      description: "Get path with interactive fzf selection",
-      command: "phantom where --fzf"
-    },
-    {
-      description: "Change directory using fzf selection",
-      command: "cd $(phantom where --fzf)"
-    }
-  ],
-  notes: [
-    "Outputs only the path, making it suitable for use in scripts",
-    "Exits with an error code if the worktree doesn't exist",
-    "With --fzf, you can interactively select the worktree"
-  ]
-};
-
-// src/bin/phantom.ts
-var commands = [
-  {
-    name: "create",
-    description: "Create a new Git worktree (phantom)",
-    handler: createHandler,
-    help: createHelp
-  },
-  {
-    name: "attach",
-    description: "Attach to an existing branch by creating a new worktree",
-    handler: attachHandler,
-    help: attachHelp
-  },
-  {
-    name: "list",
-    description: "List all Git worktrees (phantoms)",
-    handler: listHandler,
-    help: listHelp
-  },
-  {
-    name: "where",
-    description: "Output the filesystem path of a specific worktree",
-    handler: whereHandler,
-    help: whereHelp
-  },
-  {
-    name: "delete",
-    description: "Delete a Git worktree (phantom)",
-    handler: deleteHandler,
-    help: deleteHelp
-  },
-  {
-    name: "exec",
-    description: "Execute a command in a worktree directory",
-    handler: execHandler,
-    help: execHelp
-  },
-  {
-    name: "shell",
-    description: "Open an interactive shell in a worktree directory",
-    handler: shellHandler,
-    help: shellHelp
-  },
-  {
-    name: "version",
-    description: "Display phantom version information",
-    handler: versionHandler,
-    help: versionHelp
-  },
-  {
-    name: "completion",
-    description: "Generate shell completion scripts",
-    handler: completionHandler,
-    help: completionHelp
-  }
-];
-function printHelp(commands2) {
-  const simpleCommands = commands2.map((cmd) => ({
-    name: cmd.name,
-    description: cmd.description
-  }));
-  console.log(helpFormatter.formatMainHelp(simpleCommands));
-}
-function findCommand(args2, commands2) {
-  if (args2.length === 0) {
-    return { command: null, remainingArgs: [] };
-  }
-  const [cmdName, ...rest] = args2;
-  const command2 = commands2.find((cmd) => cmd.name === cmdName);
-  if (!command2) {
-    return { command: null, remainingArgs: args2 };
-  }
-  if (command2.subcommands && rest.length > 0) {
-    const { command: subcommand, remainingArgs: remainingArgs2 } = findCommand(
-      rest,
-      command2.subcommands
-    );
-    if (subcommand) {
-      return { command: subcommand, remainingArgs: remainingArgs2 };
-    }
-  }
-  return { command: command2, remainingArgs: rest };
-}
-var args = argv.slice(2);
-if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
-  printHelp(commands);
-  exit2(0);
-}
-if (args[0] === "--version" || args[0] === "-v") {
-  versionHandler();
-  exit2(0);
-}
-var { command, remainingArgs } = findCommand(args, commands);
-if (!command || !command.handler) {
-  console.error(`Error: Unknown command '${args.join(" ")}'
-`);
-  printHelp(commands);
-  exit2(1);
-}
-if (remainingArgs.includes("--help") || remainingArgs.includes("-h")) {
-  if (command.help) {
-    console.log(helpFormatter.formatCommandHelp(command.help));
-  } else {
-    console.log(`Help not available for command '${command.name}'`);
-  }
-  exit2(0);
-}
-try {
-  await command.handler(remainingArgs);
-} catch (error) {
-  console.error(
-    "Error:",
-    error instanceof Error ? error.message : String(error)
-  );
-  exit2(1);
-}
-//# sourceMappingURL=phantom.js.map