fix(repo): Fetch tags for release

Author: pedronauck

.github/workflows/release.yml

@@ -61,6 +61,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          fetch-tags: true
 
       - uses: ./.github/actions/setup-go
         with:
@@ -94,6 +95,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          fetch-tags: true
 
       - uses: ./.github/actions/setup-go
         with:
@@ -134,6 +136,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          fetch-tags: true
 
       - name: Set up Go with caching
         uses: ./.github/actions/setup-go

pkg/release/internal/orchestrator/pr_release.go

@@ -150,17 +150,26 @@ func (o *PRReleaseOrchestrator) updateAndCreatePR(
 	if err := o.updatePackageVersions(ctx, version); err != nil {
 		return fmt.Errorf("failed to update package versions: %w", err)
 	}
+
 	changelog, err := o.generateChangelog(ctx, version, "unreleased")
 	if err != nil {
 		return fmt.Errorf("failed to generate changelog: %w", err)
 	}
+
+	// Dry-run: stop here so no commit, push or PR is made.
+	if cfg.DryRun {
+		o.printStatus(cfg.CIOutput,
+			fmt.Sprintf("🛈 Dry-run complete – release %s prepared locally (no commit/push/PR).", version))
+		return nil
+	}
+
 	if err := o.commitChanges(ctx, version); err != nil {
 		return fmt.Errorf("failed to commit changes: %w", err)
 	}
 	if err := o.gitRepo.PushBranch(ctx, branchName); err != nil {
 		return fmt.Errorf("failed to push branch: %w", err)
 	}
-	if !cfg.SkipPR && !cfg.DryRun {
+	if !cfg.SkipPR {
 		if err := o.createPullRequest(ctx, version, changelog, branchName); err != nil {
 			return fmt.Errorf("failed to create pull request: %w", err)
 		}

pkg/release/internal/repository/git_impl.go

@@ -10,6 +10,7 @@ import (
 	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/plumbing/transport/http"
 )
 
@@ -39,14 +40,23 @@ func NewGitExtendedRepository() (GitExtendedRepository, error) {
 
 // LatestTag returns the latest git tag.
 func (r *gitRepository) LatestTag(_ context.Context) (string, error) {
+	// First, try to fetch tags from remote to ensure we have the latest
+	remote, err := r.repo.Remote("origin")
+	if err == nil {
+		// Fetch tags from remote (ignore error if already up to date)
+		_ = remote.Fetch(&git.FetchOptions{
+			RefSpecs: []config.RefSpec{
+				config.RefSpec("+refs/tags/*:refs/tags/*"),
+			},
+			Auth: r.getAuth(),
+		})
+	}
 	tagRefs, err := r.repo.Tags()
 	if err != nil {
 		return "", fmt.Errorf("failed to get tags: %w", err)
 	}
-
 	var latestTag string
 	var latestCommitTime time.Time
-
 	if err := tagRefs.ForEach(func(ref *plumbing.Reference) error {
 		// Try to get the commit directly first (lightweight tag)
 		commit, err := r.repo.CommitObject(ref.Hash())
@@ -61,7 +71,6 @@ func (r *gitRepository) LatestTag(_ context.Context) (string, error) {
 				return nil // Skip if we can't get the commit
 			}
 		}
-
 		if commit.Committer.When.After(latestCommitTime) {
 			latestCommitTime = commit.Committer.When
 			latestTag = ref.Name().Short()
@@ -70,27 +79,72 @@ func (r *gitRepository) LatestTag(_ context.Context) (string, error) {
 	}); err != nil {
 		return "", fmt.Errorf("failed to iterate tags: %w", err)
 	}
-
 	return latestTag, nil
 }
 
 // CommitsSinceTag returns the number of commits since the given tag.
 func (r *gitRepository) CommitsSinceTag(_ context.Context, tag string) (int, error) {
+	// First, try to fetch the tag from remote if it doesn't exist locally
 	tagRef, err := r.repo.Tag(tag)
 	if err != nil {
-		return 0, fmt.Errorf("failed to get tag %s: %w", tag, err)
+		// Tag doesn't exist locally, try to fetch it from remote
+		remote, err := r.repo.Remote("origin")
+		if err != nil {
+			return 0, fmt.Errorf("failed to get remote: %w", err)
+		}
+		// Fetch tags from remote
+		if err := remote.Fetch(&git.FetchOptions{
+			RefSpecs: []config.RefSpec{
+				config.RefSpec("+refs/tags/*:refs/tags/*"),
+			},
+			Auth: r.getAuth(),
+		}); err != nil && err != git.NoErrAlreadyUpToDate {
+			return 0, fmt.Errorf("failed to fetch tags from remote: %w", err)
+		}
+		// Try to get the tag again
+		tagRef, err = r.repo.Tag(tag)
+		if err != nil {
+			return 0, fmt.Errorf("failed to get tag %s after fetching: %w", tag, err)
+		}
 	}
-
-	commits, err := r.repo.Log(&git.LogOptions{From: tagRef.Hash()})
+	// Resolve the tag to a commit hash (handles lightweight *and* annotated tags)
+	var tagCommitHash plumbing.Hash
+	if commit, err := r.repo.CommitObject(tagRef.Hash()); err == nil {
+		// Lightweight tag – hash already points to commit
+		tagCommitHash = commit.Hash
+	} else if tagObj, err := r.repo.TagObject(tagRef.Hash()); err == nil {
+		// Annotated tag – resolve to the tagged commit
+		if commit, err := r.repo.CommitObject(tagObj.Target); err == nil {
+			tagCommitHash = commit.Hash
+		}
+	}
+	if tagCommitHash == (plumbing.Hash{}) {
+		return 0, fmt.Errorf("failed to resolve commit for tag %s", tag)
+	}
+	// Get HEAD commit
+	head, err := r.repo.Head()
 	if err != nil {
-		return 0, fmt.Errorf("failed to get commits since tag %s: %w", tag, err)
+		return 0, fmt.Errorf("failed to get HEAD: %w", err)
 	}
-
+	headCommit, err := r.repo.CommitObject(head.Hash())
+	if err != nil {
+		return 0, fmt.Errorf("failed to get HEAD commit: %w", err)
+	}
+	// Count commits from tag to HEAD (excluding the tag commit itself)
 	var count int
-	if err := commits.ForEach(func(_ *object.Commit) error {
+	commits, err := r.repo.Log(&git.LogOptions{From: headCommit.Hash})
+	if err != nil {
+		return 0, fmt.Errorf("failed to get commits: %w", err)
+	}
+	err = commits.ForEach(func(c *object.Commit) error {
+		// Stop when we reach the tag commit
+		if c.Hash == tagCommitHash {
+			return storer.ErrStop
+		}
 		count++
 		return nil
-	}); err != nil {
+	})
+	if err != nil && err != storer.ErrStop {
 		return 0, fmt.Errorf("failed to iterate commits: %w", err)
 	}
 	return count, nil

pkg/release/internal/service/cliff_impl.go

@@ -115,10 +115,11 @@ func (s *cliffService) CalculateNextVersion(ctx context.Context, latestTag strin
 		return nil, fmt.Errorf("invalid latest tag: %w", err)
 	}
 
+	// git-cliff determines the next version relative to the most recent tag
+	// automatically.  Supplying --tag together with --bumped-version makes it
+	// interpret the given tag as the *target* version, which results in the
+	// same tag being echoed back.  Therefore we only need --bumped-version.
 	args := []string{"--bumped-version"}
-	if latestTag != "" {
-		args = append(args, "--tag", latestTag)
-	}
 
 	output, err := s.executeCommand(ctx, "git-cliff", args...)
 	if err != nil {

pkg/release/internal/usecase/check_changes.go

@@ -21,20 +21,19 @@ func (uc *CheckChangesUseCase) Execute(ctx context.Context) (bool, string, error
 	if err != nil {
 		return false, "", fmt.Errorf("failed to get latest tag: %w", err)
 	}
-
 	if latestTag == "" {
 		return true, "", nil // Initial release
 	}
-
 	commitsSince, err := uc.GitRepo.CommitsSinceTag(ctx, latestTag)
-	if err != nil || commitsSince == 0 {
-		return false, latestTag, err
+	if err != nil {
+		return false, latestTag, fmt.Errorf("failed to get commits since tag: %w", err)
+	}
+	if commitsSince == 0 {
+		return false, latestTag, nil
 	}
-
 	nextVer, err := uc.CliffSvc.CalculateNextVersion(ctx, latestTag)
 	if err != nil {
 		return false, latestTag, fmt.Errorf("failed to calculate next version: %w", err)
 	}
-
 	return nextVer.String() != latestTag, latestTag, nil
 }