@aku11i/phantom 1.2.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aku11i/phantom",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "A powerful CLI tool for managing Git worktrees for parallel development",
   "keywords": [
     "git",
@@ -31,5 +31,8 @@
     "README.md",
     "LICENSE"
   ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "dependencies": {}
 }

package/phantom.js

@@ -131,19 +131,6 @@ import { argv, exit as exit2 } from "node:process";
 // src/handlers/attach.ts
 import { parseArgs } from "node:util";
 
-// ../core/src/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);
-}
-
-// ../core/src/config/loader.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-
 // ../shared/src/types/result.ts
 var ok = (value) => ({
   ok: true,
@@ -164,6 +151,10 @@ var exitCodes = {
   validationError: 3
 };
 
+// ../core/src/config/loader.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+
 // ../../node_modules/.pnpm/zod@3.25.64/node_modules/zod/dist/esm/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -4211,13 +4202,16 @@ var phantomConfigSchema = external_exports.object({
   postCreate: external_exports.object({
     copyFiles: external_exports.array(external_exports.string()).optional(),
     commands: external_exports.array(external_exports.string()).optional()
-  }).passthrough().optional()
+  }).passthrough().optional(),
+  preDelete: external_exports.object({
+    commands: external_exports.array(external_exports.string()).optional()
+  }).passthrough().optional(),
+  worktreesDirectory: external_exports.string().optional()
 }).passthrough();
 function validateConfig(config) {
   const result = phantomConfigSchema.safeParse(config);
   if (!result.success) {
     const error = result.error;
-    const formattedError = error.format();
     const firstError = error.errors[0];
     const path3 = firstError.path.join(".");
     const message = path3 ? `${path3}: ${firstError.message}` : firstError.message;
@@ -4265,6 +4259,30 @@ async function loadConfig(gitRoot) {
   }
 }
 
+// ../core/src/paths.ts
+import { isAbsolute, join } from "node:path";
+function getWorktreesDirectory(gitRoot, worktreesDirectory) {
+  if (worktreesDirectory) {
+    return isAbsolute(worktreesDirectory) ? worktreesDirectory : join(gitRoot, worktreesDirectory);
+  }
+  return join(gitRoot, ".git", "phantom", "worktrees");
+}
+function getWorktreePathFromDirectory(worktreeDirectory, name) {
+  return join(worktreeDirectory, name);
+}
+
+// ../core/src/context.ts
+async function createContext(gitRoot) {
+  const configResult = await loadConfig(gitRoot);
+  const config = isOk(configResult) ? configResult.value : null;
+  const worktreesDirectory = config?.worktreesDirectory;
+  return {
+    gitRoot,
+    worktreesDirectory: getWorktreesDirectory(gitRoot, worktreesDirectory),
+    config
+  };
+}
+
 // ../core/src/worktree/errors.ts
 var WorktreeError = class extends Error {
   constructor(message) {
@@ -4387,7 +4405,7 @@ async function fetch(options = {}) {
 }
 
 // ../git/src/libs/list-worktrees.ts
-async function listWorktrees(gitRoot) {
+async function listWorktrees(_gitRoot) {
   const { stdout: stdout2 } = await executeGitCommand([
     "worktree",
     "list",
@@ -4517,10 +4535,170 @@ async function copyFiles(sourceDir, targetDir, files) {
   return ok({ copiedFiles, skippedFiles });
 }
 
+// ../process/src/errors.ts
+var ProcessError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = this.constructor.name;
+    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";
+  }
+};
+
+// ../process/src/spawn.ts
+import {
+  spawn as nodeSpawn
+} from "node:child_process";
+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)));
+        }
+      }
+    });
+  });
+}
+
+// ../process/src/tmux.ts
+async function isInsideTmux() {
+  return process.env.TMUX !== void 0;
+}
+async function executeTmuxCommand(options) {
+  const { direction, command: command2, args: args2, cwd, env, windowName } = options;
+  const tmuxArgs = [];
+  switch (direction) {
+    case "new":
+      tmuxArgs.push("new-window");
+      if (windowName) {
+        tmuxArgs.push("-n", windowName);
+      }
+      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);
+  if (args2 && args2.length > 0) {
+    tmuxArgs.push(...args2);
+  }
+  const result = await spawnProcess({
+    command: "tmux",
+    args: tmuxArgs
+  });
+  return result;
+}
+
+// ../process/src/env.ts
+function getPhantomEnv(worktreeName, worktreePath) {
+  return {
+    PHANTOM: "1",
+    PHANTOM_NAME: worktreeName,
+    PHANTOM_PATH: worktreePath
+  };
+}
+
+// ../process/src/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();
+  });
+}
+
 // ../core/src/worktree/validate.ts
 import fs2 from "node:fs/promises";
-async function validateWorktreeExists(gitRoot, name) {
-  const worktreePath = getWorktreePath(gitRoot, name);
+async function validateWorktreeExists(_gitRoot, worktreeDirectory, name) {
+  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name);
   try {
     await fs2.access(worktreePath);
     return ok({ path: worktreePath });
@@ -4528,8 +4706,8 @@ async function validateWorktreeExists(gitRoot, name) {
     return err(new WorktreeNotFoundError(name));
   }
 }
-async function validateWorktreeDoesNotExist(gitRoot, name) {
-  const worktreePath = getWorktreePath(gitRoot, name);
+async function validateWorktreeDoesNotExist(_gitRoot, worktreeDirectory, name) {
+  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name);
   try {
     await fs2.access(worktreePath);
     return err(new WorktreeAlreadyExistsError(name));
@@ -4555,21 +4733,91 @@ function validateWorktreeName(name) {
   return ok(void 0);
 }
 
+// ../core/src/exec.ts
+async function execInWorktree(gitRoot, worktreeDirectory, worktreeName, command2, options) {
+  const validation = await validateWorktreeExists(
+    gitRoot,
+    worktreeDirectory,
+    worktreeName
+  );
+  if (isErr(validation)) {
+    return err(validation.error);
+  }
+  const worktreePath = validation.value.path;
+  const [cmd, ...args2] = command2;
+  const stdio = options?.interactive ? "inherit" : ["ignore", "inherit", "inherit"];
+  return spawnProcess({
+    command: cmd,
+    args: args2,
+    options: {
+      cwd: worktreePath,
+      stdio
+    }
+  });
+}
+
+// ../core/src/worktree/post-create.ts
+async function executePostCreateCommands(options) {
+  const { gitRoot, worktreesDirectory, worktreeName, commands: commands2 } = options;
+  const executedCommands = [];
+  for (const command2 of commands2) {
+    console.log(`Executing: ${command2}`);
+    const shell = process.env.SHELL || "/bin/sh";
+    const cmdResult = await execInWorktree(
+      gitRoot,
+      worktreesDirectory,
+      worktreeName,
+      [shell, "-c", command2]
+    );
+    if (isErr(cmdResult)) {
+      const errorMessage = cmdResult.error instanceof Error ? cmdResult.error.message : String(cmdResult.error);
+      return err(
+        new Error(
+          `Failed to execute post-create command "${command2}": ${errorMessage}`
+        )
+      );
+    }
+    if (cmdResult.value.exitCode !== 0) {
+      return err(
+        new Error(
+          `Post-create command failed with exit code ${cmdResult.value.exitCode}: ${command2}`
+        )
+      );
+    }
+    executedCommands.push(command2);
+  }
+  return ok({ executedCommands });
+}
+async function copyFilesToWorktree(gitRoot, worktreesDirectory, worktreeName, filesToCopy) {
+  const worktreePath = getWorktreePathFromDirectory(
+    worktreesDirectory,
+    worktreeName
+  );
+  const copyResult = await copyFiles(gitRoot, worktreePath, filesToCopy);
+  if (isErr(copyResult)) {
+    return err(copyResult.error);
+  }
+  return ok(void 0);
+}
+
 // ../core/src/worktree/create.ts
-async function createWorktree(gitRoot, name, options = {}) {
+async function createWorktree(gitRoot, worktreeDirectory, name, options, postCreateCopyFiles, postCreateCommands) {
   const nameValidation = validateWorktreeName(name);
   if (isErr(nameValidation)) {
     return nameValidation;
   }
   const { branch = name, base = "HEAD" } = options;
-  const worktreesPath = getPhantomDirectory(gitRoot);
-  const worktreePath = getWorktreePath(gitRoot, name);
+  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name);
   try {
-    await fs3.access(worktreesPath);
+    await fs3.access(worktreeDirectory);
   } catch {
-    await fs3.mkdir(worktreesPath, { recursive: true });
+    await fs3.mkdir(worktreeDirectory, { recursive: true });
   }
-  const validation = await validateWorktreeDoesNotExist(gitRoot, name);
+  const validation = await validateWorktreeDoesNotExist(
+    gitRoot,
+    worktreeDirectory,
+    name
+  );
   if (isErr(validation)) {
     return err(validation.error);
   }
@@ -4595,6 +4843,31 @@ async function createWorktree(gitRoot, name, options = {}) {
         copyError = copyResult.error.message;
       }
     }
+    if (postCreateCopyFiles && postCreateCopyFiles.length > 0) {
+      const copyResult = await copyFilesToWorktree(
+        gitRoot,
+        worktreeDirectory,
+        name,
+        postCreateCopyFiles
+      );
+      if (isErr(copyResult)) {
+        if (!copyError) {
+          copyError = copyResult.error.message;
+        }
+      }
+    }
+    if (postCreateCommands && postCreateCommands.length > 0) {
+      console.log("\nRunning post-create commands...");
+      const commandsResult = await executePostCreateCommands({
+        gitRoot,
+        worktreesDirectory: worktreeDirectory,
+        worktreeName: name,
+        commands: postCreateCommands
+      });
+      if (isErr(commandsResult)) {
+        return err(new WorktreeError(commandsResult.error.message));
+      }
+    }
     return ok({
       message: `Created worktree '${name}' at ${worktreePath}`,
       path: worktreePath,
@@ -4608,6 +4881,39 @@ async function createWorktree(gitRoot, name, options = {}) {
   }
 }
 
+// ../core/src/worktree/pre-delete.ts
+async function executePreDeleteCommands(options) {
+  const { gitRoot, worktreesDirectory, worktreeName, commands: commands2 } = options;
+  const executedCommands = [];
+  for (const command2 of commands2) {
+    console.log(`Executing pre-delete command: ${command2}`);
+    const shell = process.env.SHELL || "/bin/sh";
+    const cmdResult = await execInWorktree(
+      gitRoot,
+      worktreesDirectory,
+      worktreeName,
+      [shell, "-c", command2]
+    );
+    if (isErr(cmdResult)) {
+      const errorMessage = cmdResult.error instanceof Error ? cmdResult.error.message : String(cmdResult.error);
+      return err(
+        new Error(
+          `Failed to execute pre-delete command "${command2}": ${errorMessage}`
+        )
+      );
+    }
+    if (cmdResult.value.exitCode !== 0) {
+      return err(
+        new Error(
+          `Pre-delete command failed with exit code ${cmdResult.value.exitCode}: ${command2}`
+        )
+      );
+    }
+    executedCommands.push(command2);
+  }
+  return ok({ executedCommands });
+}
+
 // ../core/src/worktree/delete.ts
 async function getWorktreeChangesStatus(worktreePath) {
   try {
@@ -4629,19 +4935,14 @@ async function getWorktreeChangesStatus(worktreePath) {
   };
 }
 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");
-    }
+  const args2 = ["worktree", "remove"];
+  if (force) {
+    args2.push("--force");
   }
+  args2.push(worktreePath);
+  await executeGitCommand(args2, {
+    cwd: gitRoot
+  });
 }
 async function deleteBranch(gitRoot, branchName) {
   try {
@@ -4652,9 +4953,13 @@ async function deleteBranch(gitRoot, branchName) {
     return err(new WorktreeError(`branch delete failed: ${errorMessage}`));
   }
 }
-async function deleteWorktree(gitRoot, name, options = {}) {
-  const { force = false } = options;
-  const validation = await validateWorktreeExists(gitRoot, name);
+async function deleteWorktree(gitRoot, worktreeDirectory, name, options, preDeleteCommands) {
+  const { force = false } = options || {};
+  const validation = await validateWorktreeExists(
+    gitRoot,
+    worktreeDirectory,
+    name
+  );
   if (isErr(validation)) {
     return err(validation.error);
   }
@@ -4667,6 +4972,18 @@ async function deleteWorktree(gitRoot, name, options = {}) {
       )
     );
   }
+  if (preDeleteCommands && preDeleteCommands.length > 0) {
+    console.log("\nRunning pre-delete commands...");
+    const preDeleteResult = await executePreDeleteCommands({
+      gitRoot,
+      worktreesDirectory: worktreeDirectory,
+      worktreeName: name,
+      commands: preDeleteCommands
+    });
+    if (isErr(preDeleteResult)) {
+      return err(new WorktreeError(preDeleteResult.error.message));
+    }
+  }
   try {
     await removeWorktree(gitRoot, worktreePath, force);
     const branchName = name;
@@ -4706,12 +5023,11 @@ async function getWorktreeStatus(worktreePath) {
     return true;
   }
 }
-async function listWorktrees2(gitRoot) {
+async function listWorktrees2(gitRoot, worktreeDirectory) {
   try {
     const gitWorktrees = await listWorktrees(gitRoot);
-    const phantomDir = getPhantomDirectory(gitRoot);
     const phantomWorktrees = gitWorktrees.filter(
-      (worktree) => worktree.path.startsWith(phantomDir)
+      (worktree) => worktree.path.startsWith(worktreeDirectory)
     );
     if (phantomWorktrees.length === 0) {
       return ok({
@@ -4721,7 +5037,7 @@ async function listWorktrees2(gitRoot) {
     }
     const worktrees = await Promise.all(
       phantomWorktrees.map(async (gitWorktree) => {
-        const name = gitWorktree.path.substring(phantomDir.length + 1);
+        const name = gitWorktree.path.substring(worktreeDirectory.length + 1);
         const isClean = await getWorktreeStatus(gitWorktree.path);
         return {
           name,
@@ -4742,12 +5058,12 @@ async function listWorktrees2(gitRoot) {
 
 // ../core/src/worktree/attach.ts
 import { existsSync } from "node:fs";
-async function attachWorktreeCore(gitRoot, name) {
+async function attachWorktreeCore(gitRoot, worktreeDirectory, name, postCreateCopyFiles, postCreateCommands) {
   const validation = validateWorktreeName(name);
   if (isErr(validation)) {
     return validation;
   }
-  const worktreePath = getWorktreePath(gitRoot, name);
+  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name);
   if (existsSync(worktreePath)) {
     return err(new WorktreeAlreadyExistsError(name));
   }
@@ -4762,12 +5078,41 @@ async function attachWorktreeCore(gitRoot, name) {
   if (isErr(attachResult)) {
     return err(attachResult.error);
   }
+  if (postCreateCopyFiles && postCreateCopyFiles.length > 0) {
+    const copyResult = await copyFilesToWorktree(
+      gitRoot,
+      worktreeDirectory,
+      name,
+      postCreateCopyFiles
+    );
+    if (isErr(copyResult)) {
+      console.warn(
+        `Warning: Failed to copy some files: ${copyResult.error.message}`
+      );
+    }
+  }
+  if (postCreateCommands && postCreateCommands.length > 0) {
+    console.log("\nRunning post-create commands...");
+    const commandsResult = await executePostCreateCommands({
+      gitRoot,
+      worktreesDirectory: worktreeDirectory,
+      worktreeName: name,
+      commands: postCreateCommands
+    });
+    if (isErr(commandsResult)) {
+      return err(new WorktreeError(commandsResult.error.message));
+    }
+  }
   return ok(worktreePath);
 }
 
 // ../core/src/worktree/where.ts
-async function whereWorktree(gitRoot, name) {
-  const validation = await validateWorktreeExists(gitRoot, name);
+async function whereWorktree(gitRoot, worktreeDirectory, name) {
+  const validation = await validateWorktreeExists(
+    gitRoot,
+    worktreeDirectory,
+    name
+  );
   if (isErr(validation)) {
     return err(validation.error);
   }
@@ -4776,169 +5121,9 @@ async function whereWorktree(gitRoot, name) {
   });
 }
 
-// ../process/src/errors.ts
-var ProcessError = class extends Error {
-  exitCode;
-  constructor(message, exitCode) {
-    super(message);
-    this.name = this.constructor.name;
-    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";
-  }
-};
-
-// ../process/src/spawn.ts
-import {
-  spawn as nodeSpawn
-} from "node:child_process";
-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)));
-        }
-      }
-    });
-  });
-}
-
-// ../process/src/tmux.ts
-async function isInsideTmux() {
-  return process.env.TMUX !== void 0;
-}
-async function executeTmuxCommand(options) {
-  const { direction, command: command2, args: args2, cwd, env, windowName } = options;
-  const tmuxArgs = [];
-  switch (direction) {
-    case "new":
-      tmuxArgs.push("new-window");
-      if (windowName) {
-        tmuxArgs.push("-n", windowName);
-      }
-      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);
-  if (args2 && args2.length > 0) {
-    tmuxArgs.push(...args2);
-  }
-  const result = await spawnProcess({
-    command: "tmux",
-    args: tmuxArgs
-  });
-  return result;
-}
-
-// ../process/src/env.ts
-function getPhantomEnv(worktreeName, worktreePath) {
-  return {
-    PHANTOM: "1",
-    PHANTOM_NAME: worktreeName,
-    PHANTOM_PATH: worktreePath
-  };
-}
-
-// ../process/src/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();
-  });
-}
-
 // ../core/src/worktree/select.ts
-async function selectWorktreeWithFzf(gitRoot) {
-  const listResult = await listWorktrees2(gitRoot);
+async function selectWorktreeWithFzf(gitRoot, worktreeDirectory) {
+  const listResult = await listWorktrees2(gitRoot, worktreeDirectory);
   if (isErr(listResult)) {
     return listResult;
   }
@@ -4985,28 +5170,13 @@ async function selectWorktreeWithFzf(gitRoot) {
   };
 }
 
-// ../core/src/exec.ts
-async function execInWorktree(gitRoot, worktreeName, command2, options = {}) {
-  const validation = await validateWorktreeExists(gitRoot, worktreeName);
-  if (isErr(validation)) {
-    return err(validation.error);
-  }
-  const worktreePath = validation.value.path;
-  const [cmd, ...args2] = command2;
-  const stdio = options.interactive ? "inherit" : ["ignore", "inherit", "inherit"];
-  return spawnProcess({
-    command: cmd,
-    args: args2,
-    options: {
-      cwd: worktreePath,
-      stdio
-    }
-  });
-}
-
 // ../core/src/shell.ts
-async function shellInWorktree(gitRoot, worktreeName) {
-  const validation = await validateWorktreeExists(gitRoot, worktreeName);
+async function shellInWorktree(gitRoot, worktreeDirectory, worktreeName) {
+  const validation = await validateWorktreeExists(
+    gitRoot,
+    worktreeDirectory,
+    worktreeName
+  );
   if (isErr(validation)) {
     return err(validation.error);
   }
@@ -5085,7 +5255,14 @@ async function attachHandler(args2) {
     );
   }
   const gitRoot = await getGitRoot();
-  const result = await attachWorktreeCore(gitRoot, branchName);
+  const context = await createContext(gitRoot);
+  const result = await attachWorktreeCore(
+    context.gitRoot,
+    context.worktreesDirectory,
+    branchName,
+    context.config?.postCreate?.copyFiles,
+    context.config?.postCreate?.commands
+  );
   if (isErr(result)) {
     const error = result.error;
     if (error instanceof WorktreeAlreadyExistsError) {
@@ -5096,17 +5273,21 @@ async function attachHandler(args2) {
     }
     exitWithError(error.message, exitCodes.generalError);
   }
-  const worktreePath = result.value;
   output.log(`Attached phantom: ${branchName}`);
   if (values.shell) {
-    const shellResult = await shellInWorktree(gitRoot, branchName);
+    const shellResult = await shellInWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      branchName
+    );
     if (isErr(shellResult)) {
       exitWithError(shellResult.error.message, exitCodes.generalError);
     }
   } else if (values.exec) {
     const shell = process.env.SHELL || "/bin/sh";
     const execResult = await execInWorktree(
-      gitRoot,
+      context.gitRoot,
+      context.worktreesDirectory,
       branchName,
       [shell, "-c", values.exec],
       { interactive: true }
@@ -5618,27 +5799,26 @@ async function createHandler(args2) {
   }
   try {
     const gitRoot = await getGitRoot();
+    const context = await createContext(gitRoot);
     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 (context.config?.postCreate?.copyFiles) {
+      filesToCopy = [...context.config.postCreate.copyFiles];
     }
     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,
-      base: baseOption
-    });
+    const result = await createWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      worktreeName,
+      {
+        copyFiles: filesToCopy.length > 0 ? filesToCopy : void 0,
+        base: baseOption
+      },
+      filesToCopy.length > 0 ? filesToCopy : void 0,
+      context.config?.postCreate?.commands
+    );
     if (isErr(result)) {
       const exitCode = result.error instanceof WorktreeAlreadyExistsError ? exitCodes.validationError : exitCodes.generalError;
       exitWithError(result.error.message, exitCode);
@@ -5650,30 +5830,6 @@ async function createHandler(args2) {
 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(
         `
@@ -5681,7 +5837,8 @@ Executing command in worktree '${worktreeName}': ${execCommand}`
       );
       const shell = process.env.SHELL || "/bin/sh";
       const execResult = await execInWorktree(
-        gitRoot,
+        context.gitRoot,
+        context.worktreesDirectory,
         worktreeName,
         [shell, "-c", execCommand],
         { interactive: true }
@@ -5699,7 +5856,11 @@ Executing command in worktree '${worktreeName}': ${execCommand}`
 Entering worktree '${worktreeName}' at ${result.value.path}`
       );
       output.log("Type 'exit' to return to your original directory\n");
-      const shellResult = await shellInWorktree(gitRoot, worktreeName);
+      const shellResult = await shellInWorktree(
+        context.gitRoot,
+        context.worktreesDirectory,
+        worktreeName
+      );
       if (isErr(shellResult)) {
         output.error(shellResult.error.message);
         const exitCode = "exitCode" in shellResult.error ? shellResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
@@ -5779,6 +5940,7 @@ async function deleteHandler(args2) {
   const forceDelete = values.force ?? false;
   try {
     const gitRoot = await getGitRoot();
+    const context = await createContext(gitRoot);
     let worktreeName;
     if (deleteCurrent) {
       const currentWorktree = await getCurrentWorktree(gitRoot);
@@ -5790,7 +5952,10 @@ async function deleteHandler(args2) {
       }
       worktreeName = currentWorktree;
     } else if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
+      const selectResult = await selectWorktreeWithFzf(
+        context.gitRoot,
+        context.worktreesDirectory
+      );
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -5801,9 +5966,15 @@ async function deleteHandler(args2) {
     } else {
       worktreeName = positionals[0];
     }
-    const result = await deleteWorktree(gitRoot, worktreeName, {
-      force: forceDelete
-    });
+    const result = await deleteWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      worktreeName,
+      {
+        force: forceDelete
+      },
+      context.config?.preDelete?.commands
+    );
     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);
@@ -5878,6 +6049,7 @@ async function execHandler(args2) {
   }
   try {
     const gitRoot = await getGitRoot();
+    const context = await createContext(gitRoot);
     if (tmuxOption && !await isInsideTmux()) {
       exitWithError(
         "The --tmux option can only be used inside a tmux session",
@@ -5886,7 +6058,10 @@ async function execHandler(args2) {
     }
     let worktreeName;
     if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
+      const selectResult = await selectWorktreeWithFzf(
+        context.gitRoot,
+        context.worktreesDirectory
+      );
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -5897,7 +6072,11 @@ async function execHandler(args2) {
     } else {
       worktreeName = positionals[0];
     }
-    const validation = await validateWorktreeExists(gitRoot, worktreeName);
+    const validation = await validateWorktreeExists(
+      context.gitRoot,
+      context.worktreesDirectory,
+      worktreeName
+    );
     if (isErr(validation)) {
       exitWithError(validation.error.message, exitCodes.generalError);
     }
@@ -5922,7 +6101,8 @@ async function execHandler(args2) {
       exitWithSuccess();
     }
     const result = await execInWorktree(
-      gitRoot,
+      context.gitRoot,
+      context.worktreesDirectory,
       worktreeName,
       commandArgs,
       { interactive: true }
@@ -9387,36 +9567,62 @@ async function checkoutIssue(issue, base) {
     );
   }
   const gitRoot = await getGitRoot();
-  const worktreeName = `issue-${issue.number}`;
-  const branchName = `issue-${issue.number}`;
-  const worktreePath = getWorktreePath(gitRoot, worktreeName);
-  const result = await createWorktree(gitRoot, worktreeName, {
-    branch: branchName,
-    base
-  });
+  const context = await createContext(gitRoot);
+  const worktreeName = `issues/${issue.number}`;
+  const branchName = `issues/${issue.number}`;
+  const existsResult = await validateWorktreeExists(
+    context.gitRoot,
+    context.worktreesDirectory,
+    worktreeName
+  );
+  if (!isErr(existsResult)) {
+    return ok({
+      message: `Issue #${issue.number} is already checked out`,
+      worktree: worktreeName,
+      path: existsResult.value.path,
+      alreadyExists: true
+    });
+  }
+  const result = await createWorktree(
+    context.gitRoot,
+    context.worktreesDirectory,
+    worktreeName,
+    {
+      branch: branchName,
+      base
+    },
+    context.config?.postCreate?.copyFiles,
+    context.config?.postCreate?.commands
+  );
   if (isErr(result)) {
-    if (result.error instanceof WorktreeAlreadyExistsError) {
-      return ok({
-        message: `Worktree for issue #${issue.number} is already checked out`,
-        worktree: worktreeName,
-        path: worktreePath,
-        alreadyExists: true
-      });
-    }
     return err(result.error);
   }
   return ok({
     message: result.value.message,
     worktree: worktreeName,
-    path: worktreePath
+    path: result.value.path
   });
 }
 
 // ../github/src/checkout/pr.ts
 async function checkoutPullRequest(pullRequest) {
   const gitRoot = await getGitRoot();
-  const worktreeName = `pr-${pullRequest.number}`;
-  const localBranch = `pr-${pullRequest.number}`;
+  const context = await createContext(gitRoot);
+  const worktreeName = `pulls/${pullRequest.number}`;
+  const localBranch = `pulls/${pullRequest.number}`;
+  const existsResult = await validateWorktreeExists(
+    context.gitRoot,
+    context.worktreesDirectory,
+    worktreeName
+  );
+  if (!isErr(existsResult)) {
+    return ok({
+      message: `PR #${pullRequest.number} is already checked out`,
+      worktree: worktreeName,
+      path: existsResult.value.path,
+      alreadyExists: true
+    });
+  }
   const upstream = pullRequest.isFromFork ? `origin/pull/${pullRequest.number}/head` : `origin/${pullRequest.head.ref}`;
   const refspec = `${upstream.replace("origin/", "")}:${localBranch}`;
   const fetchResult = await fetch({ refspec });
@@ -9437,24 +9643,21 @@ async function checkoutPullRequest(pullRequest) {
       `Warning: Could not set upstream branch: ${setUpstreamResult.error.message}`
     );
   }
-  const attachResult = await attachWorktreeCore(gitRoot, worktreeName);
-  const worktreePath = getWorktreePath(gitRoot, worktreeName);
+  const attachResult = await attachWorktreeCore(
+    context.gitRoot,
+    context.worktreesDirectory,
+    worktreeName,
+    context.config?.postCreate?.copyFiles,
+    context.config?.postCreate?.commands
+  );
   if (isErr(attachResult)) {
-    if (attachResult.error instanceof WorktreeAlreadyExistsError) {
-      return ok({
-        message: `Worktree for PR #${pullRequest.number} is already checked out`,
-        worktree: worktreeName,
-        path: worktreePath,
-        alreadyExists: true
-      });
-    }
     return err(attachResult.error);
   }
   const message = pullRequest.isFromFork ? `Checked out PR #${pullRequest.number} from fork ${pullRequest.head.repo.full_name}` : `Checked out PR #${pullRequest.number} from branch ${pullRequest.head.ref}`;
   return ok({
     message,
     worktree: worktreeName,
-    path: worktreePath
+    path: attachResult.value
   });
 }
 
@@ -9707,8 +9910,8 @@ var githubCheckoutHelp = {
     }
   ],
   notes: [
-    "For PRs: Creates worktree named 'pr-{number}' with the PR's branch",
-    "For Issues: Creates worktree named 'issue-{number}' with a new branch",
+    "For PRs: Creates worktree named 'pulls/{number}' with the PR's branch",
+    "For Issues: Creates worktree named 'issues/{number}' with a new branch",
     "",
     "Requirements:",
     "  - GitHub CLI (gh) must be installed",
@@ -9745,8 +9948,12 @@ async function listHandler(args2 = []) {
   });
   try {
     const gitRoot = await getGitRoot();
+    const context = await createContext(gitRoot);
     if (values.fzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
+      const selectResult = await selectWorktreeWithFzf(
+        context.gitRoot,
+        context.worktreesDirectory
+      );
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -9754,7 +9961,10 @@ async function listHandler(args2 = []) {
         output.log(selectResult.value.name);
       }
     } else {
-      const result = await listWorktrees2(gitRoot);
+      const result = await listWorktrees2(
+        context.gitRoot,
+        context.worktreesDirectory
+      );
       if (isErr(result)) {
         exitWithError("Failed to list worktrees", exitCodes.generalError);
       }
@@ -13057,7 +13267,7 @@ var StdioServerTransport = class {
 // ../mcp/package.json
 var package_default = {
   name: "@aku11i/phantom-mcp",
-  version: "1.2.0",
+  version: "2.0.0",
   private: true,
   type: "module",
   main: "./src/index.ts",
@@ -13092,10 +13302,18 @@ var createWorktreeTool = {
   inputSchema: schema,
   handler: async ({ name, baseBranch }) => {
     const gitRoot = await getGitRoot();
-    const result = await createWorktree(gitRoot, name, {
-      branch: name,
-      base: baseBranch
-    });
+    const context = await createContext(gitRoot);
+    const result = await createWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      name,
+      {
+        branch: name,
+        base: baseBranch
+      },
+      context.config?.postCreate?.copyFiles,
+      context.config?.postCreate?.commands
+    );
     if (!isOk(result)) {
       throw new Error(result.error.message);
     }
@@ -13130,7 +13348,16 @@ var deleteWorktreeTool = {
   inputSchema: schema2,
   handler: async ({ name, force }) => {
     const gitRoot = await getGitRoot();
-    const result = await deleteWorktree(gitRoot, name, { force });
+    const context = await createContext(gitRoot);
+    const result = await deleteWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      name,
+      {
+        force
+      },
+      context.config?.preDelete?.commands
+    );
     if (!isOk(result)) {
       throw new Error(result.error.message);
     }
@@ -13195,7 +13422,11 @@ var listWorktreesTool = {
   inputSchema: schema4,
   handler: async () => {
     const gitRoot = await getGitRoot();
-    const result = await listWorktrees2(gitRoot);
+    const context = await createContext(gitRoot);
+    const result = await listWorktrees2(
+      context.gitRoot,
+      context.worktreesDirectory
+    );
     if (!isOk(result)) {
       throw new Error("Failed to list worktrees");
     }
@@ -13370,6 +13601,7 @@ async function shellHandler(args2) {
   let worktreeName;
   try {
     const gitRoot = await getGitRoot();
+    const context = await createContext(gitRoot);
     if (tmuxOption && !await isInsideTmux()) {
       exitWithError(
         "The --tmux option can only be used inside a tmux session",
@@ -13377,7 +13609,10 @@ async function shellHandler(args2) {
       );
     }
     if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(gitRoot);
+      const selectResult = await selectWorktreeWithFzf(
+        context.gitRoot,
+        context.worktreesDirectory
+      );
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -13388,7 +13623,11 @@ async function shellHandler(args2) {
     } else {
       worktreeName = positionals[0];
     }
-    const validation = await validateWorktreeExists(gitRoot, worktreeName);
+    const validation = await validateWorktreeExists(
+      context.gitRoot,
+      context.worktreesDirectory,
+      worktreeName
+    );
     if (isErr(validation)) {
       exitWithError(validation.error.message, exitCodes.generalError);
     }
@@ -13415,7 +13654,11 @@ async function shellHandler(args2) {
       `Entering worktree '${worktreeName}' at ${validation.value.path}`
     );
     output.log("Type 'exit' to return to your original directory\n");
-    const result = await shellInWorktree(gitRoot, worktreeName);
+    const result = await shellInWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      worktreeName
+    );
     if (isErr(result)) {
       const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.notFound : result.error.exitCode || exitCodes.generalError;
       exitWithError(result.error.message, exitCode);
@@ -13435,7 +13678,7 @@ import { parseArgs as parseArgs9 } from "node:util";
 // package.json
 var package_default2 = {
   name: "@aku11i/phantom-cli",
-  version: "1.2.0",
+  version: "2.0.0",
   private: true,
   type: "module",
   scripts: {
@@ -13511,8 +13754,12 @@ async function whereHandler(args2) {
       exitCodes.generalError
     );
   }
+  const context = await createContext(gitRoot);
   if (useFzf) {
-    const selectResult = await selectWorktreeWithFzf(gitRoot);
+    const selectResult = await selectWorktreeWithFzf(
+      context.gitRoot,
+      context.worktreesDirectory
+    );
     if (isErr(selectResult)) {
       exitWithError(selectResult.error.message, exitCodes.generalError);
     }
@@ -13523,7 +13770,11 @@ async function whereHandler(args2) {
   } else {
     worktreeName = positionals[0];
   }
-  const result = await whereWorktree(gitRoot, worktreeName);
+  const result = await whereWorktree(
+    context.gitRoot,
+    context.worktreesDirectory,
+    worktreeName
+  );
   if (isErr(result)) {
     exitWithError(result.error.message, exitCodes.notFound);
   }