opencode-worktree 0.3.4 → 0.4.0

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
 
@@ -8,18 +8,21 @@ Terminal UI for managing git worktrees and launching `opencode` in the selected
 - 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
+- **Create branch from worktree**: create a new branch from any worktree's current commit, with optional checkout
 - 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
+- **Global configuration**: settings stored in `~/.config/opencode-worktree/config.json` with per-repo overrides
 - 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,14 +45,22 @@ 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)
+- `b`: create a new branch from selected worktree's current commit
+- `c`: edit configuration (hooks, open command, launch command)
 - `r`: refresh list
 - `q` or `Esc`: quit (or cancel dialogs/modes)
 
+### Create branch from worktree
+
+1. Select a worktree and press `b`
+2. Enter a name for the new branch
+3. The branch is created starting from the worktree's current commit
+4. Choose whether to checkout the new branch in the worktree
+
 ### Multi-select delete mode
 
 1. Press `d` to enter selection mode
@@ -59,73 +70,92 @@ opencode-worktree /path/to/your/repo
 
 ## Configuration
 
-You can configure per-repository settings by creating a `.opencode-worktree.json` file in your repository root.
+Configuration is stored globally at `~/.config/opencode-worktree/config.json` with support for default settings and per-repository overrides. Press `c` in the TUI to edit settings.
 
-### First-time setup
+Repositories are identified by their git remote URL (e.g., `github.com/user/repo`).
 
-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`.
+### Configuration structure
 
-### Editing configuration
+```json
+{
+  "default": {
+    "postCreateHook": "",
+    "openCommand": "",
+    "launchCommand": "opencode"
+  },
+  "repos": {
+    "github.com/user/repo": {
+      "postCreateHook": "npm install",
+      "launchCommand": "cursor"
+    }
+  }
+}
+```
 
-Press `c` at any time to edit your configuration. You can configure:
+### Configuration options
 
-- **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`)
+| 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` |
 
-### Post-create hooks
+### Example per-repo configuration
 
-Run a command automatically after creating a new worktree. Useful for installing dependencies.
+When you edit config in the TUI, settings are saved under the repo's key (derived from git remote URL):
 
 ```json
 {
-  "postCreateHook": "npm install"
+  "default": {
+    "launchCommand": "opencode"
+  },
+  "repos": {
+    "github.com/myorg/frontend": {
+      "postCreateHook": "npm install",
+      "openCommand": "code",
+      "launchCommand": "cursor"
+    },
+    "github.com/myorg/backend": {
+      "postCreateHook": "go mod download",
+      "launchCommand": "zed"
+    }
+  }
 }
 ```
 
-The hook output is streamed to the TUI in real-time. If the hook fails, you can choose to open opencode anyway or cancel.
+### Editing configuration
 
-**Examples:**
+Press `c` at any time to edit your configuration. The config editor title shows which repository you're configuring (e.g., "Config: github.com/user/repo"). Use `Tab` to switch between fields.
 
-```json
-{
-  "postCreateHook": "bun install"
-}
-```
+**Note:** Repositories without a git remote will use default settings. The TUI shows a warning when editing config for repos without a remote.
 
-```json
-{
-  "postCreateHook": "npm install && npm run setup"
-}
-```
+### Post-create hooks
+
+Run a command automatically after creating a new worktree. Useful for installing dependencies.
+
+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:** `npm install`, `bun install`, `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:** `code`, `webstorm`, `idea`
 
-**Examples:**
+### Custom launch command
 
-```json
-{
-  "openCommand": "code"
-}
-```
+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
-{
-  "postCreateHook": "npm install",
-  "openCommand": "webstorm"
-}
-```
+**Examples:** `cursor`, `claude`, `code`, `zed`
+
+### Migration from v0.3.x
+
+Previous versions stored config in `.opencode-worktree.json` files in each repository. These files are now ignored. Your settings will need to be reconfigured via the TUI (`c` key), which will save them to the new global config location.
 
 ## 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.4",
+  "version": "0.4.0",
   "private": false,
   "type": "module",
   "description": "TUI for managing git worktrees with opencode integration.",

package/src/config.ts

@@ -1,74 +1,213 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
+import { getRepoKey } from "./git.js";
+import type { Config, GlobalConfig, LoadRepoConfigResult } from "./types.js";
 
-export type Config = {
-  postCreateHook?: string;
-  openCommand?: string; // Custom command to open worktree folder (e.g., "webstorm", "code")
+// Re-export Config type for backwards compatibility
+export type { Config } from "./types.js";
+
+const CONFIG_DIR = join(homedir(), ".config", "opencode-worktree");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+/**
+ * Get the path to the global config directory
+ */
+export const getGlobalConfigDir = (): string => {
+  return CONFIG_DIR;
 };
 
-const CONFIG_FILENAME = ".opencode-worktree.json";
+/**
+ * Get the path to the global config file
+ */
+export const getGlobalConfigPath = (): string => {
+  return CONFIG_FILE;
+};
 
 /**
- * Get the path to the config file for a repo
+ * Get the default configuration values
  */
-export const getConfigPath = (repoRoot: string): string => {
-  return join(repoRoot, CONFIG_FILENAME);
+export const getDefaultConfig = (): Config => {
+  return {
+    postCreateHook: "",
+    openCommand: "",
+    launchCommand: "opencode",
+  };
 };
 
 /**
- * Check if a config file exists for the repo
+ * Create an empty global config structure
  */
-export const configExists = (repoRoot: string): boolean => {
-  return existsSync(getConfigPath(repoRoot));
+const createEmptyGlobalConfig = (): GlobalConfig => {
+  return {
+    default: getDefaultConfig(),
+    repos: {},
+  };
 };
 
 /**
- * Load per-repo configuration from .opencode-worktree.json in the repo root
+ * Ensure the config directory exists
  */
-export const loadRepoConfig = (repoRoot: string): Config => {
-  const configPath = getConfigPath(repoRoot);
+const ensureConfigDir = (): boolean => {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
 
-  if (!existsSync(configPath)) {
-    return {};
+/**
+ * Load the entire global config file
+ */
+export const loadGlobalConfig = (): GlobalConfig => {
+  if (!existsSync(CONFIG_FILE)) {
+    return createEmptyGlobalConfig();
   }
 
   try {
-    const content = readFileSync(configPath, "utf8");
+    const content = readFileSync(CONFIG_FILE, "utf8");
     const parsed = JSON.parse(content);
 
-    // Validate the config structure
+    // Validate and normalize the config structure
     if (typeof parsed !== "object" || parsed === null) {
-      return {};
+      return createEmptyGlobalConfig();
     }
 
-    const config: Config = {};
+    const globalConfig: GlobalConfig = {
+      default: { ...getDefaultConfig() },
+      repos: {},
+    };
 
-    if (typeof parsed.postCreateHook === "string") {
-      config.postCreateHook = parsed.postCreateHook;
+    // Parse default config
+    if (typeof parsed.default === "object" && parsed.default !== null) {
+      if (typeof parsed.default.postCreateHook === "string") {
+        globalConfig.default.postCreateHook = parsed.default.postCreateHook;
+      }
+      if (typeof parsed.default.openCommand === "string") {
+        globalConfig.default.openCommand = parsed.default.openCommand;
+      }
+      if (typeof parsed.default.launchCommand === "string") {
+        globalConfig.default.launchCommand = parsed.default.launchCommand;
+      }
     }
 
-    if (typeof parsed.openCommand === "string") {
-      config.openCommand = parsed.openCommand;
+    // Parse repos config
+    if (typeof parsed.repos === "object" && parsed.repos !== null) {
+      for (const [key, value] of Object.entries(parsed.repos)) {
+        if (typeof value === "object" && value !== null) {
+          const repoConfig: Partial<Config> = {};
+          const v = value as Record<string, unknown>;
+
+          if (typeof v.postCreateHook === "string") {
+            repoConfig.postCreateHook = v.postCreateHook;
+          }
+          if (typeof v.openCommand === "string") {
+            repoConfig.openCommand = v.openCommand;
+          }
+          if (typeof v.launchCommand === "string") {
+            repoConfig.launchCommand = v.launchCommand;
+          }
+
+          // Only add if there are actual values
+          if (Object.keys(repoConfig).length > 0) {
+            globalConfig.repos[key] = repoConfig;
+          }
+        }
+      }
     }
 
-    return config;
+    return globalConfig;
   } catch {
     // If we can't read or parse the config, return empty
-    return {};
+    return createEmptyGlobalConfig();
   }
 };
 
 /**
- * Save configuration to .opencode-worktree.json in the repo root
+ * Save the entire global config file
  */
-export const saveRepoConfig = (repoRoot: string, config: Config): boolean => {
-  const configPath = getConfigPath(repoRoot);
+export const saveGlobalConfig = (config: GlobalConfig): boolean => {
+  if (!ensureConfigDir()) {
+    return false;
+  }
 
   try {
     const content = JSON.stringify(config, null, 2) + "\n";
-    writeFileSync(configPath, content, "utf8");
+    writeFileSync(CONFIG_FILE, content, "utf8");
     return true;
   } catch {
     return false;
   }
 };
+
+/**
+ * Load configuration for a specific repository
+ * Merges default config with repo-specific overrides
+ * Returns the config and the repo key (null if no remote)
+ */
+export const loadRepoConfig = (repoRoot: string): LoadRepoConfigResult => {
+  const repoKey = getRepoKey(repoRoot);
+  const globalConfig = loadGlobalConfig();
+
+  // Start with default config
+  const config: Config = { ...globalConfig.default };
+
+  // If we have a repo key, merge in repo-specific config
+  if (repoKey && globalConfig.repos[repoKey]) {
+    const repoConfig = globalConfig.repos[repoKey];
+
+    if (repoConfig.postCreateHook !== undefined) {
+      config.postCreateHook = repoConfig.postCreateHook;
+    }
+    if (repoConfig.openCommand !== undefined) {
+      config.openCommand = repoConfig.openCommand;
+    }
+    if (repoConfig.launchCommand !== undefined) {
+      config.launchCommand = repoConfig.launchCommand;
+    }
+  }
+
+  return { config, repoKey };
+};
+
+/**
+ * Save configuration for a specific repository
+ * Only saves values that differ from the default
+ * Returns false if there's no remote (can't save repo-specific config)
+ */
+export const saveRepoConfig = (repoRoot: string, config: Config): boolean => {
+  const repoKey = getRepoKey(repoRoot);
+
+  if (!repoKey) {
+    // No remote - can't save repo-specific config
+    return false;
+  }
+
+  const globalConfig = loadGlobalConfig();
+
+  // Calculate which values differ from default
+  const repoConfig: Partial<Config> = {};
+
+  if (config.postCreateHook !== globalConfig.default.postCreateHook) {
+    repoConfig.postCreateHook = config.postCreateHook;
+  }
+  if (config.openCommand !== globalConfig.default.openCommand) {
+    repoConfig.openCommand = config.openCommand;
+  }
+  if (config.launchCommand !== globalConfig.default.launchCommand) {
+    repoConfig.launchCommand = config.launchCommand;
+  }
+
+  // Update or remove the repo entry
+  if (Object.keys(repoConfig).length > 0) {
+    globalConfig.repos[repoKey] = repoConfig;
+  } else {
+    // All values match default, remove the entry
+    delete globalConfig.repos[repoKey];
+  }
+
+  return saveGlobalConfig(globalConfig);
+};

package/src/git.ts

@@ -1,6 +1,71 @@
 import { execFileSync } from "node:child_process";
 import { WorktreeInfo } from "./types.js";
 
+/**
+ * Get the remote origin URL for a repository
+ */
+export const getRemoteOriginUrl = (repoRoot: string): string | null => {
+  try {
+    const output = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Normalize a git remote URL to a consistent key format
+ * Examples:
+ *   git@github.com:user/repo.git → github.com/user/repo
+ *   https://github.com/user/repo.git → github.com/user/repo
+ *   ssh://git@github.com/user/repo.git → github.com/user/repo
+ */
+export const normalizeRemoteUrl = (url: string): string => {
+  let normalized = url.trim();
+
+  // Remove .git suffix
+  if (normalized.endsWith(".git")) {
+    normalized = normalized.slice(0, -4);
+  }
+
+  // Handle SSH format: git@github.com:user/repo
+  const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
+  if (sshMatch) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+
+  // Handle SSH URL format: ssh://git@github.com/user/repo
+  const sshUrlMatch = normalized.match(/^ssh:\/\/git@([^/]+)\/(.+)$/);
+  if (sshUrlMatch) {
+    return `${sshUrlMatch[1]}/${sshUrlMatch[2]}`;
+  }
+
+  // Handle HTTPS format: https://github.com/user/repo
+  const httpsMatch = normalized.match(/^https?:\/\/([^/]+)\/(.+)$/);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+
+  // Fallback: return as-is (shouldn't happen for valid URLs)
+  return normalized;
+};
+
+/**
+ * Get the normalized repo key for a repository (for config lookup)
+ * Returns null if no remote origin is configured
+ */
+export const getRepoKey = (repoRoot: string): string | null => {
+  const remoteUrl = getRemoteOriginUrl(repoRoot);
+  if (!remoteUrl) {
+    return null;
+  }
+  return normalizeRemoteUrl(remoteUrl);
+};
+
 export const resolveRepoRoot = (cwd: string): string | null => {
   try {
     const output = execFileSync("git", ["rev-parse", "--show-toplevel"], {
@@ -280,3 +345,69 @@ export const deleteWorktree = (
     return { success: false, error, step: "branch" };
   }
 };
+
+export type CreateBranchResult =
+  | { success: true }
+  | { success: false; error: string };
+
+/**
+ * Create a new branch from a specific commit
+ */
+export const createBranchFromCommit = (
+  repoRoot: string,
+  branchName: string,
+  commitHash: string,
+): CreateBranchResult => {
+  try {
+    execFileSync("git", ["branch", branchName, commitHash], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return { success: false, error };
+  }
+};
+
+export type CheckoutResult =
+  | { success: true }
+  | { success: false; error: string };
+
+/**
+ * Checkout a branch in a specific worktree
+ * Note: This changes the branch the worktree is tracking
+ */
+export const checkoutBranch = (
+  worktreePath: string,
+  branchName: string,
+): CheckoutResult => {
+  try {
+    execFileSync("git", ["checkout", branchName], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return { success: false, error };
+  }
+};
+
+/**
+ * Get the current HEAD commit hash for a worktree
+ */
+export const getHeadCommit = (worktreePath: string): string | null => {
+  try {
+    const output = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+};

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/types.ts

@@ -8,3 +8,29 @@ export type WorktreeInfo = {
   isOnRemote: boolean;
   lastModified: Date | null;
 };
+
+/**
+ * Per-repo configuration options
+ */
+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")
+};
+
+/**
+ * Global configuration structure stored at ~/.config/opencode-worktree/config.json
+ * Contains default settings and per-repo overrides keyed by normalized git remote URL
+ */
+export type GlobalConfig = {
+  default: Config;
+  repos: Record<string, Partial<Config>>;
+};
+
+/**
+ * Result of loading repo config, includes the repo key for display purposes
+ */
+export type LoadRepoConfigResult = {
+  config: Config;
+  repoKey: string | null; // null means no remote origin configured
+};