[refactor] Codebase cleanup: reduce duplication and improve consistency (#86)

* [refactor] Small fixes: dead code, constants, flag consistency

- Export errWorktreeNotFound from operations package, remove cmd/ duplicate
- Use flagForce constant in rename.go instead of hardcoded "force"
- Remove dead return value from parseCount in git/branch.go
- Merge identical hintDryRunMerged/hintDryRunStale into hintDryRunClean
- Remove stub Config.Validate() that always returned nil
- Replace package-level flag vars in list.go with local GetBool/GetString calls

* [refactor] Extract parallel collection helper

Add generic internal/parallel.Collect[T] to replace repeated
WaitGroup+semaphore pattern across 6 call sites (status, list, log,
mcp/tool_status, mcp/tool_list, mcp/tool_sync).

* [refactor] Unify JSON output types between CLI and MCP

Move shared JSON types (ListItem, StatusData, ExecData, etc.) to
internal/output/types.go. Both cmd/ and internal/mcp/ now import
from the same source, eliminating duplicate struct definitions.

* [refactor] Extract post-create setup from duplicate and restore

Add operations.PostCreateSetup() to encapsulate the copy-files,
install-deps, run-hooks sequence shared by add, duplicate, and restore.
Reduces duplication and ensures consistent error messages.

* [fix] Add fetch error warning to MCP sync handler

Surface git fetch errors as a warning field in the MCP sync result
instead of silently discarding them, matching the CLI behavior.

* [chore] Make MCP command help platform-agnostic

Remove Claude Code-specific configuration example from mcp command
long description.

* [refactor] Reduce parameter counts and add maxparams lint rule

Refactor three 8-parameter functions down to 5 parameters each by
bundling related args into structs, then add a custom lint rule to
prevent regression.

Author: lugassawan

.golangci.yml

@@ -39,7 +39,7 @@ linters:
     custom:
       rimbalint:
         type: "module"
-        description: "Rimba custom lint rules (nolocalstruct, nolateexport)"
+        description: "Rimba custom lint rules (maxparams, nolocalstruct, nolateexport)"
     decorder:
       dec-order:
         - type

cmd/clean.go

@@ -18,11 +18,10 @@ const (
 	flagMerged = "merged"
 	flagStale  = "stale"
 
-	hintMerged       = "Remove worktrees whose branches are already merged into main"
-	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"
+	hintMerged      = "Remove worktrees whose branches are already merged into main"
+	hintDryRunPrune = "Preview what would be pruned without making changes"
+	hintDryRunClean = "Preview what would be removed without making changes"
+	hintForce       = "Skip confirmation prompt"
 )
 
 func init() {
@@ -98,7 +97,7 @@ func cleanMerged(cmd *cobra.Command, r git.Runner) error {
 	}
 
 	hint.New(cmd, hintPainter(cmd)).
-		Add(flagDryRun, hintDryRunMerged).
+		Add(flagDryRun, hintDryRunClean).
 		Add(flagForce, hintForce).
 		Show()
 
@@ -160,7 +159,7 @@ func cleanStale(cmd *cobra.Command, r git.Runner) error {
 	}
 
 	hint.New(cmd, hintPainter(cmd)).
-		Add(flagDryRun, hintDryRunStale).
+		Add(flagDryRun, hintDryRunClean).
 		Add(flagForce, hintForce).
 		Add(flagStaleDays, "Customize the staleness threshold (default: 14 days)").
 		Show()

cmd/deps.go

@@ -7,6 +7,7 @@ import (
 	"github.com/lugassawan/rimba/internal/config"
 	"github.com/lugassawan/rimba/internal/deps"
 	"github.com/lugassawan/rimba/internal/git"
+	"github.com/lugassawan/rimba/internal/operations"
 	"github.com/lugassawan/rimba/internal/output"
 	"github.com/lugassawan/rimba/internal/resolver"
 	"github.com/lugassawan/rimba/internal/spinner"
@@ -172,7 +173,7 @@ var depsInstallCmd = &cobra.Command{
 				}
 			}
 			if !found {
-				return fmt.Errorf(errWorktreeNotFound, task)
+				return fmt.Errorf(operations.ErrWorktreeNotFoundFmt, task)
 			}
 		}
 

cmd/duplicate.go

@@ -6,8 +6,6 @@ import (
 	"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/operations"
@@ -89,11 +87,6 @@ var duplicateCmd = &cobra.Command{
 		wtDir := filepath.Join(repoRoot, cfg.WorktreeDir)
 		wtPath := resolver.WorktreePath(wtDir, newBranch)
 
-		wtEntries, err := git.ListWorktrees(r)
-		if err != nil {
-			return err
-		}
-
 		// Validate
 		if git.BranchExists(r, newBranch) {
 			return fmt.Errorf("branch %q already exists", newBranch)
@@ -117,36 +110,28 @@ var duplicateCmd = &cobra.Command{
 			return err
 		}
 
-		// Copy files
-		s.Update("Copying files...")
-		copied, err := fileutil.CopyEntries(repoRoot, wtPath, cfg.CopyFiles)
-		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, newTask)
-		}
-
-		// Dependencies — prefer cloning from source worktree
+		// Post-create setup: copy files, deps, hooks
 		skipDeps, _ := cmd.Flags().GetBool(flagSkipDeps)
+		skipHooks, _ := cmd.Flags().GetBool(flagSkipHooks)
 		var configModules []config.ModuleConfig
 		if cfg.Deps != nil {
 			configModules = cfg.Deps.Modules
 		}
 
-		var depsResults []deps.InstallResult
-		if !skipDeps {
-			s.Update("Installing dependencies...")
-			depsResults = operations.InstallDepsPreferSource(r, wtPath, wt.Path, cfg.IsAutoDetectDeps(), configModules, 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 = operations.RunPostCreateHooks(wtPath, cfg.PostCreate, func(cur, total int, name string) {
-				s.Update(fmt.Sprintf("Running hooks... (%s) [%d/%d]", name, cur, total))
-			})
+		pcResult, err := operations.PostCreateSetup(r, operations.PostCreateParams{
+			RepoRoot:      repoRoot,
+			WtPath:        wtPath,
+			Task:          newTask,
+			CopyFiles:     cfg.CopyFiles,
+			SkipDeps:      skipDeps,
+			AutoDetect:    cfg.IsAutoDetectDeps(),
+			ConfigModules: configModules,
+			SkipHooks:     skipHooks,
+			PostCreate:    cfg.PostCreate,
+			SourcePath:    wt.Path,
+		}, func(msg string) { s.Update(msg) })
+		if err != nil {
+			return err
 		}
 
 		s.Stop()
@@ -155,15 +140,15 @@ var duplicateCmd = &cobra.Command{
 		fmt.Fprintf(out, "Duplicated worktree %q as %q\n", task, newTask)
 		fmt.Fprintf(out, "  Branch: %s\n", newBranch)
 		fmt.Fprintf(out, "  Path:   %s\n", wtPath)
-		if len(copied) > 0 {
-			fmt.Fprintf(out, "  Copied: %v\n", copied)
+		if len(pcResult.Copied) > 0 {
+			fmt.Fprintf(out, "  Copied: %v\n", pcResult.Copied)
 		}
-		if skipped := fileutil.SkippedEntries(cfg.CopyFiles, copied); len(skipped) > 0 {
-			fmt.Fprintf(out, "  Skipped (not found): %v\n", skipped)
+		if len(pcResult.Skipped) > 0 {
+			fmt.Fprintf(out, "  Skipped (not found): %v\n", pcResult.Skipped)
 		}
 
-		printInstallResults(out, depsResults)
-		printHookResultsList(out, hookResults)
+		printInstallResults(out, pcResult.DepsResults)
+		printHookResultsList(out, pcResult.HookResults)
 
 		return nil
 	},

cmd/exec.go

@@ -19,23 +19,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-type execJSONData struct {
-	Command string           `json:"command"`
-	Results []execJSONResult `json:"results"`
-	Success bool             `json:"success"`
-}
-
-type execJSONResult struct {
-	Task      string `json:"task"`
-	Branch    string `json:"branch"`
-	Path      string `json:"path"`
-	ExitCode  int    `json:"exit_code"`
-	Stdout    string `json:"stdout"`
-	Stderr    string `json:"stderr"`
-	Error     string `json:"error,omitempty"`
-	Cancelled bool   `json:"cancelled,omitempty"`
-}
-
 const (
 	flagFailFast    = "fail-fast"
 	flagConcurrency = "concurrency"
@@ -157,9 +140,9 @@ var execCmd = &cobra.Command{
 		s.Stop()
 
 		if isJSON(cmd) {
-			jsonResults := make([]execJSONResult, len(results))
+			jsonResults := make([]output.ExecResult, len(results))
 			for i, r := range results {
-				jr := execJSONResult{
+				jr := output.ExecResult{
 					Task:      r.Target.Task,
 					Branch:    r.Target.Branch,
 					Path:      r.Target.Path,
@@ -173,7 +156,7 @@ var execCmd = &cobra.Command{
 				}
 				jsonResults[i] = jr
 			}
-			data := execJSONData{
+			data := output.ExecData{
 				Command: args[0],
 				Results: jsonResults,
 				Success: !hasFailure(results),

cmd/exec_test.go

@@ -164,9 +164,9 @@ func TestPrintExecResultsJSON(t *testing.T) {
 	}
 
 	// Simulate the JSON output path from exec command
-	jsonResults := make([]execJSONResult, len(results))
+	jsonResults := make([]output.ExecResult, len(results))
 	for i, r := range results {
-		jr := execJSONResult{
+		jr := output.ExecResult{
 			Task:     r.Target.Task,
 			Branch:   r.Target.Branch,
 			Path:     r.Target.Path,
@@ -179,7 +179,7 @@ func TestPrintExecResultsJSON(t *testing.T) {
 		}
 		jsonResults[i] = jr
 	}
-	data := execJSONData{
+	data := output.ExecData{
 		Command: "echo hello",
 		Results: jsonResults,
 		Success: !hasFailure(results),

cmd/list.go

@@ -5,34 +5,19 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"sync"
 
 	"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/output"
+	"github.com/lugassawan/rimba/internal/parallel"
 	"github.com/lugassawan/rimba/internal/resolver"
 	"github.com/lugassawan/rimba/internal/spinner"
 	"github.com/lugassawan/rimba/internal/termcolor"
 	"github.com/spf13/cobra"
 )
 
-type listJSONItem struct {
-	Task      string                  `json:"task"`
-	Type      string                  `json:"type"`
-	Branch    string                  `json:"branch"`
-	Path      string                  `json:"path"`
-	IsCurrent bool                    `json:"is_current"`
-	Status    resolver.WorktreeStatus `json:"status"`
-}
-
-type listArchivedJSONItem struct {
-	Task   string `json:"task"`
-	Type   string `json:"type"`
-	Branch string `json:"branch"`
-}
-
 const (
 	flagType     = "type"
 	flagDirty    = "dirty"
@@ -51,20 +36,13 @@ type candidate struct {
 	isCurrent   bool
 }
 
-var (
-	listType     string
-	listDirty    bool
-	listBehind   bool
-	listArchived bool
-)
-
 func init() {
 	rootCmd.AddCommand(listCmd)
 
-	listCmd.Flags().StringVar(&listType, flagType, "", "filter by prefix type (e.g. feature, bugfix)")
-	listCmd.Flags().BoolVar(&listDirty, flagDirty, false, "show only dirty worktrees")
-	listCmd.Flags().BoolVar(&listBehind, flagBehind, false, "show only worktrees behind upstream")
-	listCmd.Flags().BoolVar(&listArchived, flagArchived, false, "show archived branches (not in any active worktree)")
+	listCmd.Flags().String(flagType, "", "filter by prefix type (e.g. feature, bugfix)")
+	listCmd.Flags().Bool(flagDirty, false, "show only dirty worktrees")
+	listCmd.Flags().Bool(flagBehind, false, "show only worktrees behind upstream")
+	listCmd.Flags().Bool(flagArchived, false, "show archived branches (not in any active worktree)")
 
 	listCmd.MarkFlagsMutuallyExclusive(flagArchived, flagType)
 	listCmd.MarkFlagsMutuallyExclusive(flagArchived, flagDirty)
@@ -87,6 +65,11 @@ var listCmd = &cobra.Command{
 	Short: "List all worktrees",
 	Long:  "Lists all git worktrees with their branch, path, and status (dirty, ahead/behind).",
 	RunE: func(cmd *cobra.Command, args []string) error {
+		listType, _ := cmd.Flags().GetString(flagType)
+		listDirty, _ := cmd.Flags().GetBool(flagDirty)
+		listBehind, _ := cmd.Flags().GetBool(flagBehind)
+		listArchived, _ := cmd.Flags().GetBool(flagArchived)
+
 		if listArchived {
 			r := newRunner()
 			mainBranch, err := resolveMainBranch(r)
@@ -120,7 +103,7 @@ var listCmd = &cobra.Command{
 
 		if len(entries) == 0 {
 			if isJSON(cmd) {
-				return output.WriteJSON(cmd.OutOrStdout(), version, "list", make([]listJSONItem, 0))
+				return output.WriteJSON(cmd.OutOrStdout(), version, "list", make([]output.ListItem, 0))
 			}
 			fmt.Fprintln(cmd.OutOrStdout(), "No worktrees found.")
 			return nil
@@ -172,31 +155,19 @@ var listCmd = &cobra.Command{
 			candidates = append(candidates, candidate{entry: e, displayPath: displayPath, isCurrent: isCurrent})
 		}
 
-		rows := make([]resolver.WorktreeDetail, len(candidates))
-		var wg sync.WaitGroup
-		sem := make(chan struct{}, 8)
-
-		for i, c := range candidates {
-			s.Update(fmt.Sprintf("Loading worktrees... (%d/%d)", i+1, len(candidates)))
-			wg.Add(1)
-			go func(idx int, c candidate) {
-				defer wg.Done()
-				sem <- struct{}{}
-				defer func() { <-sem }()
-
-				status := operations.CollectWorktreeStatus(r, c.entry.Path)
-				rows[idx] = resolver.NewWorktreeDetail(c.entry.Branch, prefixes, c.displayPath, status, c.isCurrent)
-			}(i, c)
-		}
-		wg.Wait()
+		rows := parallel.Collect(len(candidates), 8, func(i int) resolver.WorktreeDetail {
+			c := candidates[i]
+			status := operations.CollectWorktreeStatus(r, c.entry.Path)
+			return resolver.NewWorktreeDetail(c.entry.Branch, prefixes, c.displayPath, status, c.isCurrent)
+		})
 
 		rows = operations.FilterDetailsByStatus(rows, listDirty, listBehind)
 
 		s.Stop()
 
 		if len(rows) == 0 {
 			if isJSON(cmd) {
-				return output.WriteJSON(cmd.OutOrStdout(), version, "list", make([]listJSONItem, 0))
+				return output.WriteJSON(cmd.OutOrStdout(), version, "list", make([]output.ListItem, 0))
 			}
 			fmt.Fprintln(cmd.OutOrStdout(), "No worktrees match the given filters.")
 			return nil
@@ -205,9 +176,9 @@ var listCmd = &cobra.Command{
 		resolver.SortDetailsByTask(rows)
 
 		if isJSON(cmd) {
-			items := make([]listJSONItem, len(rows))
+			items := make([]output.ListItem, len(rows))
 			for i, r := range rows {
-				items[i] = listJSONItem{
+				items[i] = output.ListItem{
 					Task:      r.Task,
 					Type:      r.Type,
 					Branch:    r.Branch,
@@ -264,11 +235,11 @@ func listArchivedBranches(cmd *cobra.Command, r git.Runner, mainBranch string) e
 	prefixes := resolver.AllPrefixes()
 
 	if isJSON(cmd) {
-		items := make([]listArchivedJSONItem, 0, len(archived))
+		items := make([]output.ListArchivedItem, 0, len(archived))
 		for _, b := range archived {
 			task, matchedPrefix := resolver.TaskFromBranch(b, prefixes)
 			typeName := strings.TrimSuffix(matchedPrefix, "/")
-			items = append(items, listArchivedJSONItem{Task: task, Type: typeName, Branch: b})
+			items = append(items, output.ListArchivedItem{Task: task, Type: typeName, Branch: b})
 		}
 		return output.WriteJSON(cmd.OutOrStdout(), version, "list", items)
 	}