opencode-worktree 0.2.9 → 0.3.1

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,86 @@ 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 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)
 - `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. 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`)
+
+### 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"
+}
+```
+
+### Custom open command
+
+Use a custom command when pressing `o` to open worktree folders. Useful for opening in your preferred IDE.
+
+```json
+{
+  "openCommand": "webstorm"
+}
+```
+
+**Examples:**
+
+```json
+{
+  "openCommand": "code"
+}
+```
+
+```json
+{
+  "postCreateHook": "npm install",
+  "openCommand": "webstorm"
+}
+```
 
 ## Update notifications
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-worktree",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "private": false,
   "type": "module",
   "description": "TUI for managing git worktrees with opencode integration.",

package/src/config.ts

@@ -0,0 +1,74 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+export type Config = {
+  postCreateHook?: string;
+  openCommand?: string; // Custom command to open worktree folder (e.g., "webstorm", "code")
+};
+
+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;
+    }
+
+    if (typeof parsed.openCommand === "string") {
+      config.openCommand = parsed.openCommand;
+    }
+
+    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,43 @@ export const launchOpenCode = (cwd: string): void => {
     process.exit(exitCode);
   });
 };
+
+/**
+ * Open a path in the system file manager or with a custom command
+ * If customCommand is provided, uses that instead of the system default
+ */
+export const openInFileManager = (path: string, customCommand?: string): boolean => {
+  let command: string;
+  let args: string[];
+
+  if (customCommand) {
+    // Use custom command (e.g., "webstorm", "code")
+    command = customCommand;
+    args = [path];
+  } else {
+    // Use system default
+    const platform = process.platform;
+
+    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;
 };