fix(gitutil): fall back to git CLI for push when no token is set

go-git's HTTPS transport does not use the system credential store,
so pushes to remotes that require credentials fail silently or with
"authentication required" when no token is provided. When token is
empty, delegate to the system git binary so that credential helpers,
SSH agents, and netrc all work as expected.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitea/workflows/ci.yml

@@ -37,4 +37,4 @@ jobs:
         run: go test ./...
 
       - name: build
-        run: go build ./cmd/...
+        run: go build -o /dev/null ./cmd/...

CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.4.2] - 2026-07-07
+
+### Fixed
+
+- **CI build step** — `go build ./cmd/...` failed with "output already exists and is a directory" because Go tried to write a binary named `cmd`, conflicting with the source directory; fixed by passing `-o /dev/null`
+- **Optional pom.xml** — releaser no longer fails when `pom.xml` (or the configured `maven.pom_path`) does not exist; it logs a notice and proceeds directly to tag and push, making the tool usable in non-Maven projects
+
 ## [0.4.0] - 2026-07-07
 
 ### Added

README.md

@@ -1,6 +1,6 @@
 # releaser
 
-![release](https://img.shields.io/badge/release-v0.4.0-blue.svg)
+![release](https://img.shields.io/badge/release-v0.4.2-blue.svg)
 
 A CI-friendly release automation tool for GitFlow workflows using Conventional Commits.
 

cmd/main.go

@@ -33,6 +33,7 @@ func newRootCmd() *cobra.Command {
 	var (
 		dryRun         bool
 		noPush         bool
+		noRelease      bool
 		noCommit       bool
 		tagOnly        bool
 		branchOverride string
@@ -62,6 +63,7 @@ func newRootCmd() *cobra.Command {
 				patternSet:     patternSet,
 				dryRun:         dryRun,
 				noPush:         noPush,
+				noRelease:      noRelease,
 				noCommit:       noCommit,
 				tagOnly:        tagOnly,
 			})
@@ -70,6 +72,7 @@ func newRootCmd() *cobra.Command {
 
 	root.Flags().BoolVar(&dryRun, "dry-run", false, "print next version without making changes")
 	root.Flags().BoolVar(&noPush, "no-push", false, "create commit and tag locally without pushing or creating a GitLab release")
+	root.Flags().BoolVar(&noRelease, "no-release", false, "push commit and tag but skip creating the GitLab release")
 	root.Flags().BoolVar(&noCommit, "no-commit", false, "update pom.xml but do not commit, tag, or push")
 	root.Flags().BoolVar(&tagOnly, "tag-only", false, "tag HEAD without updating pom.xml (assumes version was already committed)")
 	root.Flags().StringVar(&branchOverride, "branch", "", "override branch name detection (required in detached HEAD)")
@@ -101,6 +104,7 @@ type options struct {
 	patternSet     bool
 	dryRun         bool
 	noPush         bool
+	noRelease      bool
 	noCommit       bool
 	tagOnly        bool
 }
@@ -203,9 +207,15 @@ func run(o options) error {
 		return nil
 	}
 
-	// --- pom.xml (skipped with --tag-only) ---
+	// --- pom.xml (skipped with --tag-only or when the file does not exist) ---
-	if !o.tagOnly {
+	pomPath := filepath.Join(absRepo, cfg.Maven.PomPath)
-		pomPath := filepath.Join(absRepo, cfg.Maven.PomPath)
+	_, statErr := os.Stat(pomPath)
+	hasPom := !errors.Is(statErr, os.ErrNotExist)
+	if statErr != nil && hasPom {
+		return fmt.Errorf("check pom path: %w", statErr)
+	}
+
+	if !o.tagOnly && hasPom {
 		currentPomVersion, err := maven.ReadVersion(pomPath)
 		if err != nil {
 			return fmt.Errorf("read pom version: %w", err)
@@ -235,6 +245,8 @@ func run(o options) error {
 			return fmt.Errorf("commit pom.xml: %w", err)
 		}
 		fmt.Fprintf(os.Stderr, "info: committed: %s\n", commitMsg)
+	} else if !o.tagOnly && !hasPom {
+		fmt.Fprintln(os.Stderr, "info: no pom.xml found — skipping version bump commit")
 	}
 
 	// --- Git tag ---
@@ -256,6 +268,10 @@ func run(o options) error {
 	fmt.Fprintln(os.Stderr, "info: pushed")
 
 	// --- GitLab release ---
+	if o.noRelease {
+		fmt.Printf("released %s\n", nextTag)
+		return nil
+	}
 	if cfg.GitLab.URL == "" || cfg.GitLab.Project == "" {
 		fmt.Fprintln(os.Stderr, "warning: GitLab URL or project not configured — skipping release creation")
 		fmt.Printf("released %s\n", nextTag)

cmd/main_test.go

@@ -211,6 +211,7 @@ func TestRunPomOverride(t *testing.T) {
 }
 
 func TestRunMissingPom(t *testing.T) {
+	// --pom points to a non-existent file: pom update is skipped, tag is still created.
 	_, dir := setupRepo(t)
 	addFile(t, dir, "x.go", "// fix")
 	repo, _ := gogit.PlainOpen(dir)
@@ -218,10 +219,38 @@ func TestRunMissingPom(t *testing.T) {
 	w.Add("x.go")
 	w.Commit("fix: patch", &gogit.CommitOptions{Author: testSig()})
 
-	// Use --pom to point to a non-existent file; keeps the working tree clean.
+	err := execCmd(t, "--no-push", "--branch", "release/1.2", "--repo", dir, "--pom", "nonexistent.xml")
-	err := execCmd(t, "--branch", "release/1.2", "--repo", dir, "--pom", "nonexistent.xml")
+	if err != nil {
-	if err == nil {
+		t.Fatalf("missing pom should be skipped, got error: %v", err)
-		t.Fatal("expected error for missing pom.xml")
+	}
+
+	// Tag must still have been created.
+	repo2, _ := gogit.PlainOpen(dir)
+	_, err = repo2.Tag("v1.2.0")
+	if err != nil {
+		t.Error("expected tag v1.2.0 to be created")
+	}
+}
+
+func TestRunNoPomAtDefaultPath(t *testing.T) {
+	// Repo with no pom.xml at the default path: runs without error, creates tag.
+	dir := t.TempDir()
+	repo, err := gogit.PlainInit(dir, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	addFile(t, dir, "main.go", "package main")
+	commitAll(t, repo, dir, "fix: initial")
+
+	err = execCmd(t, "--no-push", "--branch", "release/2.0", "--repo", dir)
+	if err != nil {
+		t.Fatalf("no pom.xml should not be an error: %v", err)
+	}
+
+	repo2, _ := gogit.PlainOpen(dir)
+	_, err = repo2.Tag("v2.0.0")
+	if err != nil {
+		t.Error("expected tag v2.0.0 to be created")
 	}
 }
 
@@ -431,6 +460,25 @@ func TestRunSkipGitLab(t *testing.T) {
 	}
 }
 
+func TestRunNoRelease(t *testing.T) {
+	_, dir := setupRepoWithRemote(t)
+	addFile(t, dir, "x.go", "// fix")
+	repo, _ := gogit.PlainOpen(dir)
+	w, _ := repo.Worktree()
+	w.Add("x.go")
+	w.Commit("fix: patch something", &gogit.CommitOptions{Author: testSig()})
+
+	// --no-release skips GitLab release even when credentials are configured
+	t.Setenv("CI_SERVER_URL", "https://gitlab.example.com")
+	t.Setenv("CI_PROJECT_ID", "42")
+	t.Setenv("GITLAB_TOKEN", "test-token")
+
+	err := execCmd(t, "--no-release", "--branch", "release/1.2", "--repo", dir)
+	if err != nil {
+		t.Fatalf("--no-release: unexpected error: %v", err)
+	}
+}
+
 func TestRunMissingToken(t *testing.T) {
 	_, dir := setupRepoWithRemote(t)
 	addFile(t, dir, "x.go", "// fix")

internal/gitutil/gitutil.go

@@ -3,6 +3,8 @@ package gitutil
 import (
 	"errors"
 	"fmt"
+	"os"
+	"os/exec"
 	"sort"
 	"time"
 
@@ -231,9 +233,17 @@ func CreateTag(repo *gogit.Repository, tagName string) error {
 }
 
 // Push pushes the given branch and tag to the "origin" remote.
-// If token is non-empty, HTTPS basic auth (oauth2/token) is used.
+// When token is non-empty, go-git is used with HTTPS basic auth (oauth2/token) — suitable for CI.
-// Passing an empty token lets go-git use the system credential helper or SSH agent.
+// When token is empty, the system git binary is invoked so that credential helpers,
+// SSH agents, and netrc are all available as they would be for a regular git push.
 func Push(repo *gogit.Repository, branchName, tagName, token string) error {
+	if token != "" {
+		return pushWithGoGit(repo, branchName, tagName, token)
+	}
+	return pushWithCLI(repo, branchName, tagName)
+}
+
+func pushWithGoGit(repo *gogit.Repository, branchName, tagName, token string) error {
 	remote, err := repo.Remote("origin")
 	if err != nil {
 		return fmt.Errorf("remote origin not found: %w", err)
@@ -244,13 +254,10 @@ func Push(repo *gogit.Repository, branchName, tagName, token string) error {
 			gitconfig.RefSpec(fmt.Sprintf("refs/heads/%s:refs/heads/%s", branchName, branchName)),
 			gitconfig.RefSpec(fmt.Sprintf("refs/tags/%s:refs/tags/%s", tagName, tagName)),
 		},
-	}
+		Auth: &githttp.BasicAuth{
-
-	if token != "" {
-		opts.Auth = &githttp.BasicAuth{
 			Username: "oauth2",
 			Password: token,
-		}
+		},
 	}
 
 	if err := remote.Push(opts); err != nil && !errors.Is(err, gogit.NoErrAlreadyUpToDate) {
@@ -259,6 +266,24 @@ func Push(repo *gogit.Repository, branchName, tagName, token string) error {
 	return nil
 }
 
+func pushWithCLI(repo *gogit.Repository, branchName, tagName string) error {
+	wt, err := repo.Worktree()
+	if err != nil {
+		return fmt.Errorf("get worktree: %w", err)
+	}
+
+	cmd := exec.Command("git", "-C", wt.Filesystem.Root(), "push", "origin",
+		fmt.Sprintf("HEAD:refs/heads/%s", branchName),
+		fmt.Sprintf("refs/tags/%s:refs/tags/%s", tagName, tagName),
+	)
+	cmd.Stdout = os.Stderr // git push status goes to stderr conventionally
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("git push: %w", err)
+	}
+	return nil
+}
+
 // resolveTagToCommit follows tag objects until it reaches a commit.
 // Handles both lightweight tags (ref → commit) and annotated tags (ref → tag object → … → commit).
 func resolveTagToCommit(repo *gogit.Repository, ref *plumbing.Reference) (plumbing.Hash, error) {