[refactor] Extract operations package from cmd layer (#49)

* [refactor] Create internal/operations package with shared worktree helpers

Extract ListWorktreeInfos and FindWorktree from cmd/helpers.go into
internal/operations/ for reuse by future consumers (exec cmd, MCP server).

* [refactor] Wire cmd/helpers.go to operations package

listWorktreeInfos and findWorktree become thin wrappers delegating
to operations.ListWorktreeInfos and operations.FindWorktree.

* [refactor] Extract sync pure functions to operations package

Move SyncBranch, CollectTasks, FilterEligible, SyncMethodLabel from
cmd/sync.go to internal/operations/sync.go. Remove redundant cmd-layer
tests that are now covered by operations/sync_test.go.

* [refactor] Extract SyncWorktree to operations package

Add SyncWorktreeResult struct and SyncWorktree function that returns
a result value instead of writing to stdout. cmd/sync.go syncWorktree
becomes a thin wrapper that formats the result for display.

* [refactor] Extract rename operation to operations package

Move worktree rename logic (prefix resolution, branch check, move,
rename) into operations.RenameWorktree returning RenameResult. The
cmd layer keeps only findWorktree + spinner + formatting.

* [refactor] Extract status collection and filtering to operations package

Move CollectWorktreeStatus and FilterDetailsByStatus from cmd/list.go
into internal/operations/status.go. The cmd layer keeps parallel
orchestration and display logic.

Author: lugassawan

cmd/helpers.go

@@ -1,11 +1,11 @@
 package cmd
 
 import (
-	"fmt"
 	"path/filepath"
 
 	"github.com/lugassawan/rimba/internal/config"
 	"github.com/lugassawan/rimba/internal/git"
+	"github.com/lugassawan/rimba/internal/operations"
 	"github.com/lugassawan/rimba/internal/resolver"
 	"github.com/lugassawan/rimba/internal/spinner"
 	"github.com/lugassawan/rimba/internal/termcolor"
@@ -48,31 +48,10 @@ func resolveMainBranch(r git.Runner) (string, error) {
 
 // listWorktreeInfos converts git worktree entries to resolver-compatible WorktreeInfo slice.
 func listWorktreeInfos(r git.Runner) ([]resolver.WorktreeInfo, error) {
-	entries, err := git.ListWorktrees(r)
-	if err != nil {
-		return nil, err
-	}
-
-	worktrees := make([]resolver.WorktreeInfo, len(entries))
-	for i, e := range entries {
-		worktrees[i] = resolver.WorktreeInfo{
-			Path:   e.Path,
-			Branch: e.Branch,
-		}
-	}
-	return worktrees, nil
+	return operations.ListWorktreeInfos(r)
 }
 
 // findWorktree looks up a worktree by task name.
 func findWorktree(r git.Runner, task string) (resolver.WorktreeInfo, error) {
-	worktrees, err := listWorktreeInfos(r)
-	if err != nil {
-		return resolver.WorktreeInfo{}, err
-	}
-
-	wt, found := resolver.FindBranchForTask(task, worktrees, resolver.AllPrefixes())
-	if !found {
-		return resolver.WorktreeInfo{}, fmt.Errorf(errWorktreeNotFound, task)
-	}
-	return wt, nil
+	return operations.FindWorktree(r, task)
 }

cmd/list.go

@@ -10,6 +10,7 @@ import (
 	"github.com/lugassawan/rimba/internal/config"
 	"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/lugassawan/rimba/internal/termcolor"
@@ -146,30 +147,13 @@ var listCmd = &cobra.Command{
 				sem <- struct{}{}
 				defer func() { <-sem }()
 
-				var status resolver.WorktreeStatus
-				if dirty, err := git.IsDirty(r, c.entry.Path); err == nil && dirty {
-					status.Dirty = true
-				}
-				ahead, behind, _ := git.AheadBehind(r, c.entry.Path)
-				status.Ahead = ahead
-				status.Behind = behind
-
+				status := operations.CollectWorktreeStatus(r, c.entry.Path)
 				rows[idx] = resolver.NewWorktreeDetail(c.entry.Branch, prefixes, c.displayPath, status, c.isCurrent)
 			}(i, c)
 		}
 		wg.Wait()
 
-		filtered := rows[:0]
-		for _, row := range rows {
-			if listDirty && !row.Status.Dirty {
-				continue
-			}
-			if listBehind && row.Status.Behind == 0 {
-				continue
-			}
-			filtered = append(filtered, row)
-		}
-		rows = filtered
+		rows = operations.FilterDetailsByStatus(rows, listDirty, listBehind)
 
 		s.Stop()
 

cmd/rename.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/lugassawan/rimba/internal/config"
 	"github.com/lugassawan/rimba/internal/git"
-	"github.com/lugassawan/rimba/internal/resolver"
+	"github.com/lugassawan/rimba/internal/operations"
 	"github.com/lugassawan/rimba/internal/spinner"
 	"github.com/spf13/cobra"
 )
@@ -44,33 +44,16 @@ var renameCmd = &cobra.Command{
 			return err
 		}
 
-		prefixes := resolver.AllPrefixes()
-
-		_, matchedPrefix := resolver.TaskFromBranch(wt.Branch, prefixes)
-		if matchedPrefix == "" {
-			matchedPrefix, _ = resolver.PrefixString(resolver.DefaultPrefixType)
-		}
-
-		newBranch := resolver.BranchName(matchedPrefix, newTask)
-
-		if git.BranchExists(r, newBranch) {
-			return fmt.Errorf("branch %q already exists", newBranch)
-		}
-
 		wtDir := filepath.Join(repoRoot, cfg.WorktreeDir)
-		newPath := resolver.WorktreePath(wtDir, newBranch)
 
 		s := spinner.New(spinnerOpts(cmd))
 		defer s.Stop()
 
 		force, _ := cmd.Flags().GetBool("force")
 		s.Start("Renaming worktree...")
-		if err := git.MoveWorktree(r, wt.Path, newPath, force); err != nil {
-			return err
-		}
 
-		if err := git.RenameBranch(r, wt.Branch, newBranch); err != nil {
-			return fmt.Errorf("worktree moved but failed to rename branch %q: %w\nTo complete manually: git branch -m %s %s", wt.Branch, err, wt.Branch, newBranch)
+		if _, err := operations.RenameWorktree(r, wt, newTask, wtDir, force); err != nil {
+			return err
 		}
 
 		s.Stop()

cmd/sync.go

@@ -8,6 +8,7 @@ import (
 	"github.com/lugassawan/rimba/internal/config"
 	"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"
@@ -17,7 +18,6 @@ const (
 	flagAll              = "all"
 	flagSyncMerge        = "merge"
 	flagIncludeInherited = "include-inherited"
-	verbRebase           = "rebase"
 
 	hintAll              = "Sync all eligible worktrees at once"
 	hintSyncMerge        = "Use merge instead of rebase (preserves history, creates merge commits)"
@@ -119,18 +119,18 @@ func syncOne(sc syncContext, task string, worktrees []resolver.WorktreeInfo, pre
 		verb = "Merging"
 	}
 	sc.s.Update(fmt.Sprintf("%s onto %s...", verb, sc.cfg.DefaultSource))
-	if err := doSync(sc.r, wt.Path, sc.cfg.DefaultSource, useMerge); err != nil {
+	if err := operations.SyncBranch(sc.r, wt.Path, sc.cfg.DefaultSource, useMerge); err != nil {
 		return err
 	}
 
 	sc.s.Stop()
-	fmt.Fprintf(sc.cmd.OutOrStdout(), "%s %s onto %s\n", syncMethodLabel(useMerge), wt.Branch, sc.cfg.DefaultSource)
+	fmt.Fprintf(sc.cmd.OutOrStdout(), "%s %s onto %s\n", operations.SyncMethodLabel(useMerge), wt.Branch, sc.cfg.DefaultSource)
 	return nil
 }
 
 func syncAll(sc syncContext, worktrees []resolver.WorktreeInfo, prefixes []string, useMerge, includeInherited bool) error { //nolint:unparam // error return matches RunE contract
-	allTasks := collectTasks(worktrees, prefixes)
-	eligible := filterEligible(worktrees, prefixes, sc.cfg.DefaultSource, allTasks, includeInherited)
+	allTasks := operations.CollectTasks(worktrees, prefixes)
+	eligible := operations.FilterEligible(worktrees, prefixes, sc.cfg.DefaultSource, allTasks, includeInherited)
 
 	var res syncResult
 	var mu sync.Mutex
@@ -160,65 +160,30 @@ func syncAll(sc syncContext, worktrees []resolver.WorktreeInfo, prefixes []strin
 	return nil
 }
 
-func collectTasks(worktrees []resolver.WorktreeInfo, prefixes []string) []string {
-	tasks := make([]string, 0, len(worktrees))
-	for _, wt := range worktrees {
-		task, _ := resolver.TaskFromBranch(wt.Branch, prefixes)
-		tasks = append(tasks, task)
-	}
-	return tasks
-}
+func syncWorktree(cmd *cobra.Command, r git.Runner, mainBranch string, wt resolver.WorktreeInfo, useMerge bool, res *syncResult, mu *sync.Mutex) {
+	sr := operations.SyncWorktree(r, mainBranch, wt, useMerge)
 
-func filterEligible(worktrees []resolver.WorktreeInfo, prefixes []string, mainBranch string, allTasks []string, includeInherited bool) []resolver.WorktreeInfo {
-	var eligible []resolver.WorktreeInfo
-	for _, wt := range worktrees {
-		if wt.Branch == mainBranch || wt.Branch == "" {
-			continue
-		}
-		task, _ := resolver.TaskFromBranch(wt.Branch, prefixes)
-		if !includeInherited && resolver.IsInherited(task, allTasks) {
-			continue
-		}
-		eligible = append(eligible, wt)
-	}
-	return eligible
-}
+	mu.Lock()
+	defer mu.Unlock()
 
-func syncWorktree(cmd *cobra.Command, r git.Runner, mainBranch string, wt resolver.WorktreeInfo, useMerge bool, res *syncResult, mu *sync.Mutex) {
-	dirty, err := git.IsDirty(r, wt.Path)
-	if err != nil {
-		mu.Lock()
-		fmt.Fprintf(cmd.OutOrStdout(), "Warning: could not check status of %s: %v\n", wt.Branch, err)
+	switch {
+	case sr.Skipped:
 		res.skippedDirty++
-		mu.Unlock()
-		return
-	}
-	if dirty {
-		mu.Lock()
-		fmt.Fprintf(cmd.OutOrStdout(), "Skipping %s (dirty)\n", wt.Branch)
-		res.skippedDirty++
-		mu.Unlock()
-		return
-	}
-
-	if err := doSync(r, wt.Path, mainBranch, useMerge); err != nil {
-		mu.Lock()
-		res.failed++
-		verb := verbRebase
-		if useMerge {
-			verb = flagSyncMerge
+		if sr.SkipReason == "dirty" {
+			fmt.Fprintf(cmd.OutOrStdout(), "Skipping %s (dirty)\n", sr.Branch)
+		} else {
+			fmt.Fprintf(cmd.OutOrStdout(), "Warning: %s: %s\n", sr.Branch, sr.SkipReason)
 		}
-		res.failures = append(res.failures, fmt.Sprintf("  %s: To resolve: cd %s && git %s %s", wt.Branch, wt.Path, verb, mainBranch))
-		mu.Unlock()
-		return
+	case sr.Failed:
+		res.failed++
+		res.failures = append(res.failures, fmt.Sprintf("  %s: To resolve: %s", sr.Branch, sr.FailureHint))
+	default:
+		res.synced++
 	}
-	mu.Lock()
-	res.synced++
-	mu.Unlock()
 }
 
 func printSyncSummary(cmd *cobra.Command, mainBranch string, useMerge bool, res *syncResult) {
-	fmt.Fprintf(cmd.OutOrStdout(), "%s %d worktree(s) onto %s", syncMethodLabel(useMerge), res.synced, mainBranch)
+	fmt.Fprintf(cmd.OutOrStdout(), "%s %d worktree(s) onto %s", operations.SyncMethodLabel(useMerge), res.synced, mainBranch)
 	if res.skippedDirty > 0 {
 		fmt.Fprintf(cmd.OutOrStdout(), ", %d skipped (dirty)", res.skippedDirty)
 	}
@@ -231,22 +196,3 @@ func printSyncSummary(cmd *cobra.Command, mainBranch string, useMerge bool, res
 		fmt.Fprintln(cmd.OutOrStdout(), f)
 	}
 }
-
-func syncMethodLabel(useMerge bool) string {
-	if useMerge {
-		return "Merged"
-	}
-	return "Rebased"
-}
-
-func doSync(r git.Runner, dir, mainBranch string, useMerge bool) error {
-	if useMerge {
-		return git.Merge(r, dir, mainBranch, false)
-	}
-	if err := git.Rebase(r, dir, mainBranch); err != nil {
-		// Abort the failed rebase to leave worktree in a clean state
-		_ = git.AbortRebase(r, dir)
-		return err
-	}
-	return nil
-}