feat: extend config merge with non-plugin field semantics (#254)

* feat: extend MergeConfig with non-plugin field merging (theme, extensions, hooks)

Rename MergePluginConfig to MergeConfig (deprecated alias preserved).
Theme: module wins if set. Extensions: additive merge deduplicated by name.
PreReleaseHooks: additive merge (root first, then module). All slice fields
are deep-copied to prevent mutation of root config.

* test: MergeConfig non-plugin field merge semantics and deep copy safety

* refactor: use maps.Copy for shallow map cloning in config merge helpers

Author: indaco

internal/commands/bump/helpers.go

@@ -120,7 +120,7 @@ func applyModuleTagPrefix(tm tagmanager.TagManager, bumpedPath string, cfg *conf
 	if moduleCfg == nil {
 		return noop, nil
 	}
-	mergedCfg := config.MergePluginConfig(cfg, moduleCfg)
+	mergedCfg := config.MergeConfig(cfg, moduleCfg)
 	if mergedCfg.Plugins == nil || mergedCfg.Plugins.TagManager == nil {
 		return noop, nil
 	}

internal/commands/tag/tagcmd.go

@@ -147,7 +147,7 @@ func resolveModuleConfig(cfg *config.Config, path string) (*config.Config, strin
 	if err != nil || moduleCfg == nil {
 		return cfg, moduleDir
 	}
-	return config.MergePluginConfig(cfg, moduleCfg), moduleDir
+	return config.MergeConfig(cfg, moduleCfg), moduleDir
 }
 
 // runCreateCmd creates a git tag for the current version.

internal/config/config.go

@@ -3,6 +3,7 @@ package config
 import (
 	"bytes"
 	"fmt"
+	"maps"
 	"os"
 	"path/filepath"
 	"strings"
@@ -202,11 +203,22 @@ func LoadConfigFromDir(dir string) (*Config, error) {
 	return loadConfigFromPath(filepath.Join(dir, ".sley.yaml"))
 }
 
-// MergePluginConfig merges a module-level config into a root config.
+// MergePluginConfig is a deprecated alias for [MergeConfig].
+var MergePluginConfig = MergeConfig
+
+// MergeConfig merges a module-level config into a root config.
 // Plugin pointer fields from module override root when non-nil.
 // CommitParser always comes from root (workspace-level setting).
+//
+// Non-plugin field semantics:
+//   - Path: always root
+//   - Workspace: always root
+//   - Theme: module wins if non-empty, else root
+//   - Extensions: additive merge (root + module, dedup by Name, module wins)
+//   - PreReleaseHooks: additive merge (root hooks then module hooks appended)
+//
 // Returns a new *Config without mutating the inputs.
-func MergePluginConfig(root, module *Config) *Config {
+func MergeConfig(root, module *Config) *Config {
 	if root == nil && module == nil {
 		return nil
 	}
@@ -217,11 +229,17 @@ func MergePluginConfig(root, module *Config) *Config {
 		return module
 	}
 
+	// Theme: module wins if non-empty.
+	theme := root.Theme
+	if module.Theme != "" {
+		theme = module.Theme
+	}
+
 	merged := &Config{
 		Path:            root.Path,
-		Theme:           root.Theme,
-		Extensions:      root.Extensions,
-		PreReleaseHooks: root.PreReleaseHooks,
+		Theme:           theme,
+		Extensions:      mergeExtensions(root.Extensions, module.Extensions),
+		PreReleaseHooks: mergePreReleaseHooks(root.PreReleaseHooks, module.PreReleaseHooks),
 		Workspace:       root.Workspace,
 	}
 
@@ -280,3 +298,96 @@ func NormalizeVersionPath(path string) string {
 // ConfigFilePerm defines secure file permissions for config files (owner read/write only).
 // References core.PermOwnerRW for consistency across the codebase.
 const ConfigFilePerm = core.PermOwnerRW
+
+// mergeExtensions performs an additive merge of root and module extension slices.
+// Deduplication is by Name: if the same Name appears in both, the module version wins.
+// Order: root extensions first (with duplicates replaced), then module-only extensions appended.
+// Returns a new slice; inputs are not modified.
+func mergeExtensions(root, module []ExtensionConfig) []ExtensionConfig {
+	if len(module) == 0 {
+		return copyExtensions(root)
+	}
+	if len(root) == 0 {
+		return copyExtensions(module)
+	}
+
+	// Build lookup of module extensions by Name.
+	moduleByName := make(map[string]ExtensionConfig, len(module))
+	for _, ext := range module {
+		moduleByName[ext.Name] = ext
+	}
+
+	seen := make(map[string]bool, len(root)+len(module))
+	result := make([]ExtensionConfig, 0, len(root)+len(module))
+
+	// Start with root order; replace duplicates with module version.
+	for _, ext := range root {
+		if mExt, ok := moduleByName[ext.Name]; ok {
+			result = append(result, copyExtension(mExt))
+		} else {
+			result = append(result, copyExtension(ext))
+		}
+		seen[ext.Name] = true
+	}
+
+	// Append module-only extensions.
+	for _, ext := range module {
+		if !seen[ext.Name] {
+			result = append(result, copyExtension(ext))
+		}
+	}
+
+	return result
+}
+
+// mergePreReleaseHooks performs an additive merge: deep-copied root hooks followed
+// by deep-copied module hooks. Returns a new slice; inputs are not modified.
+func mergePreReleaseHooks(root, module []map[string]PreReleaseHookConfig) []map[string]PreReleaseHookConfig {
+	total := len(root) + len(module)
+	if total == 0 {
+		return nil
+	}
+
+	result := make([]map[string]PreReleaseHookConfig, 0, total)
+	for _, m := range root {
+		result = append(result, copyHookMap(m))
+	}
+	for _, m := range module {
+		result = append(result, copyHookMap(m))
+	}
+	return result
+}
+
+// copyExtensions returns a deep copy of the given extension slice.
+// Returns nil for nil or empty input.
+func copyExtensions(exts []ExtensionConfig) []ExtensionConfig {
+	if len(exts) == 0 {
+		return nil
+	}
+	out := make([]ExtensionConfig, len(exts))
+	for i, ext := range exts {
+		out[i] = copyExtension(ext)
+	}
+	return out
+}
+
+// copyExtension returns a deep copy of a single ExtensionConfig,
+// including its Config map.
+func copyExtension(ext ExtensionConfig) ExtensionConfig {
+	cp := ext
+	if ext.Config != nil {
+		cp.Config = make(map[string]any, len(ext.Config))
+		maps.Copy(cp.Config, ext.Config)
+	}
+	return cp
+}
+
+// copyHookMap returns a deep copy of a single pre-release hook map.
+func copyHookMap(m map[string]PreReleaseHookConfig) map[string]PreReleaseHookConfig {
+	if m == nil {
+		return nil
+	}
+	cp := make(map[string]PreReleaseHookConfig, len(m))
+	maps.Copy(cp, m)
+	return cp
+}

internal/config/config_test.go

@@ -105,6 +105,188 @@ func TestLoadConfigFromDir(t *testing.T) {
 	}
 }
 
+func TestMergeConfig_Theme(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name      string
+		rootTheme string
+		modTheme  string
+		want      string
+	}{
+		{"module_has_theme", "sley", "dracula", "dracula"},
+		{"module_has_no_theme", "sley", "", "sley"},
+		{"both_empty", "", "", ""},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			root := &Config{Theme: tt.rootTheme}
+			mod := &Config{Theme: tt.modTheme}
+			merged := MergeConfig(root, mod)
+			if merged.Theme != tt.want {
+				t.Errorf("Theme = %q, want %q", merged.Theme, tt.want)
+			}
+		})
+	}
+}
+
+func TestMergeConfig_Extensions_Additive(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name    string
+		root    []ExtensionConfig
+		module  []ExtensionConfig
+		want    []string // expected names in order
+		wantNil bool
+	}{
+		{
+			"root_A_module_B",
+			[]ExtensionConfig{{Name: "docker-sync"}},
+			[]ExtensionConfig{{Name: "cargo-check"}},
+			[]string{"docker-sync", "cargo-check"},
+			false,
+		},
+		{
+			"duplicate_by_name_module_wins",
+			[]ExtensionConfig{{Name: "docker-sync", Path: "a"}},
+			[]ExtensionConfig{{Name: "docker-sync", Path: "b"}},
+			[]string{"docker-sync"},
+			false,
+		},
+		{
+			"module_empty",
+			[]ExtensionConfig{{Name: "docker-sync"}},
+			nil,
+			[]string{"docker-sync"},
+			false,
+		},
+		{
+			"root_empty",
+			nil,
+			[]ExtensionConfig{{Name: "cargo-check"}},
+			[]string{"cargo-check"},
+			false,
+		},
+		{
+			"both_empty",
+			nil,
+			nil,
+			nil,
+			true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			root := &Config{Extensions: tt.root}
+			mod := &Config{Extensions: tt.module}
+			merged := MergeConfig(root, mod)
+			if tt.wantNil {
+				if merged.Extensions != nil {
+					t.Errorf("expected nil extensions, got %v", merged.Extensions)
+				}
+				return
+			}
+			if len(merged.Extensions) != len(tt.want) {
+				t.Fatalf("expected %d extensions, got %d: %v", len(tt.want), len(merged.Extensions), merged.Extensions)
+			}
+			for i, name := range tt.want {
+				if merged.Extensions[i].Name != name {
+					t.Errorf("ext[%d] = %q, want %q", i, merged.Extensions[i].Name, name)
+				}
+			}
+			// Check duplicate: module path wins
+			if tt.name == "duplicate_by_name_module_wins" {
+				if merged.Extensions[0].Path != "b" {
+					t.Errorf("duplicate: expected module path 'b', got %q", merged.Extensions[0].Path)
+				}
+			}
+		})
+	}
+}
+
+func TestMergeConfig_PreReleaseHooks_Additive(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name   string
+		root   []map[string]PreReleaseHookConfig
+		module []map[string]PreReleaseHookConfig
+		want   int // expected total hooks
+	}{
+		{"root_plus_module", []map[string]PreReleaseHookConfig{{"lint": {Command: "lint"}}}, []map[string]PreReleaseHookConfig{{"test": {Command: "test"}}}, 2},
+		{"module_only", nil, []map[string]PreReleaseHookConfig{{"test": {Command: "test"}}}, 1},
+		{"both_empty", nil, nil, 0},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			root := &Config{PreReleaseHooks: tt.root}
+			mod := &Config{PreReleaseHooks: tt.module}
+			merged := MergeConfig(root, mod)
+			got := len(merged.PreReleaseHooks)
+			if got != tt.want {
+				t.Errorf("expected %d hooks, got %d", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestMergeConfig_DeepCopy(t *testing.T) {
+	t.Parallel()
+
+	t.Run("extensions_deep_copy", func(t *testing.T) {
+		t.Parallel()
+		root := &Config{Extensions: []ExtensionConfig{{Name: "original", Path: "/root"}}}
+		mod := &Config{Extensions: []ExtensionConfig{{Name: "added"}}}
+		merged := MergeConfig(root, mod)
+
+		// Mutate merged
+		merged.Extensions[0].Name = "mutated"
+
+		// Root must be unchanged
+		if root.Extensions[0].Name != "original" {
+			t.Errorf("root was mutated: got %q, want 'original'", root.Extensions[0].Name)
+		}
+	})
+
+	t.Run("hooks_deep_copy", func(t *testing.T) {
+		t.Parallel()
+		root := &Config{PreReleaseHooks: []map[string]PreReleaseHookConfig{{"lint": {Command: "lint"}}}}
+		mod := &Config{}
+		merged := MergeConfig(root, mod)
+
+		// Mutate merged
+		merged.PreReleaseHooks[0]["lint"] = PreReleaseHookConfig{Command: "mutated"}
+
+		// Root must be unchanged
+		if root.PreReleaseHooks[0]["lint"].Command != "lint" {
+			t.Errorf("root was mutated: got %q, want 'lint'", root.PreReleaseHooks[0]["lint"].Command)
+		}
+	})
+}
+
+func TestMergeConfig_PathAlwaysRoot(t *testing.T) {
+	t.Parallel()
+	root := &Config{Path: ".version"}
+	mod := &Config{Path: "custom.version"}
+	merged := MergeConfig(root, mod)
+	if merged.Path != ".version" {
+		t.Errorf("Path = %q, want '.version' (root always)", merged.Path)
+	}
+}
+
+func TestMergeConfig_WorkspaceAlwaysRoot(t *testing.T) {
+	t.Parallel()
+	rootWs := &WorkspaceConfig{Modules: []ModuleConfig{{Name: "root-mod"}}}
+	modWs := &WorkspaceConfig{Modules: []ModuleConfig{{Name: "module-mod"}}}
+	root := &Config{Workspace: rootWs}
+	mod := &Config{Workspace: modWs}
+	merged := MergeConfig(root, mod)
+	if merged.Workspace != rootWs {
+		t.Error("expected workspace from root, not module")
+	}
+}
+
 func TestMergePluginConfig(t *testing.T) {
 	t.Parallel()