feat: tag-driven release — version injected via ldflags, no more manual bumps

Author: fullstackjam

.github/workflows/release.yml

@@ -33,13 +33,24 @@ jobs:
         with:
           go-version: '1.22'
 
+      - name: Get version from tag
+        id: version
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            VERSION="${{ github.event.inputs.version }}"
+          else
+            VERSION="${GITHUB_REF#refs/tags/}"
+          fi
+          # Strip 'v' prefix for the version string
+          echo "version=${VERSION#v}" >> $GITHUB_OUTPUT
+
       - name: Build
         env:
           GOOS: ${{ matrix.os }}
           GOARCH: ${{ matrix.arch }}
           CGO_ENABLED: '0'
         run: |
-          go build -ldflags="-s -w" -trimpath -o openboot-${{ matrix.os }}-${{ matrix.arch }} ./cmd/openboot
+          go build -ldflags="-s -w -X github.com/openbootdotdev/openboot/internal/cli.version=${{ steps.version.outputs.version }}" -trimpath -o openboot-${{ matrix.os }}-${{ matrix.arch }} ./cmd/openboot
 
       - name: Install UPX
         run: |

AGENTS.md

@@ -78,7 +78,7 @@ cli (root)
 - **Testing**: Table-driven with testify/assert. Build tags for integration/e2e
 - **Concurrency**: `sync.WaitGroup` with bounded workers (max 4 for brew)
 - **Dry-run**: All destructive operations check `cfg.DryRun` first
-- **Version string**: Hardcoded in `internal/cli/root.go` — bump manually before release
+- **Version string**: Default `"dev"` in `internal/cli/root.go` — injected via ldflags at build time, never edit manually
 - **Config storage**: `~/.openboot/` directory for auth, state, snapshots
 
 ## ANTI-PATTERNS
@@ -93,24 +93,32 @@ cli (root)
 ## COMMANDS
 
 ```bash
-make build              # go build -o openboot ./cmd/openboot
-make build-release      # Optimized: -ldflags="-s -w" -trimpath + UPX
-make test-unit          # go test -v ./...
-make test-integration   # go test -v -tags=integration ./...
-make test-e2e           # go test -v -tags=e2e -short ./...
-make test-all           # All above + coverage
-make clean              # Remove binaries + coverage
-go vet ./...            # Lint check
+make build                    # Dev build (version=dev)
+make build VERSION=0.19.0     # Build with specific version
+make build-release VERSION=0.19.0  # Optimized + UPX with version
+make test-unit                # go test -v ./...
+make test-integration         # go test -v -tags=integration ./...
+make test-e2e                 # go test -v -tags=e2e -short ./...
+make test-all                 # All above + coverage
+make clean                    # Remove binaries + coverage
+go vet ./...                  # Lint check
 ```
 
 ## RELEASE PROCESS
 
-1. Bump version in `internal/cli/root.go`
-2. `git commit && git push`
-3. Build: `GOOS=darwin GOARCH=arm64 go build -ldflags="-s -w" -o openboot-darwin-arm64 ./cmd/openboot`
-4. `gh release create vX.Y.Z openboot-darwin-arm64 openboot-darwin-amd64 checksums.txt`
+Tag-driven. CI handles everything. **Never edit root.go for version bumps.**
 
-CI auto-releases on `v*` tags via `.github/workflows/release.yml`.
+```bash
+git tag v0.19.0
+git push --tags
+# CI builds binaries with version injected via ldflags, creates GitHub release
+```
+
+- Version is `"dev"` in source — overridden by `-ldflags -X` at build time
+- Dev builds (`version=dev`) skip auto-update
+- CI workflow: `.github/workflows/release.yml` extracts version from git tag
+
+**When to release**: Only for user-facing changes (features, bug fixes, package updates). Skip for docs, AGENTS.md, CI config, test-only changes.
 
 ## NOTES
 

Makefile

@@ -2,6 +2,8 @@
 
 BINARY_NAME=openboot
 BINARY_PATH=./$(BINARY_NAME)
+VERSION ?= dev
+LDFLAGS=-X github.com/openbootdotdev/openboot/internal/cli.version=$(VERSION)
 COVERAGE_FILE=coverage.out
 COVERAGE_HTML=coverage.html
 
@@ -27,11 +29,11 @@ test-all:
 	$(MAKE) test-coverage
 
 build:
-	go build -o $(BINARY_PATH) ./cmd/openboot
+	go build -ldflags="$(LDFLAGS)" -o $(BINARY_PATH) ./cmd/openboot
 
 build-release:
-	@echo "Building optimized release binary..."
-	go build -ldflags="-s -w" -trimpath -o $(BINARY_PATH) ./cmd/openboot
+	@echo "Building optimized release binary (version=$(VERSION))..."
+	go build -ldflags="-s -w $(LDFLAGS)" -trimpath -o $(BINARY_PATH) ./cmd/openboot
 	@echo "Original size: $$(du -h $(BINARY_PATH) | cut -f1)"
 	@if command -v upx >/dev/null 2>&1; then \
 		echo "Compressing with UPX..."; \

internal/cli/root.go

@@ -11,7 +11,7 @@ import (
 )
 
 var (
-	version = "0.18.2"
+	version = "dev"
 	cfg     = &config.Config{}
 )
 

internal/updater/updater.go

@@ -196,6 +196,10 @@ func isNewerVersion(latest, current string) bool {
 	if latest == "" {
 		return false
 	}
+	// Dev builds (built from source without version injection) never auto-update
+	if current == "dev" {
+		return false
+	}
 	latestClean := trimVersionPrefix(latest)
 	currentClean := trimVersionPrefix(current)
 	return latestClean != currentClean && latestClean > currentClean