@jhorst11/wt 1.0.1 → 2.0.1

package/src/config.js

@@ -0,0 +1,257 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+
+const CONFIG_DIR = '.wt';
+const CONFIG_FILE = 'config.json';
+
+/**
+ * Load configuration from .wt/config.json or config.json at the given directory.
+ * Tries .wt/config.json first (for repo/directory configs), then config.json (for global configs).
+ * Returns an object with defaults for any missing fields.
+ */
+export function loadConfig(dirPath) {
+  const configPaths = [
+    join(dirPath, CONFIG_DIR, CONFIG_FILE),  // .wt/config.json (for repo/directory)
+    join(dirPath, CONFIG_FILE),               // config.json (for global config dir)
+  ];
+  const defaults = {
+    projectsDir: undefined,
+    worktreesDir: undefined,
+    branchPrefix: undefined,
+    hooks: {},
+  };
+
+  let raw;
+  for (const configPath of configPaths) {
+    try {
+      raw = readFileSync(configPath, 'utf8');
+      break;
+    } catch {
+      // Try next path
+    }
+  }
+
+  if (!raw) {
+    return defaults;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return defaults;
+  }
+
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    return defaults;
+  }
+
+  const result = { ...defaults };
+
+  if (typeof parsed.projectsDir === 'string') {
+    result.projectsDir = parsed.projectsDir;
+  }
+
+  if (typeof parsed.worktreesDir === 'string') {
+    result.worktreesDir = parsed.worktreesDir;
+  }
+
+  if (typeof parsed.branchPrefix === 'string') {
+    result.branchPrefix = parsed.branchPrefix;
+  }
+
+  if (typeof parsed.hooks === 'object' && parsed.hooks !== null && !Array.isArray(parsed.hooks)) {
+    for (const [hookName, commands] of Object.entries(parsed.hooks)) {
+      if (Array.isArray(commands) && commands.every((c) => typeof c === 'string')) {
+        result.hooks[hookName] = commands;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Find all config files from global to cwd within repo boundaries.
+ * Walks up from cwd to repoRoot, collecting all .wt/config.json paths.
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string} repoRoot - Git repository root
+ * @param {string} [globalConfigPath] - Path to global config (default: ~/.wt/config.json)
+ * @returns {string[]} Array of config file paths (global first)
+ */
+function findConfigFiles(cwd, repoRoot, globalConfigPath = join(homedir(), '.wt', CONFIG_FILE)) {
+  const paths = [];
+
+  // Add global config if it exists
+  try {
+    readFileSync(globalConfigPath, 'utf8');
+    paths.push(globalConfigPath);
+  } catch {
+    // Global config doesn't exist, that's fine
+  }
+
+  // Build list of directories from repoRoot down to cwd
+  // Normalize paths for comparison
+  const normalizedCwd = cwd.replace(/\/$/, '');
+  const normalizedRepoRoot = repoRoot.replace(/\/$/, '');
+
+  if (!normalizedCwd.startsWith(normalizedRepoRoot)) {
+    // cwd is outside repo root, skip walking
+    return paths;
+  }
+
+  // Collect config paths from repoRoot up to cwd
+  const configPaths = [];
+
+  // Start at repoRoot
+  let current = normalizedRepoRoot;
+  const parts = normalizedCwd.slice(normalizedRepoRoot.length).split('/').filter(Boolean);
+
+  // Add repo root config
+  const repoConfigPath = join(normalizedRepoRoot, CONFIG_DIR, CONFIG_FILE);
+  try {
+    readFileSync(repoConfigPath, 'utf8');
+    configPaths.push(repoConfigPath);
+  } catch {
+    // No config at repo root
+  }
+
+  // Add configs for each directory down to cwd
+  for (const part of parts) {
+    current = join(current, part);
+    const configPath = join(current, CONFIG_DIR, CONFIG_FILE);
+    try {
+      readFileSync(configPath, 'utf8');
+      configPaths.push(configPath);
+    } catch {
+      // No config at this directory
+    }
+  }
+
+  return paths.concat(configPaths);
+}
+
+/**
+ * Merge multiple config objects with last-wins strategy.
+ * For scalar fields, last defined value wins.
+ * For hooks object, merge all hook definitions.
+ *
+ * @param {Object[]} configs - Array of config objects (least specific first)
+ * @returns {Object} Merged config
+ */
+function mergeConfigs(configs) {
+  const result = {
+    projectsDir: undefined,
+    worktreesDir: undefined,
+    branchPrefix: undefined,
+    hooks: {},
+  };
+
+  for (const config of configs) {
+    if (config.projectsDir !== undefined) {
+      result.projectsDir = config.projectsDir;
+    }
+    if (config.worktreesDir !== undefined) {
+      result.worktreesDir = config.worktreesDir;
+    }
+    if (config.branchPrefix !== undefined) {
+      result.branchPrefix = config.branchPrefix;
+    }
+    if (config.hooks && typeof config.hooks === 'object') {
+      for (const [hookName, commands] of Object.entries(config.hooks)) {
+        result.hooks[hookName] = commands;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Resolve hierarchical config by walking up from cwd to repoRoot.
+ * Returns merged config with defaults for any missing fields.
+ *
+ * @param {string} [cwd] - Current working directory (default: process.cwd())
+ * @param {string} repoRoot - Git repository root
+ * @param {string} [globalConfigPath] - Override global config path (for testing)
+ * @returns {Object} Resolved config with all fields
+ */
+export function resolveConfig(cwd = process.cwd(), repoRoot, globalConfigPath) {
+  const defaults = {
+    projectsDir: join(homedir(), 'projects'),
+    worktreesDir: join(homedir(), 'projects', 'worktrees'),
+    branchPrefix: '',
+    hooks: {},
+  };
+
+  // Determine the effective global config path
+  const effectiveGlobalConfigPath = globalConfigPath || join(homedir(), '.wt', CONFIG_FILE);
+
+  // Find all config files from global to cwd
+  const configPaths = findConfigFiles(cwd, repoRoot, effectiveGlobalConfigPath);
+
+  // Load each config file by extracting the directory path
+  const configs = configPaths.map((path) => {
+    // For global config, extract the directory containing it
+    if (path === effectiveGlobalConfigPath) {
+      const globalConfigDir = path.endsWith(CONFIG_FILE)
+        ? path.slice(0, path.lastIndexOf('/'))
+        : path;
+      return loadConfig(globalConfigDir);
+    }
+    // For other configs at /path/.wt/config.json, directory is /path
+    const dirPath = path.slice(0, path.lastIndexOf('/.wt'));
+    return loadConfig(dirPath);
+  });
+
+  // Merge configs
+  const merged = mergeConfigs(configs);
+
+  // Apply defaults for missing fields
+  return {
+    projectsDir: merged.projectsDir ?? defaults.projectsDir,
+    worktreesDir: merged.worktreesDir ?? defaults.worktreesDir,
+    branchPrefix: merged.branchPrefix ?? defaults.branchPrefix,
+    hooks: merged.hooks,
+  };
+}
+
+/**
+ * Run hook commands sequentially. Each command runs with cwd set to `wtPath`
+ * and receives WT_SOURCE, WT_BRANCH, and WT_PATH as environment variables.
+ *
+ * Returns an array of { command, success, error? } results.
+ * Hook failures are non-fatal — they produce warnings but don't throw.
+ */
+export function runHooks(hookName, config, { source, path: wtPath, branch }) {
+  const commands = config.hooks?.[hookName];
+  if (!commands || commands.length === 0) return [];
+
+  const env = {
+    ...process.env,
+    WT_SOURCE: source,
+    WT_BRANCH: branch,
+    WT_PATH: wtPath,
+  };
+
+  const results = [];
+
+  for (const cmd of commands) {
+    try {
+      execSync(cmd, {
+        cwd: wtPath,
+        env,
+        stdio: 'pipe',
+        timeout: 300_000, // 5 minute timeout per command
+      });
+      results.push({ command: cmd, success: true });
+    } catch (err) {
+      results.push({ command: cmd, success: false, error: err.message });
+    }
+  }
+
+  return results;
+}

package/src/git.js

@@ -1,18 +1,7 @@
 import { simpleGit } from 'simple-git';
-import { homedir } from 'os';
 import { join, basename, relative } from 'path';
 import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
-
-// Configuration - can be overridden via environment variables
-const config = {
-  projectsDir: process.env.W_PROJECTS_DIR || join(homedir(), 'projects'),
-  worktreesDir: process.env.W_WORKTREES_DIR || join(homedir(), 'projects', 'worktrees'),
-  branchPrefix: process.env.W_DEFAULT_BRANCH_PREFIX || '',
-};
-
-export function getConfig() {
-  return { ...config };
-}
+import { resolveConfig } from './config.js';
 
 export async function getGit(cwd = process.cwd()) {
   return simpleGit(cwd);
@@ -96,7 +85,7 @@ export async function getAllBranches(cwd = process.cwd()) {
   };
 }
 
-export function getWorktreesBase(repoRoot) {
+export function getWorktreesBase(repoRoot, config) {
   const projectsDir = config.projectsDir.replace(/\/$/, '');
   let repoRel;
 
@@ -141,8 +130,8 @@ export async function getWorktrees(cwd = process.cwd()) {
   }
 }
 
-export async function getWorktreesInBase(repoRoot) {
-  const base = getWorktreesBase(repoRoot);
+export async function getWorktreesInBase(repoRoot, config) {
+  const base = getWorktreesBase(repoRoot, config);
   if (!existsSync(base)) return [];
 
   try {
@@ -182,8 +171,9 @@ export async function getMainRepoPath(cwd = process.cwd()) {
   }
 }
 
-export function buildBranchName(leaf, prefix = config.branchPrefix) {
+export function buildBranchName(leaf, config) {
   const cleanLeaf = leaf.replace(/^\//, '').replace(/ /g, '-');
+  const prefix = config.branchPrefix || '';
   if (prefix) {
     return `${prefix.replace(/\/$/, '')}/${cleanLeaf}`;
   }
@@ -193,8 +183,13 @@ export function buildBranchName(leaf, prefix = config.branchPrefix) {
 export async function branchExistsLocal(branchName, cwd = process.cwd()) {
   try {
     const git = await getGit(cwd);
-    await git.raw(['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`]);
-    return true;
+    // Do not use --quiet: simple-git swallows non-zero exit codes when output is
+    // empty, so `--quiet` (which suppresses output) causes the try-block to
+    // succeed even when the ref does not exist.  Without --quiet the command
+    // prints the SHA on success (keeping the try path) and writes to stderr on
+    // failure (causing simple-git to throw into the catch path).
+    const result = await git.raw(['show-ref', '--verify', `refs/heads/${branchName}`]);
+    return result.trim().length > 0;
   } catch {
     return false;
   }
@@ -213,10 +208,37 @@ export async function branchExistsRemote(branchName, cwd = process.cwd()) {
 export async function ensureBranch(branchName, baseBranch = null, cwd = process.cwd()) {
   const git = await getGit(cwd);
 
+  // Resolve detached HEAD to the actual commit SHA so it's usable as a base
+  if (baseBranch === 'HEAD') {
+    try {
+      baseBranch = (await git.revparse(['HEAD'])).trim();
+    } catch {
+      throw new Error('HEAD does not point to a valid commit. Is this a new repository with no commits?');
+    }
+  }
+
   // If baseBranch is a remote ref, fetch it first to ensure it's up to date
   if (baseBranch && baseBranch.startsWith('origin/')) {
     const remoteBranchName = baseBranch.replace('origin/', '');
-    await git.fetch(['origin', `${remoteBranchName}:refs/remotes/origin/${remoteBranchName}`]).catch(() => {});
+    try {
+      await git.fetch(['origin', `${remoteBranchName}:refs/remotes/origin/${remoteBranchName}`]);
+    } catch (fetchErr) {
+      // Fetch failed - verify the remote ref still exists locally from a previous fetch
+      try {
+        await git.revparse(['--verify', baseBranch]);
+      } catch {
+        throw new Error(`Failed to fetch remote branch '${remoteBranchName}' and no local copy exists. The remote branch may have been deleted.`);
+      }
+    }
+  }
+
+  // If baseBranch is specified, verify it resolves to a valid ref
+  if (baseBranch) {
+    try {
+      await git.revparse(['--verify', baseBranch]);
+    } catch {
+      throw new Error(`Base branch '${baseBranch}' does not exist or is not a valid reference.`);
+    }
   }
 
   // Check if branch exists locally
@@ -228,9 +250,7 @@ export async function ensureBranch(branchName, baseBranch = null, cwd = process.
         const remoteSha = (await git.revparse([baseBranch])).trim();
 
         if (localSha !== remoteSha) {
-          // Local branch exists but points to different commit than remote
-          // Reset the local branch to match the remote
-          await git.branch(['-f', branchName, baseBranch]);
+          await git.raw(['branch', '-f', branchName, baseBranch]);
           return { created: false, source: 'updated-from-remote' };
         }
       } catch {
@@ -248,9 +268,9 @@ export async function ensureBranch(branchName, baseBranch = null, cwd = process.
 
   // Create new branch from base
   if (baseBranch) {
-    await git.branch([branchName, baseBranch]);
+    await git.raw(['branch', branchName, baseBranch]);
   } else {
-    await git.branch([branchName]);
+    await git.raw(['branch', branchName]);
   }
 
   return { created: true, source: 'new' };
@@ -259,7 +279,11 @@ export async function ensureBranch(branchName, baseBranch = null, cwd = process.
 export async function createWorktree(name, branchName, baseBranch = null, cwd = process.cwd()) {
   const git = await getGit(cwd);
   const repoRoot = await getRepoRoot(cwd);
-  const worktreesBase = getWorktreesBase(repoRoot);
+  const config = resolveConfig(cwd, repoRoot);
+  const worktreesBase = getWorktreesBase(repoRoot, config);
+
+  // Prune stale worktree references before creating a new one
+  await pruneWorktrees(cwd);
 
   // Ensure worktrees directory exists
   if (!existsSync(worktreesBase)) {
@@ -276,10 +300,11 @@ export async function createWorktree(name, branchName, baseBranch = null, cwd =
   // Fetch all remotes
   await git.fetch(['--all', '--prune']).catch(() => {});
 
-  // Ensure branch exists
+  // Ensure branch exists (or determine if we need to create it)
   const branchResult = await ensureBranch(branchName, baseBranch, cwd);
 
-  // Create worktree
+  // Create worktree — ensureBranch guarantees the branch already exists, so we
+  // just attach the worktree to it.
   await git.raw(['worktree', 'add', worktreePath, branchName]);
 
   return {
@@ -293,6 +318,10 @@ export async function createWorktree(name, branchName, baseBranch = null, cwd =
 
 export async function removeWorktree(path, force = false, cwd = process.cwd()) {
   const git = await getGit(cwd);
+
+  // Prune stale worktree references before removing
+  await pruneWorktrees(cwd);
+
   const args = ['worktree', 'remove'];
   if (force) args.push('--force');
   args.push(path);

package/src/setup.js

@@ -1,4 +1,5 @@
 import { select, confirm } from '@inquirer/prompts';
+import { ExitPromptError } from '@inquirer/core';
 import { homedir } from 'os';
 import { existsSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
@@ -130,7 +131,7 @@ export async function setupCommand() {
     info(`SHELL environment variable: ${process.env.SHELL || 'not set'}`);
     spacer();
     console.log(`  ${colors.muted('Please manually add the shell wrapper to your shell config.')}`);
-    console.log(`  ${colors.muted('See:')} ${colors.path('https://github.com/your-repo/wt#shell-integration')}`);
+    console.log(`  ${colors.muted('See:')} ${colors.path('https://github.com/jhorst11/wt#shell-integration')}`);
     spacer();
     return;
   }
@@ -158,34 +159,44 @@ export async function setupCommand() {
   console.log(`  ${colors.muted('add a small shell function to your')} ${colors.path(config.rcFile)}`);
   spacer();
 
-  const action = await select({
-    message: 'How would you like to proceed?',
-    choices: [
-      {
-        name: `${icons.sparkles}  Auto-install (append to ${config.rcFile})`,
-        value: 'auto',
-        description: 'Recommended - automatically adds the integration',
-      },
-      {
-        name: `${icons.info}  Show me the code to copy`,
-        value: 'show',
-        description: 'Display the code so you can add it manually',
-      },
-      {
-        name: `${colors.muted(icons.cross + '  Skip for now')}`,
-        value: 'skip',
-      },
-    ],
-    theme: { prefix: icons.tree },
-  });
+  try {
+    const action = await select({
+      message: 'How would you like to proceed?',
+      choices: [
+        {
+          name: `${icons.sparkles}  Auto-install (append to ${config.rcFile})`,
+          value: 'auto',
+          description: 'Recommended - automatically adds the integration',
+        },
+        {
+          name: `${icons.info}  Show me the code to copy`,
+          value: 'show',
+          description: 'Display the code so you can add it manually',
+        },
+        {
+          name: `${colors.muted(icons.cross + '  Skip for now')}`,
+          value: 'skip',
+        },
+      ],
+      theme: { prefix: icons.tree },
+    });
 
-  if (action === 'auto') {
-    await autoInstall(config);
-  } else if (action === 'show') {
-    showManualInstructions(config);
-  } else {
-    info('Skipped. You can run `wt setup` anytime to configure shell integration.');
-    spacer();
+    if (action === 'auto') {
+      await autoInstall(config);
+    } else if (action === 'show') {
+      showManualInstructions(config);
+    } else {
+      info('Skipped. You can run `wt setup` anytime to configure shell integration.');
+      spacer();
+    }
+  } catch (err) {
+    if (err instanceof ExitPromptError) {
+      spacer();
+      info('Cancelled');
+      spacer();
+      return;
+    }
+    throw err;
   }
 }
 

package/src/ui.js

@@ -1,6 +1,10 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import figures from 'figures';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 
 // Custom gradient for the logo
 const wtGradient = gradient(['#00d4ff', '#7c3aed', '#f472b6']);
@@ -52,7 +56,7 @@ export function showLogo() {
 }
 
 export function showMiniLogo() {
-  console.log(`\n  ${icons.tree} ${wtGradient('worktree')} ${colors.muted('v1.0.0')}\n`);
+  console.log(`\n  ${icons.tree} ${wtGradient('worktree')} ${colors.muted(`v${version}`)}\n`);
 }
 
 export function success(message) {
@@ -125,10 +129,12 @@ export function showHelp() {
   const commands = [
     ['wt', 'Interactive menu to manage worktrees'],
     ['wt new', 'Create a new worktree interactively'],
-    ['wt list', 'List all worktrees for current repo'],
-    ['wt remove', 'Remove a worktree interactively'],
+    ['wt list|ls', 'List all worktrees for current repo'],
+    ['wt go [name]', 'Jump to a worktree (interactive if no name)'],
+    ['wt merge', 'Merge a worktree branch into another branch'],
+    ['wt remove|rm', 'Remove a worktree interactively'],
     ['wt home', 'Jump back to the main repository'],
-    ['wt go <name>', 'Jump to a specific worktree'],
+    ['wt setup', 'Configure shell integration for auto-navigation'],
   ];
 
   commands.forEach(([cmd, desc]) => {