[refactor] Extract shared service layer between CLI and MCP (#83)

* [refactor] Add operations foundation: ProgressFunc, deps helpers, ResolveMainBranch

Phase 0 of service layer extraction (#70, #81):
- Add ProgressFunc type and nil-safe notify helper for operation progress
- Move deps install helpers (InstallDeps, InstallDepsPreferSource,
  WorktreePathsExcluding, RunPostCreateHooks) from cmd to operations
- Extract ResolveMainBranch into operations with configDefault parameter

* [refactor] Extract Remove operation into shared service layer

Phase 1 of service layer extraction (#70, #81):
- Add RemoveWorktree operation with RemoveResult struct
- Add removeAndCleanup private helper (used by remove, merge, clean)
- Convert cmd/remove.go to thin wrapper over operations
- Convert internal/mcp/tool_remove.go to thin wrapper over operations

* [refactor] Extract clean operations into shared service layer

Move FindMergedCandidates, FindStaleCandidates, and RemoveCandidates
from inline implementations in cmd/clean.go and mcp/tool_clean.go
into internal/operations/clean.go. Both CLI and MCP layers now call
the shared operations, keeping only formatting and output logic.

Also removes the force parameter from removeAndCleanup since all
callers pass false.

Phase 2 of #70 / #81

* [refactor] Extract merge operation into shared service layer

Move worktree resolution, concurrent dirty checks, merge execution,
and auto-cleanup logic from cmd/merge.go and mcp/tool_merge.go into
operations.MergeWorktree. Both layers now build MergeParams, call the
shared operation, and format the MergeResult for their output format.

Also removes checkMergeDirty from MCP (now handled by operations) and
fixes the dirtyResult type reference in cmd/merge_bench_test.go.

Phase 3 of #70 / #81

* [refactor] Phase 4: Extract Add operation into operations package

Move worktree creation logic from cmd/add.go and internal/mcp/tool_add.go
into internal/operations/add.go. Both layers are now thin wrappers.

Also moves deps/hooks helpers (installDeps, installDepsPreferSource,
runHooks, worktreePathsExcluding) into operations/deps_install.go,
updating cmd/duplicate.go and cmd/restore.go to use the shared functions.

* [refactor] Phase 5: Consolidate resolveMainBranch via operations

Remove duplicate resolveMainBranch from internal/mcp/tool_list.go.
Both cmd and MCP layers now delegate to operations.ResolveMainBranch.

* [test] Add coverage tests for operations package

Cover previously untested paths: InstallDeps/InstallDepsPreferSource
no-modules early return, RunPostCreateHooks, AddWorktree deps/hooks
branches, checkDirty error paths, FindMergedCandidates squash-merge
error, FindStaleCandidates commit-time error.

Brings total coverage from 96.4% to 97.1%.

Author: lugassawan

cmd/add.go

@@ -2,15 +2,12 @@ package cmd
 
 import (
 	"fmt"
-	"os"
 	"path/filepath"
 
 	"github.com/lugassawan/rimba/internal/config"
-	"github.com/lugassawan/rimba/internal/deps"
-	"github.com/lugassawan/rimba/internal/fileutil"
 	"github.com/lugassawan/rimba/internal/git"
 	"github.com/lugassawan/rimba/internal/hint"
-	"github.com/lugassawan/rimba/internal/resolver"
+	"github.com/lugassawan/rimba/internal/operations"
 	"github.com/lugassawan/rimba/internal/spinner"
 	"github.com/spf13/cobra"
 )
@@ -55,22 +52,8 @@ var addCmd = &cobra.Command{
 			source = cfg.DefaultSource
 		}
 
-		branch := resolver.BranchName(prefix, task)
-		wtDir := filepath.Join(repoRoot, cfg.WorktreeDir)
-		wtPath := resolver.WorktreePath(wtDir, branch)
-
-		wtEntries, err := git.ListWorktrees(r)
-		if err != nil {
-			return err
-		}
-
-		// Validate
-		if git.BranchExists(r, branch) {
-			return fmt.Errorf("branch %q already exists", branch)
-		}
-		if _, err := os.Stat(wtPath); err == nil {
-			return fmt.Errorf("worktree path already exists: %s", wtPath)
-		}
+		skipDeps, _ := cmd.Flags().GetBool(flagSkipDeps)
+		skipHooks, _ := cmd.Flags().GetBool(flagSkipHooks)
 
 		hint.New(cmd, hintPainter(cmd)).
 			Add(flagSkipDeps, hintSkipDeps).
@@ -81,54 +64,41 @@ var addCmd = &cobra.Command{
 		s := spinner.New(spinnerOpts(cmd))
 		defer s.Stop()
 
-		// Create worktree
-		s.Start("Creating worktree...")
-		if err := git.AddWorktree(r, wtPath, branch, source); err != nil {
-			return err
+		var configModules []config.ModuleConfig
+		if cfg.Deps != nil {
+			configModules = cfg.Deps.Modules
 		}
 
-		// Copy files
-		s.Update("Copying files...")
-		copied, err := fileutil.CopyEntries(repoRoot, wtPath, cfg.CopyFiles)
+		result, err := operations.AddWorktree(r, operations.AddParams{
+			Task:          task,
+			Prefix:        prefix,
+			Source:        source,
+			RepoRoot:      repoRoot,
+			WorktreeDir:   filepath.Join(repoRoot, cfg.WorktreeDir),
+			CopyFiles:     cfg.CopyFiles,
+			SkipDeps:      skipDeps,
+			AutoDetect:    cfg.IsAutoDetectDeps(),
+			ConfigModules: configModules,
+			SkipHooks:     skipHooks,
+			PostCreate:    cfg.PostCreate,
+		}, func(msg string) { s.Start(msg) })
 		if err != nil {
-			return fmt.Errorf("worktree created but failed to copy files: %w\nTo retry, manually copy files to: %s\nTo remove the worktree: rimba remove %s", err, wtPath, task)
-		}
-
-		// Dependencies
-		skipDeps, _ := cmd.Flags().GetBool(flagSkipDeps)
-		var depsResults []deps.InstallResult
-		if !skipDeps {
-			s.Update("Installing dependencies...")
-			depsResults = installDeps(r, cfg, wtPath, wtEntries, func(cur, total int, name string) {
-				s.Update(fmt.Sprintf("Installing dependencies... (%s) [%d/%d]", name, cur, total))
-			})
-		}
-
-		// Post-create hooks
-		skipHooks, _ := cmd.Flags().GetBool(flagSkipHooks)
-		var hookResults []deps.HookResult
-		if !skipHooks && len(cfg.PostCreate) > 0 {
-			s.Update("Running hooks...")
-			hookResults = runHooks(wtPath, cfg.PostCreate, func(cur, total int, name string) {
-				s.Update(fmt.Sprintf("Running hooks... (%s) [%d/%d]", name, cur, total))
-			})
+			return err
 		}
 
-		s.Stop()
-
 		out := cmd.OutOrStdout()
 		fmt.Fprintf(out, "Created worktree for task %q\n", task)
-		fmt.Fprintf(out, "  Branch: %s\n", branch)
-		fmt.Fprintf(out, "  Path:   %s\n", wtPath)
-		if len(copied) > 0 {
-			fmt.Fprintf(out, "  Copied: %v\n", copied)
+		fmt.Fprintf(out, "  Branch: %s\n", result.Branch)
+		fmt.Fprintf(out, "  Path:   %s\n", result.Path)
+		if len(result.Copied) > 0 {
+			fmt.Fprintf(out, "  Copied: %v\n", result.Copied)
 		}
-		if skipped := fileutil.SkippedEntries(cfg.CopyFiles, copied); len(skipped) > 0 {
-			fmt.Fprintf(out, "  Skipped (not found): %v\n", skipped)
+		if len(result.Skipped) > 0 {
+			fmt.Fprintf(out, "  Skipped (not found): %v\n", result.Skipped)
 		}
 
-		printInstallResults(out, depsResults)
-		printHookResultsList(out, hookResults)
+		printInstallResults(out, result.DepsResults)
+		printHookResultsList(out, result.HookResults)
 
 		return nil
 	},

cmd/clean.go

@@ -4,10 +4,10 @@ import (
 	"bufio"
 	"fmt"
 	"strings"
-	"time"
 
 	"github.com/lugassawan/rimba/internal/git"
 	"github.com/lugassawan/rimba/internal/hint"
+	"github.com/lugassawan/rimba/internal/operations"
 	"github.com/lugassawan/rimba/internal/resolver"
 	"github.com/lugassawan/rimba/internal/spinner"
 	"github.com/spf13/cobra"
@@ -19,23 +19,12 @@ const (
 	flagStale  = "stale"
 
 	hintMerged       = "Remove worktrees whose branches are already merged into main"
-	hintStale        = "Remove worktrees with no recent commits (configure with --stale-days)"
 	hintDryRunPrune  = "Preview what would be pruned without making changes"
 	hintDryRunMerged = "Preview what would be removed without making changes"
 	hintDryRunStale  = "Preview what would be removed without making changes"
 	hintForce        = "Skip confirmation prompt"
 )
 
-type cleanCandidate struct {
-	path   string
-	branch string
-}
-
-type staleCandidate struct {
-	cleanCandidate
-	lastCommit time.Time
-}
-
 func init() {
 	cleanCmd.Flags().Bool(flagDryRun, false, "Show what would be pruned/removed without making changes")
 	cleanCmd.Flags().Bool(flagMerged, false, "Remove worktrees whose branches are merged into main")
@@ -127,7 +116,7 @@ func cleanMerged(cmd *cobra.Command, r git.Runner) error {
 	}
 
 	s.Update("Analyzing branches...")
-	candidates, err := findMergedCandidates(r, mergeRef, mainBranch)
+	candidates, err := operations.FindMergedCandidates(r, mergeRef, mainBranch)
 	if err != nil {
 		return err
 	}
@@ -150,82 +139,16 @@ func cleanMerged(cmd *cobra.Command, r git.Runner) error {
 		return nil
 	}
 
-	removed := removeWorktrees(cmd, r, candidates)
+	items := operations.RemoveCandidates(r, candidates, func(msg string) {
+		s.Update(msg)
+	})
+	printCleanedItems(cmd, items)
+
+	removed := countRemoved(items)
 	fmt.Fprintf(cmd.OutOrStdout(), "Cleaned %d merged worktree(s).\n", removed)
 	return nil
 }
 
-func findMergedCandidates(r git.Runner, mergeRef, mainBranch string) ([]cleanCandidate, error) {
-	mergedList, err := git.MergedBranches(r, mergeRef)
-	if err != nil {
-		return nil, fmt.Errorf("failed to list merged branches: %w", err)
-	}
-
-	mergedSet := make(map[string]bool, len(mergedList))
-	for _, b := range mergedList {
-		mergedSet[b] = true
-	}
-
-	entries, err := git.ListWorktrees(r)
-	if err != nil {
-		return nil, err
-	}
-
-	var candidates []cleanCandidate
-	for _, e := range git.FilterEntries(entries, mainBranch) {
-		if mergedSet[e.Branch] {
-			candidates = append(candidates, cleanCandidate{path: e.Path, branch: e.Branch})
-			continue
-		}
-
-		// Fallback: squash-merge detection
-		squashed, err := git.IsSquashMerged(r, mergeRef, e.Branch)
-		if err != nil {
-			continue
-		}
-		if squashed {
-			candidates = append(candidates, cleanCandidate{path: e.Path, branch: e.Branch})
-		}
-	}
-	return candidates, nil
-}
-
-func printMergedCandidates(cmd *cobra.Command, candidates []cleanCandidate) {
-	prefixes := resolver.AllPrefixes()
-	fmt.Fprintln(cmd.OutOrStdout(), "Merged worktrees:")
-	for _, c := range candidates {
-		task, _ := resolver.TaskFromBranch(c.branch, prefixes)
-		fmt.Fprintf(cmd.OutOrStdout(), "  %s (%s)\n", task, c.branch)
-	}
-}
-
-func confirmRemoval(cmd *cobra.Command, count int, label string) bool {
-	fmt.Fprintf(cmd.OutOrStdout(), "\nRemove %d %s worktree(s)? [y/N] ", count, label)
-	reader := bufio.NewReader(cmd.InOrStdin())
-	answer, _ := reader.ReadString('\n')
-	answer = strings.TrimSpace(strings.ToLower(answer))
-	return answer == "y" || answer == "yes"
-}
-
-func removeWorktrees(cmd *cobra.Command, r git.Runner, candidates []cleanCandidate) int {
-	var removed int
-	for _, c := range candidates {
-		if err := git.RemoveWorktree(r, c.path, false); err != nil {
-			fmt.Fprintf(cmd.OutOrStdout(), "Failed to remove worktree %s: %v\nTo remove manually: rimba remove %s\n", c.branch, err, c.branch)
-			continue
-		}
-		fmt.Fprintf(cmd.OutOrStdout(), "Removed worktree: %s\n", c.path)
-
-		if err := git.DeleteBranch(r, c.branch, true); err != nil {
-			fmt.Fprintf(cmd.OutOrStdout(), "Worktree removed but failed to delete branch: %v\nTo delete manually: git branch -D %s\n", err, c.branch)
-			continue
-		}
-		fmt.Fprintf(cmd.OutOrStdout(), "Deleted branch: %s\n", c.branch)
-		removed++
-	}
-	return removed
-}
-
 func cleanStale(cmd *cobra.Command, r git.Runner) error {
 	dryRun, _ := cmd.Flags().GetBool(flagDryRun)
 	force, _ := cmd.Flags().GetBool(flagForce)
@@ -246,7 +169,7 @@ func cleanStale(cmd *cobra.Command, r git.Runner) error {
 	defer s.Stop()
 
 	s.Start("Analyzing worktree activity...")
-	candidates, err := findStaleCandidates(r, mainBranch, staleDays)
+	candidates, err := operations.FindStaleCandidates(r, mainBranch, staleDays)
 	if err != nil {
 		return err
 	}
@@ -268,47 +191,69 @@ func cleanStale(cmd *cobra.Command, r git.Runner) error {
 		return nil
 	}
 
-	toRemove := make([]cleanCandidate, len(candidates))
+	toRemove := make([]operations.CleanCandidate, len(candidates))
 	for i, c := range candidates {
-		toRemove[i] = c.cleanCandidate
+		toRemove[i] = c.CleanCandidate
 	}
 
-	removed := removeWorktrees(cmd, r, toRemove)
+	items := operations.RemoveCandidates(r, toRemove, func(msg string) {
+		s.Update(msg)
+	})
+	printCleanedItems(cmd, items)
+
+	removed := countRemoved(items)
 	fmt.Fprintf(cmd.OutOrStdout(), "Cleaned %d stale worktree(s).\n", removed)
 	return nil
 }
 
-func findStaleCandidates(r git.Runner, mainBranch string, staleDays int) ([]staleCandidate, error) {
-	entries, err := git.ListWorktrees(r)
-	if err != nil {
-		return nil, err
+func printMergedCandidates(cmd *cobra.Command, candidates []operations.CleanCandidate) {
+	prefixes := resolver.AllPrefixes()
+	fmt.Fprintln(cmd.OutOrStdout(), "Merged worktrees:")
+	for _, c := range candidates {
+		task, _ := resolver.TaskFromBranch(c.Branch, prefixes)
+		fmt.Fprintf(cmd.OutOrStdout(), "  %s (%s)\n", task, c.Branch)
+	}
+}
+
+func printStaleCandidates(cmd *cobra.Command, candidates []operations.StaleCandidate) {
+	prefixes := resolver.AllPrefixes()
+	fmt.Fprintln(cmd.OutOrStdout(), "Stale worktrees:")
+	for _, c := range candidates {
+		task, _ := resolver.TaskFromBranch(c.Branch, prefixes)
+		age := resolver.FormatAge(c.LastCommit)
+		fmt.Fprintf(cmd.OutOrStdout(), "  %s (%s) — last commit: %s\n", task, c.Branch, age)
 	}
+}
 
-	threshold := time.Now().Add(-time.Duration(staleDays) * 24 * time.Hour)
+func confirmRemoval(cmd *cobra.Command, count int, label string) bool {
+	fmt.Fprintf(cmd.OutOrStdout(), "\nRemove %d %s worktree(s)? [y/N] ", count, label)
+	reader := bufio.NewReader(cmd.InOrStdin())
+	answer, _ := reader.ReadString('\n')
+	answer = strings.TrimSpace(strings.ToLower(answer))
+	return answer == "y" || answer == "yes"
+}
 
-	var candidates []staleCandidate
-	for _, e := range git.FilterEntries(entries, mainBranch) {
-		ct, err := git.LastCommitTime(r, e.Branch)
-		if err != nil {
+func printCleanedItems(cmd *cobra.Command, items []operations.CleanedItem) {
+	for _, item := range items {
+		if !item.WorktreeRemoved {
+			fmt.Fprintf(cmd.OutOrStdout(), "Failed to remove worktree %s\nTo remove manually: rimba remove %s\n", item.Branch, item.Branch)
 			continue
 		}
-
-		if ct.Before(threshold) {
-			candidates = append(candidates, staleCandidate{
-				cleanCandidate: cleanCandidate{path: e.Path, branch: e.Branch},
-				lastCommit:     ct,
-			})
+		fmt.Fprintf(cmd.OutOrStdout(), "Removed worktree: %s\n", item.Path)
+		if item.BranchDeleted {
+			fmt.Fprintf(cmd.OutOrStdout(), "Deleted branch: %s\n", item.Branch)
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "Worktree removed but failed to delete branch\nTo delete manually: git branch -D %s\n", item.Branch)
 		}
 	}
-	return candidates, nil
 }
 
-func printStaleCandidates(cmd *cobra.Command, candidates []staleCandidate) {
-	prefixes := resolver.AllPrefixes()
-	fmt.Fprintln(cmd.OutOrStdout(), "Stale worktrees:")
-	for _, c := range candidates {
-		task, _ := resolver.TaskFromBranch(c.branch, prefixes)
-		age := resolver.FormatAge(c.lastCommit)
-		fmt.Fprintf(cmd.OutOrStdout(), "  %s (%s) — last commit: %s\n", task, c.branch, age)
+func countRemoved(items []operations.CleanedItem) int {
+	count := 0
+	for _, item := range items {
+		if item.WorktreeRemoved && item.BranchDeleted {
+			count++
+		}
 	}
+	return count
 }