feat: add retag command (#339)

Co-authored-by: pat-s <patrick.schratz@gmail.com>

Author: xoxys

README.md

@@ -167,6 +167,7 @@ COMMANDS:
    release-notes, rn             generate release notes
    changelog, cgl                generate changelog
    tag, tg                       generate tag with version based on git commit messages
+   retag, rt                     move the most recent (or a specific) tag to HEAD and force-push it
    commit, cmt                   execute git commit with conventional commit message helper
    validate-commit-message, vcm  use as prepare-commit-message hook to validate and enhance commit message
    help, h                       Shows a list of commands or help for one command

app/app.go

@@ -25,8 +25,9 @@ var (
 
 // Tag git tag info.
 type Tag struct {
-	Name string
-	Date time.Time
+	Name      string
+	Date      time.Time
+	Annotated bool
 }
 
 // LogRangeType type of log range.
@@ -270,7 +271,6 @@ func (g GitSV) Tag(version semver.Version, annotate, local bool) (string, error)
 
 	var tagOpts *git.CreateTagOptions
 	if annotate {
-		// Create an annotated tag with a message
 		tagOpts = &git.CreateTagOptions{
 			Message: tagMsg,
 		}
@@ -336,7 +336,9 @@ func (g GitSV) Tags() ([]Tag, error) {
 
 		// Try to get annotated tag first
 		tagObj, err := repo.TagObject(ref.Hash())
-		if err == nil {
+
+		annotated := err == nil
+		if annotated {
 			tagDate = tagObj.Tagger.When
 		} else {
 			// For lightweight tags, get the commit
@@ -348,8 +350,9 @@ func (g GitSV) Tags() ([]Tag, error) {
 		}
 
 		tags = append(tags, Tag{
-			Name: tagName,
-			Date: tagDate,
+			Name:      tagName,
+			Date:      tagDate,
+			Annotated: annotated,
 		})
 
 		return nil
@@ -366,6 +369,83 @@ func (g GitSV) Tags() ([]Tag, error) {
 	return tags, nil
 }
 
+// Retag moves the existing tag with the given name to HEAD. The exact name
+// is preserved (no pattern reformatting). If the tag already points to HEAD
+// and no annotation upgrade is required, the local rewrite is skipped.
+func (g GitSV) Retag(existingName string, annotate, local bool) (string, error) {
+	repo, err := git.PlainOpen(".")
+	if err != nil {
+		return existingName, fmt.Errorf("failed to open git repository: %w", err)
+	}
+
+	head, err := repo.Head()
+	if err != nil {
+		return existingName, fmt.Errorf("failed to get HEAD reference: %w", err)
+	}
+
+	tagCommit, existingAnnotated, err := resolveTagCommit(repo, existingName)
+	if err != nil {
+		return existingName, fmt.Errorf("failed to resolve tag %q: %w", existingName, err)
+	}
+
+	if tagCommit != head.Hash() || (annotate && !existingAnnotated) {
+		tagMsg := fmt.Sprintf("Version %s", existingName)
+
+		var tagOpts *git.CreateTagOptions
+		if annotate {
+			tagOpts = &git.CreateTagOptions{Message: tagMsg}
+		}
+
+		if delErr := repo.DeleteTag(existingName); delErr != nil && !errors.Is(delErr, git.ErrTagNotFound) {
+			return existingName, fmt.Errorf("failed to delete existing tag: %w", delErr)
+		}
+
+		if _, err = repo.CreateTag(existingName, head.Hash(), tagOpts); err != nil {
+			return existingName, fmt.Errorf("failed to create tag: %w", err)
+		}
+	}
+
+	if local {
+		return existingName, nil
+	}
+
+	remote, err := repo.Remote("origin")
+	if err != nil {
+		return existingName, fmt.Errorf("failed to get remote: %w", err)
+	}
+
+	refSpec := fmt.Sprintf("refs/tags/%s:refs/tags/%s", existingName, existingName)
+
+	if err = remote.Push(&git.PushOptions{
+		RefSpecs: []config.RefSpec{config.RefSpec(refSpec)},
+		Force:    true,
+	}); err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
+		return existingName, fmt.Errorf("failed to push tag: %w", err)
+	}
+
+	return existingName, nil
+}
+
+// resolveTagCommit returns the commit hash the named tag points to and
+// whether the tag is annotated, handling both annotated and lightweight
+// tags.
+func resolveTagCommit(repo *git.Repository, name string) (plumbing.Hash, bool, error) {
+	ref, err := repo.Reference(plumbing.ReferenceName("refs/tags/"+name), false)
+	if err != nil {
+		return plumbing.ZeroHash, false, err
+	}
+
+	if ref == nil {
+		return plumbing.ZeroHash, false, plumbing.ErrReferenceNotFound
+	}
+
+	if tagObj, terr := repo.TagObject(ref.Hash()); terr == nil {
+		return tagObj.Target, true, nil
+	}
+
+	return ref.Hash(), false, nil
+}
+
 // Branch get git branch.
 func (g GitSV) Branch() string {
 	repo, err := git.PlainOpen(".")

app/app_test.go

@@ -25,6 +25,8 @@ type testRepo struct {
 func setupGitRepo(t *testing.T, tr testRepo) string {
 	t.Helper()
 
+	t.Setenv("GIT_CONFIG_GLOBAL", "/dev/null")
+
 	// Create a temporary directory using t.TempDir() which is automatically cleaned up
 	tmpDir := t.TempDir()
 

app/commands/retag.go

@@ -0,0 +1,84 @@
+package commands
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+
+	"github.com/thegeeklab/git-sv/app"
+	"github.com/thegeeklab/git-sv/sv"
+	"github.com/urfave/cli/v3"
+)
+
+var (
+	errNoTagToRetag = errors.New("no tag found to retag")
+	errTagNotFound  = errors.New("tag not found")
+)
+
+func RetagFlags(settings *app.RetagSettings) []cli.Flag {
+	return []cli.Flag{
+		&cli.BoolFlag{
+			Name:        "annotate",
+			Aliases:     []string{"a"},
+			Usage:       "force an annotated tag object (annotated source tags are preserved regardless)",
+			Destination: &settings.Annotate,
+		},
+		&cli.BoolFlag{
+			Name:        "local",
+			Usage:       "retag local tag only",
+			Destination: &settings.Local,
+		},
+		&cli.StringFlag{
+			Name:        "tag",
+			Aliases:     []string{"t"},
+			Usage:       "retag a specific existing tag instead of the most recently created one",
+			Destination: &settings.Tag,
+		},
+	}
+}
+
+func RetagHandler(g app.GitSV, settings *app.RetagSettings) cli.ActionFunc {
+	return func(_ context.Context, _ *cli.Command) error {
+		tags, err := g.Tags()
+		if err != nil {
+			return fmt.Errorf("error listing tags: %w", err)
+		}
+
+		var target app.Tag
+
+		if settings.Tag != "" {
+			idx := slices.IndexFunc(tags, func(t app.Tag) bool { return t.Name == settings.Tag })
+			if idx < 0 {
+				return fmt.Errorf("%w: %s", errTagNotFound, settings.Tag)
+			}
+
+			target = tags[idx]
+		} else {
+			if len(tags) == 0 {
+				return errNoTagToRetag
+			}
+
+			// Tags() is sorted by date (oldest first), so the most recently
+			// created tag is the last entry.
+			target = tags[len(tags)-1]
+		}
+
+		if _, err := sv.ToVersion(target.Name); err != nil {
+			return fmt.Errorf("error parsing version: %s from git tag: %w", target.Name, err)
+		}
+
+		// Preserve the original tag type: never silently downgrade an annotated
+		// tag to a lightweight one.
+		annotate := settings.Annotate || target.Annotated
+
+		tagname, err := g.Retag(target.Name, annotate, settings.Local)
+		if err != nil {
+			return fmt.Errorf("error retagging %s: %w", target.Name, err)
+		}
+
+		fmt.Println(tagname)
+
+		return nil
+	}
+}