fix: scope commit and changelog inference to module in bump auto --module (#261)

Author: indaco

internal/commands/bump/auto.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"github.com/indaco/sley/internal/clix"
 	"github.com/indaco/sley/internal/config"
@@ -19,7 +20,7 @@ import (
 
 // bumpDeps holds injectable dependencies for auto bump operations.
 type bumpDeps struct {
-	inferFromCommits   func(registry *plugins.PluginRegistry, since, until string) string
+	inferFromCommits   func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string
 	inferFromChangelog func(registry *plugins.PluginRegistry) string
 	newBumper          func() semver.VersionBumper
 	getCommits         gitlog.GetCommitsFn
@@ -126,13 +127,27 @@ func runBumpAuto(ctx context.Context, cfg *config.Config, registry *plugins.Plug
 	}
 
 	// Handle multi-module mode
-	// For auto bump, we need to determine the bump type first
-	bumpType := determineBumpType(deps, registry, label, disableInfer, since, until)
+	// For auto bump, we need to determine the bump type first.
+	// When a single module is targeted (--module), scope commit inference
+	// to that module's tag prefix and directory so we find the correct
+	// last tag and only consider relevant commits.
+	tagPrefix, modulePath := "", ""
+	if len(execCtx.Modules) == 1 {
+		mod := execCtx.Modules[0]
+		modulePath = filepath.Dir(mod.RelPath)
+		if modulePath == "." {
+			modulePath = ""
+		}
+		tagPrefix = resolveTagPrefix(registry, modulePath)
+	}
+	bumpType := determineBumpType(deps, registry, label, disableInfer, since, until, tagPrefix, modulePath)
 	return runMultiModuleBump(ctx, cmd, cfg, execCtx, registry, deps, bumpType, "", meta, isPreserveMeta)
 }
 
 // determineBumpType determines the bump type for multi-module auto bump.
-func determineBumpType(deps *bumpDeps, registry *plugins.PluginRegistry, label string, disableInfer bool, since, until string) operations.BumpType {
+// tagPrefix and modulePath scope commit inference to a specific module's tags
+// and directory (empty for global/all-module inference).
+func determineBumpType(deps *bumpDeps, registry *plugins.PluginRegistry, label string, disableInfer bool, since, until, tagPrefix, modulePath string) operations.BumpType {
 	switch label {
 	case "patch":
 		return operations.BumpPatch
@@ -146,7 +161,7 @@ func determineBumpType(deps *bumpDeps, registry *plugins.PluginRegistry, label s
 			inferred := deps.inferFromChangelog(registry)
 			if inferred == "" {
 				// Fall back to commit parser
-				inferred = deps.inferFromCommits(registry, since, until)
+				inferred = deps.inferFromCommits(registry, since, until, tagPrefix, modulePath)
 			}
 
 			if inferred != "" {
@@ -262,8 +277,8 @@ func getNextVersion(
 			// Try changelog parser first if it should take precedence
 			inferred := deps.inferFromChangelog(registry)
 			if inferred == "" {
-				// Fall back to commit parser
-				inferred = deps.inferFromCommits(registry, since, until)
+				// Fall back to commit parser (no module scoping in single-module mode)
+				inferred = deps.inferFromCommits(registry, since, until, "", "")
 			}
 
 			if inferred != "" {
@@ -318,13 +333,21 @@ func promotePreRelease(current semver.SemVersion, preserveMeta bool) semver.SemV
 }
 
 // tryInferBumpTypeFromCommitParserPlugin tries to infer bump type from commit messages.
-func tryInferBumpTypeFromCommitParserPlugin(registry *plugins.PluginRegistry, since, until string) string {
+// tagPrefix scopes tag resolution to tags matching the prefix (e.g. "<module-name>/v").
+// modulePath scopes git log to commits touching that directory (e.g. "<module-name>").
+// Both are empty for single-module or global inference.
+func tryInferBumpTypeFromCommitParserPlugin(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
 	parser := registry.GetCommitParser()
 	if parser == nil {
 		return ""
 	}
 
-	gl := gitlog.NewGitLog()
+	var gl *gitlog.GitLog
+	if tagPrefix != "" || modulePath != "" {
+		gl = gitlog.NewGitLogWithScope(tagPrefix, modulePath)
+	} else {
+		gl = gitlog.NewGitLog()
+	}
 	commits, err := gl.GetCommits(since, until)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "failed to read commits: %v\n", err)

internal/commands/bump/bump_auto_test.go

@@ -104,7 +104,7 @@ func TestCLI_BumpAutoCmd_InferredBump(t *testing.T) {
 	versionPath := testutils.WriteTempVersionFile(t, tmp, "1.2.3")
 
 	deps := defaultTestDeps()
-	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until string) string {
+	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
 		return "minor"
 	}
 	ctx := testContext(deps)
@@ -199,7 +199,7 @@ func TestCLI_BumpAutoCmd_InferredPromotion(t *testing.T) {
 	versionPath := testutils.WriteTempVersionFile(t, tmp, "1.2.3-beta.1")
 
 	deps := defaultTestDeps()
-	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until string) string {
+	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
 		return "minor"
 	}
 	ctx := testContext(deps)
@@ -228,7 +228,7 @@ func TestCLI_BumpAutoCmd_PromotePreReleaseWithPreserveMeta(t *testing.T) {
 	versionPath := testutils.WriteTempVersionFile(t, tmp, "1.2.3-beta.2+ci.99")
 
 	deps := defaultTestDeps()
-	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until string) string {
+	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
 		return "minor" // Force a non-empty inference so that promotePreRelease is called
 	}
 	ctx := testContext(deps)
@@ -279,7 +279,7 @@ func TestCLI_BumpAutoCmd_InferredBumpFails(t *testing.T) {
 	deps.newBumper = func() semver.VersionBumper {
 		return mockBumper{bumpByLabelErr: fmt.Errorf("forced inferred bump failure")}
 	}
-	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until string) string {
+	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
 		return "minor"
 	}
 	ctx := testContext(deps)
@@ -308,7 +308,7 @@ func TestTryInferBumpTypeFromCommitParserPlugin_GetCommitsError(t *testing.T) {
 		t.Fatalf("failed to register parser: %v", err)
 	}
 	// Without a real git repo, getCommits will fail → should return ""
-	label := tryInferBumpTypeFromCommitParserPlugin(registry, "", "")
+	label := tryInferBumpTypeFromCommitParserPlugin(registry, "", "", "", "")
 	if label != "" {
 		t.Errorf("expected empty label on gitlog error, got %q", label)
 	}
@@ -321,15 +321,15 @@ func TestTryInferBumpTypeFromCommitParserPlugin_ParserError(t *testing.T) {
 	if err := registry.RegisterCommitParser(&parser); err != nil {
 		t.Fatalf("failed to register parser: %v", err)
 	}
-	label := tryInferBumpTypeFromCommitParserPlugin(registry, "", "")
+	label := tryInferBumpTypeFromCommitParserPlugin(registry, "", "", "", "")
 	if label != "" {
 		t.Errorf("expected empty label on error, got %q", label)
 	}
 }
 
 func TestTryInferBumpTypeFromCommitParserPlugin_NoParser(t *testing.T) {
 	registry := plugins.NewPluginRegistry()
-	label := tryInferBumpTypeFromCommitParserPlugin(registry, "", "")
+	label := tryInferBumpTypeFromCommitParserPlugin(registry, "", "", "", "")
 	if label != "" {
 		t.Errorf("expected empty label when no parser, got %q", label)
 	}
@@ -547,11 +547,13 @@ func TestDetermineBumpType(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			deps := &bumpDeps{
 				inferFromChangelog: func(registry *plugins.PluginRegistry) string { return tt.mockChangelog },
-				inferFromCommits:   func(registry *plugins.PluginRegistry, since, until string) string { return tt.mockCommit },
+				inferFromCommits: func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
+					return tt.mockCommit
+				},
 			}
 
 			registry := plugins.NewPluginRegistry()
-			result := determineBumpType(deps, registry, tt.label, tt.disableInfer, "", "")
+			result := determineBumpType(deps, registry, tt.label, tt.disableInfer, "", "", "", "")
 
 			if string(result) != tt.expected {
 				t.Errorf("expected %q, got %q", tt.expected, string(result))
@@ -836,7 +838,7 @@ func TestBumpAuto_InferredMinorBump_WithTagManager(t *testing.T) {
 	testutils.WriteTempVersionFile(t, tmpDir, "1.0.0")
 
 	deps := defaultTestDeps()
-	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until string) string {
+	deps.inferFromCommits = func(registry *plugins.PluginRegistry, since, until, tagPrefix, modulePath string) string {
 		return "minor"
 	}
 	ctx := testContext(deps)

internal/commands/bump/helpers.go

@@ -297,7 +297,7 @@ func resolveTagPrefix(registry *plugins.PluginRegistry, modulePath string) strin
 		return ""
 	}
 	tm := registry.GetTagManager()
-	if tm == nil || !tm.IsAutoCreateEnabled() {
+	if tm == nil || !tm.GetConfig().Enabled {
 		return ""
 	}
 	return tagmanager.InterpolatePrefix(tm.GetConfig().Prefix, modulePath)
@@ -326,30 +326,51 @@ func generateChangelogAfterBump(registry *plugins.PluginRegistry, version, _ sem
 
 	versionStr := "v" + version.String()
 
-	// Use actual git tag for commit range, not version file content
-	// The version file may contain pre-release/metadata that doesn't match a real tag
-	prevVersionStr, err := changeloggenerator.GetLatestTag()
-	if err != nil {
-		// If no tags exist, generate from all commits
-		prevVersionStr = ""
-	}
-
-	if err := cg.GenerateForVersion(versionStr, prevVersionStr, bumpType); err != nil {
+	// Pass empty previousVersion so GenerateForVersion resolves the commit
+	// range internally via the plugin's scoped GitOps (which respects TagPrefix
+	// and ModulePath set by applyModuleChangelog above).
+	if err := cg.GenerateForVersion(versionStr, "", bumpType); err != nil {
 		return fmt.Errorf("failed to generate changelog: %w", err)
 	}
 
-	cfg := cg.GetConfig()
+	printChangelogStatus(cg.GetConfig(), versionStr)
+	return nil
+}
+
+// printChangelogStatus prints a message about which changelog files were actually
+// created on disk. Only prints for files that exist, preventing false positives
+// when GenerateForVersion returns nil without writing (e.g. zero commits).
+func printChangelogStatus(cfg *changeloggenerator.Config, versionStr string) {
+	versionedPath := filepath.Join(cfg.ChangesDir, versionStr+".md")
+	versionedExists := fileExists(versionedPath)
+	unifiedExists := fileExists(cfg.ChangelogPath)
+
 	switch cfg.Mode {
 	case "versioned":
-		printer.PrintFaint(fmt.Sprintf("Generated changelog: %s", printer.Info(fmt.Sprintf("%s/%s.md", cfg.ChangesDir, versionStr))))
+		if versionedExists {
+			printer.PrintFaint(fmt.Sprintf("Generated changelog: %s", printer.Info(versionedPath)))
+		}
 	case "unified":
-		printer.PrintFaint(fmt.Sprintf("Updated changelog: %s", printer.Info(cfg.ChangelogPath)))
+		if unifiedExists {
+			printer.PrintFaint(fmt.Sprintf("Updated changelog: %s", printer.Info(cfg.ChangelogPath)))
+		}
 	case "both":
-		printer.PrintFaint(fmt.Sprintf("Generated changelog: %s and %s",
-			printer.Info(fmt.Sprintf("%s/%s.md", cfg.ChangesDir, versionStr)), printer.Info(cfg.ChangelogPath)))
+		switch {
+		case versionedExists && unifiedExists:
+			printer.PrintFaint(fmt.Sprintf("Generated changelog: %s and %s",
+				printer.Info(versionedPath), printer.Info(cfg.ChangelogPath)))
+		case versionedExists:
+			printer.PrintFaint(fmt.Sprintf("Generated changelog: %s", printer.Info(versionedPath)))
+		case unifiedExists:
+			printer.PrintFaint(fmt.Sprintf("Updated changelog: %s", printer.Info(cfg.ChangelogPath)))
+		}
 	}
+}
 
-	return nil
+// fileExists returns true if the path exists on disk.
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
 }
 
 // recordAuditLogEntry records the version bump to the audit log if enabled.

internal/plugins/commitparser/gitlog/gitlog.go

@@ -34,13 +34,30 @@ type ExecCommandFunc func(name string, arg ...string) *exec.Cmd
 // GitLog retrieves commit messages from a git repository.
 type GitLog struct {
 	ExecCommandFn ExecCommandFunc
+	// TagPrefix scopes tag resolution to tags matching this prefix.
+	// Empty means use the latest tag globally.
+	TagPrefix string
+	// ModulePath scopes git log to commits touching this directory.
+	// Empty means no path filtering (all commits).
+	ModulePath string
 }
 
 // NewGitLog creates a GitLog with the real exec.Command implementation.
 func NewGitLog() *GitLog {
 	return &GitLog{ExecCommandFn: exec.Command}
 }
 
+// NewGitLogWithScope creates a GitLog scoped to a specific module.
+// tagPrefix filters tag resolution (e.g. "<module-name>/v") and modulePath
+// scopes git log to commits touching that directory (e.g. "<module-name>").
+func NewGitLogWithScope(tagPrefix, modulePath string) *GitLog {
+	return &GitLog{
+		ExecCommandFn: exec.Command,
+		TagPrefix:     tagPrefix,
+		ModulePath:    modulePath,
+	}
+}
+
 // GetCommitsFn is the function type for GetCommits (used for dependency injection).
 type GetCommitsFn func(since, until string) ([]string, error)
 
@@ -75,7 +92,12 @@ func (g *GitLog) GetCommits(since string, until string) ([]string, error) {
 	}
 
 	revRange := since + ".." + until
-	cmd := g.ExecCommandFn("git", "log", "--pretty=format:%s", revRange)
+	args := []string{"log", "--pretty=format:%s", revRange}
+	// Scope to module path if set (only commits touching this directory)
+	if g.ModulePath != "" {
+		args = append(args, "--", g.ModulePath)
+	}
+	cmd := g.ExecCommandFn("git", args...)
 
 	var stderr bytes.Buffer
 	cmd.Stderr = &stderr
@@ -97,6 +119,12 @@ func (g *GitLog) GetCommits(since string, until string) ([]string, error) {
 }
 
 func (g *GitLog) getLastTag() (string, error) {
+	// When a tag prefix is set, use git tag --list with version sorting
+	// to find the latest tag matching the prefix (e.g. "<module-name>/v*").
+	if g.TagPrefix != "" {
+		return g.getLastTagWithPrefix(g.TagPrefix)
+	}
+
 	cmd := g.ExecCommandFn("git", "describe", "--tags", "--abbrev=0")
 	var stderr bytes.Buffer
 	cmd.Stderr = &stderr
@@ -117,3 +145,29 @@ func (g *GitLog) getLastTag() (string, error) {
 
 	return tag, nil
 }
+
+// getLastTagWithPrefix returns the most recent tag matching the given prefix.
+// Uses git tag --list with version sorting to find the latest match.
+func (g *GitLog) getLastTagWithPrefix(prefix string) (string, error) {
+	cmd := g.ExecCommandFn("git", "tag", "--list", prefix+"*", "--sort=-v:refname")
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+
+	out, err := cmd.Output()
+	if err != nil {
+		stderrMsg := strings.TrimSpace(stderr.String())
+		if stderrMsg != "" {
+			return "", fmt.Errorf("git tag list failed: %s: %w", stderrMsg, err)
+		}
+		return "", fmt.Errorf("git tag list failed: %w", err)
+	}
+
+	output := strings.TrimSpace(string(out))
+	if output == "" {
+		return "", fmt.Errorf("no tags found matching prefix %q", prefix)
+	}
+
+	// First line is the latest tag (sorted by version descending)
+	tag, _, _ := strings.Cut(output, "\n")
+	return strings.TrimSpace(tag), nil
+}