@jhorst11/wt 2.0.1 → 2.1.0

package/src/config.js

@@ -1,257 +0,0 @@
-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,397 +0,0 @@
-import { simpleGit } from 'simple-git';
-import { join, basename, relative } from 'path';
-import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
-import { resolveConfig } from './config.js';
-
-export async function getGit(cwd = process.cwd()) {
-  return simpleGit(cwd);
-}
-
-export async function isGitRepo(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    await git.revparse(['--git-dir']);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function getRepoRoot(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    const root = await git.revparse(['--show-toplevel']);
-    return root.trim();
-  } catch {
-    return null;
-  }
-}
-
-export async function getCurrentBranch(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
-    return branch.trim();
-  } catch {
-    return null;
-  }
-}
-
-export async function getLocalBranches(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    const result = await git.branchLocal();
-    return result.all.map((name) => ({
-      name,
-      isCurrent: name === result.current,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-export async function getRemoteBranches(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    // Fetch latest from remote first
-    await git.fetch(['--all', '--prune']).catch(() => {});
-    const result = await git.branch(['-r']);
-    return result.all
-      .filter((name) => !name.includes('HEAD'))
-      .map((name) => ({
-        name: name.replace(/^origin\//, ''),
-        fullName: name,
-        isRemote: true,
-      }));
-  } catch {
-    return [];
-  }
-}
-
-export async function getAllBranches(cwd = process.cwd()) {
-  const [local, remote] = await Promise.all([
-    getLocalBranches(cwd),
-    getRemoteBranches(cwd),
-  ]);
-
-  // Merge and dedupe, preferring local branches
-  const localNames = new Set(local.map((b) => b.name));
-  const uniqueRemote = remote.filter((b) => !localNames.has(b.name));
-
-  return {
-    local,
-    remote: uniqueRemote,
-    all: [...local.map((b) => ({ ...b, type: 'local' })), ...uniqueRemote.map((b) => ({ ...b, type: 'remote' }))],
-  };
-}
-
-export function getWorktreesBase(repoRoot, config) {
-  const projectsDir = config.projectsDir.replace(/\/$/, '');
-  let repoRel;
-
-  if (repoRoot.startsWith(projectsDir + '/')) {
-    repoRel = repoRoot.slice(projectsDir.length + 1);
-  } else {
-    repoRel = basename(repoRoot);
-  }
-
-  return join(config.worktreesDir, repoRel);
-}
-
-export async function getWorktrees(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    const result = await git.raw(['worktree', 'list', '--porcelain']);
-    const worktrees = [];
-    let current = {};
-
-    for (const line of result.split('\n')) {
-      if (line.startsWith('worktree ')) {
-        if (current.path) worktrees.push(current);
-        current = { path: line.slice(9) };
-      } else if (line.startsWith('branch ')) {
-        current.branch = line.slice(7).replace('refs/heads/', '');
-      } else if (line === 'bare') {
-        current.bare = true;
-      } else if (line === 'detached') {
-        current.detached = true;
-      }
-    }
-    if (current.path) worktrees.push(current);
-
-    // Add name (last part of path) and identify main vs worktrees
-    return worktrees.map((wt, index) => ({
-      ...wt,
-      name: basename(wt.path),
-      isMain: index === 0,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-export async function getWorktreesInBase(repoRoot, config) {
-  const base = getWorktreesBase(repoRoot, config);
-  if (!existsSync(base)) return [];
-
-  try {
-    const entries = readdirSync(base);
-    const worktrees = [];
-
-    for (const entry of entries) {
-      const entryPath = join(base, entry);
-      if (statSync(entryPath).isDirectory()) {
-        // Check if it's a valid git worktree
-        const gitFile = join(entryPath, '.git');
-        if (existsSync(gitFile)) {
-          const branch = await getCurrentBranch(entryPath);
-          worktrees.push({
-            name: entry,
-            path: entryPath,
-            branch: branch || 'unknown',
-          });
-        }
-      }
-    }
-
-    return worktrees;
-  } catch {
-    return [];
-  }
-}
-
-export async function getMainRepoPath(cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    const result = await git.raw(['worktree', 'list', '--porcelain']);
-    const firstLine = result.split('\n').find((l) => l.startsWith('worktree '));
-    return firstLine ? firstLine.slice(9) : null;
-  } catch {
-    return null;
-  }
-}
-
-export function buildBranchName(leaf, config) {
-  const cleanLeaf = leaf.replace(/^\//, '').replace(/ /g, '-');
-  const prefix = config.branchPrefix || '';
-  if (prefix) {
-    return `${prefix.replace(/\/$/, '')}/${cleanLeaf}`;
-  }
-  return cleanLeaf;
-}
-
-export async function branchExistsLocal(branchName, cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    // 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;
-  }
-}
-
-export async function branchExistsRemote(branchName, cwd = process.cwd()) {
-  try {
-    const git = await getGit(cwd);
-    const result = await git.raw(['ls-remote', '--exit-code', '--heads', 'origin', branchName]);
-    return result.length > 0;
-  } catch {
-    return false;
-  }
-}
-
-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/', '');
-    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
-  if (await branchExistsLocal(branchName, cwd)) {
-    // If we have a remote baseBranch, update local branch to match it
-    if (baseBranch && baseBranch.startsWith('origin/')) {
-      try {
-        const localSha = (await git.revparse([branchName])).trim();
-        const remoteSha = (await git.revparse([baseBranch])).trim();
-
-        if (localSha !== remoteSha) {
-          await git.raw(['branch', '-f', branchName, baseBranch]);
-          return { created: false, source: 'updated-from-remote' };
-        }
-      } catch {
-        // If we can't compare, fall through to use local as-is
-      }
-    }
-    return { created: false, source: 'local' };
-  }
-
-  // Check if branch exists on remote (with same name as branchName)
-  if (await branchExistsRemote(branchName, cwd)) {
-    await git.fetch(['origin', `${branchName}:${branchName}`]);
-    return { created: false, source: 'remote' };
-  }
-
-  // Create new branch from base
-  if (baseBranch) {
-    await git.raw(['branch', branchName, baseBranch]);
-  } else {
-    await git.raw(['branch', branchName]);
-  }
-
-  return { created: true, source: 'new' };
-}
-
-export async function createWorktree(name, branchName, baseBranch = null, cwd = process.cwd()) {
-  const git = await getGit(cwd);
-  const repoRoot = await getRepoRoot(cwd);
-  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)) {
-    mkdirSync(worktreesBase, { recursive: true });
-  }
-
-  const worktreePath = join(worktreesBase, name);
-
-  // Check if worktree already exists
-  if (existsSync(worktreePath)) {
-    return { success: false, error: 'Worktree directory already exists', path: worktreePath };
-  }
-
-  // Fetch all remotes
-  await git.fetch(['--all', '--prune']).catch(() => {});
-
-  // Ensure branch exists (or determine if we need to create it)
-  const branchResult = await ensureBranch(branchName, baseBranch, cwd);
-
-  // Create worktree — ensureBranch guarantees the branch already exists, so we
-  // just attach the worktree to it.
-  await git.raw(['worktree', 'add', worktreePath, branchName]);
-
-  return {
-    success: true,
-    path: worktreePath,
-    branch: branchName,
-    branchCreated: branchResult.created,
-    branchSource: branchResult.source,
-  };
-}
-
-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);
-
-  await git.raw(args);
-  return { success: true };
-}
-
-export async function pruneWorktrees(cwd = process.cwd()) {
-  const git = await getGit(cwd);
-  await git.raw(['worktree', 'prune']);
-  return { success: true };
-}
-
-export function isValidBranchName(name) {
-  // Basic validation - git allows most characters but not some special ones
-  if (!name || name.length === 0) return false;
-  if (name.startsWith('-') || name.startsWith('.')) return false;
-  if (name.endsWith('/') || name.endsWith('.')) return false;
-  if (name.includes('..') || name.includes('//')) return false;
-  if (/[\s~^:?*\[\]\\]/.test(name)) return false;
-  return true;
-}
-
-export async function mergeBranch(sourceBranch, targetBranch = null, cwd = process.cwd()) {
-  const git = await getGit(cwd);
-
-  // If target specified, checkout to it first
-  if (targetBranch) {
-    await git.checkout(targetBranch);
-  }
-
-  // Merge the source branch
-  const result = await git.merge([sourceBranch, '--no-edit']);
-
-  return {
-    success: true,
-    merged: sourceBranch,
-    into: targetBranch || await getCurrentBranch(cwd),
-    result,
-  };
-}
-
-export async function getMainBranch(cwd = process.cwd()) {
-  const git = await getGit(cwd);
-
-  // Try common main branch names
-  const candidates = ['main', 'master', 'develop'];
-  const branches = await getLocalBranches(cwd);
-  const branchNames = branches.map(b => b.name);
-
-  for (const candidate of candidates) {
-    if (branchNames.includes(candidate)) {
-      return candidate;
-    }
-  }
-
-  // Fall back to first branch
-  return branchNames[0] || 'main';
-}
-
-export async function hasUncommittedChanges(cwd = process.cwd()) {
-  const git = await getGit(cwd);
-  const status = await git.status();
-  return !status.isClean();
-}
-
-export async function deleteBranch(branchName, force = false, cwd = process.cwd()) {
-  const git = await getGit(cwd);
-  const flag = force ? '-D' : '-d';
-  await git.branch([flag, branchName]);
-  return { success: true };
-}