Add clickable GitHub profile links to contributors

Author: me4502

api/api.gen.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/spongepowered/systemofadownload/internal/activity"
 	"github.com/spongepowered/systemofadownload/internal/gitcache"
+	"github.com/spongepowered/systemofadownload/internal/githubapi"
 	"github.com/spongepowered/systemofadownload/internal/otelsetup"
 	"github.com/spongepowered/systemofadownload/internal/repository"
 	"github.com/spongepowered/systemofadownload/internal/sonatype"
@@ -38,6 +39,7 @@ type Config struct {
 	SonatypeRepoDenyList []string
 	DatabaseURL          string
 	GitCacheDir          string
+	GitHubToken          string
 	MetricsPort          string
 	BuildID              string
 	PodName              string
@@ -98,6 +100,7 @@ func NewConfig() *Config {
 		SonatypeRepoDenyList: repoDeny,
 		DatabaseURL:          databaseURL,
 		GitCacheDir:          gitCacheDir,
+		GitHubToken:          os.Getenv("GITHUB_TOKEN"),
 		MetricsPort:          metricsPort,
 		BuildID:              buildID,
 		PodName:              podName,
@@ -274,8 +277,11 @@ func main() {
 			},
 			activity.NewVersionIndexActivities,
 			activity.NewVersionOrderingActivities,
-			func(repo repository.Repository) *activity.ChangelogActivities {
-				return &activity.ChangelogActivities{Repo: repo}
+			func(cfg *Config, repo repository.Repository) *activity.ChangelogActivities {
+				return &activity.ChangelogActivities{
+					Repo:   repo,
+					GitHub: githubapi.NewClient(http.DefaultClient, cfg.GitHubToken),
+				}
 			},
 			func(cfg *Config) *gitcache.Manager {
 				return gitcache.NewManager(cfg.GitCacheDir)

cmd/worker/main.go

@@ -37,15 +37,15 @@ VersionSyncWorkflow ────────────────────
       │         ├── [per submodule, parallel]                         |
       │         │    ├── EnsureRepoCloned  (local: submodule repo)   |
       │         │    └── GetCommitDetails  (local: submodule SHA)    |
-      │         └── StoreEnrichedCommit    (DB)                      |
+      │         └── StoreEnrichedCommit    (GitHub author lookup + DB)|
       └── ChangelogBatchWorkflow   (sequential, sort_order ASC)      |
            └── ChangelogVersionWorkflow (per version)                 |
                 ├── GetPreviousVersionCommit (DB)                     |
                 ├── [wait for N-1 enrichment if needed]               |
                 ├── ComputeChangelog       (local: git log)           |
                 ├── [per submodule with changed pointer]              |
                 │    └── ComputeChangelog  (local: submodule log)     |
-                └── StoreChangelog         (DB)                       |
+                └── StoreChangelog         (GitHub author lookup + DB)|
 ──────────────────────────────────────────────────────────────────────┘
 ```
 
@@ -56,6 +56,7 @@ The worker uses Temporal's [Worker Deployment Versioning](https://docs.temporal.
 **Configuration (env vars):**
 - `BUILD_ID` (required) — image tag or version identifier, set by the deployment pipeline. The worker will refuse to start if this is empty.
 - `POD_NAME` (optional) — Kubernetes pod name, used as the Temporal client `Identity` for traceability in the Temporal UI.
+- `GITHUB_TOKEN` (optional) — authenticates commit-author lookups for higher API limits and private repositories. Public GitHub repositories are queried without authentication when unset.
 
 **Worker registration:**
 ```go
@@ -132,6 +133,15 @@ Processes a single version: fetches assets from Sonatype, stores them, identifie
 
 Downloads jar files and parses `META-INF/git.properties` or `META-INF/MANIFEST.MF` to extract git commit SHAs and repository URLs. Uses the same sliding window pattern as batch indexing (window size 3, page size 5).
 
+During commit and changelog persistence, GitHub-hosted commits are resolved to
+their associated GitHub username. GitHub noreply addresses are handled locally;
+other addresses use the GitHub commit API. The username is stored alongside the
+Git author name and email, while lookup failures retain the Git name fallback.
+`StoreChangelog` has a two-minute activity timeout to accommodate bounded,
+parallel lookups across large changelogs. GitHub lookups stop five seconds
+before the activity deadline so optional enrichment cannot consume the time
+needed for the database write.
+
 ### VersionOrderingWorkflow
 
 Computes version sort ordering using schema-driven parsing and optionally the Mojang version manifest for correct Minecraft version placement.

docs/WORKFLOWS.md

@@ -4,16 +4,21 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log/slog"
+	"sync"
+	"time"
 
 	"github.com/spongepowered/systemofadownload/internal/db"
 	"github.com/spongepowered/systemofadownload/internal/domain"
+	"github.com/spongepowered/systemofadownload/internal/githubapi"
 	"github.com/spongepowered/systemofadownload/internal/repository"
 )
 
 // ChangelogActivities provides normal (non-local) activities for
 // commit enrichment DB reads and writes.
 type ChangelogActivities struct {
-	Repo repository.Repository
+	Repo   repository.Repository
+	GitHub *githubapi.Client
 }
 
 // FetchVersionsForEnrichmentInput is the input for FetchVersionsForEnrichment.
@@ -203,6 +208,8 @@ type StoreEnrichedCommitInput struct {
 
 // StoreEnrichedCommit writes the enriched commit info back to the DB.
 func (a *ChangelogActivities) StoreEnrichedCommit(ctx context.Context, input StoreEnrichedCommitInput) error { //nolint:gocritic // Temporal activity signature requires value type
+	a.resolveCommitInfoAuthors(ctx, &input.CommitInfo)
+
 	data, err := json.Marshal(input.CommitInfo)
 	if err != nil {
 		return fmt.Errorf("marshaling enriched commit: %w", err)
@@ -225,6 +232,8 @@ type StoreChangelogInput struct {
 // StoreChangelog reads the current commit_body, merges the changelog into it,
 // and writes it back. This preserves the enrichment data already stored.
 func (a *ChangelogActivities) StoreChangelog(ctx context.Context, input StoreChangelogInput) error {
+	a.resolveChangelogAuthors(ctx, &input.Changelog)
+
 	return a.Repo.WithTx(ctx, func(tx repository.Tx) error {
 		av, err := tx.GetArtifactVersionByID(ctx, input.VersionID)
 		if err != nil {
@@ -256,3 +265,137 @@ func (a *ChangelogActivities) StoreChangelog(ctx context.Context, input StoreCha
 		})
 	})
 }
+
+type authorLookup struct {
+	author     *domain.CommitAuthor
+	repository string
+	sha        string
+}
+
+func (a *ChangelogActivities) resolveCommitInfoAuthors(ctx context.Context, info *domain.CommitInfo) {
+	lookups := []authorLookup{{
+		author:     info.Author,
+		repository: info.Repository,
+		sha:        info.Sha,
+	}}
+	for i := range info.Submodules {
+		lookups = append(lookups, authorLookup{
+			author:     info.Submodules[i].Author,
+			repository: info.Submodules[i].Repository,
+			sha:        info.Submodules[i].Sha,
+		})
+	}
+	a.resolveAuthors(ctx, lookups)
+}
+
+func (a *ChangelogActivities) resolveChangelogAuthors(ctx context.Context, changelog *domain.Changelog) {
+	var lookups []authorLookup
+	collectChangelogAuthorLookups(changelog, "", &lookups)
+	a.resolveAuthors(ctx, lookups)
+}
+
+func collectChangelogAuthorLookups(changelog *domain.Changelog, repoURL string, lookups *[]authorLookup) {
+	if changelog == nil {
+		return
+	}
+	for i := range changelog.Commits {
+		commit := &changelog.Commits[i]
+		commitRepo := repoURL
+		if owner, repo, ok := githubapi.ParseRepository(commit.URL); ok {
+			commitRepo = "https://github.com/" + owner + "/" + repo
+		}
+		*lookups = append(*lookups, authorLookup{
+			author:     commit.Author,
+			repository: commitRepo,
+			sha:        commit.Sha,
+		})
+	}
+	for subRepo, subChangelog := range changelog.SubmoduleChangelogs {
+		collectChangelogAuthorLookups(subChangelog, subRepo, lookups)
+	}
+}
+
+func (a *ChangelogActivities) resolveAuthors(ctx context.Context, lookups []authorLookup) {
+	if a.GitHub == nil || len(lookups) == 0 {
+		return
+	}
+
+	lookupCtx, cancel, ok := githubLookupContext(ctx)
+	if !ok {
+		slog.WarnContext(ctx, "skipping GitHub author lookup to preserve database persistence time")
+		return
+	}
+	defer cancel()
+
+	const concurrency = 4
+	sem := make(chan struct{}, concurrency)
+	var wg sync.WaitGroup
+	var errorCount int
+	var firstErr error
+	var errorMu sync.Mutex
+
+	for i := range lookups {
+		lookup := lookups[i]
+		if lookup.author == nil || lookup.author.GitHubUsername != "" {
+			continue
+		}
+
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			select {
+			case sem <- struct{}{}:
+			case <-lookupCtx.Done():
+				errorMu.Lock()
+				errorCount++
+				if firstErr == nil {
+					firstErr = lookupCtx.Err()
+				}
+				errorMu.Unlock()
+				return
+			}
+			defer func() { <-sem }()
+
+			username, err := a.GitHub.ResolveUsername(
+				lookupCtx,
+				lookup.repository,
+				lookup.sha,
+				lookup.author.Email,
+			)
+			if err != nil {
+				errorMu.Lock()
+				errorCount++
+				if firstErr == nil {
+					firstErr = err
+				}
+				errorMu.Unlock()
+				return
+			}
+			lookup.author.GitHubUsername = username
+		}()
+	}
+	wg.Wait()
+
+	if errorCount > 0 {
+		slog.WarnContext(ctx, "GitHub author lookup failed; using Git author names",
+			"failures", errorCount,
+			"error", firstErr,
+		)
+	}
+}
+
+const githubLookupPersistenceReserve = 5 * time.Second
+
+func githubLookupContext(ctx context.Context) (context.Context, context.CancelFunc, bool) {
+	if deadline, ok := ctx.Deadline(); ok {
+		lookupDeadline := deadline.Add(-githubLookupPersistenceReserve)
+		if !time.Now().Before(lookupDeadline) {
+			return nil, nil, false
+		}
+		lookupCtx, cancel := context.WithDeadline(ctx, lookupDeadline)
+		return lookupCtx, cancel, true
+	}
+
+	lookupCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	return lookupCtx, cancel, true
+}