perf: stream git log output via bufio.Scanner, fix bench map hint

Replace cmd.Output()+strings.Split with StdoutPipe+bufio.Scanner so the
full git log is never loaded into memory as a bulk string. On a repo with
10k commits the old path double-copied ~500 KB ([]byte→string→[]string);
now each line is processed in-place from a 64 KB ring buffer.

Also switch from TrimSpace to bytes.TrimRight("\r") — precise, no leading
space scan — and fix BenchmarkCoChangePipelineSimulated's pairs map hint
from commits×files (20k) to files*(files-1)/2 (190), the actual unique
pair ceiling.

Author: SimplyLiz

internal/perf/analyzer.go

@@ -1,6 +1,8 @@
 package perf
 
 import (
+	"bufio"
+	"bytes"
 	"context"
 	"fmt"
 	"log/slog"
@@ -240,11 +242,14 @@ func (a *Analyzer) buildCoChangePairs(ctx context.Context, since time.Time, scop
 	cmd := exec.CommandContext(ctx, "git", args...)
 	cmd.Dir = a.repoRoot
 
-	out, err := cmd.Output()
+	var stderrBuf bytes.Buffer
+	cmd.Stderr = &stderrBuf
+
+	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok && len(exitErr.Stderr) > 0 {
-			return nil, nil, fmt.Errorf("git log: %s", exitErr.Stderr)
-		}
+		return nil, nil, fmt.Errorf("git log pipe: %w", err)
+	}
+	if err := cmd.Start(); err != nil {
 		return nil, nil, fmt.Errorf("git log: %w", err)
 	}
 
@@ -255,22 +260,35 @@ func (a *Analyzer) buildCoChangePairs(ctx context.Context, since time.Time, scop
 	seen := make(map[string]bool, 32)
 	var currentFiles []string
 
-	// Parse output: groups of files per commit, separated by blank lines.
-	for _, line := range strings.Split(string(out), "\n") {
-		line = strings.TrimSpace(line)
-		if strings.HasPrefix(line, "COMMIT ") {
-			// Flush previous group.
+	// Stream git output line by line — avoids loading the full log into memory
+	// and copying it to a string before splitting.
+	commitPrefix := []byte("COMMIT ")
+	scanner := bufio.NewScanner(stdout)
+	for scanner.Scan() {
+		b := bytes.TrimRight(scanner.Bytes(), "\r")
+		if bytes.HasPrefix(b, commitPrefix) {
 			a.recordCommit(currentFiles, pairCounts, fileTotals, seen)
 			currentFiles = currentFiles[:0]
 			continue
 		}
-		if line == "" {
+		if len(b) == 0 {
 			continue
 		}
-		currentFiles = append(currentFiles, line)
+		currentFiles = append(currentFiles, string(b))
+	}
+	if scanErr := scanner.Err(); scanErr != nil {
+		_ = cmd.Wait()
+		return nil, nil, fmt.Errorf("reading git log: %w", scanErr)
 	}
 	a.recordCommit(currentFiles, pairCounts, fileTotals, seen)
 
+	if err := cmd.Wait(); err != nil {
+		if s := stderrBuf.String(); s != "" {
+			return nil, nil, fmt.Errorf("git log: %s", s)
+		}
+		return nil, nil, fmt.Errorf("git log: %w", err)
+	}
+
 	return pairCounts, fileTotals, nil
 }
 

internal/perf/perf_bench_test.go

@@ -39,10 +39,11 @@ import (
 //   correlationFilter/~20kpairs: ~372 µs/op,      0 B/op,   0 allocs/op
 //
 // Notable: recordCommit is O(files²) per commit — the dominant cost on repos
-// with large commits (fmt sweeps, mass renames). The seen map is now allocated
-// once in buildCoChangePairs and reused across commits (range-delete to clear),
-// reducing CoChangePipeline allocs by ~97% at 1k commits. The ignore filter
-// cuts pairing work by dropping testdata/vendor before O(n²).
+// with large commits (fmt sweeps, mass renames). The seen map is allocated once
+// in buildCoChangePairs and reused across commits (range-delete to clear),
+// reducing CoChangePipeline allocs by ~97% at 1k commits. git output is parsed
+// via bufio.Scanner to avoid loading the full log into memory before processing.
+// The ignore filter cuts pairing work by dropping testdata/vendor before O(n²).
 //
 // Use benchstat for before/after comparison:
 //   go test -bench=. -benchmem -count=6 -run=^$ ./internal/perf > before.txt
@@ -162,7 +163,7 @@ func BenchmarkCoChangePipelineSimulated(b *testing.B) {
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
-				pairs := make(map[filePair]int, sc.commits*sc.files)
+				pairs := make(map[filePair]int, sc.files*(sc.files-1)/2)
 				totals := make(map[string]int, sc.files*2)
 				seen := make(map[string]bool, sc.files)
 				for _, batch := range batches {