chore(release-tool): normalize version tags

Automatically normalize git tags based on kumahq/kuma conventions:
- Add v prefix for newer versions (>= 2.13.x, >= 3.x, specific patches)
- Remove v prefix for older versions
- Release names always use plain version numbers (e.g., `2.12.5`)
- Git tags follow version-specific conventions

Also adds `mise.toml` with pinned `golangci-lint` version.

Signed-off-by: Bart Smykla <bartek@smykla.com>

Author: bartsmykla

Makefile

@@ -9,13 +9,11 @@ build/release-tool:
 	mkdir -p build
 	go build -o build ./cmd/release-tool/...
 
-GOPATH?=$(shell go env GOPATH)
-
 .PHONY: check
 check:
 	go fmt ./...
 	go mod tidy
-	test -n "$$CI" || $(GOPATH)/bin/golangci-lint run -v
+	test -n "$$CI" || mise exec -- golangci-lint run -v
 
 .PHONY: test
 test:

cmd/internal/github/graphql.go

@@ -311,36 +311,57 @@ func (c GQLClient) graphqlQuery(query string, variables map[string]interface{})
 	return out, err
 }
 
-func (c GQLClient) UpsertRelease(ctx context.Context, repo string, release string, contentModifier func(repositoryRelease *github.RepositoryRelease) error) error {
+func (c GQLClient) UpsertRelease(
+	ctx context.Context,
+	repo string,
+	releaseName string,
+	tagName string,
+	contentModifier func(repositoryRelease *github.RepositoryRelease) error,
+) error {
 	releases, err := c.ReleaseGraphQL(repo)
 	if err != nil {
 		return err
 	}
+
 	var existingRelease *GQLRelease
+
 	for _, r := range releases {
-		if r.Name == release {
+		if r.Name == releaseName || r.Name == tagName {
 			existingRelease = &r
 			break
 		}
 	}
+
 	owner, name := SplitRepo(repo)
+
 	if existingRelease == nil {
-		releasePayload := &github.RepositoryRelease{Name: &release, Draft: github.Ptr(true), TagName: &release}
+		releasePayload := &github.RepositoryRelease{
+			Name:    &releaseName,
+			Draft:   github.Ptr(true),
+			TagName: &tagName,
+		}
+
 		err := contentModifier(releasePayload)
 		if err != nil {
 			return err
 		}
+
 		_, _, err = c.Cl.Repositories.CreateRelease(ctx, owner, name, releasePayload)
+
 		return err
 	}
+
 	releasePayload, _, err := c.Cl.Repositories.GetRelease(ctx, owner, name, int64(existingRelease.Id))
 	if err != nil {
 		return err
 	}
+
 	err = contentModifier(releasePayload)
 	if err != nil {
 		return err
 	}
+
 	_, _, err = c.Cl.Repositories.EditRelease(ctx, owner, name, int64(existingRelease.Id), releasePayload)
+
 	return err
 }

cmd/release-tool/changelog.go

@@ -107,7 +107,8 @@ It will then output a changelog with all PRs with the same changelog grouped tog
 			return err
 		}
 
-		out, err := getChangelog(gqlClient, config.repo, config.branch, config.fromTag)
+		// Use warnOnNormalize=true since config.fromTag is user-provided
+		out, err := getChangelog(gqlClient, config.repo, config.branch, config.fromTag, true)
 		if err != nil {
 			return err
 		}
@@ -128,9 +129,14 @@ It will then output a changelog with all PRs with the same changelog grouped tog
 	},
 }
 
-func getChangelog(gqlClient *github.GQLClient, repo string, branch string, tag string) (changeloggenerator.Changelog, error) {
+func getChangelog(gqlClient *github.GQLClient, repo string, branch string, tag string, warnOnNormalize bool) (changeloggenerator.Changelog, error) {
 	// Normalize tag to ensure correct v-prefix based on kumahq/kuma conventions
-	normalizedTag := NormalizeVersionTag(tag)
+	var normalizedTag string
+	if warnOnNormalize {
+		normalizedTag = NormalizeVersionTagWithWarning(tag)
+	} else {
+		normalizedTag = NormalizeVersionTag(tag)
+	}
 
 	// Retrieve data from github
 	commit, err := gqlClient.CommitByRef(repo, normalizedTag)

cmd/release-tool/release.go

@@ -63,12 +63,16 @@ TODO summary of some simple stuff.
 			return err
 		}
 
-		_, err = fmt.Fprintf(cmd.OutOrStdout(), "getting changelog from %s on repo %s and branch %s\n", prevVersion, config.repo, branch)
+		// Normalize the previous version tag for display and lookup
+		prevTag := NormalizeVersionTag(prevVersion.String())
+
+		_, err = fmt.Fprintf(cmd.OutOrStdout(), "getting changelog from %s on repo %s and branch %s\n", prevTag, config.repo, branch)
 		if err != nil {
 			return err
 		}
 
-		changelog, err := getChangelog(gqlClient, config.repo, branch, prevVersion.String())
+		// Use warnOnNormalize=false since prevVersion is auto-derived, not user-provided
+		changelog, err := getChangelog(gqlClient, config.repo, branch, prevTag, false)
 		if err != nil {
 			return err
 		}
@@ -112,13 +116,13 @@ TODO summary of some simple stuff.
 			return err
 		}
 
-		// Ensure release name has v-prefix to match Git tag format
-		releaseTag := config.release
-		if !strings.HasPrefix(releaseTag, "v") {
-			releaseTag = "v" + releaseTag
-		}
+		// Normalize release tag to match kumahq/kuma Git tag format
+		// Use WithWarning since config.release is user-provided
+		releaseTag := NormalizeVersionTagWithWarning(config.release)
+		// Release name should not have v prefix (just the version number)
+		releaseName := strings.TrimPrefix(releaseTag, "v")
 
-		return gqlClient.UpsertRelease(cmd.Context(), config.repo, releaseTag, func(release *github2.RepositoryRelease) error {
+		return gqlClient.UpsertRelease(cmd.Context(), config.repo, releaseName, releaseTag, func(release *github2.RepositoryRelease) error {
 			if !release.GetDraft() {
 				return fmt.Errorf("release :%s has already published release notes, updating release-notes of released versions is not supported", release)
 			}
@@ -130,6 +134,8 @@ TODO summary of some simple stuff.
 				return fmt.Errorf("release body exceeds GitHub limit: %d characters (max %d). Use --dry-run to preview the body and consider manually truncating", len(body), GitHubMaxBodySize)
 			}
 
+			// Normalize release name to not have v prefix (SLSA provenance may create releases with v prefix)
+			release.Name = github2.Ptr(releaseName)
 			release.Body = github2.Ptr(body)
 
 			return nil

cmd/release-tool/version.go

@@ -9,7 +9,8 @@ import (
 )
 
 // NormalizeVersionTag ensures the version tag has the correct format (with or without v prefix)
-// based on kumahq/kuma tagging conventions. Logs a warning if v prefix was auto-added.
+// based on kumahq/kuma tagging conventions. Does not log warnings (use NormalizeVersionTagWithWarning
+// for user-provided values that should warn).
 //
 // Tagging convention:
 //   - >= 2.13.x or >= 3.x: always v prefix
@@ -19,22 +20,37 @@ import (
 //   - 2.7.x: v prefix if patch >= 20
 //   - Other older versions: no v prefix
 func NormalizeVersionTag(tag string) string {
-	if strings.HasPrefix(tag, "v") {
-		return tag
-	}
+	return normalizeVersionTag(tag, false)
+}
+
+// NormalizeVersionTagWithWarning normalizes the tag and logs a warning if the prefix was added or removed.
+// Use this for user-provided values where the warning is helpful.
+func NormalizeVersionTagWithWarning(tag string) string {
+	return normalizeVersionTag(tag, true)
+}
 
-	v, err := semver.NewVersion(tag)
+func normalizeVersionTag(tag string, warn bool) string {
+	hasPrefix := strings.HasPrefix(tag, "v")
+	cleanTag := strings.TrimPrefix(tag, "v")
+
+	v, err := semver.NewVersion(cleanTag)
 	if err != nil {
 		return tag
 	}
 
 	if needsVPrefix(v) {
-		_, _ = fmt.Fprintf(os.Stderr, "Warning: auto-adding 'v' prefix to tag %s -> v%s (kumahq/kuma uses v-prefixed tags for this version)\n", tag, tag)
+		if !hasPrefix && warn {
+			_, _ = fmt.Fprintf(os.Stderr, "Warning: auto-adding 'v' prefix to tag %s -> v%s (kumahq/kuma uses v-prefixed tags for this version)\n", tag, tag)
+		}
+
+		return "v" + cleanTag
+	}
 
-		return "v" + tag
+	if hasPrefix && warn {
+		_, _ = fmt.Fprintf(os.Stderr, "Warning: auto-removing 'v' prefix from tag %s -> %s (kumahq/kuma uses non-prefixed tags for this version)\n", tag, cleanTag)
 	}
 
-	return tag
+	return cleanTag
 }
 
 // needsVPrefix determines if a version should have a v prefix based on kumahq/kuma conventions.

cmd/release-tool/version_test.go

@@ -81,7 +81,7 @@ func TestNormalizeVersionTag(t *testing.T) {
 		input    string
 		expected string
 	}{
-		// Already has v prefix - unchanged
+		// Already has v prefix and needs it - unchanged
 		{"v2.12.4", "v2.12.4"},
 		{"v2.11.8", "v2.11.8"},
 		{"v3.0.0", "v3.0.0"},
@@ -103,8 +103,18 @@ func TestNormalizeVersionTag(t *testing.T) {
 		{"2.9.0", "2.9.0"},
 		{"2.8.5", "2.8.5"},
 
+		// Has v prefix but shouldn't - should be removed
+		{"v2.12.3", "2.12.3"},
+		{"v2.11.7", "2.11.7"},
+		{"v2.10.8", "2.10.8"},
+		{"v2.7.19", "2.7.19"},
+		{"v2.9.0", "2.9.0"},
+		{"v2.8.5", "2.8.5"},
+		{"v1.5.0", "1.5.0"},
+
 		// Invalid version - unchanged
 		{"invalid", "invalid"},
+		{"vinvalid", "vinvalid"},
 		{"", ""},
 	}
 

mise.toml

@@ -0,0 +1,2 @@
+[tools]
+golangci-lint = "2.6.2"