@aku11i/phantom 3.0.1 → 3.1.0

package/phantom.js

@@ -3684,49 +3684,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative, options, skipNormalization) {
+    function resolveComponent(base, relative2, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse4(serialize(base, options), options);
-        relative = parse4(serialize(relative, options), options);
+        relative2 = parse4(serialize(relative2, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative.scheme) {
-        target.scheme = relative.scheme;
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (!options.tolerant && relative2.scheme) {
+        target.scheme = relative2.scheme;
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
-          target.userinfo = relative.userinfo;
-          target.host = relative.host;
-          target.port = relative.port;
-          target.path = removeDotSegments(relative.path || "");
-          target.query = relative.query;
+        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
+          target.userinfo = relative2.userinfo;
+          target.host = relative2.host;
+          target.port = relative2.port;
+          target.path = removeDotSegments(relative2.path || "");
+          target.query = relative2.query;
         } else {
-          if (!relative.path) {
+          if (!relative2.path) {
             target.path = base.path;
-            if (relative.query !== void 0) {
-              target.query = relative.query;
+            if (relative2.query !== void 0) {
+              target.query = relative2.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative.path[0] === "/") {
-              target.path = removeDotSegments(relative.path);
+            if (relative2.path[0] === "/") {
+              target.path = removeDotSegments(relative2.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative.path;
+                target.path = "/" + relative2.path;
               } else if (!base.path) {
-                target.path = relative.path;
+                target.path = relative2.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative.query;
+            target.query = relative2.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3734,7 +3734,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative.fragment;
+      target.fragment = relative2.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -6891,6 +6891,18 @@ import { argv, exit as exit2 } from "node:process";
 // src/handlers/attach.ts
 import { parseArgs } from "node:util";
 
+// ../core/src/config/loader.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// ../shared/src/constants/exit-codes.ts
+var exitCodes = {
+  success: 0,
+  generalError: 1,
+  notFound: 2,
+  validationError: 3
+};
+
 // ../shared/src/types/result.ts
 var ok = (value) => ({
   ok: true,
@@ -6903,18 +6915,6 @@ var err = (error2) => ({
 var isOk = (result) => result.ok;
 var isErr = (result) => !result.ok;
 
-// ../shared/src/constants/exit-codes.ts
-var exitCodes = {
-  success: 0,
-  generalError: 1,
-  notFound: 2,
-  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, {
@@ -11043,6 +11043,169 @@ async function createContext(gitRoot) {
   };
 }
 
+// ../process/src/env.ts
+function getPhantomEnv(worktreeName, worktreePath) {
+  return {
+    PHANTOM: "1",
+    PHANTOM_NAME: worktreeName,
+    PHANTOM_PATH: worktreePath
+  };
+}
+
+// ../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/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", (error2) => {
+      if (error2.message.includes("ENOENT")) {
+        resolve2(
+          err(new Error("fzf command not found. Please install fzf first."))
+        );
+      } else {
+        resolve2(err(error2));
+      }
+    });
+    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();
+  });
+}
+
+// ../process/src/spawn.ts
+import {
+  spawn as nodeSpawn
+} from "node:child_process";
+async function spawnProcess(config2) {
+  return new Promise((resolve2) => {
+    const { command: command2, args: args2 = [], options = {} } = config2;
+    const childProcess = nodeSpawn(command2, args2, {
+      stdio: "inherit",
+      ...options
+    });
+    childProcess.on("error", (error2) => {
+      resolve2(err(new ProcessSpawnError(command2, error2.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;
+}
+
+// ../core/src/worktree/validate.ts
+import fs2 from "node:fs/promises";
+
 // ../core/src/worktree/errors.ts
 var WorktreeError = class extends Error {
   constructor(message) {
@@ -11069,8 +11232,8 @@ var BranchNotFoundError = class extends WorktreeError {
   }
 };
 
-// ../core/src/worktree/create.ts
-import fs3 from "node:fs/promises";
+// ../core/src/worktree/list.ts
+import { relative } from "node:path";
 
 // ../git/src/executor.ts
 import { execFile as execFileCallback } from "node:child_process";
@@ -11252,234 +11415,86 @@ async function setUpstreamBranch(gitRoot, branch, upstream) {
   }
 }
 
-// ../core/src/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 (error2) {
-      if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
-        skippedFiles.push(file);
-      } else {
-        return err(
-          new FileCopyError(
-            file,
-            error2 instanceof Error ? error2.message : String(error2)
-          )
-        );
-      }
-    }
+// ../core/src/worktree/list.ts
+async function getWorktreeStatus(worktreePath) {
+  try {
+    const { stdout: stdout2 } = await executeGitCommandInDirectory(worktreePath, [
+      "status",
+      "--porcelain"
+    ]);
+    return !stdout2;
+  } catch {
+    return true;
   }
-  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(config2) {
-  return new Promise((resolve2) => {
-    const { command: command2, args: args2 = [], options = {} } = config2;
-    const childProcess = nodeSpawn(command2, args2, {
-      stdio: "inherit",
-      ...options
-    });
-    childProcess.on("error", (error2) => {
-      resolve2(err(new ProcessSpawnError(command2, error2.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();
+async function listWorktrees2(gitRoot) {
+  try {
+    const gitWorktrees = await listWorktrees(gitRoot);
+    const filteredWorktrees = gitWorktrees.filter(
+      (worktree) => Boolean(relative(gitRoot, worktree.path))
+    );
+    if (filteredWorktrees.length === 0) {
+      return ok({
+        worktrees: [],
+        message: "No worktrees found"
       });
     }
-    fzf.on("error", (error2) => {
-      if (error2.message.includes("ENOENT")) {
-        resolve2(
-          err(new Error("fzf command not found. Please install fzf first."))
-        );
-      } else {
-        resolve2(err(error2));
-      }
-    });
-    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}`)));
-      }
+    const worktrees = await Promise.all(
+      filteredWorktrees.map(async (gitWorktree) => {
+        const shortHead = gitWorktree.head?.slice(0, 7) ?? "HEAD";
+        const branchName = gitWorktree.branch && gitWorktree.branch !== "(detached HEAD)" ? gitWorktree.branch : shortHead;
+        const isClean = await getWorktreeStatus(gitWorktree.path);
+        const pathToDisplay = relative(process.cwd(), gitWorktree.path) || ".";
+        return {
+          name: branchName,
+          path: gitWorktree.path,
+          pathToDisplay,
+          branch: branchName,
+          isClean
+        };
+      })
+    );
+    return ok({
+      worktrees
     });
-    fzf.stdin.write(items.join("\n"));
-    fzf.stdin.end();
-  });
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`Failed to list worktrees: ${errorMessage}`);
+  }
 }
 
 // ../core/src/worktree/validate.ts
-import fs2 from "node:fs/promises";
-async function validateWorktreeExists(_gitRoot, worktreeDirectory, name) {
-  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name);
-  try {
-    await fs2.access(worktreePath);
-    return ok({ path: worktreePath });
-  } catch {
+async function validateWorktreeExists(gitRoot, _worktreeDirectory, name) {
+  const worktreesResult = await listWorktrees2(gitRoot);
+  if (isErr(worktreesResult)) {
+    return err(new WorktreeNotFoundError(name));
+  }
+  const worktree = worktreesResult.value.worktrees.find(
+    (wt) => wt.name === name
+  );
+  if (!worktree) {
     return err(new WorktreeNotFoundError(name));
   }
+  return ok({ path: worktree.path });
 }
-async function validateWorktreeDoesNotExist(_gitRoot, worktreeDirectory, name) {
-  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name);
-  try {
-    await fs2.access(worktreePath);
+async function validateWorktreeDoesNotExist(gitRoot, _worktreeDirectory, name) {
+  const worktreesResult = await listWorktrees2(gitRoot);
+  if (isErr(worktreesResult)) {
     return err(new WorktreeAlreadyExistsError(name));
-  } catch {
-    return ok({ path: worktreePath });
   }
+  const worktree = worktreesResult.value.worktrees.find(
+    (wt) => wt.name === name
+  );
+  if (worktree) {
+    return err(new WorktreeAlreadyExistsError(name));
+  }
+  return ok(void 0);
 }
 function validateWorktreeName(name) {
   if (!name || name.trim() === "") {
     return err(new Error("Phantom name cannot be empty"));
   }
-  const validNamePattern = /^[a-zA-Z0-9\-_.\/]+$/;
+  const validNamePattern = /^[a-zA-Z0-9\-_./]+$/;
   if (!validNamePattern.test(name)) {
     return err(
       new Error(
@@ -11516,6 +11531,77 @@ async function execInWorktree(gitRoot, worktreeDirectory, worktreeName, command2
   });
 }
 
+// ../core/src/shell.ts
+async function shellInWorktree(gitRoot, worktreeDirectory, worktreeName) {
+  const validation = await validateWorktreeExists(
+    gitRoot,
+    worktreeDirectory,
+    worktreeName
+  );
+  if (isErr(validation)) {
+    return err(validation.error);
+  }
+  const worktreePath = validation.value.path;
+  const shell = process.env.SHELL || "/bin/sh";
+  return spawnProcess({
+    command: shell,
+    args: [],
+    options: {
+      cwd: worktreePath,
+      env: {
+        ...process.env,
+        ...getPhantomEnv(worktreeName, worktreePath)
+      }
+    }
+  });
+}
+
+// ../core/src/worktree/attach.ts
+import { existsSync } from "node:fs";
+
+// ../core/src/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 (error2) {
+      if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
+        skippedFiles.push(file);
+      } else {
+        return err(
+          new FileCopyError(
+            file,
+            error2 instanceof Error ? error2.message : String(error2)
+          )
+        );
+      }
+    }
+  }
+  return ok({ copiedFiles, skippedFiles });
+}
+
 // ../core/src/worktree/post-create.ts
 async function executePostCreateCommands(options) {
   const { gitRoot, worktreesDirectory, worktreeName, commands: commands2 } = options;
@@ -11560,7 +11646,57 @@ async function copyFilesToWorktree(gitRoot, worktreesDirectory, worktreeName, fi
   return ok(void 0);
 }
 
+// ../core/src/worktree/attach.ts
+async function attachWorktreeCore(gitRoot, worktreeDirectory, name, postCreateCopyFiles, postCreateCommands) {
+  const validation = validateWorktreeName(name);
+  if (isErr(validation)) {
+    return validation;
+  }
+  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, 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);
+  }
+  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/create.ts
+import fs3 from "node:fs/promises";
 async function createWorktree(gitRoot, worktreeDirectory, name, options, postCreateCopyFiles, postCreateCommands) {
   const nameValidation = validateWorktreeName(name);
   if (isErr(nameValidation)) {
@@ -11687,187 +11823,34 @@ async function getWorktreeChangesStatus(worktreePath) {
         changedFiles: stdout2.split("\n").length
       };
     }
-  } catch {
-  }
-  return {
-    hasUncommittedChanges: false,
-    changedFiles: 0
-  };
-}
-async function removeWorktree(gitRoot, worktreePath, force = false) {
-  const args2 = ["worktree", "remove"];
-  if (force) {
-    args2.push("--force");
-  }
-  args2.push(worktreePath);
-  await executeGitCommand(args2, {
-    cwd: gitRoot
-  });
-}
-async function deleteBranch(gitRoot, branchName) {
-  try {
-    await executeGitCommand(["branch", "-D", branchName], { cwd: gitRoot });
-    return ok(true);
-  } catch (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    return err(new WorktreeError(`branch delete failed: ${errorMessage}`));
-  }
-}
-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);
-  }
-  const worktreePath = validation.value.path;
-  const status = await getWorktreeChangesStatus(worktreePath);
-  if (status.hasUncommittedChanges && !force) {
-    return err(
-      new WorktreeError(
-        `Worktree '${name}' has uncommitted changes (${status.changedFiles} files). Use --force to delete anyway.`
-      )
-    );
-  }
-  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;
-    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 (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    return err(new WorktreeError(`worktree remove failed: ${errorMessage}`));
-  }
-}
-
-// ../core/src/worktree/list.ts
-async function getWorktreeStatus(worktreePath) {
-  try {
-    const { stdout: stdout2 } = await executeGitCommandInDirectory(worktreePath, [
-      "status",
-      "--porcelain"
-    ]);
-    return !stdout2;
-  } catch {
-    return true;
-  }
-}
-async function listWorktrees2(gitRoot, worktreeDirectory) {
-  try {
-    const gitWorktrees = await listWorktrees(gitRoot);
-    const phantomWorktrees = gitWorktrees.filter(
-      (worktree) => worktree.path.startsWith(worktreeDirectory)
-    );
-    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(worktreeDirectory.length + 1);
-        const isClean = await getWorktreeStatus(gitWorktree.path);
-        return {
-          name,
-          path: gitWorktree.path,
-          branch: gitWorktree.branch || "(detached HEAD)",
-          isClean
-        };
-      })
-    );
-    return ok({
-      worktrees
-    });
-  } catch (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    throw new Error(`Failed to list worktrees: ${errorMessage}`);
-  }
-}
-
-// ../core/src/worktree/attach.ts
-import { existsSync } from "node:fs";
-async function attachWorktreeCore(gitRoot, worktreeDirectory, name, postCreateCopyFiles, postCreateCommands) {
-  const validation = validateWorktreeName(name);
-  if (isErr(validation)) {
-    return validation;
-  }
-  const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, 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);
-  }
-  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}`
-      );
-    }
+  } catch {
   }
-  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 {
+    hasUncommittedChanges: false,
+    changedFiles: 0
+  };
+}
+async function removeWorktree(gitRoot, worktreePath, force = false) {
+  const args2 = ["worktree", "remove"];
+  if (force) {
+    args2.push("--force");
   }
-  return ok(worktreePath);
+  args2.push(worktreePath);
+  await executeGitCommand(args2, {
+    cwd: gitRoot
+  });
 }
-
-// ../core/src/worktree/where.ts
-async function whereWorktree(gitRoot, worktreeDirectory, name) {
+async function deleteBranch(gitRoot, branchName) {
+  try {
+    await executeGitCommand(["branch", "-D", branchName], { cwd: gitRoot });
+    return ok(true);
+  } catch (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    return err(new WorktreeError(`branch delete failed: ${errorMessage}`));
+  }
+}
+async function deleteWorktree(gitRoot, worktreeDirectory, name, options, preDeleteCommands) {
+  const { force = false } = options || {};
   const validation = await validateWorktreeExists(
     gitRoot,
     worktreeDirectory,
@@ -11876,14 +11859,57 @@ async function whereWorktree(gitRoot, worktreeDirectory, name) {
   if (isErr(validation)) {
     return err(validation.error);
   }
-  return ok({
-    path: validation.value.path
-  });
+  const worktreePath = validation.value.path;
+  const status = await getWorktreeChangesStatus(worktreePath);
+  if (status.hasUncommittedChanges && !force) {
+    return err(
+      new WorktreeError(
+        `Worktree '${name}' has uncommitted changes (${status.changedFiles} files). Use --force to delete anyway.`
+      )
+    );
+  }
+  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;
+    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 (error2) {
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    return err(new WorktreeError(`worktree remove failed: ${errorMessage}`));
+  }
 }
 
 // ../core/src/worktree/select.ts
-async function selectWorktreeWithFzf(gitRoot, worktreeDirectory) {
-  const listResult = await listWorktrees2(gitRoot, worktreeDirectory);
+async function selectWorktreeWithFzf(gitRoot) {
+  const listResult = await listWorktrees2(gitRoot);
   if (isErr(listResult)) {
     return listResult;
   }
@@ -11895,9 +11921,8 @@ async function selectWorktreeWithFzf(gitRoot, worktreeDirectory) {
     };
   }
   const list = worktrees.map((wt) => {
-    const branchInfo = wt.branch ? `(${wt.branch})` : "";
     const status = !wt.isClean ? " [dirty]" : "";
-    return `${wt.name} ${branchInfo}${status}`;
+    return `${wt.name} (${wt.pathToDisplay})${status}`;
   });
   const fzfResult = await selectWithFzf(list, {
     prompt: "Select worktree> ",
@@ -11930,28 +11955,18 @@ async function selectWorktreeWithFzf(gitRoot, worktreeDirectory) {
   };
 }
 
-// ../core/src/shell.ts
-async function shellInWorktree(gitRoot, worktreeDirectory, worktreeName) {
+// ../core/src/worktree/where.ts
+async function whereWorktree(gitRoot, worktreeDirectory, name) {
   const validation = await validateWorktreeExists(
     gitRoot,
     worktreeDirectory,
-    worktreeName
+    name
   );
   if (isErr(validation)) {
     return err(validation.error);
   }
-  const worktreePath = validation.value.path;
-  const shell = process.env.SHELL || "/bin/sh";
-  return spawnProcess({
-    command: shell,
-    args: [],
-    options: {
-      cwd: worktreePath,
-      env: {
-        ...process.env,
-        ...getPhantomEnv(worktreeName, worktreePath)
-      }
-    }
+  return ok({
+    path: validation.value.path
   });
 }
 
@@ -12745,10 +12760,7 @@ async function deleteHandler(args2) {
       }
       worktreeName = currentWorktree;
     } else if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(
-        context.gitRoot,
-        context.worktreesDirectory
-      );
+      const selectResult = await selectWorktreeWithFzf(context.gitRoot);
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -12838,119 +12850,299 @@ async function execHandler(args2) {
         exitCodes.validationError
       );
     }
-    commandArgs = positionals.slice(1);
+    commandArgs = positionals.slice(1);
+  }
+  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",
+        exitCodes.validationError
+      );
+    }
+    let worktreeName;
+    if (useFzf) {
+      const selectResult = await selectWorktreeWithFzf(context.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(
+      context.gitRoot,
+      context.worktreesDirectory,
+      worktreeName
+    );
+    if (isErr(validation)) {
+      exitWithError(validation.error.message, exitCodes.generalError);
+    }
+    if (tmuxDirection) {
+      output.log(
+        `Executing command in worktree '${worktreeName}' in tmux ${tmuxDirection === "new" ? "window" : "pane"}...`
+      );
+      const [command2, ...args3] = commandArgs;
+      const tmuxResult = await executeTmuxCommand({
+        direction: tmuxDirection,
+        command: command2,
+        args: args3,
+        cwd: validation.value.path,
+        env: getPhantomEnv(worktreeName, validation.value.path),
+        windowName: tmuxDirection === "new" ? worktreeName : void 0
+      });
+      if (isErr(tmuxResult)) {
+        output.error(tmuxResult.error.message);
+        const exitCode = "exitCode" in tmuxResult.error ? tmuxResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
+        exitWithError("", exitCode);
+      }
+      exitWithSuccess();
+    }
+    const result = await execInWorktree(
+      context.gitRoot,
+      context.worktreesDirectory,
+      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 (error2) {
+    exitWithError(
+      error2 instanceof Error ? error2.message : String(error2),
+      exitCodes.generalError
+    );
+  }
+}
+
+// src/help/github.ts
+var githubHelp = {
+  name: "github",
+  usage: "phantom github <subcommand> [options]",
+  description: "GitHub-specific commands for phantom",
+  examples: [
+    {
+      command: "phantom github checkout 123",
+      description: "Create a worktree for PR or issue #123"
+    },
+    {
+      command: "phantom gh checkout 456",
+      description: "Same as above, using the gh alias"
+    }
+  ],
+  notes: [
+    "Subcommands:",
+    "  checkout    Create a worktree for a GitHub PR or issue",
+    "",
+    "Alias: 'gh' can be used instead of 'github'",
+    "",
+    "Requirements:",
+    "  - GitHub CLI (gh) must be installed",
+    "  - Must be authenticated with 'gh auth login'"
+  ]
+};
+var githubCheckoutHelp = {
+  name: "github checkout",
+  usage: "phantom github checkout <number> [options]",
+  description: "Create a worktree for a GitHub PR or issue",
+  options: [
+    {
+      name: "--base",
+      type: "string",
+      description: "Base branch for new issue branches (issues only, default: repository HEAD)"
+    }
+  ],
+  examples: [
+    {
+      command: "phantom github checkout 123",
+      description: "Create a worktree for PR #123 (checks out PR branch)"
+    },
+    {
+      command: "phantom github checkout 456",
+      description: "Create a worktree for issue #456 (creates new branch)"
+    },
+    {
+      command: "phantom github checkout 789 --base develop",
+      description: "Create a worktree for issue #789 based on develop branch"
+    }
+  ],
+  notes: [
+    "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",
+    "  - Must be authenticated with 'gh auth login'"
+  ]
+};
+
+// src/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");
   }
-  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",
-        exitCodes.validationError
+  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("");
     }
-    let worktreeName;
-    if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(
-        context.gitRoot,
-        context.worktreesDirectory
-      );
-      if (isErr(selectResult)) {
-        exitWithError(selectResult.error.message, exitCodes.generalError);
+    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 (!selectResult.value) {
-        exitWithSuccess();
+    }
+    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}`);
+        }
       }
-      worktreeName = selectResult.value.name;
-    } else {
-      worktreeName = positionals[0];
+      lines.push("");
     }
-    const validation = await validateWorktreeExists(
-      context.gitRoot,
-      context.worktreesDirectory,
-      worktreeName
-    );
-    if (isErr(validation)) {
-      exitWithError(validation.error.message, exitCodes.generalError);
+    return lines.join("\n");
+  }
+  formatOptionName(option) {
+    const parts = [];
+    if (option.short) {
+      parts.push(`-${option.short},`);
     }
-    if (tmuxDirection) {
-      output.log(
-        `Executing command in worktree '${worktreeName}' in tmux ${tmuxDirection === "new" ? "window" : "pane"}...`
-      );
-      const [command2, ...args3] = commandArgs;
-      const tmuxResult = await executeTmuxCommand({
-        direction: tmuxDirection,
-        command: command2,
-        args: args3,
-        cwd: validation.value.path,
-        env: getPhantomEnv(worktreeName, validation.value.path),
-        windowName: tmuxDirection === "new" ? worktreeName : void 0
-      });
-      if (isErr(tmuxResult)) {
-        output.error(tmuxResult.error.message);
-        const exitCode = "exitCode" in tmuxResult.error ? tmuxResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError;
-        exitWithError("", exitCode);
+    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;
       }
-      exitWithSuccess();
     }
-    const result = await execInWorktree(
-      context.gitRoot,
-      context.worktreesDirectory,
-      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);
+    if (currentLine) {
+      lines.push(currentLine);
     }
-    process.exit(result.value.exitCode);
-  } catch (error2) {
-    exitWithError(
-      error2 instanceof Error ? error2.message : String(error2),
-      exitCodes.generalError
-    );
+    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/handlers/github.ts
+async function githubHandler(args2) {
+  if (args2.length === 0) {
+    console.log(helpFormatter.formatCommandHelp(githubHelp));
+    return;
   }
+  throw new Error(`Unknown github subcommand: ${args2[0]}`);
 }
 
 // src/handlers/github-checkout.ts
 import { parseArgs as parseArgs5 } from "node:util";
 
-// ../github/src/api/types.ts
-function isPullRequest(issue2) {
-  return issue2.pullRequest !== void 0;
-}
-
-// ../github/src/api/repo-info.ts
+// ../github/src/client.ts
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-var execFileAsync = promisify2(execFile2);
-var repoInfoSchema = external_exports.object({
-  owner: external_exports.string(),
-  repo: external_exports.string()
-});
-async function getGitHubRepoInfo() {
-  try {
-    const { stdout: stdout2 } = await execFileAsync("gh", [
-      "repo",
-      "view",
-      "--json",
-      "owner,name"
-    ]);
-    const data = JSON.parse(stdout2);
-    return repoInfoSchema.parse({
-      owner: data.owner.login,
-      repo: data.name
-    });
-  } catch (error2) {
-    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    throw new Error(`Failed to get repository info: ${errorMessage}`);
-  }
-}
-
-// ../github/src/client.ts
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
 
 // ../../node_modules/.pnpm/universal-user-agent@7.0.3/node_modules/universal-user-agent/index.js
 function getUserAgent() {
@@ -16480,10 +16672,10 @@ var Octokit2 = Octokit.plugin(requestLog, legacyRestEndpointMethods, paginateRes
 );
 
 // ../github/src/client.ts
-var execFileAsync2 = promisify3(execFile3);
+var execFileAsync = promisify2(execFile2);
 async function getGitHubToken() {
   try {
-    const { stdout: stdout2 } = await execFileAsync2("gh", ["auth", "token"]);
+    const { stdout: stdout2 } = await execFileAsync("gh", ["auth", "token"]);
     return stdout2.trim();
   } catch (error2) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
@@ -16546,25 +16738,57 @@ async function fetchIssue(owner, repo, number3) {
       repo,
       issue_number: issueNumber
     });
-    let pullRequest;
-    if (data.pull_request) {
-      const pr = await fetchPullRequest(owner, repo, number3);
-      if (pr) {
-        pullRequest = pr;
-      }
-    }
-    return {
-      number: data.number,
-      pullRequest
-    };
+    let pullRequest;
+    if (data.pull_request) {
+      const pr = await fetchPullRequest(owner, repo, number3);
+      if (pr) {
+        pullRequest = pr;
+      }
+    }
+    return {
+      number: data.number,
+      pullRequest
+    };
+  } catch (error2) {
+    if (error2 instanceof Error && "status" in error2 && error2.status === 404) {
+      return null;
+    }
+    throw error2;
+  }
+}
+
+// ../github/src/api/repo-info.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var execFileAsync2 = promisify3(execFile3);
+var repoInfoSchema = external_exports.object({
+  owner: external_exports.string(),
+  repo: external_exports.string()
+});
+async function getGitHubRepoInfo() {
+  try {
+    const { stdout: stdout2 } = await execFileAsync2("gh", [
+      "repo",
+      "view",
+      "--json",
+      "owner,name"
+    ]);
+    const data = JSON.parse(stdout2);
+    return repoInfoSchema.parse({
+      owner: data.owner.login,
+      repo: data.name
+    });
   } catch (error2) {
-    if (error2 instanceof Error && "status" in error2 && error2.status === 404) {
-      return null;
-    }
-    throw error2;
+    const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`Failed to get repository info: ${errorMessage}`);
   }
 }
 
+// ../github/src/api/types.ts
+function isPullRequest(issue2) {
+  return issue2.pullRequest !== void 0;
+}
+
 // ../github/src/checkout/issue.ts
 async function checkoutIssue(issue2, base) {
   if (isPullRequest(issue2)) {
@@ -16771,221 +16995,6 @@ Opening worktree '${result.value.worktree}' in tmux ${tmuxDirection === "new" ?
   }
 }
 
-// src/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/help/github.ts
-var githubHelp = {
-  name: "github",
-  usage: "phantom github <subcommand> [options]",
-  description: "GitHub-specific commands for phantom",
-  examples: [
-    {
-      command: "phantom github checkout 123",
-      description: "Create a worktree for PR or issue #123"
-    },
-    {
-      command: "phantom gh checkout 456",
-      description: "Same as above, using the gh alias"
-    }
-  ],
-  notes: [
-    "Subcommands:",
-    "  checkout    Create a worktree for a GitHub PR or issue",
-    "",
-    "Alias: 'gh' can be used instead of 'github'",
-    "",
-    "Requirements:",
-    "  - GitHub CLI (gh) must be installed",
-    "  - Must be authenticated with 'gh auth login'"
-  ]
-};
-var githubCheckoutHelp = {
-  name: "github checkout",
-  usage: "phantom github checkout <number> [options]",
-  description: "Create a worktree for a GitHub PR or issue",
-  options: [
-    {
-      name: "--base",
-      type: "string",
-      description: "Base branch for new issue branches (issues only, default: repository HEAD)"
-    }
-  ],
-  examples: [
-    {
-      command: "phantom github checkout 123",
-      description: "Create a worktree for PR #123 (checks out PR branch)"
-    },
-    {
-      command: "phantom github checkout 456",
-      description: "Create a worktree for issue #456 (creates new branch)"
-    },
-    {
-      command: "phantom github checkout 789 --base develop",
-      description: "Create a worktree for issue #789 based on develop branch"
-    }
-  ],
-  notes: [
-    "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",
-    "  - Must be authenticated with 'gh auth login'"
-  ]
-};
-
-// src/handlers/github.ts
-async function githubHandler(args2) {
-  if (args2.length === 0) {
-    console.log(helpFormatter.formatCommandHelp(githubHelp));
-    return;
-  }
-  throw new Error(`Unknown github subcommand: ${args2[0]}`);
-}
-
 // src/handlers/list.ts
 import { parseArgs as parseArgs6 } from "node:util";
 async function listHandler(args2 = []) {
@@ -17006,12 +17015,8 @@ async function listHandler(args2 = []) {
   });
   try {
     const gitRoot = await getGitRoot();
-    const context = await createContext(gitRoot);
     if (values.fzf) {
-      const selectResult = await selectWorktreeWithFzf(
-        context.gitRoot,
-        context.worktreesDirectory
-      );
+      const selectResult = await selectWorktreeWithFzf(gitRoot);
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -17019,10 +17024,7 @@ async function listHandler(args2 = []) {
         output.log(selectResult.value.name);
       }
     } else {
-      const result = await listWorktrees2(
-        context.gitRoot,
-        context.worktreesDirectory
-      );
+      const result = await listWorktrees2(gitRoot);
       if (isErr(result)) {
         exitWithError("Failed to list worktrees", exitCodes.generalError);
       }
@@ -17038,14 +17040,9 @@ async function listHandler(args2 = []) {
           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}`);
+          output.log(`${worktree.name} (${worktree.pathToDisplay})${status}`);
         }
       }
     }
@@ -25808,7 +25805,7 @@ var StdioServerTransport = class {
 // ../mcp/package.json
 var package_default = {
   name: "@aku11i/phantom-mcp",
-  version: "3.0.1",
+  version: "3.1.0",
   private: true,
   type: "module",
   main: "./src/index.ts",
@@ -25963,11 +25960,7 @@ var listWorktreesTool = {
   inputSchema: schema4,
   handler: async () => {
     const gitRoot = await getGitRoot();
-    const context = await createContext(gitRoot);
-    const result = await listWorktrees2(
-      context.gitRoot,
-      context.worktreesDirectory
-    );
+    const result = await listWorktrees2(gitRoot);
     if (!isOk(result)) {
       throw new Error("Failed to list worktrees");
     }
@@ -26150,10 +26143,7 @@ async function shellHandler(args2) {
       );
     }
     if (useFzf) {
-      const selectResult = await selectWorktreeWithFzf(
-        context.gitRoot,
-        context.worktreesDirectory
-      );
+      const selectResult = await selectWorktreeWithFzf(context.gitRoot);
       if (isErr(selectResult)) {
         exitWithError(selectResult.error.message, exitCodes.generalError);
       }
@@ -26219,13 +26209,15 @@ import { parseArgs as parseArgs9 } from "node:util";
 // package.json
 var package_default2 = {
   name: "@aku11i/phantom-cli",
-  version: "3.0.1",
+  version: "3.1.0",
   private: true,
   type: "module",
   scripts: {
     phantom: "node --no-warnings --experimental-strip-types src/bin/phantom.ts",
     prebuild: "git clean -fdx dist",
     build: "node build.ts",
+    precompile: "rm -f output/*",
+    compile: "node --no-warnings --experimental-strip-types build-executable.ts",
     typecheck: "tsc --noEmit",
     "test:shell": "pnpm run test:shell:bash && pnpm run test:shell:zsh && pnpm run test:shell:fish",
     "test:shell:bash": "node --test --experimental-strip-types --experimental-test-module-mocks src/completions/phantom.bash.test.shell.js",
@@ -26301,10 +26293,7 @@ async function whereHandler(args2) {
   }
   const context = await createContext(gitRoot);
   if (useFzf) {
-    const selectResult = await selectWorktreeWithFzf(
-      context.gitRoot,
-      context.worktreesDirectory
-    );
+    const selectResult = await selectWorktreeWithFzf(context.gitRoot);
     if (isErr(selectResult)) {
       exitWithError(selectResult.error.message, exitCodes.generalError);
     }