Adopt kit git helpers and pin the Go toolchain (#576)

## Summary
- Switch git repository discovery and author lookup onto `go.kenn.io/kit v0.1.0`
- Thread caller `ctx` through the git outcome path instead of using background contexts
- Pin the Go toolchain consistently in `go.mod` and the Docker build image

## Testing
- `go test ./internal/db/git ./internal/db`
- `docker build --target build -t agentsview-kit-check .`
- `go test ./...` reported one unrelated existing failure in `internal/parser` (`TestParseWorkBuddySession`)

Co-authored-by: Marius van Niekerk <mariusvniekerk@users.noreply.github.com>

Author: mariusvniekerk

Dockerfile

@@ -8,7 +8,7 @@ RUN npm ci
 COPY frontend/ ./
 RUN npm run build
 
-FROM golang:1.26-bookworm AS build
+FROM golang:1.26.3-bookworm AS build
 
 RUN apt-get update \
     && apt-get install -y --no-install-recommends build-essential ca-certificates \

cmd/agentsview/token_use.go

@@ -317,8 +317,8 @@ func sessionUsageData(sessionID string) (*sessionUsageOutput, int, error) {
 			Machine:                 "local",
 			BlockedResultCategories: appCfg.ResultContentBlockedCategories,
 		})
-		if syncErr := engine.SyncSingleSession(
-			resolvedID,
+		if syncErr := engine.SyncSingleSessionContext(
+			ctx, resolvedID,
 		); syncErr != nil {
 			// Not fatal: session may already be in the DB
 			// from a previous sync, or may not exist at all.

go.mod

@@ -1,6 +1,6 @@
 module go.kenn.io/agentsview
 
-go 1.26.2
+go 1.26.3
 
 require (
 	github.com/BurntSushi/toml v1.6.0
@@ -14,6 +14,7 @@ require (
 	github.com/spf13/pflag v1.0.10
 	github.com/stretchr/testify v1.11.1
 	github.com/tidwall/gjson v1.19.0
+	go.kenn.io/kit v0.1.0
 	golang.org/x/mod v0.36.0
 	golang.org/x/sync v0.20.0
 	golang.org/x/sys v0.44.0

go.sum

@@ -48,6 +48,8 @@ github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
 github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
 github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
 github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+go.kenn.io/kit v0.1.0 h1:7l8aWAcnal/+DXT8I9t9UlvQrNCjsBoGrUiyJVS6i+c=
+go.kenn.io/kit v0.1.0/go.mod h1:nuRwWHhrDZP2rC8Auntl71la2Iu04B4twUkJl0SxIJ4=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=
 golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=

internal/db/git/log.go

@@ -5,10 +5,11 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"os/exec"
 	"regexp"
 	"strconv"
 	"strings"
+
+	gitcmd "go.kenn.io/kit/git/cmd"
 )
 
 // LogResult aggregates author-filtered counts from `git log --numstat` output.
@@ -33,20 +34,19 @@ type LogResult struct {
 func AggregateLog(
 	ctx context.Context, repo, authorEmail, since, until string,
 ) (LogResult, error) {
-	cmd := exec.CommandContext(
-		ctx, "git", "log",
+	runner := gitcmd.New()
+	runner.NullGlobalConfig = false
+	out, stderr, err := runner.Run(
+		ctx, repo, nil,
+		"log",
 		"--numstat",
 		"--format=%H",
 		"--since="+since,
 		"--until="+until,
 		"--author="+authorEmailPattern(authorEmail),
 	)
-	cmd.Dir = repo
-	var stderr bytes.Buffer
-	cmd.Stderr = &stderr
-	out, err := cmd.Output()
 	if err != nil {
-		msg := strings.TrimSpace(stderr.String())
+		msg := strings.TrimSpace(string(stderr))
 		// An empty repo (initialized but no commits, or a worktree
 		// pointed at an unborn branch) is a normal state, not an
 		// error — there is simply no log to aggregate. Treat as a
@@ -169,17 +169,19 @@ func authorEmailPattern(email string) string {
 // AuthorEmail returns `git config user.email` run from inside the repo,
 // falling back to the global config. Returns "" if neither is set or git
 // is not available.
-func AuthorEmail(repo string) string {
-	cmd := exec.Command("git", "config", "user.email")
-	cmd.Dir = repo
-	out, err := cmd.Output()
+func AuthorEmail(ctx context.Context, repo string) string {
+	localRunner := gitcmd.New()
+	localRunner.NullGlobalConfig = false
+	out, err := localRunner.Output(ctx, repo, "config", "user.email")
 	if err == nil {
 		if v := strings.TrimSpace(string(out)); v != "" {
 			return v
 		}
 	}
-	cmd = exec.Command("git", "config", "--global", "user.email")
-	out, err = cmd.Output()
+
+	globalRunner := gitcmd.New()
+	globalRunner.NullGlobalConfig = false
+	out, err = globalRunner.Output(ctx, "", "config", "--global", "user.email")
 	if err != nil {
 		return ""
 	}

internal/db/git/log_test.go

@@ -178,13 +178,49 @@ func TestAggregateLog_EmptyRepoReturnsZero(t *testing.T) {
 	assert.Equal(t, LogResult{}, got, "AggregateLog on empty repo")
 }
 
+func TestAggregateLog_UsesGlobalGitConfig(t *testing.T) {
+	skipIfNoGit(t)
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
+	globalConfig := filepath.Join(home, ".gitconfig")
+	t.Setenv("GIT_CONFIG_GLOBAL", globalConfig)
+
+	attrsPath := filepath.Join(home, "attributes")
+	require.NoError(t, os.WriteFile(
+		attrsPath, []byte("*.txt binary\n"), 0o644,
+	), "write global attributes")
+	require.NoError(t, os.WriteFile(
+		globalConfig,
+		[]byte("[core]\n\tattributesfile = "+filepath.ToSlash(attrsPath)+"\n"),
+		0o644,
+	), "write global git config")
+
+	repo := initRepo(t)
+	writeFile(t, repo, "configured-binary.txt", []byte("a\nb\nc\n"))
+	commitAs(t, repo, "test@example.com", "Test User", "c1")
+
+	got, err := AggregateLog(
+		context.Background(),
+		repo, "test@example.com",
+		"1970-01-01T00:00:00Z", "2099-01-01T00:00:00Z",
+	)
+	require.NoError(t, err, "AggregateLog")
+	assert.Equal(t, LogResult{
+		Commits:      1,
+		LOCAdded:     0,
+		LOCRemoved:   0,
+		FilesChanged: 1,
+	}, got, "AggregateLog should respect global git config")
+}
+
 func TestAuthorEmail_LocalConfig(t *testing.T) {
 	skipIfNoGit(t)
 	repo := t.TempDir()
 	gitRun(t, repo, nil, "init", "-q", "-b", "main")
 	gitRun(t, repo, nil, "config", "user.email", "local@example.com")
 
-	got := AuthorEmail(repo)
+	got := AuthorEmail(context.Background(), repo)
 	assert.Equal(t, "local@example.com", got, "AuthorEmail")
 }
 
@@ -221,10 +257,40 @@ func TestAuthorEmail_FallsBackToGlobal(t *testing.T) {
 	out, err = initCmd.CombinedOutput()
 	require.NoError(t, err, "git init: %s", out)
 
-	got := AuthorEmail(repo)
+	got := AuthorEmail(context.Background(), repo)
 	assert.Equal(t, "global@example.com", got, "AuthorEmail (global fallback)")
 }
 
+func TestAuthorEmail_UsesIncludeIfGitdir(t *testing.T) {
+	skipIfNoGit(t)
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
+	globalConfig := filepath.Join(home, ".gitconfig")
+	t.Setenv("GIT_CONFIG_GLOBAL", globalConfig)
+
+	repo := t.TempDir()
+	gitRun(t, repo, nil, "init", "-q", "-b", "main")
+
+	includePath := filepath.Join(home, "repo.gitconfig")
+	require.NoError(t, os.WriteFile(
+		includePath,
+		[]byte("[user]\n\temail = includeif@example.com\n"),
+		0o644,
+	), "write include config")
+	gitdir, err := filepath.EvalSymlinks(filepath.Join(repo, ".git"))
+	require.NoError(t, err, "resolve repo gitdir")
+	require.NoError(t, os.WriteFile(
+		globalConfig,
+		[]byte(`[includeIf "gitdir:`+filepath.ToSlash(gitdir)+`"]
+	path = `+filepath.ToSlash(includePath)+"\n"),
+		0o644,
+	), "write global config")
+
+	got := AuthorEmail(context.Background(), repo)
+	assert.Equal(t, "includeif@example.com", got, "AuthorEmail (includeIf.gitdir)")
+}
+
 func TestParseNumstat_SkipsBinaryLOCButCountsFile(t *testing.T) {
 	// Unit test of the pure parser, independent of git exec.
 	input := []byte(strings.Join([]string{

internal/db/git/repos.go

@@ -3,13 +3,12 @@
 package git
 
 import (
-	"bytes"
 	"context"
 	"os"
-	"os/exec"
 	"path/filepath"
-	"strings"
 	"time"
+
+	gitrepo "go.kenn.io/kit/git/repo"
 )
 
 // DiscoverRepos resolves each cwd to its enclosing git repository toplevel and
@@ -23,11 +22,11 @@ import (
 // helper falls back to walking upward from the nearest existing ancestor and
 // invoking `git rev-parse` from there — that mirrors how the parser package
 // recovers repo roots for archived sessions whose cwd has been deleted.
-func DiscoverRepos(cwds []string) []string {
+func DiscoverRepos(ctx context.Context, cwds []string) []string {
 	seen := map[string]struct{}{}
 	out := []string{}
 	for _, cwd := range cwds {
-		root := findRepoRoot(cwd)
+		root := findRepoRoot(ctx, cwd)
 		if root == "" {
 			continue
 		}
@@ -42,15 +41,15 @@ func DiscoverRepos(cwds []string) []string {
 
 // findRepoRoot returns the absolute repo toplevel for start, or "" when no
 // enclosing repo can be resolved.
-func findRepoRoot(start string) string {
+func findRepoRoot(ctx context.Context, start string) string {
 	if start == "" {
 		return ""
 	}
 	dir := existingAncestor(start)
 	if dir == "" {
 		return ""
 	}
-	return gitToplevel(dir)
+	return gitToplevel(ctx, dir)
 }
 
 // existingAncestor returns the closest ancestor of path that exists on disk
@@ -79,18 +78,12 @@ func existingAncestor(path string) string {
 // gitToplevel runs `git rev-parse --show-toplevel` from dir and returns the
 // trimmed result, or "" if git fails or prints nothing. A 5s timeout guards
 // against hung git invocations on broken repos.
-func gitToplevel(dir string) string {
-	ctx, cancel := context.WithTimeout(
-		context.Background(), 5*time.Second,
-	)
+func gitToplevel(ctx context.Context, dir string) string {
+	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
 	defer cancel()
-	cmd := exec.CommandContext(ctx, "git", "rev-parse", "--show-toplevel")
-	cmd.Dir = dir
-	var stderr bytes.Buffer
-	cmd.Stderr = &stderr
-	out, err := cmd.Output()
+	root, err := gitrepo.Root(ctx, dir)
 	if err != nil {
 		return ""
 	}
-	return strings.TrimSpace(string(out))
+	return root
 }

internal/db/git/repos_test.go

@@ -1,6 +1,7 @@
 package git
 
 import (
+	"context"
 	"os"
 	"path/filepath"
 	"sort"
@@ -54,7 +55,7 @@ func TestDiscoverRepos_FindsRootAndFiltersMissing(t *testing.T) {
 	sub := mkdirIn(t, repoA, "subdir")
 	outside := t.TempDir()
 
-	got := DiscoverRepos([]string{sub, outside})
+	got := DiscoverRepos(context.Background(), []string{sub, outside})
 	want := []string{repoA}
 	assert.Equal(t, canonAll(want), canonAll(got), "DiscoverRepos")
 }
@@ -65,17 +66,17 @@ func TestDiscoverRepos_Dedup(t *testing.T) {
 	sub1 := mkdirIn(t, repoA, "sub1")
 	sub2 := mkdirIn(t, repoA, "sub2/deeper")
 
-	got := DiscoverRepos([]string{sub1, sub2, repoA})
+	got := DiscoverRepos(context.Background(), []string{sub1, sub2, repoA})
 	require.Len(t, got, 1, "want exactly one entry (dedup)")
 	assert.Equal(t, canonAll([]string{repoA}), canonAll(got),
 		"DiscoverRepos")
 }
 
 func TestDiscoverRepos_EmptyInputReturnsEmptySlice(t *testing.T) {
-	got := DiscoverRepos(nil)
+	got := DiscoverRepos(context.Background(), nil)
 	require.NotNil(t, got, "DiscoverRepos(nil)")
 	assert.Empty(t, got, "DiscoverRepos(nil) should be empty slice")
-	got = DiscoverRepos([]string{})
+	got = DiscoverRepos(context.Background(), []string{})
 	require.NotNil(t, got, "DiscoverRepos([])")
 	assert.Empty(t, got, "DiscoverRepos([]) should be empty slice")
 }
@@ -98,7 +99,7 @@ func TestDiscoverRepos_LinkedWorktreeResolves(t *testing.T) {
 		"worktree", "add", "-b", "feature", worktreeRoot,
 	)
 
-	got := DiscoverRepos([]string{worktreeRoot})
+	got := DiscoverRepos(context.Background(), []string{worktreeRoot})
 	require.Len(t, got, 1, "want one worktree root")
 	assert.Equal(t,
 		canonAll([]string{worktreeRoot}),
@@ -113,6 +114,6 @@ func TestDiscoverRepos_MissingCwdSkipped(t *testing.T) {
 	skipIfNoGit(t)
 	missing := filepath.Join(t.TempDir(), "no", "such", "path")
 
-	got := DiscoverRepos([]string{missing})
+	got := DiscoverRepos(context.Background(), []string{missing})
 	assert.Empty(t, got, "DiscoverRepos missing path")
 }

internal/db/session_stats.go

@@ -1392,7 +1392,7 @@ func (db *DB) computeOutcomeStats(
 			cwds = append(cwds, r.cwd)
 		}
 	}
-	repos := git.DiscoverRepos(cwds)
+	repos := git.DiscoverRepos(ctx, cwds)
 	if len(repos) == 0 {
 		return nil
 	}
@@ -1402,7 +1402,7 @@ func (db *DB) computeOutcomeStats(
 	out := &StatsOutcomeStats{}
 	contributed := false
 	for _, repo := range repos {
-		email := git.AuthorEmail(repo)
+		email := git.AuthorEmail(ctx, repo)
 		if email == "" {
 			continue
 		}