feat(discover): support three versioning models in multi-module detection (#187)

* feat(discover): support three versioning models in multi-module detection

* test(discover): add tests for the three versioning models in multi-module detection

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

Author: indaco

internal/commands/discover/types.go

@@ -9,6 +9,7 @@ import (
 type Prompter interface {
 	Confirm(title, description string) (bool, error)
 	MultiSelect(title, description string, options []huh.Option[string], defaults []string) ([]string, error)
+	Select(title, description string, options []huh.Option[string]) (string, error)
 }
 
 // TUIPrompter implements Prompter using the tui package.
@@ -29,6 +30,11 @@ func (p *TUIPrompter) MultiSelect(title, description string, options []huh.Optio
 	return tui.MultiSelect(title, description, options, defaults)
 }
 
+// Select shows a single-select prompt.
+func (p *TUIPrompter) Select(title, description string, options []huh.Option[string]) (string, error) {
+	return tui.Select(title, description, options)
+}
+
 // OutputFormat controls how discovery results are displayed.
 type OutputFormat string
 

internal/commands/discover/workflow.go

@@ -74,7 +74,12 @@ func (w *Workflow) runInitWorkflow(ctx context.Context) (bool, error) {
 		return false, nil
 	}
 
-	// If we have sync candidates (multi-module project), run the dependency-check setup
+	// Handle multi-module projects specially
+	if w.result.Mode == discovery.MultiModule {
+		return w.runMultiModuleSetup(ctx)
+	}
+
+	// If we have sync candidates (manifest files), run the dependency-check setup
 	if len(w.result.SyncCandidates) > 0 {
 		return w.runDependencyCheckSetup(ctx)
 	}
@@ -83,6 +88,245 @@ func (w *Workflow) runInitWorkflow(ctx context.Context) (bool, error) {
 	return w.createConfigWithDefaults(ctx)
 }
 
+// WorkspaceChoice represents the user's choice for multi-module configuration.
+type WorkspaceChoice string
+
+const (
+	// WorkspaceChoiceCoordinated syncs all .version files to root (coordinated versioning).
+	WorkspaceChoiceCoordinated WorkspaceChoice = "coordinated"
+	// WorkspaceChoiceWorkspace configures independent module versions (workspace mode).
+	WorkspaceChoiceWorkspace WorkspaceChoice = "workspace"
+	// WorkspaceChoiceSingleRoot uses only the root .version for all manifests.
+	WorkspaceChoiceSingleRoot WorkspaceChoice = "single"
+)
+
+// runMultiModuleSetup handles configuration for multi-module/monorepo projects.
+func (w *Workflow) runMultiModuleSetup(ctx context.Context) (bool, error) {
+	fmt.Println()
+	printer.PrintInfo(fmt.Sprintf("Found %d modules - this appears to be a monorepo.", len(w.result.Modules)))
+	fmt.Println()
+
+	// Show discovered modules
+	printer.PrintFaint("Discovered modules:")
+	for _, m := range w.result.Modules {
+		fmt.Printf("  - %s (%s)\n", m.Name, m.RelPath)
+	}
+	fmt.Println()
+
+	// Ask how to configure the project
+	choice, err := w.prompter.Select(
+		"How would you like to configure versioning?",
+		"Choose how to manage versions in this monorepo.",
+		[]huh.Option[string]{
+			huh.NewOption("Coordinated versioning (recommended) - all .version files sync to root", string(WorkspaceChoiceCoordinated)),
+			huh.NewOption("Independent workspace - each module versioned separately", string(WorkspaceChoiceWorkspace)),
+			huh.NewOption("Single root only - ignore submodule .version files", string(WorkspaceChoiceSingleRoot)),
+		},
+	)
+	if err != nil {
+		return false, err
+	}
+
+	if choice == "" {
+		printer.PrintFaint("Configuration canceled.")
+		return false, nil
+	}
+
+	switch WorkspaceChoice(choice) {
+	case WorkspaceChoiceCoordinated:
+		return w.createConfigWithCoordinatedVersioning(ctx)
+	case WorkspaceChoiceWorkspace:
+		return w.createConfigWithWorkspace(ctx)
+	case WorkspaceChoiceSingleRoot:
+		// Only configure dependency-check for manifest files found near root
+		return w.runDependencyCheckSetup(ctx)
+	default:
+		return w.createConfigWithDefaults(ctx)
+	}
+}
+
+// createConfigWithCoordinatedVersioning creates .sley.yaml with coordinated versioning.
+// All submodule .version files and manifest files sync to the root .version.
+func (w *Workflow) createConfigWithCoordinatedVersioning(ctx context.Context) (bool, error) {
+	// Ensure root .version exists
+	if err := w.ensureVersionFile(ctx); err != nil {
+		return false, err
+	}
+
+	// Combine: submodule .version files + manifest files as sync candidates
+	var allSyncCandidates []discovery.SyncCandidate
+
+	// Add submodule .version files (excluding root)
+	for _, m := range w.result.Modules {
+		if m.RelPath == ".version" {
+			continue // Skip root
+		}
+		allSyncCandidates = append(allSyncCandidates, discovery.SyncCandidate{
+			Path:        m.RelPath,
+			Format:      parser.FormatRaw,
+			Field:       "",
+			Version:     m.Version,
+			Description: "Version file (" + m.RelPath + ")",
+		})
+	}
+
+	// Add manifest files
+	allSyncCandidates = append(allSyncCandidates, w.result.SyncCandidates...)
+
+	// Create config with dependency-check for ALL files
+	return w.createConfigWithDependencyCheck(ctx, allSyncCandidates)
+}
+
+// createConfigWithWorkspace creates .sley.yaml with workspace configuration for multi-module projects.
+func (w *Workflow) createConfigWithWorkspace(ctx context.Context) (bool, error) {
+	// Initialize .version file if needed
+	if err := w.ensureVersionFile(ctx); err != nil {
+		return false, err
+	}
+
+	// Default plugins: commit-parser and tag-manager
+	selectedPlugins := []string{"commit-parser", "tag-manager"}
+
+	// Generate config with workspace discovery enabled
+	configData, err := generateConfigYAMLWithWorkspace(defaultVersionPath(), selectedPlugins, w.result.SyncCandidates)
+	if err != nil {
+		return false, fmt.Errorf("failed to generate config: %w", err)
+	}
+
+	// Write config file
+	if err := os.WriteFile(".sley.yaml", configData, config.ConfigFilePerm); err != nil {
+		return false, fmt.Errorf("failed to write config file: %w", err)
+	}
+
+	w.printWorkspaceInitSuccess(selectedPlugins)
+	return true, nil
+}
+
+// printWorkspaceInitSuccess prints success messages after workspace initialization.
+func (w *Workflow) printWorkspaceInitSuccess(plugins []string) {
+	fmt.Println()
+	printer.PrintSuccess(fmt.Sprintf("Created .sley.yaml with workspace configuration and %d plugin(s)", len(plugins)))
+
+	// Show enabled plugins
+	fmt.Println()
+	printer.PrintInfo("Enabled plugins:")
+	for _, p := range plugins {
+		fmt.Printf("  - %s\n", p)
+	}
+
+	// Show workspace info
+	fmt.Println()
+	printer.PrintInfo("Workspace configuration:")
+	fmt.Println("  - Auto-discovery enabled")
+	fmt.Println("  - Each module manages its own .version file")
+
+	// Show discovered modules
+	fmt.Println()
+	printer.PrintInfo(fmt.Sprintf("Discovered %d module(s):", len(w.result.Modules)))
+	for _, m := range w.result.Modules {
+		fmt.Printf("  - %s (%s)\n", m.Name, m.RelPath)
+	}
+
+	// Note about per-module dependency-check
+	if len(w.result.SyncCandidates) > 0 {
+		fmt.Println()
+		printer.PrintFaint("Tip: Each module can have its own .sley.yaml with dependency-check")
+		printer.PrintFaint("     configured for manifests in that module's directory.")
+	}
+
+	// Next steps
+	fmt.Println()
+	printer.PrintInfo("Next steps:")
+	fmt.Println("  - Review .sley.yaml and adjust settings")
+	fmt.Println("  - Run 'sley bump patch' to see available modules")
+	fmt.Println("  - Run 'sley doctor' to verify setup")
+}
+
+// generateConfigYAMLWithWorkspace generates the YAML configuration content with workspace settings.
+func generateConfigYAMLWithWorkspace(versionPath string, plugins []string, syncCandidates []discovery.SyncCandidate) ([]byte, error) {
+	cfg := &config.Config{
+		Path: versionPath,
+	}
+
+	// Create workspace config with discovery enabled
+	enabled := true
+	recursive := true
+	moduleMaxDepth := 10
+	cfg.Workspace = &config.WorkspaceConfig{
+		Discovery: &config.DiscoveryConfig{
+			Enabled:        &enabled,
+			Recursive:      &recursive,
+			ModuleMaxDepth: &moduleMaxDepth,
+			Exclude:        []string{"testdata", "node_modules"},
+		},
+	}
+
+	// Create plugins config based on selections
+	pluginsCfg := &config.PluginConfig{}
+
+	for _, name := range plugins {
+		switch name {
+		case "commit-parser":
+			pluginsCfg.CommitParser = true
+		case "tag-manager":
+			pluginsCfg.TagManager = &config.TagManagerConfig{
+				Enabled: true,
+			}
+		case "dependency-check":
+			depCheck := &config.DependencyCheckConfig{
+				Enabled:  true,
+				AutoSync: true,
+			}
+			if len(syncCandidates) > 0 {
+				depCheck.Files = make([]config.DependencyFileConfig, len(syncCandidates))
+				for i, c := range syncCandidates {
+					depCheck.Files[i] = config.DependencyFileConfig{
+						Path:    c.Path,
+						Format:  c.Format.String(),
+						Field:   c.Field,
+						Pattern: c.Pattern,
+					}
+				}
+			}
+			pluginsCfg.DependencyCheck = depCheck
+		}
+	}
+
+	cfg.Plugins = pluginsCfg
+
+	return marshalConfigWithWorkspaceComments(cfg, plugins)
+}
+
+// marshalConfigWithWorkspaceComments marshals config to YAML with helpful comments for workspace.
+func marshalConfigWithWorkspaceComments(cfg *config.Config, plugins []string) ([]byte, error) {
+	data, err := marshalToYAML(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add header comments
+	var result strings.Builder
+	result.WriteString("# sley configuration file\n")
+	result.WriteString("# Documentation: https://github.com/indaco/sley\n")
+	result.WriteString("# Generated by 'sley discover'\n")
+	result.WriteString("\n")
+	result.WriteString("# This is a workspace configuration for a multi-module project.\n")
+	result.WriteString("# Each module with a .version file is discovered automatically.\n")
+	result.WriteString("# Modules can have their own .sley.yaml for module-specific settings.\n")
+	result.WriteString("\n")
+
+	if len(plugins) > 0 {
+		result.WriteString("# Enabled plugins:\n")
+		for _, name := range plugins {
+			result.WriteString(fmt.Sprintf("#   - %s\n", name))
+		}
+		result.WriteString("\n")
+	}
+
+	result.Write(data)
+	return []byte(result.String()), nil
+}
+
 // runExistingConfigWorkflow handles the case when .sley.yaml already exists.
 func (w *Workflow) runExistingConfigWorkflow(ctx context.Context) (bool, error) {
 	// Check for mismatches and offer to fix