Add repository-specific hooks support for prune

Introduces a hooks system that allows repos to define custom scripts
executed during prune operations. Hooks are placed in .sprout/hooks/
within each repository.

Features:
- HooksService to discover and execute hooks from .sprout/hooks/
- post-prune hook runs after each worktree is removed
- Environment variables passed to hooks: SPROUT_WORKTREE_PATH,
  SPROUT_BRANCH, SPROUT_REPO_ROOT
- Dry-run mode shows which hooks would run
- Verbose flag (-v) for detailed hook execution output

Example use case: Clean up Xcode DerivedData when pruning worktrees
from iOS projects.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: gage-halverson-fetch

Sources/sprout/Commands/Prune.swift

@@ -30,13 +30,25 @@ struct Prune: AsyncParsableCommand {
     @Argument(help: "Branch name or pattern to prune (optional - launches picker if not provided)")
     var branch: String?
 
+    @Flag(name: [.short, .long], help: "Print verbose output")
+    var verbose: Bool = false
+
     @MainActor
     func run() async throws {
         let gitService = GitService()
+        let hooksService = HooksService()
 
         // Get list of worktrees
         let worktrees = try await gitService.listWorktrees()
 
+        // Find the main repo root for hooks
+        let mainRepoRoot: String?
+        if let firstWorktree = worktrees.first {
+            mainRepoRoot = hooksService.findMainRepoRoot(from: firstWorktree.path)
+        } else {
+            mainRepoRoot = try? await gitService.getRepoRoot()
+        }
+
         if worktrees.isEmpty {
             print("No worktrees found.")
             return
@@ -132,13 +144,44 @@ struct Prune: AsyncParsableCommand {
         for wt in toRemove {
             if dryRun {
                 print("Would remove: \(wt.branch) (\(wt.path))")
+                if let repoRoot = mainRepoRoot {
+                    let hookPath = "\(repoRoot)/.sprout/hooks/post-prune"
+                    if FileManager.default.fileExists(atPath: hookPath) {
+                        print("  Would run post-prune hook")
+                    }
+                }
             } else {
                 print("Removing \(wt.branch)...", terminator: " ")
                 fflush(stdout)
                 do {
+                    // Capture worktree path before removal for hook
+                    let worktreePath = wt.path
+
                     try await gitService.removeWorktree(at: wt.path)
                     try await gitService.deleteBranch(wt.branch)
                     print("done")
+
+                    // Run post-prune hook if it exists
+                    if let repoRoot = mainRepoRoot {
+                        let env = HooksService.HookEnvironment(
+                            worktreePath: worktreePath,
+                            branch: wt.branch,
+                            repoRoot: repoRoot
+                        )
+                        do {
+                            let hookRan = try await hooksService.run(
+                                .postPrune,
+                                in: repoRoot,
+                                environment: env,
+                                verbose: verbose
+                            )
+                            if hookRan && verbose {
+                                print("  post-prune hook completed")
+                            }
+                        } catch {
+                            print("  post-prune hook failed: \(error)")
+                        }
+                    }
                 } catch {
                     print("error: \(error)")
                 }

Sources/sprout/Services/HooksService.swift

@@ -0,0 +1,151 @@
+import Foundation
+
+/// Executes repository-specific hooks from .sprout/hooks/
+struct HooksService {
+    /// Available hook types
+    enum Hook: String {
+        case postPrune = "post-prune"
+        case prePrune = "pre-prune"
+        case postLaunch = "post-launch"
+    }
+
+    /// Environment variables passed to hook scripts
+    struct HookEnvironment {
+        var worktreePath: String?
+        var branch: String?
+        var repoRoot: String?
+
+        var asDict: [String: String] {
+            var env: [String: String] = [:]
+            if let path = worktreePath {
+                env["SPROUT_WORKTREE_PATH"] = path
+            }
+            if let branch = branch {
+                env["SPROUT_BRANCH"] = branch
+            }
+            if let root = repoRoot {
+                env["SPROUT_REPO_ROOT"] = root
+            }
+            return env
+        }
+    }
+
+    /// Run a hook if it exists in the repository
+    /// - Parameters:
+    ///   - hook: The hook type to run
+    ///   - repoRoot: Root directory of the repository
+    ///   - environment: Environment variables to pass to the script
+    ///   - verbose: Whether to print debug output
+    /// - Returns: true if hook was found and executed, false if no hook exists
+    @discardableResult
+    func run(
+        _ hook: Hook,
+        in repoRoot: String,
+        environment: HookEnvironment,
+        verbose: Bool = false
+    ) async throws -> Bool {
+        let hookPath = "\(repoRoot)/.sprout/hooks/\(hook.rawValue)"
+        let expandedPath = NSString(string: hookPath).expandingTildeInPath
+
+        // Check if hook exists
+        guard FileManager.default.fileExists(atPath: expandedPath) else {
+            if verbose {
+                print("No \(hook.rawValue) hook found at \(hookPath)")
+            }
+            return false
+        }
+
+        // Check if executable
+        guard FileManager.default.isExecutableFile(atPath: expandedPath) else {
+            print("Warning: Hook exists but is not executable: \(hookPath)")
+            print("Run: chmod +x \(hookPath)")
+            return false
+        }
+
+        if verbose {
+            print("Running \(hook.rawValue) hook...")
+        }
+
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: expandedPath)
+        process.currentDirectoryURL = URL(fileURLWithPath: repoRoot)
+
+        // Merge with existing environment
+        var processEnv = ProcessInfo.processInfo.environment
+        for (key, value) in environment.asDict {
+            processEnv[key] = value
+        }
+        process.environment = processEnv
+
+        let stdout = Pipe()
+        let stderr = Pipe()
+        process.standardOutput = stdout
+        process.standardError = stderr
+
+        try process.run()
+        process.waitUntilExit()
+
+        // Print output
+        let outData = stdout.fileHandleForReading.readDataToEndOfFile()
+        if let outStr = String(data: outData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !outStr.isEmpty {
+            print(outStr)
+        }
+
+        let errData = stderr.fileHandleForReading.readDataToEndOfFile()
+        if let errStr = String(data: errData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !errStr.isEmpty {
+            FileHandle.standardError.write(Data(errStr.utf8))
+            FileHandle.standardError.write(Data("\n".utf8))
+        }
+
+        if process.terminationStatus != 0 {
+            throw HookError.executionFailed(hook.rawValue, Int(process.terminationStatus))
+        }
+
+        return true
+    }
+
+    /// Find the main repo root from a worktree path
+    /// Worktrees are typically at ../worktrees/{branch}, so main repo is a sibling
+    func findMainRepoRoot(from worktreePath: String) -> String? {
+        // Check if this worktree has a .git file (not directory) pointing to main repo
+        let gitPath = "\(worktreePath)/.git"
+
+        guard FileManager.default.fileExists(atPath: gitPath) else {
+            return nil
+        }
+
+        // For worktrees, .git is a file containing "gitdir: /path/to/main/.git/worktrees/branch"
+        guard let contents = try? String(contentsOfFile: gitPath, encoding: .utf8),
+              contents.hasPrefix("gitdir:") else {
+            // This is the main repo (has .git directory)
+            return worktreePath
+        }
+
+        // Parse the gitdir path to find main repo
+        // Format: gitdir: /path/to/main/.git/worktrees/branchname
+        let gitdirPath = contents
+            .replacingOccurrences(of: "gitdir:", with: "")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+        // Go up from .git/worktrees/branch to get main repo root
+        if let range = gitdirPath.range(of: "/.git/worktrees/") {
+            return String(gitdirPath[..<range.lowerBound])
+        }
+
+        return nil
+    }
+}
+
+/// Errors from hook execution
+enum HookError: Error, CustomStringConvertible {
+    case executionFailed(String, Int)
+
+    var description: String {
+        switch self {
+        case .executionFailed(let hook, let code):
+            return "Hook '\(hook)' failed with exit code \(code)"
+        }
+    }
+}