@paths.design/caws-cli 8.0.1 → 8.2.0

package/dist/utils/typescript-detector.js

@@ -101,10 +101,40 @@ function detectTestFramework(projectDir = process.cwd(), packageJson = null) {
 }
 
 /**
- * Get workspace directories from package.json
+ * Expand workspace glob patterns to actual directories
+ * Shared helper for npm, pnpm, and lerna workspace resolution
+ * @param {string[]} patterns - Workspace patterns (may include globs like "packages/*")
  * @param {string} projectDir - Project directory path
- * @returns {string[]} Array of workspace directories
+ * @returns {string[]} Array of resolved workspace directory paths
  */
+function expandWorkspacePatterns(patterns, projectDir) {
+  const workspaceDirs = [];
+  for (const pattern of patterns) {
+    if (pattern.includes('*')) {
+      const baseDir = pattern.split('*')[0];
+      const fullBaseDir = path.join(projectDir, baseDir);
+
+      if (fs.existsSync(fullBaseDir)) {
+        const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const wsPath = path.join(fullBaseDir, entry.name);
+            if (fs.existsSync(path.join(wsPath, 'package.json'))) {
+              workspaceDirs.push(wsPath);
+            }
+          }
+        }
+      }
+    } else {
+      const wsPath = path.join(projectDir, pattern);
+      if (fs.existsSync(path.join(wsPath, 'package.json'))) {
+        workspaceDirs.push(wsPath);
+      }
+    }
+  }
+  return workspaceDirs;
+}
+
 /**
  * Get workspace directories from npm/yarn package.json workspaces
  * @param {string} projectDir - Project directory path
@@ -120,36 +150,7 @@ function getNpmWorkspaces(projectDir) {
   try {
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
     const workspaces = packageJson.workspaces || [];
-
-    // Convert glob patterns to actual directories (simple implementation)
-    const workspaceDirs = [];
-    for (const ws of workspaces) {
-      // Handle simple patterns like "packages/*" or "iterations/*"
-      if (ws.includes('*')) {
-        const baseDir = ws.split('*')[0];
-        const fullBaseDir = path.join(projectDir, baseDir);
-
-        if (fs.existsSync(fullBaseDir)) {
-          const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              const wsPath = path.join(fullBaseDir, entry.name);
-              if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-                workspaceDirs.push(wsPath);
-              }
-            }
-          }
-        }
-      } else {
-        // Direct path
-        const wsPath = path.join(projectDir, ws);
-        if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-          workspaceDirs.push(wsPath);
-        }
-      }
-    }
-
-    return workspaceDirs;
+    return expandWorkspacePatterns(workspaces, projectDir);
   } catch (error) {
     return [];
   }
@@ -171,35 +172,7 @@ function getPnpmWorkspaces(projectDir) {
     const yaml = require('js-yaml');
     const config = yaml.load(fs.readFileSync(pnpmFile, 'utf8'));
     const workspacePatterns = config.packages || [];
-
-    // Convert glob patterns to actual directories
-    const workspaceDirs = [];
-    for (const pattern of workspacePatterns) {
-      if (pattern.includes('*')) {
-        const baseDir = pattern.split('*')[0];
-        const fullBaseDir = path.join(projectDir, baseDir);
-
-        if (fs.existsSync(fullBaseDir)) {
-          const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              const wsPath = path.join(fullBaseDir, entry.name);
-              if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-                workspaceDirs.push(wsPath);
-              }
-            }
-          }
-        }
-      } else {
-        // Direct path
-        const wsPath = path.join(projectDir, pattern);
-        if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-          workspaceDirs.push(wsPath);
-        }
-      }
-    }
-
-    return workspaceDirs;
+    return expandWorkspacePatterns(workspacePatterns, projectDir);
   } catch (error) {
     return [];
   }
@@ -220,35 +193,7 @@ function getLernaWorkspaces(projectDir) {
   try {
     const config = JSON.parse(fs.readFileSync(lernaFile, 'utf8'));
     const workspacePatterns = config.packages || ['packages/*'];
-
-    // Convert glob patterns to actual directories
-    const workspaceDirs = [];
-    for (const pattern of workspacePatterns) {
-      if (pattern.includes('*')) {
-        const baseDir = pattern.split('*')[0];
-        const fullBaseDir = path.join(projectDir, baseDir);
-
-        if (fs.existsSync(fullBaseDir)) {
-          const entries = fs.readdirSync(fullBaseDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory()) {
-              const wsPath = path.join(fullBaseDir, entry.name);
-              if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-                workspaceDirs.push(wsPath);
-              }
-            }
-          }
-        }
-      } else {
-        // Direct path
-        const wsPath = path.join(projectDir, pattern);
-        if (fs.existsSync(path.join(wsPath, 'package.json'))) {
-          workspaceDirs.push(wsPath);
-        }
-      }
-    }
-
-    return workspaceDirs;
+    return expandWorkspacePatterns(workspacePatterns, projectDir);
   } catch (error) {
     return [];
   }
@@ -416,6 +361,7 @@ module.exports = {
   getNpmWorkspaces,
   getPnpmWorkspaces,
   getLernaWorkspaces,
+  expandWorkspacePatterns,
   checkHoistedDependency,
   checkTypeScriptTestConfig,
   generateRecommendations,

package/dist/validation/spec-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec-validation.d.ts","sourceRoot":"","sources":["../../src/validation/spec-validation.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,mEA8HC;AAED;;;;;GAKG;AACH,kFAgdC;AAoCD;;;;;GAKG;AACH,0CAJW,MAAM,eAEJ,MAAM,CAkBlB;AAED;;;;;GAKG;AACH,uCAJW,MAAM,eAEJ,OAAO,CAKnB;AAnED;;;;;;GAMG;AACH,0EAFa,MAAM,CAclB;AAED;;;;GAIG;AACH,0CAHW,MAAM,GACJ,MAAM,CAQlB"}
+{"version":3,"file":"spec-validation.d.ts","sourceRoot":"","sources":["../../src/validation/spec-validation.js"],"names":[],"mappings":"AA6DA;;;;;GAKG;AACH,mEA8HC;AAED;;;;;GAKG;AACH,kFAgdC;AAoCD;;;;;GAKG;AACH,0CAJW,MAAM,eAEJ,MAAM,CAkBlB;AAED;;;;;GAKG;AACH,uCAJW,MAAM,eAEJ,OAAO,CAKnB;AAnED;;;;;;GAMG;AACH,0EAFa,MAAM,CAclB;AAED;;;;GAIG;AACH,0CAHW,MAAM,GACJ,MAAM,CAQlB"}

package/dist/validation/spec-validation.js

@@ -5,6 +5,59 @@
  */
 
 const { deriveBudget, checkBudgetCompliance } = require('../budget-derivation');
+const { execSync } = require('child_process');
+
+/**
+ * Get actual budget statistics from git history
+ * Analyzes changes since last tag or initial commit
+ * @param {string} specDir - Project directory
+ * @returns {Object|null} Budget stats or null on failure
+ */
+function getActualBudgetStats(specDir) {
+  const cwd = specDir || process.cwd();
+  try {
+    // Get base ref (last tag or initial commit)
+    let baseRef;
+    try {
+      baseRef = execSync('git describe --tags --abbrev=0 2>/dev/null', {
+        cwd,
+        encoding: 'utf8'
+      }).trim();
+    } catch {
+      // No tags found, use initial commit
+      baseRef = execSync('git rev-list --max-parents=0 HEAD', {
+        cwd,
+        encoding: 'utf8'
+      }).trim();
+    }
+
+    // Count files changed since base ref
+    const filesOutput = execSync(`git diff --name-only ${baseRef}..HEAD`, {
+      cwd,
+      encoding: 'utf8'
+    });
+    const files_changed = filesOutput.trim().split('\n').filter(Boolean).length;
+
+    // Count lines changed (added + removed)
+    const numstatOutput = execSync(`git diff --numstat ${baseRef}..HEAD`, {
+      cwd,
+      encoding: 'utf8'
+    });
+    let lines_changed = 0;
+    for (const line of numstatOutput.trim().split('\n').filter(Boolean)) {
+      const [added, removed] = line.split('\t');
+      // Handle binary files (shown as '-')
+      const addedNum = added === '-' ? 0 : parseInt(added, 10) || 0;
+      const removedNum = removed === '-' ? 0 : parseInt(removed, 10) || 0;
+      lines_changed += addedNum + removedNum;
+    }
+
+    return { files_changed, lines_changed };
+  } catch {
+    // Git not available or not a repository
+    return null;
+  }
+}
 
 /**
  * Basic validation of working spec
@@ -511,14 +564,14 @@ function validateWorkingSpecWithSuggestions(spec, options = {}) {
       try {
         const derivedBudget = deriveBudget(spec, projectRoot);
 
-        // Mock current stats for now - in real implementation this would analyze git changes
-        const mockStats = {
-          files_changed: 50, // This would be calculated from actual changes
-          lines_changed: 5000,
-          risk_tier: spec.risk_tier,
+        // Get actual stats from git history
+        const actualStats = getActualBudgetStats(projectRoot) || {
+          files_changed: 0,
+          lines_changed: 0,
         };
+        actualStats.risk_tier = spec.risk_tier;
 
-        budgetCheck = checkBudgetCompliance(derivedBudget, mockStats);
+        budgetCheck = checkBudgetCompliance(derivedBudget, actualStats);
 
         if (!budgetCheck.compliant) {
           for (const violation of budgetCheck.violations) {

package/dist/worktree/worktree-manager.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Create a new git worktree with scope isolation
+ * @param {string} name - Worktree name
+ * @param {Object} options - Creation options
+ * @param {string} [options.scope] - Sparse checkout pattern (e.g., "src/auth/**")
+ * @param {string} [options.baseBranch] - Base branch to create from
+ * @param {string} [options.specId] - Associated spec ID for standard+ modes
+ * @returns {Object} Created worktree info
+ */
+export function createWorktree(name: string, options?: {
+    scope?: string;
+    baseBranch?: string;
+    specId?: string;
+}): any;
+/**
+ * List all registered worktrees with filesystem validation
+ * @returns {Array} Worktree entries with status
+ */
+export function listWorktrees(): any[];
+/**
+ * Destroy a worktree
+ * @param {string} name - Worktree name
+ * @param {Object} options - Destruction options
+ * @param {boolean} [options.deleteBranch] - Also delete the branch
+ * @param {boolean} [options.force] - Force removal even if dirty
+ */
+export function destroyWorktree(name: string, options?: {
+    deleteBranch?: boolean;
+    force?: boolean;
+}): void;
+/**
+ * Prune stale worktree entries
+ * @param {Object} options - Prune options
+ * @param {number} [options.maxAgeDays] - Remove entries older than this many days
+ * @returns {Array} Pruned entries
+ */
+export function pruneWorktrees(options?: {
+    maxAgeDays?: number;
+}): any[];
+/**
+ * Load the worktree registry
+ * @param {string} root - Repository root
+ * @returns {Object} Registry object
+ */
+export function loadRegistry(root: string): any;
+/**
+ * Get the git repository root
+ * @returns {string} Absolute path to repo root
+ */
+export function getRepoRoot(): string;
+export const WORKTREES_DIR: ".caws/worktrees";
+export const REGISTRY_FILE: ".caws/worktrees.json";
+export const BRANCH_PREFIX: "caws/";
+//# sourceMappingURL=worktree-manager.d.ts.map

package/dist/worktree/worktree-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-manager.d.ts","sourceRoot":"","sources":["../../src/worktree/worktree-manager.js"],"names":[],"mappings":"AA+DA;;;;;;;;GAQG;AACH,qCAPW,MAAM,YAEd;IAAyB,KAAK,GAAtB,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,MAAM,GAAvB,MAAM;CACd,OA4IF;AAED;;;GAGG;AACH,uCAqCC;AAED;;;;;;GAMG;AACH,sCALW,MAAM,YAEd;IAA0B,YAAY,GAA9B,OAAO;IACW,KAAK,GAAvB,OAAO;CACjB,QAqDA;AAED;;;;;GAKG;AACH,yCAHG;IAAyB,UAAU,GAA3B,MAAM;CACd,SA6CF;AA1UD;;;;GAIG;AACH,mCAHW,MAAM,OAahB;AAnCD;;;GAGG;AACH,+BAFa,MAAM,CAMlB;AAZD,4BAAsB,iBAAiB,CAAC;AACxC,4BAAsB,sBAAsB,CAAC;AAC7C,4BAAsB,OAAO,CAAC"}

package/dist/worktree/worktree-manager.js

@@ -0,0 +1,378 @@
+/**
+ * @fileoverview CAWS Git Worktree Manager
+ * Provides CRUD operations for git worktrees with scope isolation
+ * @author @darianrosebrook
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const WORKTREES_DIR = '.caws/worktrees';
+const REGISTRY_FILE = '.caws/worktrees.json';
+const BRANCH_PREFIX = 'caws/';
+
+/**
+ * Get the git repository root
+ * @returns {string} Absolute path to repo root
+ */
+function getRepoRoot() {
+  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+  }).trim();
+}
+
+/**
+ * Get current branch name
+ * @returns {string}
+ */
+function getCurrentBranch() {
+  return execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+    encoding: 'utf8',
+  }).trim();
+}
+
+/**
+ * Load the worktree registry
+ * @param {string} root - Repository root
+ * @returns {Object} Registry object
+ */
+function loadRegistry(root) {
+  const registryPath = path.join(root, REGISTRY_FILE);
+  try {
+    if (fs.existsSync(registryPath)) {
+      return JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    }
+  } catch {
+    // Corrupted registry, start fresh
+  }
+  return { version: 1, worktrees: {} };
+}
+
+/**
+ * Save the worktree registry
+ * @param {string} root - Repository root
+ * @param {Object} registry - Registry object
+ */
+function saveRegistry(root, registry) {
+  const registryPath = path.join(root, REGISTRY_FILE);
+  fs.ensureDirSync(path.dirname(registryPath));
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+}
+
+/**
+ * Create a new git worktree with scope isolation
+ * @param {string} name - Worktree name
+ * @param {Object} options - Creation options
+ * @param {string} [options.scope] - Sparse checkout pattern (e.g., "src/auth/**")
+ * @param {string} [options.baseBranch] - Base branch to create from
+ * @param {string} [options.specId] - Associated spec ID for standard+ modes
+ * @returns {Object} Created worktree info
+ */
+function createWorktree(name, options = {}) {
+  const root = getRepoRoot();
+  const { scope, baseBranch, specId } = options;
+
+  // Validate name
+  if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error('Worktree name must contain only letters, numbers, hyphens, and underscores');
+  }
+
+  const registry = loadRegistry(root);
+
+  // Check for duplicate
+  if (registry.worktrees[name]) {
+    throw new Error(`Worktree '${name}' already exists. Use 'caws worktree destroy ${name}' first.`);
+  }
+
+  const worktreePath = path.join(root, WORKTREES_DIR, name);
+  const branchName = BRANCH_PREFIX + name;
+  const base = baseBranch || getCurrentBranch();
+
+  // Create the worktree directory
+  fs.ensureDirSync(path.dirname(worktreePath));
+
+  // Create git worktree with new branch
+  try {
+    execFileSync('git', ['worktree', 'add', '-b', branchName, worktreePath, base], {
+      cwd: root,
+      stdio: 'pipe',
+    });
+  } catch (error) {
+    // Branch might already exist
+    if (error.message.includes('already exists')) {
+      execFileSync('git', ['worktree', 'add', worktreePath, branchName], {
+        cwd: root,
+        stdio: 'pipe',
+      });
+    } else {
+      throw new Error(`Failed to create worktree: ${error.message}`);
+    }
+  }
+
+  // Set up sparse checkout if scope is provided
+  if (scope) {
+    try {
+      execFileSync('git', ['sparse-checkout', 'init', '--cone'], {
+        cwd: worktreePath,
+        stdio: 'pipe',
+      });
+
+      // Parse scope patterns (comma-separated)
+      const patterns = scope.split(',').map((p) => p.trim());
+      execFileSync('git', ['sparse-checkout', 'set', ...patterns], {
+        cwd: worktreePath,
+        stdio: 'pipe',
+      });
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️  Sparse checkout setup failed: ${error.message}`));
+      console.warn(chalk.blue('💡 Worktree created but without sparse checkout'));
+    }
+  }
+
+  // Copy .caws/ config into worktree
+  const cawsSource = path.join(root, '.caws');
+  const cawsDest = path.join(worktreePath, '.caws');
+  if (fs.existsSync(cawsSource)) {
+    try {
+      fs.copySync(cawsSource, cawsDest, {
+        filter: (src) => {
+          // Don't copy worktrees directory or registry into the worktree
+          const rel = path.relative(cawsSource, src);
+          return !rel.startsWith('worktrees') && rel !== 'worktrees.json';
+        },
+      });
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  // Generate working spec if in standard+ mode and specId provided
+  if (specId) {
+    try {
+      const { generateWorkingSpec } = require('../generators/working-spec');
+      const specContent = generateWorkingSpec({
+        projectId: specId,
+        projectTitle: `Worktree: ${name}`,
+        projectDescription: `Isolated worktree for ${name}`,
+        riskTier: 3,
+        projectMode: 'feature',
+        scopeIn: scope || 'src/',
+        scopeOut: 'node_modules/, dist/, build/',
+        maxFiles: 25,
+        maxLoc: 1000,
+        blastModules: scope || 'src',
+        dataMigration: false,
+        rollbackSlo: '5m',
+        projectThreats: '',
+        projectInvariants: 'System maintains data consistency',
+        acceptanceCriteria: 'Given current state, when action occurs, then expected result',
+        a11yRequirements: 'keyboard',
+        perfBudget: 250,
+        securityRequirements: 'validation',
+        contractType: '',
+        contractPath: '',
+        observabilityLogs: '',
+        observabilityMetrics: '',
+        observabilityTraces: '',
+        migrationPlan: '',
+        rollbackPlan: '',
+        needsOverride: false,
+        isExperimental: false,
+        aiConfidence: 0.8,
+        uncertaintyAreas: '',
+        complexityFactors: '',
+      });
+      const specPath = path.join(cawsDest, 'working-spec.yaml');
+      fs.ensureDirSync(path.dirname(specPath));
+      fs.writeFileSync(specPath, specContent);
+    } catch {
+      // Non-fatal: spec generation is optional
+    }
+  }
+
+  // Register worktree
+  const entry = {
+    name,
+    path: worktreePath,
+    branch: branchName,
+    baseBranch: base,
+    scope: scope || null,
+    specId: specId || null,
+    createdAt: new Date().toISOString(),
+    status: 'active',
+  };
+
+  registry.worktrees[name] = entry;
+  saveRegistry(root, registry);
+
+  return entry;
+}
+
+/**
+ * List all registered worktrees with filesystem validation
+ * @returns {Array} Worktree entries with status
+ */
+function listWorktrees() {
+  const root = getRepoRoot();
+  const registry = loadRegistry(root);
+
+  // Get actual git worktrees for validation
+  let gitWorktrees = [];
+  try {
+    const output = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+      cwd: root,
+      encoding: 'utf8',
+    });
+    gitWorktrees = output
+      .split('\n\n')
+      .filter(Boolean)
+      .map((block) => {
+        const lines = block.split('\n');
+        const worktreeLine = lines.find((l) => l.startsWith('worktree '));
+        return worktreeLine ? worktreeLine.replace('worktree ', '') : null;
+      })
+      .filter(Boolean);
+  } catch {
+    // Git worktree list failed
+  }
+
+  const entries = Object.values(registry.worktrees).map((entry) => {
+    const exists = fs.existsSync(entry.path);
+    const inGit = gitWorktrees.some(
+      (wt) => path.resolve(wt) === path.resolve(entry.path)
+    );
+
+    return {
+      ...entry,
+      status: exists && inGit ? 'active' : exists ? 'orphaned' : 'missing',
+    };
+  });
+
+  return entries;
+}
+
+/**
+ * Destroy a worktree
+ * @param {string} name - Worktree name
+ * @param {Object} options - Destruction options
+ * @param {boolean} [options.deleteBranch] - Also delete the branch
+ * @param {boolean} [options.force] - Force removal even if dirty
+ */
+function destroyWorktree(name, options = {}) {
+  const root = getRepoRoot();
+  const registry = loadRegistry(root);
+  const { deleteBranch = false, force = false } = options;
+
+  const entry = registry.worktrees[name];
+  if (!entry) {
+    throw new Error(`Worktree '${name}' not found in registry`);
+  }
+
+  // Remove git worktree
+  try {
+    const args = ['worktree', 'remove'];
+    if (force) args.push('--force');
+    args.push(entry.path);
+    execFileSync('git', args, { cwd: root, stdio: 'pipe' });
+  } catch (error) {
+    if (force) {
+      // Force cleanup: remove directory manually
+      if (fs.existsSync(entry.path)) {
+        fs.removeSync(entry.path);
+      }
+      // Prune git worktree list
+      try {
+        execFileSync('git', ['worktree', 'prune'], { cwd: root, stdio: 'pipe' });
+      } catch {
+        // Non-fatal
+      }
+    } else {
+      throw new Error(`Failed to remove worktree: ${error.message}. Use --force to override.`);
+    }
+  }
+
+  // Optionally delete branch
+  if (deleteBranch && entry.branch) {
+    try {
+      execFileSync('git', ['branch', '-d', entry.branch], { cwd: root, stdio: 'pipe' });
+    } catch {
+      if (force) {
+        try {
+          execFileSync('git', ['branch', '-D', entry.branch], { cwd: root, stdio: 'pipe' });
+        } catch {
+          // Non-fatal
+        }
+      }
+    }
+  }
+
+  // Update registry
+  registry.worktrees[name].status = 'destroyed';
+  registry.worktrees[name].destroyedAt = new Date().toISOString();
+  saveRegistry(root, registry);
+}
+
+/**
+ * Prune stale worktree entries
+ * @param {Object} options - Prune options
+ * @param {number} [options.maxAgeDays] - Remove entries older than this many days
+ * @returns {Array} Pruned entries
+ */
+function pruneWorktrees(options = {}) {
+  const root = getRepoRoot();
+  const registry = loadRegistry(root);
+  const { maxAgeDays = 30 } = options;
+
+  const now = new Date();
+  const pruned = [];
+
+  for (const [name, entry] of Object.entries(registry.worktrees)) {
+    const created = new Date(entry.createdAt);
+    const ageDays = (now - created) / (1000 * 60 * 60 * 24);
+
+    const shouldPrune =
+      entry.status === 'destroyed' ||
+      (!fs.existsSync(entry.path) && ageDays > maxAgeDays) ||
+      (maxAgeDays === 0 && entry.status === 'destroyed');
+
+    if (shouldPrune) {
+      // Clean up filesystem if still exists
+      if (fs.existsSync(entry.path)) {
+        try {
+          execFileSync('git', ['worktree', 'remove', '--force', entry.path], {
+            cwd: root,
+            stdio: 'pipe',
+          });
+        } catch {
+          fs.removeSync(entry.path);
+        }
+      }
+      pruned.push(entry);
+      delete registry.worktrees[name];
+    }
+  }
+
+  // Prune git's worktree list
+  try {
+    execFileSync('git', ['worktree', 'prune'], { cwd: root, stdio: 'pipe' });
+  } catch {
+    // Non-fatal
+  }
+
+  saveRegistry(root, registry);
+  return pruned;
+}
+
+module.exports = {
+  createWorktree,
+  listWorktrees,
+  destroyWorktree,
+  pruneWorktrees,
+  loadRegistry,
+  getRepoRoot,
+  WORKTREES_DIR,
+  REGISTRY_FILE,
+  BRANCH_PREFIX,
+};