feat(sync): implement deferred per-target metrics recording

Activate Task 7 deferred metrics in RepositorySync.Execute: track
finalBranchName/commitSHA/allChanges/finalErr via defer and call
recordTargetResult on every exit path (success, failure, skipped,
no_changes). Implement full recordTargetResult that resolves repo/group/
target DB IDs, calculates per-file line counts, builds a
BroadcastSyncTargetResult, persists file change records, and aggregates
run-level totals via Engine.RecordTargetStats.

Extend SyncMetricsRecorder with LookupGroupID, LookupRepoID, and
LookupTargetID; implement them in dbMetricsAdapter with sentinel errors
for unconfigured repos. Update NewDBMetricsAdapter to accept all four
repository types and wire them in the CLI sync command. Resolve group and
source-repo DB IDs during recordSyncRunStart. Implement isRunningInCI
with real env-var checks (CI, GITHUB_ACTIONS, GITLAB_CI, etc.).

Author: mrz1836

internal/cli/sync.go

@@ -460,8 +460,11 @@ func tryAttachMetricsRecorder(engine *sync.Engine, log *logrus.Logger) func() {
 		return func() {}
 	}
 
-	repo := db.NewBroadcastSyncRepo(database.DB())
-	adapter := sync.NewDBMetricsAdapter(repo)
+	syncRepo := db.NewBroadcastSyncRepo(database.DB())
+	repoRepo := db.NewRepoRepository(database.DB())
+	targetRepo := db.NewTargetRepository(database.DB())
+	groupRepo := db.NewGroupRepository(database.DB())
+	adapter := sync.NewDBMetricsAdapter(syncRepo, repoRepo, targetRepo, groupRepo)
 	engine.SetSyncMetricsRecorder(adapter)
 
 	return func() { _ = database.Close() }

internal/sync/engine.go

@@ -141,6 +141,18 @@ func (e *Engine) setCurrentRun(run *BroadcastSyncRun) {
 	e.currentRun = run
 }
 
+// RecordTargetStats adds per-target file/line counts to the current run totals (thread-safe).
+// Called from concurrent RepositorySync goroutines; the mutex ensures safe aggregation.
+func (e *Engine) RecordTargetStats(filesChanged, linesAdded, linesRemoved int) {
+	e.currentRunMu.Lock()
+	defer e.currentRunMu.Unlock()
+	if e.currentRun != nil {
+		e.currentRun.TotalFilesChanged += filesChanged
+		e.currentRun.TotalLinesAdded += linesAdded
+		e.currentRun.TotalLinesRemoved += linesRemoved
+	}
+}
+
 // GitClient returns the git client for repository operations.
 func (e *Engine) GitClient() git.Client {
 	return e.git
@@ -581,10 +593,19 @@ func (e *Engine) recordSyncRunStart(ctx context.Context, group config.Group, cur
 		SourceCommit: currentState.Source.LatestCommit,
 	}
 
-	// TODO: Set group ID if available (requires DB lookup to convert string ID to uint)
-	// For now, we'll rely on ExternalID and SourceCommit for tracking
-	// groupID lookup would require database access here
-	run.GroupID = nil
+	// Resolve group ID from external ID string to DB uint
+	if groupID, err := e.syncRepo.LookupGroupID(ctx, group.ID); err == nil {
+		run.GroupID = &groupID
+	} else {
+		log.WithError(err).Debug("Could not resolve group DB ID, field will be nil")
+	}
+
+	// Resolve source repo ID from "org/repo" to DB uint
+	if sourceRepoID, err := e.syncRepo.LookupRepoID(ctx, currentState.Source.Repo); err == nil {
+		run.SourceRepoID = &sourceRepoID
+	} else {
+		log.WithError(err).Debug("Could not resolve source repo DB ID, field will be nil")
+	}
 
 	// Create the run in the database
 	if err := e.syncRepo.CreateSyncRun(ctx, run); err != nil {

internal/sync/engine_unit_test.go

@@ -18,6 +18,11 @@ var (
 	errMockFileChanges = errors.New("mock file changes error")
 )
 
+// Static error variables for lookup mock methods.
+var (
+	errMockLookup = errors.New("mock lookup error")
+)
+
 // mockSyncMetricsRecorder is a minimal mock implementing SyncMetricsRecorder.
 type mockSyncMetricsRecorder struct{}
 
@@ -37,6 +42,18 @@ func (m *mockSyncMetricsRecorder) CreateFileChanges(_ context.Context, _ []Broad
 	return errMockFileChanges
 }
 
+func (m *mockSyncMetricsRecorder) LookupGroupID(_ context.Context, _ string) (uint, error) {
+	return 0, errMockLookup
+}
+
+func (m *mockSyncMetricsRecorder) LookupRepoID(_ context.Context, _ string) (uint, error) {
+	return 0, errMockLookup
+}
+
+func (m *mockSyncMetricsRecorder) LookupTargetID(_ context.Context, _ uint, _ string) (uint, error) {
+	return 0, errMockLookup
+}
+
 func TestEngine_MetricsRecorder(t *testing.T) {
 	t.Parallel()
 

internal/sync/metrics.go

@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"os"
 	"time"
 )
 
@@ -22,6 +23,15 @@ type SyncMetricsRecorder interface {
 
 	// CreateFileChanges batch creates file change records
 	CreateFileChanges(ctx context.Context, changes []BroadcastSyncFileChange) error
+
+	// LookupGroupID resolves a config group external ID string to a DB uint ID
+	LookupGroupID(ctx context.Context, groupExternalID string) (uint, error)
+
+	// LookupRepoID resolves an "org/repo" string to a DB uint ID
+	LookupRepoID(ctx context.Context, repoFullName string) (uint, error)
+
+	// LookupTargetID resolves a group DB ID + repo full name to a target DB uint ID
+	LookupTargetID(ctx context.Context, groupDBID uint, repoFullName string) (uint, error)
 }
 
 // BroadcastSyncRun is a minimal representation for the sync engine
@@ -150,8 +160,11 @@ func DetermineTrigger(options *Options) string {
 
 // isRunningInCI checks if we're running in a CI environment
 func isRunningInCI() bool {
-	// For now, we'll just return false as a safe default
-	// This can be enhanced later with actual env var checking:
-	// - Check for CI, GITHUB_ACTIONS, GITLAB_CI, CIRCLECI, etc.
+	ciVars := []string{"CI", "GITHUB_ACTIONS", "GITLAB_CI", "CIRCLECI", "TRAVIS", "JENKINS_URL", "BUILDKITE"}
+	for _, v := range ciVars {
+		if os.Getenv(v) != "" {
+			return true
+		}
+	}
 	return false
 }

internal/sync/metrics_adapter.go

@@ -2,18 +2,37 @@ package sync
 
 import (
 	"context"
+	"errors"
+	"fmt"
+	"strings"
 
 	"github.com/mrz1836/go-broadcast/internal/db"
 )
 
+// Sentinel errors for metrics adapter
+var (
+	ErrGroupRepoNotConfigured  = errors.New("group repository not configured")
+	ErrRepoRepoNotConfigured   = errors.New("repo repository not configured")
+	ErrTargetRepoNotConfigured = errors.New("target repository not configured")
+	ErrInvalidRepoFullName     = errors.New("invalid repo full name: expected org/repo format")
+)
+
 // dbMetricsAdapter adapts the db.BroadcastSyncRepo to the SyncMetricsRecorder interface
 type dbMetricsAdapter struct {
-	repo db.BroadcastSyncRepo
+	repo       db.BroadcastSyncRepo
+	repoRepo   db.RepoRepository
+	targetRepo db.TargetRepository
+	groupRepo  db.GroupRepository
 }
 
 // NewDBMetricsAdapter creates a new database metrics adapter
-func NewDBMetricsAdapter(repo db.BroadcastSyncRepo) SyncMetricsRecorder {
-	return &dbMetricsAdapter{repo: repo}
+func NewDBMetricsAdapter(repo db.BroadcastSyncRepo, repoRepo db.RepoRepository, targetRepo db.TargetRepository, groupRepo db.GroupRepository) SyncMetricsRecorder {
+	return &dbMetricsAdapter{
+		repo:       repo,
+		repoRepo:   repoRepo,
+		targetRepo: targetRepo,
+		groupRepo:  groupRepo,
+	}
 }
 
 // CreateSyncRun creates a new sync run record
@@ -58,6 +77,46 @@ func (a *dbMetricsAdapter) CreateFileChanges(ctx context.Context, changes []Broa
 	return a.repo.CreateFileChanges(ctx, dbChanges)
 }
 
+// LookupGroupID resolves a config group external ID string to a DB uint ID
+func (a *dbMetricsAdapter) LookupGroupID(ctx context.Context, groupExternalID string) (uint, error) {
+	if a.groupRepo == nil {
+		return 0, ErrGroupRepoNotConfigured
+	}
+	group, err := a.groupRepo.GetByExternalID(ctx, groupExternalID)
+	if err != nil {
+		return 0, fmt.Errorf("failed to look up group %q: %w", groupExternalID, err)
+	}
+	return group.ID, nil
+}
+
+// LookupRepoID resolves an "org/repo" string to a DB uint ID
+func (a *dbMetricsAdapter) LookupRepoID(ctx context.Context, repoFullName string) (uint, error) {
+	if a.repoRepo == nil {
+		return 0, ErrRepoRepoNotConfigured
+	}
+	parts := strings.SplitN(repoFullName, "/", 2)
+	if len(parts) != 2 {
+		return 0, fmt.Errorf("%w: %q", ErrInvalidRepoFullName, repoFullName)
+	}
+	repo, err := a.repoRepo.GetByFullName(ctx, parts[0], parts[1])
+	if err != nil {
+		return 0, fmt.Errorf("failed to look up repo %q: %w", repoFullName, err)
+	}
+	return repo.ID, nil
+}
+
+// LookupTargetID resolves a group DB ID + repo full name to a target DB uint ID
+func (a *dbMetricsAdapter) LookupTargetID(ctx context.Context, groupDBID uint, repoFullName string) (uint, error) {
+	if a.targetRepo == nil {
+		return 0, ErrTargetRepoNotConfigured
+	}
+	target, err := a.targetRepo.GetByRepoName(ctx, groupDBID, repoFullName)
+	if err != nil {
+		return 0, fmt.Errorf("failed to look up target for group %d, repo %q: %w", groupDBID, repoFullName, err)
+	}
+	return target.ID, nil
+}
+
 // convertSyncRunToDB converts sync engine's BroadcastSyncRun to db model
 func convertSyncRunToDB(run *BroadcastSyncRun) *db.BroadcastSyncRun {
 	return &db.BroadcastSyncRun{

internal/sync/metrics_adapter_test.go

@@ -1,6 +1,7 @@
 package sync
 
 import (
+	"context"
 	"testing"
 	"time"
 
@@ -158,7 +159,98 @@ func TestNewDBMetricsAdapter(t *testing.T) {
 	t.Parallel()
 
 	testDB := db.TestDB(t)
-	repo := db.NewBroadcastSyncRepo(testDB)
-	adapter := NewDBMetricsAdapter(repo)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	repoRepo := db.NewRepoRepository(testDB)
+	targetRepo := db.NewTargetRepository(testDB)
+	groupRepo := db.NewGroupRepository(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, repoRepo, targetRepo, groupRepo)
 	require.NotNil(t, adapter)
 }
+
+func TestDBMetricsAdapter_LookupGroupID_NotConfigured(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, nil, nil, nil)
+
+	_, err := adapter.LookupGroupID(context.Background(), "some-group")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "group repository not configured")
+}
+
+func TestDBMetricsAdapter_LookupRepoID_NotConfigured(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, nil, nil, nil)
+
+	_, err := adapter.LookupRepoID(context.Background(), "org/repo")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "repo repository not configured")
+}
+
+func TestDBMetricsAdapter_LookupTargetID_NotConfigured(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, nil, nil, nil)
+
+	_, err := adapter.LookupTargetID(context.Background(), 1, "org/repo")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "target repository not configured")
+}
+
+func TestDBMetricsAdapter_LookupRepoID_InvalidFormat(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	repoRepo := db.NewRepoRepository(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, repoRepo, nil, nil)
+
+	_, err := adapter.LookupRepoID(context.Background(), "invalid-no-slash")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "invalid repo full name")
+}
+
+func TestDBMetricsAdapter_LookupGroupID_NotFound(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	groupRepo := db.NewGroupRepository(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, nil, nil, groupRepo)
+
+	_, err := adapter.LookupGroupID(context.Background(), "nonexistent-group")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to look up group")
+}
+
+func TestDBMetricsAdapter_LookupRepoID_NotFound(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	repoRepo := db.NewRepoRepository(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, repoRepo, nil, nil)
+
+	_, err := adapter.LookupRepoID(context.Background(), "nonexistent/repo")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to look up repo")
+}
+
+func TestDBMetricsAdapter_LookupTargetID_NotFound(t *testing.T) {
+	t.Parallel()
+
+	testDB := db.TestDB(t)
+	syncRepo := db.NewBroadcastSyncRepo(testDB)
+	targetRepo := db.NewTargetRepository(testDB)
+	adapter := NewDBMetricsAdapter(syncRepo, nil, targetRepo, nil)
+
+	_, err := adapter.LookupTargetID(context.Background(), 999, "nonexistent/repo")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to look up target")
+}