opencode-worktree 0.3.3 → 0.3.5

package/README.md

@@ -1,6 +1,6 @@
 # opencode-worktree
 
-Terminal UI for managing git worktrees and launching `opencode` in the selected worktree.
+Terminal UI for managing git worktrees and launching your preferred coding tool in the selected worktree.
 
 ## Features
 
@@ -9,17 +9,18 @@ Terminal UI for managing git worktrees and launching `opencode` in the selected
 - 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
+- Open worktree folder in file manager or custom editor
 - 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
+- **Customizable launch command**: use `opencode`, `cursor`, `claude`, `code`, or any CLI tool
 - Refresh list on demand
+- Update notifications when new versions are available
 
 ## Requirements
 
 - Git
-- `opencode` available on your PATH
+- A CLI tool available on your PATH (e.g., `opencode`, `cursor`, `claude`, `code`)
 
 ## Install (npm)
 
@@ -42,11 +43,11 @@ opencode-worktree /path/to/your/repo
 ## Keybindings
 
 - `Up`/`Down` or `j`/`k`: navigate
-- `Enter`: open selected worktree in opencode (or toggle selection in delete mode)
+- `Enter`: open selected worktree in configured tool (or toggle selection in delete mode)
 - `o`: open worktree folder in file manager or custom editor (configurable)
 - `d`: enter multi-select delete mode (press again to confirm deletion)
 - `n`: create new worktree
-- `c`: edit configuration (post-create hooks)
+- `c`: edit configuration (hooks, open command, launch command)
 - `r`: refresh list
 - `q` or `Esc`: quit (or cancel dialogs/modes)
 
@@ -59,18 +60,33 @@ opencode-worktree /path/to/your/repo
 
 ## Configuration
 
-You can configure per-repository settings by creating a `.opencode-worktree.json` file in your repository root.
+You can configure per-repository settings by creating a `.opencode-worktree.json` file in your repository root, or by pressing `c` in the TUI.
+
+### Configuration options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `postCreateHook` | Command to run after creating a worktree | none |
+| `openCommand` | Command for opening worktree folders (`o` key) | system default |
+| `launchCommand` | Command to launch when selecting a worktree (`Enter` key) | `opencode` |
+
+### Example configuration
+
+```json
+{
+  "postCreateHook": "npm install",
+  "openCommand": "code",
+  "launchCommand": "cursor"
+}
+```
 
 ### 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`.
+When you first run `opencode-worktree` in a repository without a configuration file, you'll be prompted to configure settings. You can also skip this step and configure later by pressing `c`.
 
 ### Editing configuration
 
-Press `c` at any time to edit your configuration. You can configure:
-
-- **Post-create hook**: Command to run after creating a worktree (e.g., `npm install`)
-- **Open command**: Custom command for opening worktree folders (e.g., `webstorm`, `code`)
+Press `c` at any time to edit your configuration. Use `Tab` to switch between fields.
 
 ### Post-create hooks
 
@@ -82,7 +98,7 @@ Run a command automatically after creating a new worktree. Useful for installing
 }
 ```
 
-The hook output is streamed to the TUI in real-time. If the hook fails, you can choose to open opencode anyway or cancel.
+The hook output is streamed to the TUI in real-time. If the hook fails, you can choose to open the tool anyway or cancel.
 
 **Examples:**
 
@@ -116,16 +132,49 @@ Use a custom command when pressing `o` to open worktree folders. Useful for open
 }
 ```
 
+### Custom launch command
+
+Use a different tool instead of `opencode` when pressing `Enter` to open a worktree. This allows you to use any CLI-based coding tool.
+
+```json
+{
+  "launchCommand": "cursor"
+}
+```
+
+**Examples:**
+
+```json
+{
+  "launchCommand": "claude"
+}
+```
+
+```json
+{
+  "launchCommand": "code"
+}
+```
+
+```json
+{
+  "launchCommand": "zed"
+}
+```
+
+### Full configuration example
+
 ```json
 {
   "postCreateHook": "npm install",
-  "openCommand": "webstorm"
+  "openCommand": "code",
+  "launchCommand": "cursor"
 }
 ```
 
 ## Update notifications
 
-When a new version is published to npm, the CLI will show a non-intrusive update message on the next run.
+When a new version is published to npm, the TUI will show a non-intrusive update message in the title bar. The version check runs in the background and doesn't slow down startup.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-worktree",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "private": false,
   "type": "module",
   "description": "TUI for managing git worktrees with opencode integration.",
@@ -42,13 +42,11 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@opentui/core": "^0.1.75",
-    "update-notifier": "^7.3.1"
+    "@opentui/core": "^0.1.75"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",
     "@types/node": "^24.2.0",
-    "@types/update-notifier": "^6.0.8",
     "typescript": "^5.9.3"
   }
 }

package/src/config.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 export type Config = {
   postCreateHook?: string;
   openCommand?: string; // Custom command to open worktree folder (e.g., "webstorm", "code")
+  launchCommand?: string; // Custom command to launch instead of opencode (e.g., "cursor", "claude")
 };
 
 const CONFIG_FILENAME = ".opencode-worktree.json";
@@ -51,6 +52,10 @@ export const loadRepoConfig = (repoRoot: string): Config => {
       config.openCommand = parsed.openCommand;
     }
 
+    if (typeof parsed.launchCommand === "string") {
+      config.launchCommand = parsed.launchCommand;
+    }
+
     return config;
   } catch {
     // If we can't read or parse the config, return empty

package/src/opencode.ts

@@ -1,14 +1,30 @@
 import { spawn, spawnSync } from "node:child_process";
 
-export const isOpenCodeAvailable = (): boolean => {
-  const result = spawnSync("opencode", ["--version"], {
+/**
+ * Check if a command is available in PATH
+ */
+export const isCommandAvailable = (command: string): boolean => {
+  const result = spawnSync(command, ["--version"], {
     stdio: "ignore",
   });
   return result.status === 0;
 };
 
-export const launchOpenCode = (cwd: string): void => {
-  const child = spawn("opencode", [], {
+/**
+ * @deprecated Use isCommandAvailable instead
+ */
+export const isOpenCodeAvailable = (): boolean => {
+  return isCommandAvailable("opencode");
+};
+
+/**
+ * Launch a command in a worktree directory
+ * If customCommand is provided, uses that instead of opencode
+ */
+export const launchCommand = (cwd: string, customCommand?: string): void => {
+  const command = customCommand || "opencode";
+  
+  const child = spawn(command, [], {
     cwd,
     stdio: "inherit",
   });
@@ -19,6 +35,13 @@ export const launchOpenCode = (cwd: string): void => {
   });
 };
 
+/**
+ * @deprecated Use launchCommand instead
+ */
+export const launchOpenCode = (cwd: string): void => {
+  launchCommand(cwd);
+};
+
 /**
  * Open a path in the system file manager or with a custom command
  * If customCommand is provided, uses that instead of the system default

package/src/ui.ts

@@ -10,7 +10,7 @@ import {
   type KeyEvent,
   type SelectOption,
 } from "@opentui/core";
-import updateNotifier from "update-notifier";
+import { checkForUpdate } from "./update-check.js";
 import { basename } from "node:path";
 import {
   createWorktree,
@@ -22,7 +22,7 @@ import {
   resolveRepoRoot,
   unlinkWorktree,
 } from "./git.js";
-import { isOpenCodeAvailable, launchOpenCode, openInFileManager } from "./opencode.js";
+import { isCommandAvailable, launchCommand, 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";
@@ -81,6 +81,7 @@ class WorktreeSelector {
 
   private opencodeAvailable = false;
   private repoRoot: string | null = null;
+  private repoConfig: Config = {};
   private isCreatingWorktree = false;
   private worktreeOptions: SelectOption[] = [];
 
@@ -103,7 +104,8 @@ class WorktreeSelector {
   private configContainer: BoxRenderable | null = null;
   private configHookInput: InputRenderable | null = null;
   private configOpenInput: InputRenderable | null = null;
-  private configActiveField: "hook" | "open" = "hook";
+  private configLaunchInput: InputRenderable | null = null;
+  private configActiveField: "hook" | "open" | "launch" = "hook";
   private isFirstTimeSetup = false;
 
   constructor(
@@ -113,7 +115,8 @@ class WorktreeSelector {
   ) {
     // Load worktrees first to get initial options
     this.repoRoot = resolveRepoRoot(this.targetPath);
-    this.opencodeAvailable = isOpenCodeAvailable();
+    this.repoConfig = this.repoRoot ? loadRepoConfig(this.repoRoot) : {};
+    this.opencodeAvailable = isCommandAvailable(this.repoConfig.launchCommand || "opencode");
     this.worktreeOptions = this.buildInitialOptions();
 
     this.title = new TextRenderable(renderer, {
@@ -128,17 +131,17 @@ class WorktreeSelector {
 
     // Display version or update notification in title line
     if (this.pkg) {
-      const notifier = updateNotifier({ pkg: this.pkg });
+      const updateInfo = checkForUpdate(this.pkg);
 
       let noticeContent: string;
       let noticeColor: string;
 
-      if (notifier.update) {
+      if (updateInfo?.hasUpdate) {
         // Update available
-        noticeContent = `Update: ${notifier.update.current} → ${notifier.update.latest} (npm i -g)`;
+        noticeContent = `Update: ${updateInfo.current} → ${updateInfo.latest} (npm i -g)`;
         noticeColor = "#F59E0B"; // Amber
       } else {
-        // On latest version
+        // On latest version (or no cache yet)
         noticeContent = `v${this.pkg.version}`;
         noticeColor = "#64748B"; // Subtle gray
       }
@@ -308,14 +311,18 @@ class WorktreeSelector {
         return;
       }
       if (key.name === "tab") {
-        // Switch between fields
+        // Cycle between fields: hook -> open -> launch -> hook
         if (this.configActiveField === "hook") {
           this.configActiveField = "open";
           this.configHookInput?.blur();
           this.configOpenInput?.focus();
+        } else if (this.configActiveField === "open") {
+          this.configActiveField = "launch";
+          this.configOpenInput?.blur();
+          this.configLaunchInput?.focus();
         } else {
           this.configActiveField = "hook";
-          this.configOpenInput?.blur();
+          this.configLaunchInput?.blur();
           this.configHookInput?.focus();
         }
         this.renderer.requestRender();
@@ -388,13 +395,14 @@ class WorktreeSelector {
     }
 
     const worktree = value as WorktreeInfo;
+    const cmdName = this.repoConfig.launchCommand || "opencode";
     if (!this.opencodeAvailable) {
-      this.setStatus("opencode is not available on PATH.", "error");
+      this.setStatus(`${cmdName} is not available on PATH.`, "error");
       return;
     }
 
     this.cleanup(false);
-    launchOpenCode(worktree.path);
+    launchCommand(worktree.path, this.repoConfig.launchCommand);
   }
 
   private openWorktreeInFileManager(): void {
@@ -521,10 +529,10 @@ class WorktreeSelector {
         this.pendingWorktreePath = result.path;
         this.runHook(result.path, config.postCreateHook);
       } else {
-        // No hook, launch opencode directly
+        // No hook, launch command directly
         this.hideCreateWorktreeInput();
         this.cleanup(false);
-        launchOpenCode(result.path);
+        launchCommand(result.path, this.repoConfig.launchCommand);
       }
     } else {
       this.setStatus(`Failed to create worktree: ${result.error}`, "error");
@@ -610,12 +618,12 @@ class WorktreeSelector {
     this.setStatus("Hook completed successfully!", "success");
     this.renderer.requestRender();
 
-    // Brief delay to show success, then launch opencode
+    // Brief delay to show success, then launch command
     setTimeout(() => {
       this.hideHookOutput();
       if (this.pendingWorktreePath) {
         this.cleanup(false);
-        launchOpenCode(this.pendingWorktreePath);
+        launchCommand(this.pendingWorktreePath, this.repoConfig.launchCommand);
       }
     }, 1000);
   }
@@ -676,7 +684,7 @@ class WorktreeSelector {
     if (choice === "open" && this.pendingWorktreePath) {
       this.hideHookOutput();
       this.cleanup(false);
-      launchOpenCode(this.pendingWorktreePath);
+      launchCommand(this.pendingWorktreePath, this.repoConfig.launchCommand);
     } else {
       // Cancel - return to list
       this.hideHookOutput();
@@ -737,7 +745,7 @@ class WorktreeSelector {
       left: 2,
       top: 3,
       width: 76,
-      height: 12,
+      height: 15,
       borderStyle: "single",
       borderColor: "#38BDF8",
       title,
@@ -771,13 +779,13 @@ class WorktreeSelector {
     });
     this.configContainer.add(this.configHookInput);
 
-    // Open command field
+    // Open folder command field
     const openLabel = new TextRenderable(this.renderer, {
       id: "config-open-label",
       position: "absolute",
       left: 1,
       top: 4,
-      content: "Open folder command (e.g., webstorm, code):",
+      content: "Open folder command (e.g., code, webstorm):",
       fg: "#94A3B8",
     });
     this.configContainer.add(openLabel);
@@ -795,12 +803,36 @@ class WorktreeSelector {
     });
     this.configContainer.add(this.configOpenInput);
 
+    // Launch command field (instead of opencode)
+    const launchLabel = new TextRenderable(this.renderer, {
+      id: "config-launch-label",
+      position: "absolute",
+      left: 1,
+      top: 7,
+      content: "Launch command (e.g., cursor, claude, code):",
+      fg: "#94A3B8",
+    });
+    this.configContainer.add(launchLabel);
+
+    this.configLaunchInput = new InputRenderable(this.renderer, {
+      id: "config-launch-input",
+      position: "absolute",
+      left: 1,
+      top: 8,
+      width: 72,
+      placeholder: "opencode (default)",
+      value: existingConfig.launchCommand || "",
+      focusedBackgroundColor: "#1E293B",
+      backgroundColor: "#1E293B",
+    });
+    this.configContainer.add(this.configLaunchInput);
+
     // Help text
     const helpText = new TextRenderable(this.renderer, {
       id: "config-help",
       position: "absolute",
       left: 1,
-      top: 7,
+      top: 10,
       content: "Tab to switch fields • Leave empty to use defaults",
       fg: "#64748B",
     });
@@ -831,12 +863,16 @@ class WorktreeSelector {
     if (this.configOpenInput) {
       this.configOpenInput.blur();
     }
+    if (this.configLaunchInput) {
+      this.configLaunchInput.blur();
+    }
 
     if (this.configContainer) {
       this.renderer.root.remove(this.configContainer.id);
       this.configContainer = null;
       this.configHookInput = null;
       this.configOpenInput = null;
+      this.configLaunchInput = null;
     }
 
     this.selectElement.visible = true;
@@ -859,6 +895,7 @@ class WorktreeSelector {
 
     const hookValue = (this.configHookInput?.value || "").trim();
     const openValue = (this.configOpenInput?.value || "").trim();
+    const launchValue = (this.configLaunchInput?.value || "").trim();
     const config: Config = {};
 
     if (hookValue) {
@@ -867,13 +904,24 @@ class WorktreeSelector {
     if (openValue) {
       config.openCommand = openValue;
     }
+    if (launchValue) {
+      config.launchCommand = launchValue;
+    }
 
     const success = saveRepoConfig(this.repoRoot, config);
 
     if (success) {
+      // Update the in-memory config
+      this.repoConfig = config;
+      
+      // Re-check if the launch command is available
+      const cmdName = config.launchCommand || "opencode";
+      this.opencodeAvailable = isCommandAvailable(cmdName);
+
       const changes: string[] = [];
       if (hookValue) changes.push(`hook: "${hookValue}"`);
       if (openValue) changes.push(`open: "${openValue}"`);
+      if (launchValue) changes.push(`launch: "${launchValue}"`);
       
       if (changes.length > 0) {
         this.setStatus(`Config saved: ${changes.join(", ")}`, "success");
@@ -922,9 +970,10 @@ class WorktreeSelector {
       );
     }
 
-    this.opencodeAvailable = isOpenCodeAvailable();
+    const cmdName = this.repoConfig.launchCommand || "opencode";
+    this.opencodeAvailable = isCommandAvailable(cmdName);
     if (!this.opencodeAvailable) {
-      this.setStatus("opencode is not available on PATH.", "error");
+      this.setStatus(`${cmdName} is not available on PATH.`, "error");
     }
 
     this.renderer.requestRender();
@@ -1063,7 +1112,7 @@ class WorktreeSelector {
     const branchDisplay = worktree.branch || basename(worktree.path);
 
     // Build dialog title
-    const title = "DELETE WORKTREE";
+    const title = `Remove: ${branchDisplay}`;
 
     this.confirmContainer = new BoxRenderable(this.renderer, {
       id: "confirm-container",
@@ -1071,30 +1120,18 @@ class WorktreeSelector {
       left: 2,
       top: 3,
       width: 76,
-      height: isDirty ? 12 : 10,
+      height: isDirty ? 10 : 8,
       borderStyle: "single",
-      borderColor: "#EF4444",
+      borderColor: "#F59E0B",
       title,
       titleAlignment: "center",
-      backgroundColor: "#1C1917",
+      backgroundColor: "#0F172A",
       border: true,
     });
     this.renderer.root.add(this.confirmContainer);
 
-    // Branch name prominently displayed
-    let yOffset = 1;
-    const branchHeader = new TextRenderable(this.renderer, {
-      id: "confirm-branch",
-      position: "absolute",
-      left: 1,
-      top: yOffset,
-      content: `Branch: ${branchDisplay}`,
-      fg: "#FBBF24",
-    });
-    this.confirmContainer.add(branchHeader);
-    yOffset += 2;
-
     // Warning for dirty worktree
+    let yOffset = 1;
     if (isDirty) {
       const warningText = new TextRenderable(this.renderer, {
         id: "confirm-warning",
@@ -1102,7 +1139,7 @@ class WorktreeSelector {
         left: 1,
         top: yOffset,
         content: "⚠ This worktree has uncommitted changes!",
-        fg: "#EF4444",
+        fg: "#F59E0B",
       });
       this.confirmContainer.add(warningText);
       yOffset += 2;
@@ -1114,7 +1151,7 @@ class WorktreeSelector {
       left: 1,
       top: yOffset,
       content: `Path: ${worktree.path}`,
-      fg: "#A8A29E",
+      fg: "#94A3B8",
     });
     this.confirmContainer.add(pathText);
     yOffset += 2;
@@ -1146,13 +1183,13 @@ class WorktreeSelector {
       width: 72,
       height: 4,
       options,
-      backgroundColor: "#1C1917",
-      focusedBackgroundColor: "#292524",
-      selectedBackgroundColor: "#44403C",
-      textColor: "#E7E5E4",
-      selectedTextColor: "#F87171",
-      descriptionColor: "#A8A29E",
-      selectedDescriptionColor: "#E7E5E4",
+      backgroundColor: "#0F172A",
+      focusedBackgroundColor: "#1E293B",
+      selectedBackgroundColor: "#1E3A5F",
+      textColor: "#E2E8F0",
+      selectedTextColor: "#38BDF8",
+      descriptionColor: "#94A3B8",
+      selectedDescriptionColor: "#E2E8F0",
       showDescription: true,
       wrapSelection: true,
     });
@@ -1192,6 +1229,17 @@ class WorktreeSelector {
       this.confirmSelect = null;
     }
 
+    // Restore original title and colors (in case we came from delete mode)
+    this.title.content = "OPENCODE WORKTREES";
+    this.title.fg = "#E2E8F0";
+    this.selectElement.backgroundColor = "#0F172A";
+    this.selectElement.focusedBackgroundColor = "#1E293B";
+    this.selectElement.selectedBackgroundColor = "#1E3A5F";
+    this.selectElement.textColor = "#E2E8F0";
+    this.selectElement.selectedTextColor = "#38BDF8";
+    this.selectElement.descriptionColor = "#94A3B8";
+    this.selectElement.selectedDescriptionColor = "#E2E8F0";
+
     this.selectElement.visible = true;
     this.instructions.content =
       "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
@@ -1283,8 +1331,21 @@ class WorktreeSelector {
     this.isSelectingForDelete = true;
     this.selectedForDelete.clear();
 
-    // Rebuild options to show checkboxes
-    this.selectElement.options = this.buildOptions(worktrees);
+    // Change title to indicate delete mode
+    this.title.content = "DELETE WORKTREES";
+    this.title.fg = "#EF4444"; // Red
+
+    // Change select element colors to danger theme
+    this.selectElement.backgroundColor = "#1C1917";
+    this.selectElement.focusedBackgroundColor = "#292524";
+    this.selectElement.selectedBackgroundColor = "#44403C";
+    this.selectElement.textColor = "#E7E5E4";
+    this.selectElement.selectedTextColor = "#F87171";
+    this.selectElement.descriptionColor = "#A8A29E";
+    this.selectElement.selectedDescriptionColor = "#E7E5E4";
+
+    // Rebuild options to show checkboxes (only deletable worktrees)
+    this.selectElement.options = this.buildOptions(deletableWorktrees);
     this.instructions.content =
       "Enter toggle selection • d confirm delete • Esc cancel";
     this.setStatus("Select worktrees to delete, then press 'd' to confirm.", "info");
@@ -1294,6 +1355,20 @@ class WorktreeSelector {
   private exitSelectMode(): void {
     this.isSelectingForDelete = false;
     this.selectedForDelete.clear();
+
+    // Restore original title
+    this.title.content = "OPENCODE WORKTREES";
+    this.title.fg = "#E2E8F0";
+
+    // Restore original select element colors
+    this.selectElement.backgroundColor = "#0F172A";
+    this.selectElement.focusedBackgroundColor = "#1E293B";
+    this.selectElement.selectedBackgroundColor = "#1E3A5F";
+    this.selectElement.textColor = "#E2E8F0";
+    this.selectElement.selectedTextColor = "#38BDF8";
+    this.selectElement.descriptionColor = "#94A3B8";
+    this.selectElement.selectedDescriptionColor = "#E2E8F0";
+
     this.loadWorktrees();
     this.instructions.content =
       "↑/↓ navigate • Enter open • o folder • d delete • n new • c config • q quit";
@@ -1320,10 +1395,13 @@ class WorktreeSelector {
       this.selectedForDelete.add(worktree.path);
     }
 
-    // Rebuild options to update checkboxes
+    // Rebuild options to update checkboxes (only deletable worktrees)
     if (this.repoRoot) {
       const worktrees = listWorktrees(this.repoRoot);
-      this.selectElement.options = this.buildOptions(worktrees);
+      const deletableWorktrees = worktrees.filter(
+        (wt) => !isMainWorktree(this.repoRoot!, wt.path)
+      );
+      this.selectElement.options = this.buildOptions(deletableWorktrees);
       // Restore selection index
       this.selectElement.setSelectedIndex(selectedIndex);
     }
@@ -1369,7 +1447,7 @@ class WorktreeSelector {
     const hasDirty = dirtyWorktrees.length > 0;
 
     const count = worktrees.length;
-    const title = `DELETE ${count} WORKTREE${count === 1 ? "" : "S"}`;
+    const title = `Delete ${count} worktree${count === 1 ? "" : "s"}`;
 
     this.confirmContainer = new BoxRenderable(this.renderer, {
       id: "confirm-container",
@@ -1377,36 +1455,18 @@ class WorktreeSelector {
       left: 2,
       top: 3,
       width: 76,
-      height: hasDirty ? 14 : 12,
+      height: hasDirty ? 12 : 10,
       borderStyle: "single",
-      borderColor: "#EF4444",
+      borderColor: "#F59E0B",
       title,
       titleAlignment: "center",
-      backgroundColor: "#1C1917",
+      backgroundColor: "#0F172A",
       border: true,
     });
     this.renderer.root.add(this.confirmContainer);
 
     let yOffset = 1;
 
-    // List branches to be deleted prominently
-    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 branchHeader = new TextRenderable(this.renderer, {
-      id: "confirm-branches",
-      position: "absolute",
-      left: 1,
-      top: yOffset,
-      content: `Branches: ${displayList}`,
-      fg: "#FBBF24",
-    });
-    this.confirmContainer.add(branchHeader);
-    yOffset += 2;
-
     // Warning for dirty worktrees
     if (hasDirty) {
       const warningText = new TextRenderable(this.renderer, {
@@ -1415,22 +1475,28 @@ class WorktreeSelector {
         left: 1,
         top: yOffset,
         content: `⚠ ${dirtyWorktrees.length} worktree${dirtyWorktrees.length === 1 ? " has" : "s have"} uncommitted changes!`,
-        fg: "#EF4444",
+        fg: "#F59E0B",
       });
       this.confirmContainer.add(warningText);
       yOffset += 2;
     }
 
-    // Info text
-    const infoText = new TextRenderable(this.renderer, {
-      id: "confirm-info",
+    // 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: "This will remove worktree directories from disk.",
-      fg: "#A8A29E",
+      content: `Worktrees: ${displayList}`,
+      fg: "#94A3B8",
     });
-    this.confirmContainer.add(infoText);
+    this.confirmContainer.add(listText);
     yOffset += 2;
 
     // Build options
@@ -1460,13 +1526,13 @@ class WorktreeSelector {
       width: 72,
       height: 4,
       options,
-      backgroundColor: "#1C1917",
-      focusedBackgroundColor: "#292524",
-      selectedBackgroundColor: "#44403C",
-      textColor: "#E7E5E4",
-      selectedTextColor: "#F87171",
-      descriptionColor: "#A8A29E",
-      selectedDescriptionColor: "#E7E5E4",
+      backgroundColor: "#0F172A",
+      focusedBackgroundColor: "#1E293B",
+      selectedBackgroundColor: "#1E3A5F",
+      textColor: "#E2E8F0",
+      selectedTextColor: "#38BDF8",
+      descriptionColor: "#94A3B8",
+      selectedDescriptionColor: "#E2E8F0",
       showDescription: true,
       wrapSelection: true,
     });

package/src/update-check.ts

@@ -0,0 +1,163 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export type UpdateInfo = {
+  hasUpdate: boolean;
+  current: string;
+  latest: string;
+};
+
+type UpdateCache = {
+  name: string; // Package name to verify cache matches
+  latest: string;
+  lastCheck: number;
+};
+
+const CACHE_DIR = path.join(os.homedir(), ".config", "configstore");
+const CACHE_FILE = path.join(CACHE_DIR, "opencode-worktree-update.json");
+
+// Check interval: 1 hour in milliseconds
+const CHECK_INTERVAL_MS = 60 * 60 * 1000;
+
+/**
+ * Read the cached update info from disk
+ * Returns null if cache doesn't exist or package name doesn't match
+ */
+function readCache(packageName: string): UpdateCache | null {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) {
+      return null;
+    }
+    const content = fs.readFileSync(CACHE_FILE, "utf-8");
+    const cache = JSON.parse(content) as UpdateCache;
+    
+    // Verify the cache is for the correct package
+    if (cache.name !== packageName) {
+      return null;
+    }
+    
+    return cache;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare two semver version strings
+ * Returns true if latest > current
+ */
+function isNewerVersion(current: string, latest: string): boolean {
+  // Handle dev versions
+  if (current === "dev" || current === "0.0.0") {
+    return false;
+  }
+
+  const parseVersion = (v: string): number[] => {
+    return v
+      .replace(/^v/, "")
+      .split(".")
+      .map((n) => parseInt(n, 10) || 0);
+  };
+
+  const currentParts = parseVersion(current);
+  const latestParts = parseVersion(latest);
+
+  for (let i = 0; i < 3; i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+
+  return false;
+}
+
+/**
+ * Spawn a detached background process to fetch the latest version from npm
+ * and write it to the cache file. This doesn't block the main process.
+ */
+function fetchLatestInBackground(packageName: string): void {
+  // Create an inline script that fetches from npm and writes to cache
+  const script = `
+    const https = require('https');
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+
+    const cacheDir = path.join(os.homedir(), '.config', 'configstore');
+    const cacheFile = path.join(cacheDir, 'opencode-worktree-update.json');
+
+    const url = 'https://registry.npmjs.org/${packageName}/latest';
+
+    https.get(url, { headers: { 'Accept': 'application/json' } }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const pkg = JSON.parse(data);
+          if (pkg.version) {
+            if (!fs.existsSync(cacheDir)) {
+              fs.mkdirSync(cacheDir, { recursive: true });
+            }
+            fs.writeFileSync(cacheFile, JSON.stringify({
+              name: '${packageName}',
+              latest: pkg.version,
+              lastCheck: Date.now()
+            }, null, 2));
+          }
+        } catch {}
+      });
+    }).on('error', () => {});
+  `;
+
+  try {
+    // Spawn node to run the script
+    const child = spawn(process.execPath, ["-e", script], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env },
+    });
+
+    // Unref so the parent process can exit independently
+    child.unref();
+  } catch {
+    // Silently fail - background fetch is best-effort
+  }
+}
+
+/**
+ * Check for updates. This is non-blocking:
+ * 1. Reads the cached latest version (if available)
+ * 2. Compares against current version
+ * 3. Spawns a background process to refresh the cache for next time
+ *
+ * Returns null if no cache exists yet (first run)
+ */
+export function checkForUpdate(pkg: {
+  name: string;
+  version: string;
+}): UpdateInfo | null {
+  const cache = readCache(pkg.name);
+  const now = Date.now();
+
+  // Spawn background fetch if cache is stale or doesn't exist
+  const shouldFetch =
+    !cache || now - cache.lastCheck > CHECK_INTERVAL_MS;
+
+  if (shouldFetch) {
+    fetchLatestInBackground(pkg.name);
+  }
+
+  // If no cache, we can't determine if there's an update yet
+  if (!cache) {
+    return null;
+  }
+
+  return {
+    hasUpdate: isNewerVersion(pkg.version, cache.latest),
+    current: pkg.version,
+    latest: cache.latest,
+  };
+}