fix: suppress version mismatch warnings in independent versioning mode (#252)

* fix: suppress version mismatch warnings in independent versioning mode

Add workspace.versioning field (independent|coordinated) to WorkspaceConfig.
When set to independent, discover command shows mismatches as info summaries instead of warnings. Updates text, table, and JSON output formatters.
JSON output gains a versioning_mode field for machine consumers.

* test: discover versioning mode and mismatch warning tests

Add TestWorkspaceConfig_IsIndependentVersioning, TestWorkspaceConfig_VersioningMode,
TestLoadConfig_InvalidVersioning for config validation. Add versioning mode tests
for JSON, text, table formatters and workflow mismatch handling.

* style: fix gofmt formatting in output.go

Author: indaco

internal/commands/discover/discovercmd.go

@@ -78,7 +78,7 @@ func runDiscoverCmd(ctx context.Context, cmd *cli.Command, cfg *config.Config) e
 	format := ParseOutputFormat(cmd.String("format"))
 	quiet := cmd.Bool("quiet")
 
-	formatter := NewFormatter(format)
+	formatter := NewFormatterWithConfig(format, cfg)
 
 	if quiet {
 		// In quiet mode, only show summary
@@ -91,7 +91,7 @@ func runDiscoverCmd(ctx context.Context, cmd *cli.Command, cfg *config.Config) e
 	noInteractive := cmd.Bool("no-interactive")
 	if !noInteractive && format == FormatText {
 		prompter := NewPrompter()
-		workflow := NewWorkflow(prompter, result, rootDir)
+		workflow := NewWorkflowWithConfig(prompter, result, rootDir, cfg)
 		if _, err := workflow.Run(ctx); err != nil {
 			return err
 		}

internal/commands/discover/output.go

@@ -6,20 +6,41 @@ import (
 	"os"
 	"strings"
 
+	"github.com/indaco/sley/internal/config"
 	"github.com/indaco/sley/internal/discovery"
 	"github.com/indaco/sley/internal/printer"
 )
 
 // Formatter handles display of discovery results.
 type Formatter struct {
 	format OutputFormat
+	cfg    *config.Config
 }
 
 // NewFormatter creates a new Formatter with the specified output format.
 func NewFormatter(format OutputFormat) *Formatter {
 	return &Formatter{format: format}
 }
 
+// NewFormatterWithConfig creates a new Formatter with the specified output format and config.
+// The config is used to adjust output severity (e.g., independent versioning shows info instead of warnings).
+func NewFormatterWithConfig(format OutputFormat, cfg *config.Config) *Formatter {
+	return &Formatter{format: format, cfg: cfg}
+}
+
+// isIndependentVersioning returns true if the config indicates independent versioning mode.
+func (f *Formatter) isIndependentVersioning() bool {
+	return f.cfg != nil && f.cfg.Workspace != nil && f.cfg.Workspace.IsIndependentVersioning()
+}
+
+// versioningMode returns the effective versioning mode string from the config.
+func (f *Formatter) versioningMode() string {
+	if f.cfg != nil && f.cfg.Workspace != nil {
+		return f.cfg.Workspace.VersioningMode()
+	}
+	return "coordinated"
+}
+
 // FormatResult formats the discovery result for display.
 func (f *Formatter) FormatResult(result *discovery.Result) string {
 	switch f.format {
@@ -72,12 +93,22 @@ func (f *Formatter) formatText(result *discovery.Result) string {
 
 	// Mismatches section
 	if len(result.Mismatches) > 0 {
-		sb.WriteString(printer.Warning("Version Mismatches:"))
-		sb.WriteString("\n")
-		for _, m := range result.Mismatches {
-			status := printer.Warning("⚠")
-			fmt.Fprintf(&sb, "  %s %s: expected %s, found %s\n",
-				status, m.Source, m.ExpectedVersion, m.ActualVersion)
+		if f.isIndependentVersioning() {
+			sb.WriteString(printer.Info(fmt.Sprintf("Version Summary (independent versioning): %d module(s) at different versions", len(result.Mismatches))))
+			sb.WriteString("\n")
+			for _, m := range result.Mismatches {
+				status := printer.Info("ℹ")
+				fmt.Fprintf(&sb, "  %s %s: %s (root: %s)\n",
+					status, m.Source, m.ActualVersion, m.ExpectedVersion)
+			}
+		} else {
+			sb.WriteString(printer.Warning("Version Mismatches:"))
+			sb.WriteString("\n")
+			for _, m := range result.Mismatches {
+				status := printer.Warning("⚠")
+				fmt.Fprintf(&sb, "  %s %s: expected %s, found %s\n",
+					status, m.Source, m.ExpectedVersion, m.ActualVersion)
+			}
 		}
 		sb.WriteString("\n")
 	}
@@ -133,7 +164,11 @@ func (f *Formatter) formatTable(result *discovery.Result) string {
 
 	// Mismatches table
 	if len(result.Mismatches) > 0 {
-		sb.WriteString("Version Mismatches:\n")
+		if f.isIndependentVersioning() {
+			fmt.Fprintf(&sb, "Version Summary (independent versioning): %d module(s) at different versions\n", len(result.Mismatches))
+		} else {
+			sb.WriteString("Version Mismatches:\n")
+		}
 		fmt.Fprintf(&sb, "%-30s %-15s %-15s\n", "SOURCE", "EXPECTED", "ACTUAL")
 		sb.WriteString(strings.Repeat("-", 60) + "\n")
 		for _, m := range result.Mismatches {
@@ -180,6 +215,7 @@ func (f *Formatter) formatJSON(result *discovery.Result) string {
 
 	output := struct {
 		Mode           string              `json:"mode"`
+		VersioningMode string              `json:"versioning_mode"`
 		Modules        []jsonModule        `json:"modules"`
 		Manifests      []jsonManifest      `json:"manifests"`
 		Mismatches     []jsonMismatch      `json:"mismatches"`
@@ -194,6 +230,7 @@ func (f *Formatter) formatJSON(result *discovery.Result) string {
 		} `json:"summary"`
 	}{
 		Mode:           result.Mode.String(),
+		VersioningMode: f.versioningMode(),
 		Modules:        make([]jsonModule, len(result.Modules)),
 		Manifests:      make([]jsonManifest, len(result.Manifests)),
 		Mismatches:     make([]jsonMismatch, len(result.Mismatches)),
@@ -269,7 +306,11 @@ func (f *Formatter) formatSummary(result *discovery.Result) string {
 	}
 
 	if mismatchCount > 0 {
-		parts = append(parts, printer.Warning(fmt.Sprintf("%d mismatch(es)", mismatchCount)))
+		if f.isIndependentVersioning() {
+			parts = append(parts, printer.Info(fmt.Sprintf("%d version difference(s) (independent)", mismatchCount)))
+		} else {
+			parts = append(parts, printer.Warning(fmt.Sprintf("%d mismatch(es)", mismatchCount)))
+		}
 	}
 
 	if len(parts) == 0 {

internal/commands/discover/output_test.go

@@ -4,6 +4,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/indaco/sley/internal/config"
 	"github.com/indaco/sley/internal/discovery"
 	"github.com/indaco/sley/internal/parser"
 	"github.com/indaco/sley/internal/testutils"
@@ -700,3 +701,178 @@ func TestFormatter_FormatResult_DefaultCase(t *testing.T) {
 		t.Error("expected text format output for invalid format")
 	}
 }
+
+func TestFormatJSON_VersioningMode(t *testing.T) {
+	result := &discovery.Result{
+		Mode: discovery.MultiModule,
+		Modules: []discovery.Module{
+			{Name: "root", RelPath: ".version", Version: "1.0.0"},
+			{Name: "sub", RelPath: "sub/.version", Version: "2.0.0"},
+		},
+		Mismatches: []discovery.Mismatch{
+			{Source: "sub/.version", ExpectedVersion: "1.0.0", ActualVersion: "2.0.0"},
+		},
+	}
+
+	tests := []struct {
+		name     string
+		cfg      *config.Config
+		wantMode string
+	}{
+		{
+			name: "independent config",
+			cfg: &config.Config{
+				Workspace: &config.WorkspaceConfig{Versioning: "independent"},
+			},
+			wantMode: `"versioning_mode": "independent"`,
+		},
+		{
+			name: "coordinated config",
+			cfg: &config.Config{
+				Workspace: &config.WorkspaceConfig{Versioning: "coordinated"},
+			},
+			wantMode: `"versioning_mode": "coordinated"`,
+		},
+		{
+			name:     "nil config defaults to coordinated",
+			cfg:      nil,
+			wantMode: `"versioning_mode": "coordinated"`,
+		},
+		{
+			name:     "empty workspace defaults to coordinated",
+			cfg:      &config.Config{},
+			wantMode: `"versioning_mode": "coordinated"`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var formatter *Formatter
+			if tt.cfg != nil {
+				formatter = NewFormatterWithConfig(FormatJSON, tt.cfg)
+			} else {
+				formatter = NewFormatter(FormatJSON)
+			}
+			output := formatter.FormatResult(result)
+
+			if !strings.Contains(output, tt.wantMode) {
+				t.Errorf("JSON output missing expected versioning_mode.\nwant substring: %s\ngot: %s", tt.wantMode, output)
+			}
+		})
+	}
+}
+
+func TestFormatText_VersioningMode_IndependentMismatches(t *testing.T) {
+	result := &discovery.Result{
+		Mode: discovery.MultiModule,
+		Modules: []discovery.Module{
+			{Name: "root", RelPath: ".version", Version: "1.0.0"},
+			{Name: "sub", RelPath: "sub/.version", Version: "2.0.0"},
+		},
+		Mismatches: []discovery.Mismatch{
+			{Source: "sub/.version", ExpectedVersion: "1.0.0", ActualVersion: "2.0.0"},
+		},
+	}
+
+	t.Run("independent shows info language", func(t *testing.T) {
+		cfg := &config.Config{
+			Workspace: &config.WorkspaceConfig{Versioning: "independent"},
+		}
+		formatter := NewFormatterWithConfig(FormatText, cfg)
+		output := formatter.FormatResult(result)
+
+		if !strings.Contains(output, "independent versioning") {
+			t.Errorf("expected 'independent versioning' in output, got:\n%s", output)
+		}
+		if strings.Contains(output, "expected 1.0.0") {
+			t.Errorf("independent mode should not use 'expected' warning language, got:\n%s", output)
+		}
+	})
+
+	t.Run("coordinated shows warning language", func(t *testing.T) {
+		cfg := &config.Config{
+			Workspace: &config.WorkspaceConfig{Versioning: "coordinated"},
+		}
+		formatter := NewFormatterWithConfig(FormatText, cfg)
+		output := formatter.FormatResult(result)
+
+		if !strings.Contains(output, "Version Mismatch") {
+			t.Errorf("expected 'Version Mismatch' in output, got:\n%s", output)
+		}
+		if !strings.Contains(output, "expected 1.0.0") {
+			t.Errorf("expected warning language with 'expected', got:\n%s", output)
+		}
+	})
+}
+
+func TestFormatTable_VersioningMode_IndependentMismatches(t *testing.T) {
+	result := &discovery.Result{
+		Mode: discovery.MultiModule,
+		Modules: []discovery.Module{
+			{Name: "root", RelPath: ".version", Version: "1.0.0"},
+		},
+		Mismatches: []discovery.Mismatch{
+			{Source: "sub/.version", ExpectedVersion: "1.0.0", ActualVersion: "2.0.0"},
+		},
+	}
+
+	t.Run("independent shows version summary", func(t *testing.T) {
+		cfg := &config.Config{
+			Workspace: &config.WorkspaceConfig{Versioning: "independent"},
+		}
+		formatter := NewFormatterWithConfig(FormatTable, cfg)
+		output := formatter.formatTable(result)
+
+		if !strings.Contains(output, "independent versioning") {
+			t.Errorf("expected 'independent versioning' in table output, got:\n%s", output)
+		}
+		if strings.Contains(output, "Version Mismatches:") {
+			t.Errorf("independent mode should not show 'Version Mismatches:' header, got:\n%s", output)
+		}
+	})
+
+	t.Run("coordinated shows mismatches header", func(t *testing.T) {
+		formatter := NewFormatter(FormatTable)
+		output := formatter.formatTable(result)
+
+		if !strings.Contains(output, "Version Mismatches:") {
+			t.Errorf("expected 'Version Mismatches:' in table output, got:\n%s", output)
+		}
+	})
+}
+
+func TestFormatter_formatSummary_VersioningMode(t *testing.T) {
+	result := &discovery.Result{
+		Modules: []discovery.Module{
+			{Version: "1.0.0", RelPath: ".version"},
+		},
+		Mismatches: []discovery.Mismatch{
+			{Source: "sub/.version"},
+			{Source: "other/.version"},
+		},
+	}
+
+	t.Run("independent shows difference count", func(t *testing.T) {
+		cfg := &config.Config{
+			Workspace: &config.WorkspaceConfig{Versioning: "independent"},
+		}
+		formatter := NewFormatterWithConfig(FormatText, cfg)
+		summary := formatter.formatSummary(result)
+
+		if !strings.Contains(summary, "version difference") {
+			t.Errorf("expected 'version difference' in summary, got: %q", summary)
+		}
+		if !strings.Contains(summary, "independent") {
+			t.Errorf("expected 'independent' in summary, got: %q", summary)
+		}
+	})
+
+	t.Run("coordinated shows mismatch count", func(t *testing.T) {
+		formatter := NewFormatter(FormatText)
+		summary := formatter.formatSummary(result)
+
+		if !strings.Contains(summary, "mismatch") {
+			t.Errorf("expected 'mismatch' in summary, got: %q", summary)
+		}
+	})
+}

internal/commands/discover/workflow.go

@@ -21,6 +21,7 @@ type Workflow struct {
 	prompter Prompter
 	result   *discovery.Result
 	rootDir  string
+	cfg      *config.Config
 }
 
 // NewWorkflow creates a new workflow handler.
@@ -32,6 +33,16 @@ func NewWorkflow(prompter Prompter, result *discovery.Result, rootDir string) *W
 	}
 }
 
+// NewWorkflowWithConfig creates a new workflow handler with config awareness.
+func NewWorkflowWithConfig(prompter Prompter, result *discovery.Result, rootDir string, cfg *config.Config) *Workflow {
+	return &Workflow{
+		prompter: prompter,
+		result:   result,
+		rootDir:  rootDir,
+		cfg:      cfg,
+	}
+}
+
 // Run executes the interactive workflow if appropriate.
 // Returns true if the workflow completed with actions taken.
 func (w *Workflow) Run(ctx context.Context) (bool, error) {
@@ -345,9 +356,14 @@ func (w *Workflow) runExistingConfigWorkflow(ctx context.Context) (bool, error)
 // runMismatchWorkflow offers to help resolve version mismatches.
 func (w *Workflow) runMismatchWorkflow(_ context.Context) (bool, error) {
 	fmt.Println()
-	printer.PrintWarning(fmt.Sprintf("Found %d version mismatch(es).", len(w.result.Mismatches)))
-	printer.PrintFaint("Consider enabling the dependency-check plugin with auto-sync to keep versions in sync.")
-	printer.PrintFaint("Run 'sley bump auto --sync' to sync versions during bumps.")
+	if w.cfg != nil && w.cfg.Workspace != nil && w.cfg.Workspace.IsIndependentVersioning() {
+		printer.PrintInfo(fmt.Sprintf("Version summary: %d module(s) at different versions (independent versioning).", len(w.result.Mismatches)))
+		printer.PrintFaint("Each module manages its own version independently.")
+	} else {
+		printer.PrintWarning(fmt.Sprintf("Found %d version mismatch(es).", len(w.result.Mismatches)))
+		printer.PrintFaint("Consider enabling the dependency-check plugin with auto-sync to keep versions in sync.")
+		printer.PrintFaint("Run 'sley bump auto --sync' to sync versions during bumps.")
+	}
 	return false, nil
 }