opencode-worktree 0.2.6 → 0.3.0

package/README.md

@@ -4,10 +4,15 @@ Terminal UI for managing git worktrees and launching `opencode` in the selected
 
 ## Features
 
-- Lists all worktrees with branch, path, and short HEAD
+- Lists all worktrees with branch, path, and metadata
+- Worktree metadata display: last edited time, dirty status, remote tracking
+- Status indicators: `[main]` for main worktree, `[*]` for uncommitted changes, `[local]` for local-only branches
 - Create new worktrees directly from the TUI
+- Post-create hooks: automatically run commands (e.g., `npm install`) after creating a worktree
+- Open worktree folder in file manager
 - Unlink worktrees (remove directory, keep branch)
 - Delete worktrees and local branches (never remote)
+- Multi-select delete mode for batch deletion
 - Launches `opencode` in the selected worktree
 - Refresh list on demand
 
@@ -37,11 +42,58 @@ opencode-worktree /path/to/your/repo
 ## Keybindings
 
 - `Up`/`Down` or `j`/`k`: navigate
-- `Enter`: open selected worktree
-- `d`: unlink/delete menu
+- `Enter`: open selected worktree in opencode (or toggle selection in delete mode)
+- `o`: open worktree folder in file manager (Finder/Explorer)
+- `d`: enter multi-select delete mode (press again to confirm deletion)
 - `n`: create new worktree
+- `c`: edit configuration (post-create hooks)
 - `r`: refresh list
-- `q` or `Esc`: quit (or cancel dialogs)
+- `q` or `Esc`: quit (or cancel dialogs/modes)
+
+### Multi-select delete mode
+
+1. Press `d` to enter selection mode
+2. Navigate with arrow keys and press `Enter` to toggle worktrees for deletion
+3. Press `d` again to confirm and choose unlink/delete action
+4. Press `Esc` to cancel and return to normal mode
+
+## Configuration
+
+You can configure per-repository settings by creating a `.opencode-worktree.json` file in your repository root.
+
+### First-time setup
+
+When you first run `opencode-worktree` in a repository without a configuration file, you'll be prompted to configure a post-create hook. You can also skip this step and configure it later by pressing `c`.
+
+### Editing configuration
+
+Press `c` at any time to edit your configuration. Currently, this allows you to set or modify the post-create hook command.
+
+### Post-create hooks
+
+Run a command automatically after creating a new worktree. Useful for installing dependencies.
+
+```json
+{
+  "postCreateHook": "npm install"
+}
+```
+
+The hook output is streamed to the TUI in real-time. If the hook fails, you can choose to open opencode anyway or cancel.
+
+**Examples:**
+
+```json
+{
+  "postCreateHook": "bun install"
+}
+```
+
+```json
+{
+  "postCreateHook": "npm install && npm run setup"
+}
+```
 
 ## Update notifications
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-worktree",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "description": "TUI for managing git worktrees with opencode integration.",
@@ -28,7 +28,8 @@
     "dev": "bun src/cli.ts",
     "build:single": "bun run script/build.ts --single",
     "build:all": "bun run script/build.ts",
-    "release:publish": "bun run script/publish.ts"
+    "release:publish": "bun run script/publish.ts",
+    "postinstall": "node ./script/postinstall.mjs"
   },
   "files": [
     "bin",

package/script/postinstall.mjs

@@ -77,6 +77,10 @@ const installBinary = async () => {
 };
 
 try {
+  if (process.env.CI) {
+    console.log("CI detected, skipping binary download.");
+    process.exit(0);
+  }
   const binaryPath = await installBinary();
   console.log(`opencode-worktree binary installed at: ${binaryPath}`);
 } catch (error) {

package/src/config.ts

@@ -0,0 +1,69 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+export type Config = {
+  postCreateHook?: string;
+};
+
+const CONFIG_FILENAME = ".opencode-worktree.json";
+
+/**
+ * Get the path to the config file for a repo
+ */
+export const getConfigPath = (repoRoot: string): string => {
+  return join(repoRoot, CONFIG_FILENAME);
+};
+
+/**
+ * Check if a config file exists for the repo
+ */
+export const configExists = (repoRoot: string): boolean => {
+  return existsSync(getConfigPath(repoRoot));
+};
+
+/**
+ * Load per-repo configuration from .opencode-worktree.json in the repo root
+ */
+export const loadRepoConfig = (repoRoot: string): Config => {
+  const configPath = getConfigPath(repoRoot);
+
+  if (!existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(content);
+
+    // Validate the config structure
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+
+    const config: Config = {};
+
+    if (typeof parsed.postCreateHook === "string") {
+      config.postCreateHook = parsed.postCreateHook;
+    }
+
+    return config;
+  } catch {
+    // If we can't read or parse the config, return empty
+    return {};
+  }
+};
+
+/**
+ * Save configuration to .opencode-worktree.json in the repo root
+ */
+export const saveRepoConfig = (repoRoot: string, config: Config): boolean => {
+  const configPath = getConfigPath(repoRoot);
+
+  try {
+    const content = JSON.stringify(config, null, 2) + "\n";
+    writeFileSync(configPath, content, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+};

package/src/git.ts

@@ -17,11 +17,19 @@ export const resolveRepoRoot = (cwd: string): string | null => {
 export const parseWorktreeList = (output: string): WorktreeInfo[] => {
   const lines = output.split(/\r?\n/);
   const worktrees: WorktreeInfo[] = [];
-  let current: WorktreeInfo | null = null;
+  let current: Partial<WorktreeInfo> | null = null;
 
   const pushCurrent = (): void => {
     if (current?.path) {
-      worktrees.push(current);
+      worktrees.push({
+        path: current.path,
+        head: current.head || "",
+        branch: current.branch || null,
+        isDetached: current.isDetached || false,
+        isDirty: false,
+        isOnRemote: false,
+        lastModified: null,
+      });
     }
   };
 
@@ -71,7 +79,10 @@ export const listWorktrees = (cwd: string): WorktreeInfo[] => {
     stdio: ["ignore", "pipe", "ignore"],
     encoding: "utf8",
   });
-  return parseWorktreeList(output);
+  const worktrees = parseWorktreeList(output);
+  
+  // Enrich each worktree with metadata
+  return worktrees.map((wt) => enrichWorktreeInfo(repoRoot, wt));
 };
 
 export type CreateWorktreeResult =
@@ -133,6 +144,68 @@ export const hasUncommittedChanges = (worktreePath: string): boolean => {
   }
 };
 
+/**
+ * Get the last commit date for a worktree
+ */
+export const getLastCommitDate = (worktreePath: string): Date | null => {
+  try {
+    const output = execFileSync(
+      "git",
+      ["log", "-1", "--format=%ci"],
+      {
+        cwd: worktreePath,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+      }
+    );
+    const dateStr = output.trim();
+    if (!dateStr) return null;
+    return new Date(dateStr);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Check if a branch exists on remote (origin)
+ */
+export const isBranchOnRemote = (
+  repoRoot: string,
+  branchName: string
+): boolean => {
+  try {
+    const output = execFileSync(
+      "git",
+      ["branch", "-r", "--list", `origin/${branchName}`],
+      {
+        cwd: repoRoot,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+      }
+    );
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Enrich worktree info with metadata (dirty status, remote status, last modified)
+ */
+export const enrichWorktreeInfo = (
+  repoRoot: string,
+  worktree: WorktreeInfo
+): WorktreeInfo => {
+  return {
+    ...worktree,
+    isDirty: hasUncommittedChanges(worktree.path),
+    isOnRemote: worktree.branch
+      ? isBranchOnRemote(repoRoot, worktree.branch)
+      : false,
+    lastModified: getLastCommitDate(worktree.path),
+  };
+};
+
 /**
  * Check if a worktree is the main worktree (the original repo clone)
  */

package/src/hooks.ts

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+
+export type HookResult = {
+  success: boolean;
+  exitCode: number | null;
+};
+
+export type HookCallbacks = {
+  onOutput: (data: string) => void;
+  onComplete: (result: HookResult) => void;
+};
+
+/**
+ * Run a post-create hook command with streaming output
+ * Returns a function to abort the hook if needed
+ */
+export const runPostCreateHook = (
+  worktreePath: string,
+  command: string,
+  callbacks: HookCallbacks
+): (() => void) => {
+  const shell = process.platform === "win32" ? "cmd" : "/bin/sh";
+  const shellFlag = process.platform === "win32" ? "/c" : "-c";
+
+  const child = spawn(shell, [shellFlag, command], {
+    cwd: worktreePath,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env },
+  });
+
+  // Stream stdout
+  child.stdout?.on("data", (data: Buffer) => {
+    callbacks.onOutput(data.toString());
+  });
+
+  // Stream stderr
+  child.stderr?.on("data", (data: Buffer) => {
+    callbacks.onOutput(data.toString());
+  });
+
+  // Handle completion
+  child.on("close", (code: number | null) => {
+    callbacks.onComplete({
+      success: code === 0,
+      exitCode: code,
+    });
+  });
+
+  // Handle errors
+  child.on("error", (err: Error) => {
+    callbacks.onOutput(`Error: ${err.message}\n`);
+    callbacks.onComplete({
+      success: false,
+      exitCode: null,
+    });
+  });
+
+  // Return abort function
+  return () => {
+    child.kill("SIGTERM");
+  };
+};

package/src/opencode.ts

@@ -18,3 +18,34 @@ export const launchOpenCode = (cwd: string): void => {
     process.exit(exitCode);
   });
 };
+
+/**
+ * Open a path in the system file manager (Finder on macOS, xdg-open on Linux, explorer on Windows)
+ */
+export const openInFileManager = (path: string): boolean => {
+  const platform = process.platform;
+  let command: string;
+  let args: string[];
+
+  if (platform === "darwin") {
+    command = "open";
+    args = [path];
+  } else if (platform === "win32") {
+    command = "explorer";
+    args = [path];
+  } else {
+    // Linux and others
+    command = "xdg-open";
+    args = [path];
+  }
+
+  try {
+    spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+    }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+};

package/src/types.ts

@@ -3,4 +3,8 @@ export type WorktreeInfo = {
   head: string;
   branch: string | null;
   isDetached: boolean;
+  // Metadata
+  isDirty: boolean;
+  isOnRemote: boolean;
+  lastModified: Date | null;
 };

package/src/ui.ts

@@ -21,8 +21,10 @@ import {
   resolveRepoRoot,
   unlinkWorktree,
 } from "./git.js";
-import { isOpenCodeAvailable, launchOpenCode } from "./opencode.js";
+import { isOpenCodeAvailable, launchOpenCode, openInFileManager } from "./opencode.js";
 import { WorktreeInfo } from "./types.js";
+import { loadRepoConfig, saveRepoConfig, configExists, type Config } from "./config.js";
+import { runPostCreateHook, type HookResult } from "./hooks.js";
 
 type StatusLevel = "info" | "warning" | "error" | "success";
 
@@ -72,6 +74,26 @@ class WorktreeSelector {
   private isCreatingWorktree = false;
   private worktreeOptions: SelectOption[] = [];
 
+  // Multi-select delete mode
+  private isSelectingForDelete = false;
+  private selectedForDelete: Set<string> = new Set(); // Set of worktree paths
+
+  // Hook execution state
+  private isRunningHook = false;
+  private hookOutputContainer: BoxRenderable | null = null;
+  private hookOutputText: TextRenderable | null = null;
+  private hookOutput: string[] = [];
+  private hookAbortFn: (() => void) | null = null;
+  private pendingWorktreePath: string | null = null;
+  private hookFailed = false;
+  private hookFailureSelect: SelectRenderable | null = null;
+
+  // Config editor state
+  private isEditingConfig = false;
+  private configContainer: BoxRenderable | null = null;
+  private configInput: InputRenderable | null = null;
+  private isFirstTimeSetup = false;
+
   constructor(
     private renderer: CliRenderer,
     private targetPath: string,
@@ -129,7 +151,7 @@ class WorktreeSelector {
       left: 2,
       top: 20,
       content:
-        "↑/↓ navigate • Enter open • d delete • n new • r refresh • q quit",
+        "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit",
       fg: "#64748B",
     });
     this.renderer.root.add(this.instructions);
@@ -138,7 +160,7 @@ class WorktreeSelector {
       SelectRenderableEvents.ITEM_SELECTED,
       (_index: number, option: SelectOption) => {
         // Ignore if we're in another mode
-        if (this.isConfirming || this.isCreatingWorktree) {
+        if (this.isConfirming || this.isCreatingWorktree || this.isSelectingForDelete) {
           return;
         }
         this.handleSelection(option.value as SelectionValue);
@@ -150,6 +172,11 @@ class WorktreeSelector {
     });
 
     this.selectElement.focus();
+
+    // Check for first-time setup
+    if (this.repoRoot && !configExists(this.repoRoot)) {
+      this.showFirstTimeSetup();
+    }
   }
 
   private getInitialStatusMessage(): string {
@@ -184,10 +211,36 @@ class WorktreeSelector {
 
   private handleKeypress(key: KeyEvent): void {
     if (key.ctrl && key.name === "c") {
+      // If running hook, abort it first
+      if (this.isRunningHook && this.hookAbortFn) {
+        this.hookAbortFn();
+        this.hookAbortFn = null;
+        this.setStatus("Hook aborted by user.", "warning");
+        this.hideHookOutput();
+        this.loadWorktrees(this.pendingWorktreePath || undefined);
+        this.selectElement.visible = true;
+        this.selectElement.focus();
+        this.instructions.content =
+          "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+        return;
+      }
       this.cleanup(true);
       return;
     }
 
+    // Handle hook running mode (only allow Ctrl+C which is handled above)
+    if (this.isRunningHook && !this.hookFailed) {
+      return;
+    }
+
+    // Handle hook failure mode - let the select handle input
+    if (this.isRunningHook && this.hookFailed) {
+      if (key.name === "escape") {
+        this.handleHookFailureChoice("cancel");
+      }
+      return;
+    }
+
     // Handle confirmation mode
     if (this.isConfirming) {
       if (key.name === "escape") {
@@ -203,6 +256,42 @@ class WorktreeSelector {
       return;
     }
 
+    // Handle config editing mode
+    if (this.isEditingConfig) {
+      if (key.name === "escape") {
+        this.hideConfigEditor();
+        return;
+      }
+      if (key.name === "return") {
+        const value = this.configInput?.value || "";
+        this.handleConfigSave(value);
+        return;
+      }
+      return;
+    }
+
+    // Handle multi-select delete mode
+    if (this.isSelectingForDelete) {
+      if (key.name === "escape") {
+        this.exitSelectMode();
+        return;
+      }
+      if (key.name === "return") {
+        this.toggleWorktreeSelection();
+        return;
+      }
+      if (key.name === "d") {
+        // Confirm deletion of selected worktrees
+        this.confirmBatchDelete();
+        return;
+      }
+      if (key.name === "q") {
+        this.exitSelectMode();
+        return;
+      }
+      return;
+    }
+
     if (key.name === "q" || key.name === "escape") {
       this.cleanup(true);
       return;
@@ -219,9 +308,21 @@ class WorktreeSelector {
       return;
     }
 
-    // 'd' for delete/unlink menu
+    // 'd' for entering delete selection mode
     if (key.name === "d") {
-      this.showDeleteConfirmation();
+      this.enterSelectMode();
+      return;
+    }
+
+    // 'o' for opening worktree path in file manager
+    if (key.name === "o") {
+      this.openWorktreeInFileManager();
+      return;
+    }
+
+    // 'c' for editing config
+    if (key.name === "c") {
+      this.showConfigEditor();
       return;
     }
   }
@@ -242,6 +343,21 @@ class WorktreeSelector {
     launchOpenCode(worktree.path);
   }
 
+  private openWorktreeInFileManager(): void {
+    const worktree = this.getSelectedWorktree();
+    if (!worktree) {
+      this.setStatus("Select a worktree to open in file manager.", "warning");
+      return;
+    }
+
+    const success = openInFileManager(worktree.path);
+    if (success) {
+      this.setStatus(`Opened ${worktree.path} in file manager.`, "success");
+    } else {
+      this.setStatus("Failed to open file manager.", "error");
+    }
+  }
+
   private showCreateWorktreeInput(): void {
     this.isCreatingWorktree = true;
     this.selectElement.visible = false;
@@ -296,7 +412,7 @@ class WorktreeSelector {
     this.renderer.requestRender();
   }
 
-  private hideCreateWorktreeInput(): void {
+  private hideCreateWorktreeInput(selectWorktreePath?: string): void {
     this.isCreatingWorktree = false;
 
     if (this.branchInput) {
@@ -311,9 +427,9 @@ class WorktreeSelector {
 
     this.selectElement.visible = true;
     this.instructions.content =
-      "↑/↓ navigate • Enter open • d delete • n new • r refresh • q quit";
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
     this.selectElement.focus();
-    this.loadWorktrees();
+    this.loadWorktrees(selectWorktreePath);
   }
 
   private handleCreateWorktree(branchName: string): void {
@@ -336,25 +452,341 @@ class WorktreeSelector {
 
     if (result.success) {
       this.setStatus(`Worktree created at ${result.path}`, "success");
-      this.renderer.requestRender();
-
-      if (this.opencodeAvailable) {
+      
+      // Check for post-create hook
+      const config = loadRepoConfig(this.repoRoot);
+      if (config.postCreateHook) {
+        this.pendingWorktreePath = result.path;
+        this.runHook(result.path, config.postCreateHook);
+      } else {
+        // No hook, launch opencode directly
         this.hideCreateWorktreeInput();
         this.cleanup(false);
         launchOpenCode(result.path);
-      } else {
-        this.setStatus(
-          `Worktree created but opencode is not available.`,
-          "warning",
-        );
-        this.hideCreateWorktreeInput();
       }
     } else {
       this.setStatus(`Failed to create worktree: ${result.error}`, "error");
     }
   }
 
-  private loadWorktrees(): void {
+  private runHook(worktreePath: string, command: string): void {
+    this.isRunningHook = true;
+    this.hookFailed = false;
+    this.hookOutput = [];
+
+    // Hide create input if still visible
+    if (this.inputContainer) {
+      this.renderer.root.remove(this.inputContainer.id);
+      this.inputContainer = null;
+      this.branchInput = null;
+    }
+    this.isCreatingWorktree = false;
+    this.selectElement.visible = false;
+
+    // Create hook output container
+    this.hookOutputContainer = new BoxRenderable(this.renderer, {
+      id: "hook-output-container",
+      position: "absolute",
+      left: 2,
+      top: 3,
+      width: 76,
+      height: 14,
+      borderStyle: "single",
+      borderColor: "#38BDF8",
+      title: `Running: ${command}`,
+      titleAlignment: "left",
+      backgroundColor: "#0F172A",
+      border: true,
+    });
+    this.renderer.root.add(this.hookOutputContainer);
+
+    this.hookOutputText = new TextRenderable(this.renderer, {
+      id: "hook-output-text",
+      position: "absolute",
+      left: 1,
+      top: 1,
+      content: "Starting...\n",
+      fg: "#94A3B8",
+    });
+    this.hookOutputContainer.add(this.hookOutputText);
+
+    this.instructions.content = "Hook running... (Ctrl+C to abort)";
+    this.setStatus(`Executing post-create hook...`, "info");
+    this.renderer.requestRender();
+
+    // Run the hook with streaming output
+    this.hookAbortFn = runPostCreateHook(worktreePath, command, {
+      onOutput: (data: string) => {
+        this.hookOutput.push(data);
+        this.updateHookOutput();
+      },
+      onComplete: (result: HookResult) => {
+        this.hookAbortFn = null;
+        if (result.success) {
+          this.onHookSuccess();
+        } else {
+          this.onHookFailure(result.exitCode);
+        }
+      },
+    });
+  }
+
+  private updateHookOutput(): void {
+    if (!this.hookOutputText) return;
+
+    // Join all output and take the last N lines that fit in the container
+    const fullOutput = this.hookOutput.join("");
+    const lines = fullOutput.split("\n");
+    const maxLines = 11; // Container height minus borders and padding
+    const visibleLines = lines.slice(-maxLines);
+    
+    this.hookOutputText.content = visibleLines.join("\n");
+    this.renderer.requestRender();
+  }
+
+  private onHookSuccess(): void {
+    this.setStatus("Hook completed successfully!", "success");
+    this.renderer.requestRender();
+
+    // Brief delay to show success, then launch opencode
+    setTimeout(() => {
+      this.hideHookOutput();
+      if (this.pendingWorktreePath) {
+        this.cleanup(false);
+        launchOpenCode(this.pendingWorktreePath);
+      }
+    }, 1000);
+  }
+
+  private onHookFailure(exitCode: number | null): void {
+    this.hookFailed = true;
+    const exitMsg = exitCode !== null ? ` (exit code: ${exitCode})` : "";
+    this.setStatus(`Hook failed${exitMsg}`, "error");
+
+    // Add failure options to the container
+    if (this.hookOutputContainer) {
+      this.hookFailureSelect = new SelectRenderable(this.renderer, {
+        id: "hook-failure-select",
+        position: "absolute",
+        left: 1,
+        top: 12,
+        width: 72,
+        height: 2,
+        options: [
+          {
+            name: "Open in opencode anyway",
+            description: "Launch opencode despite hook failure",
+            value: "open",
+          },
+          {
+            name: "Cancel",
+            description: "Return to worktree list",
+            value: "cancel",
+          },
+        ],
+        backgroundColor: "#0F172A",
+        focusedBackgroundColor: "#1E293B",
+        selectedBackgroundColor: "#1E3A5F",
+        textColor: "#E2E8F0",
+        selectedTextColor: "#38BDF8",
+        descriptionColor: "#94A3B8",
+        selectedDescriptionColor: "#E2E8F0",
+        showDescription: false,
+        wrapSelection: true,
+      });
+      this.hookOutputContainer.add(this.hookFailureSelect);
+
+      this.hookFailureSelect.on(
+        SelectRenderableEvents.ITEM_SELECTED,
+        (_index: number, option: SelectOption) => {
+          this.handleHookFailureChoice(option.value as string);
+        }
+      );
+
+      this.hookFailureSelect.focus();
+    }
+
+    this.instructions.content = "↑/↓ select • Enter confirm";
+    this.renderer.requestRender();
+  }
+
+  private handleHookFailureChoice(choice: string): void {
+    if (choice === "open" && this.pendingWorktreePath) {
+      this.hideHookOutput();
+      this.cleanup(false);
+      launchOpenCode(this.pendingWorktreePath);
+    } else {
+      // Cancel - return to list
+      this.hideHookOutput();
+      this.loadWorktrees(this.pendingWorktreePath || undefined);
+      this.selectElement.visible = true;
+      this.selectElement.focus();
+      this.instructions.content =
+        "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+    }
+  }
+
+  private hideHookOutput(): void {
+    this.isRunningHook = false;
+    this.hookFailed = false;
+    this.hookOutput = [];
+    this.pendingWorktreePath = null;
+
+    if (this.hookFailureSelect) {
+      this.hookFailureSelect.blur();
+      this.hookFailureSelect = null;
+    }
+
+    if (this.hookOutputContainer) {
+      this.renderer.root.remove(this.hookOutputContainer.id);
+      this.hookOutputContainer = null;
+      this.hookOutputText = null;
+    }
+  }
+
+  // ========== Config Editor Methods ==========
+
+  private showFirstTimeSetup(): void {
+    this.isFirstTimeSetup = true;
+    this.showConfigEditor();
+  }
+
+  private showConfigEditor(): void {
+    if (!this.repoRoot) {
+      this.setStatus("No git repository found.", "error");
+      return;
+    }
+
+    this.isEditingConfig = true;
+    this.selectElement.visible = false;
+    this.selectElement.blur();
+
+    // Load existing config to pre-fill
+    const existingConfig = loadRepoConfig(this.repoRoot);
+
+    const title = this.isFirstTimeSetup
+      ? "First-time Setup: Configure Post-create Hook"
+      : "Edit Post-create Hook";
+
+    this.configContainer = new BoxRenderable(this.renderer, {
+      id: "config-container",
+      position: "absolute",
+      left: 2,
+      top: 3,
+      width: 76,
+      height: 8,
+      borderStyle: "single",
+      borderColor: "#38BDF8",
+      title,
+      titleAlignment: "center",
+      backgroundColor: "#0F172A",
+      border: true,
+    });
+    this.renderer.root.add(this.configContainer);
+
+    const helpText = new TextRenderable(this.renderer, {
+      id: "config-help",
+      position: "absolute",
+      left: 1,
+      top: 1,
+      content: "Command to run after creating a worktree (e.g., npm install):",
+      fg: "#94A3B8",
+    });
+    this.configContainer.add(helpText);
+
+    const skipHint = new TextRenderable(this.renderer, {
+      id: "config-skip-hint",
+      position: "absolute",
+      left: 1,
+      top: 4,
+      content: "Leave empty to skip post-create hooks.",
+      fg: "#64748B",
+    });
+    this.configContainer.add(skipHint);
+
+    this.configInput = new InputRenderable(this.renderer, {
+      id: "config-hook-input",
+      position: "absolute",
+      left: 1,
+      top: 3,
+      width: 72,
+      placeholder: "npm install",
+      value: existingConfig.postCreateHook || "",
+      focusedBackgroundColor: "#1E293B",
+      backgroundColor: "#1E293B",
+    });
+    this.configContainer.add(this.configInput);
+
+    this.instructions.content = "Enter to save • Esc to cancel";
+    this.setStatus(
+      this.isFirstTimeSetup
+        ? "Welcome! Configure your post-create hook for this repository."
+        : "Edit the post-create hook command.",
+      "info"
+    );
+
+    // Delay focus to prevent the triggering keypress from being captured
+    setTimeout(() => {
+      this.configInput?.focus();
+      this.renderer.requestRender();
+    }, 0);
+  }
+
+  private hideConfigEditor(): void {
+    this.isEditingConfig = false;
+    this.isFirstTimeSetup = false;
+
+    if (this.configInput) {
+      this.configInput.blur();
+    }
+
+    if (this.configContainer) {
+      this.renderer.root.remove(this.configContainer.id);
+      this.configContainer = null;
+      this.configInput = null;
+    }
+
+    this.selectElement.visible = true;
+    this.instructions.content =
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+    
+    // Delay focus to prevent the Enter keypress from triggering a selection
+    setTimeout(() => {
+      this.selectElement.focus();
+      this.renderer.requestRender();
+    }, 0);
+  }
+
+  private handleConfigSave(hookCommand: string): void {
+    if (!this.repoRoot) {
+      this.setStatus("No git repository found.", "error");
+      this.hideConfigEditor();
+      return;
+    }
+
+    const trimmed = hookCommand.trim();
+    const config: Config = {};
+
+    if (trimmed) {
+      config.postCreateHook = trimmed;
+    }
+
+    const success = saveRepoConfig(this.repoRoot, config);
+
+    if (success) {
+      if (trimmed) {
+        this.setStatus(`Post-create hook saved: "${trimmed}"`, "success");
+      } else {
+        this.setStatus("Post-create hook cleared.", "success");
+      }
+    } else {
+      this.setStatus("Failed to save config.", "error");
+    }
+
+    this.hideConfigEditor();
+  }
+
+  private loadWorktrees(selectWorktreePath?: string): void {
     this.repoRoot = resolveRepoRoot(this.targetPath);
     if (!this.repoRoot) {
       this.setStatus("No git repository found in this directory.", "error");
@@ -366,6 +798,17 @@ class WorktreeSelector {
     const worktrees = listWorktrees(this.repoRoot);
     this.selectElement.options = this.buildOptions(worktrees);
 
+    // Preselect a specific worktree if path is provided
+    if (selectWorktreePath) {
+      const index = this.selectElement.options.findIndex((opt: SelectOption) => {
+        if (opt.value === CREATE_NEW_WORKTREE_VALUE) return false;
+        return (opt.value as WorktreeInfo).path === selectWorktreePath;
+      });
+      if (index >= 0) {
+        this.selectElement.setSelectedIndex(index);
+      }
+    }
+
     if (worktrees.length === 0) {
       this.setStatus(
         "No worktrees detected. Select 'Create new worktree' to add one.",
@@ -394,24 +837,89 @@ class WorktreeSelector {
     };
 
     const worktreeOptions = worktrees.map((worktree) => {
-      const shortHead = worktree.head ? worktree.head.slice(0, 7) : "unknown";
       const baseName = basename(worktree.path);
-      const label = worktree.branch
+      const isMain = this.repoRoot && isMainWorktree(this.repoRoot, worktree.path);
+      
+      // Build base label
+      let label = worktree.branch
         ? worktree.branch
         : worktree.isDetached
           ? `${baseName} (detached)`
           : baseName;
 
+      // Add status indicators
+      const indicators: string[] = [];
+      if (isMain) {
+        indicators.push("main");
+      }
+      if (worktree.isDirty) {
+        indicators.push("*");
+      }
+      if (!worktree.isOnRemote && worktree.branch && !isMain) {
+        indicators.push("local");
+      }
+      
+      if (indicators.length > 0) {
+        label = `${label} [${indicators.join(" ")}]`;
+      }
+
+      // Add checkbox prefix in selection mode
+      let displayName = label;
+      if (this.isSelectingForDelete) {
+        const isSelected = this.selectedForDelete.has(worktree.path);
+        if (isMain) {
+          displayName = `  [main] ${worktree.branch || baseName}`;
+        } else {
+          displayName = isSelected ? `[x] ${label}` : `[ ] ${label}`;
+        }
+      }
+
+      // Build description with metadata
+      const descParts: string[] = [];
+      
+      // Last modified date
+      if (worktree.lastModified) {
+        descParts.push(this.formatRelativeDate(worktree.lastModified));
+      }
+      
+      // Path (shortened if too long)
+      const maxPathLen = 45;
+      const pathDisplay = worktree.path.length > maxPathLen
+        ? "..." + worktree.path.slice(-maxPathLen + 3)
+        : worktree.path;
+      descParts.push(pathDisplay);
+
       return {
-        name: label,
-        description: `${worktree.path} - ${shortHead}`,
+        name: displayName,
+        description: descParts.join(" | "),
         value: worktree,
       };
     });
 
+    // Don't show create option in delete selection mode
+    if (this.isSelectingForDelete) {
+      return worktreeOptions;
+    }
+
     return [createOption, ...worktreeOptions];
   }
 
+  private formatRelativeDate(date: Date): string {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / (1000 * 60));
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+
+    if (diffMins < 1) return "just now";
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays < 7) return `${diffDays}d ago`;
+    if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
+    if (diffDays < 365) return `${Math.floor(diffDays / 30)}mo ago`;
+    return `${Math.floor(diffDays / 365)}y ago`;
+  }
+
   private setStatus(message: string, level: StatusLevel): void {
     this.statusText.content = message;
     this.statusText.fg = statusColors[level];
@@ -573,7 +1081,7 @@ class WorktreeSelector {
 
     this.selectElement.visible = true;
     this.instructions.content =
-      "↑/↓ navigate • Enter open • d delete • n new • r refresh • q quit";
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
     this.selectElement.focus();
     this.loadWorktrees();
   }
@@ -640,6 +1148,307 @@ class WorktreeSelector {
     this.hideConfirmDialog();
   }
 
+  // ========== Multi-select delete mode methods ==========
+
+  private enterSelectMode(): void {
+    if (!this.repoRoot) {
+      this.setStatus("No git repository found.", "error");
+      return;
+    }
+
+    const worktrees = listWorktrees(this.repoRoot);
+    // Filter out main worktree
+    const deletableWorktrees = worktrees.filter(
+      (wt) => !isMainWorktree(this.repoRoot!, wt.path)
+    );
+
+    if (deletableWorktrees.length === 0) {
+      this.setStatus("No worktrees available for deletion.", "warning");
+      return;
+    }
+
+    this.isSelectingForDelete = true;
+    this.selectedForDelete.clear();
+
+    // Rebuild options to show checkboxes
+    this.selectElement.options = this.buildOptions(worktrees);
+    this.instructions.content =
+      "Enter toggle selection • d confirm delete • Esc cancel";
+    this.setStatus("Select worktrees to delete, then press 'd' to confirm.", "info");
+    this.renderer.requestRender();
+  }
+
+  private exitSelectMode(): void {
+    this.isSelectingForDelete = false;
+    this.selectedForDelete.clear();
+    this.loadWorktrees();
+    this.instructions.content =
+      "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
+    this.renderer.requestRender();
+  }
+
+  private toggleWorktreeSelection(): void {
+    const selectedIndex = this.selectElement.getSelectedIndex();
+    const option = this.selectElement.options[selectedIndex];
+    if (!option) return;
+
+    const worktree = option.value as WorktreeInfo;
+    if (!worktree.path) return;
+
+    // Prevent selecting main worktree
+    if (this.repoRoot && isMainWorktree(this.repoRoot, worktree.path)) {
+      this.setStatus("Cannot delete the main worktree.", "warning");
+      return;
+    }
+
+    if (this.selectedForDelete.has(worktree.path)) {
+      this.selectedForDelete.delete(worktree.path);
+    } else {
+      this.selectedForDelete.add(worktree.path);
+    }
+
+    // Rebuild options to update checkboxes
+    if (this.repoRoot) {
+      const worktrees = listWorktrees(this.repoRoot);
+      this.selectElement.options = this.buildOptions(worktrees);
+      // Restore selection index
+      this.selectElement.setSelectedIndex(selectedIndex);
+    }
+
+    const count = this.selectedForDelete.size;
+    this.setStatus(
+      count === 0
+        ? "Select worktrees to delete, then press 'd' to confirm."
+        : `${count} worktree${count === 1 ? "" : "s"} selected for deletion.`,
+      "info"
+    );
+    this.renderer.requestRender();
+  }
+
+  private confirmBatchDelete(): void {
+    if (this.selectedForDelete.size === 0) {
+      this.setStatus("No worktrees selected. Use Enter to select.", "warning");
+      return;
+    }
+
+    // Get the worktree info for selected paths
+    if (!this.repoRoot) return;
+
+    const worktrees = listWorktrees(this.repoRoot);
+    const toDelete = worktrees.filter((wt) =>
+      this.selectedForDelete.has(wt.path)
+    );
+
+    // Show batch confirmation dialog
+    this.showBatchDeleteConfirmation(toDelete);
+  }
+
+  private showBatchDeleteConfirmation(worktrees: WorktreeInfo[]): void {
+    this.isConfirming = true;
+    this.isSelectingForDelete = false;
+    this.selectElement.visible = false;
+    this.selectElement.blur();
+
+    // Check if any have uncommitted changes
+    const dirtyWorktrees = worktrees.filter((wt) =>
+      hasUncommittedChanges(wt.path)
+    );
+    const hasDirty = dirtyWorktrees.length > 0;
+
+    const count = worktrees.length;
+    const title = `Delete ${count} worktree${count === 1 ? "" : "s"}`;
+
+    this.confirmContainer = new BoxRenderable(this.renderer, {
+      id: "confirm-container",
+      position: "absolute",
+      left: 2,
+      top: 3,
+      width: 76,
+      height: hasDirty ? 12 : 10,
+      borderStyle: "single",
+      borderColor: "#F59E0B",
+      title,
+      titleAlignment: "center",
+      backgroundColor: "#0F172A",
+      border: true,
+    });
+    this.renderer.root.add(this.confirmContainer);
+
+    let yOffset = 1;
+
+    // Warning for dirty worktrees
+    if (hasDirty) {
+      const warningText = new TextRenderable(this.renderer, {
+        id: "confirm-warning",
+        position: "absolute",
+        left: 1,
+        top: yOffset,
+        content: `⚠ ${dirtyWorktrees.length} worktree${dirtyWorktrees.length === 1 ? " has" : "s have"} uncommitted changes!`,
+        fg: "#F59E0B",
+      });
+      this.confirmContainer.add(warningText);
+      yOffset += 2;
+    }
+
+    // List worktrees to be deleted
+    const branchNames = worktrees
+      .map((wt) => wt.branch || basename(wt.path))
+      .slice(0, 3);
+    const displayList =
+      branchNames.join(", ") + (worktrees.length > 3 ? `, +${worktrees.length - 3} more` : "");
+
+    const listText = new TextRenderable(this.renderer, {
+      id: "confirm-list",
+      position: "absolute",
+      left: 1,
+      top: yOffset,
+      content: `Worktrees: ${displayList}`,
+      fg: "#94A3B8",
+    });
+    this.confirmContainer.add(listText);
+    yOffset += 2;
+
+    // Build options
+    const options: SelectOption[] = [
+      {
+        name: "Unlink all (default)",
+        description: "Remove worktree directories, keep branches for later use",
+        value: CONFIRM_UNLINK_VALUE,
+      },
+      {
+        name: "Delete all",
+        description: "Remove worktrees AND delete local branches (never remote)",
+        value: CONFIRM_DELETE_VALUE,
+      },
+      {
+        name: "Cancel",
+        description: "Go back without changes",
+        value: CONFIRM_CANCEL_VALUE,
+      },
+    ];
+
+    this.confirmSelect = new SelectRenderable(this.renderer, {
+      id: "confirm-select",
+      position: "absolute",
+      left: 1,
+      top: yOffset,
+      width: 72,
+      height: 4,
+      options,
+      backgroundColor: "#0F172A",
+      focusedBackgroundColor: "#1E293B",
+      selectedBackgroundColor: "#1E3A5F",
+      textColor: "#E2E8F0",
+      selectedTextColor: "#38BDF8",
+      descriptionColor: "#94A3B8",
+      selectedDescriptionColor: "#E2E8F0",
+      showDescription: true,
+      wrapSelection: true,
+    });
+    this.confirmContainer.add(this.confirmSelect);
+
+    // Store worktrees for batch deletion
+    const worktreesToDelete = worktrees;
+
+    this.confirmSelect.on(
+      SelectRenderableEvents.ITEM_SELECTED,
+      (_index: number, option: SelectOption) => {
+        this.handleBatchConfirmAction(
+          option.value as ConfirmAction,
+          worktreesToDelete,
+          hasDirty
+        );
+      }
+    );
+
+    this.instructions.content =
+      "↑/↓ select action • Enter confirm • Esc cancel";
+    this.setStatus(
+      hasDirty
+        ? "Warning: Some worktrees have uncommitted changes!"
+        : `Ready to remove ${count} worktree${count === 1 ? "" : "s"}.`,
+      hasDirty ? "warning" : "info"
+    );
+
+    this.confirmSelect.focus();
+    this.renderer.requestRender();
+  }
+
+  private handleBatchConfirmAction(
+    action: ConfirmAction,
+    worktrees: WorktreeInfo[],
+    hasDirty: boolean
+  ): void {
+    if (action === CONFIRM_CANCEL_VALUE) {
+      this.selectedForDelete.clear();
+      this.hideConfirmDialog();
+      return;
+    }
+
+    if (!this.repoRoot) {
+      this.selectedForDelete.clear();
+      this.hideConfirmDialog();
+      return;
+    }
+
+    const count = worktrees.length;
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const worktree of worktrees) {
+      const branchName = worktree.branch || basename(worktree.path);
+      const isDirty = hasUncommittedChanges(worktree.path);
+
+      if (action === CONFIRM_UNLINK_VALUE) {
+        const result = unlinkWorktree(this.repoRoot, worktree.path, isDirty);
+        if (result.success) {
+          successCount++;
+        } else {
+          failCount++;
+        }
+      } else if (action === CONFIRM_DELETE_VALUE) {
+        if (!worktree.branch) {
+          // Can't delete branch for detached HEAD, just unlink
+          const result = unlinkWorktree(this.repoRoot, worktree.path, isDirty);
+          if (result.success) {
+            successCount++;
+          } else {
+            failCount++;
+          }
+        } else {
+          const result = deleteWorktree(
+            this.repoRoot,
+            worktree.path,
+            worktree.branch,
+            isDirty
+          );
+          if (result.success) {
+            successCount++;
+          } else {
+            failCount++;
+          }
+        }
+      }
+    }
+
+    this.selectedForDelete.clear();
+
+    if (failCount === 0) {
+      const actionWord = action === CONFIRM_UNLINK_VALUE ? "unlinked" : "deleted";
+      this.setStatus(
+        `Successfully ${actionWord} ${successCount} worktree${successCount === 1 ? "" : "s"}.`,
+        "success"
+      );
+    } else {
+      this.setStatus(
+        `Completed with ${successCount} success, ${failCount} failed.`,
+        "warning"
+      );
+    }
+
+    this.hideConfirmDialog();
+  }
+
   private cleanup(shouldExit: boolean): void {
     this.selectElement.blur();
     if (this.branchInput) {