fix: skip git-filter-repo header line in ParseCommitMap

The commit-map file produced by git-filter-repo starts with an
'old new' header line. The new SHA length validation rejects it.
Skip the header when it appears on the first line.

perf(commitremap): hex lookup table and byte-level sliding window

Replace branch-heavy isHexByte with a [256]bool lookup table for
branchless hex byte validation. Replace JSON-walk replaceSHA with
byte-level replaceSHABytes sliding window that finds and replaces
SHAs everywhere in file content (URLs, markdown, composite strings).

Remove old replaceSHA function. Add commitMapSHALen validation,
benchmark suite, and updated tests.

refactor(bench): migrate benchmarks to b.Loop() (Go 1.24+)

- Replace for i := 0; i < b.N; i++ with b.Loop() in all 5 benchmarks
- Fix dead-code elimination risk in BenchmarkIsHexByte
- Move make+copy setup outside timed loop in BenchmarkReplaceSHABytes
- Remove unnecessary b.ResetTimer() calls (b.Loop auto-excludes setup)

Author: pmartindev

pkg/commitremap/benchmark_test.go

@@ -0,0 +1,225 @@
+package commitremap
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+// generateCommitMap creates a commit map with n entries of 40-char hex SHAs.
+func generateCommitMap(n int) map[string]string {
+	m := make(map[string]string, n)
+	buf := make([]byte, 20) // 20 bytes = 40 hex chars
+	for i := 0; i < n; i++ {
+		rand.Read(buf)
+		old := hex.EncodeToString(buf)
+		rand.Read(buf)
+		new_ := hex.EncodeToString(buf)
+		m[old] = new_
+	}
+	return m
+}
+
+// generateJSONWithSHAs creates a JSON byte slice containing numObjects objects,
+// each with shaFields fields containing SHAs from the commit map.
+// hitRate controls what fraction of SHAs are in the commit map (0.0-1.0).
+func generateJSONWithSHAs(commitMap map[string]string, numObjects, shaFields int, hitRate float64) []byte {
+	// Collect some real keys for hits
+	keys := make([]string, 0, len(commitMap))
+	for k := range commitMap {
+		keys = append(keys, k)
+		if len(keys) >= numObjects*shaFields {
+			break
+		}
+	}
+
+	buf := make([]byte, 20)
+	objects := make([]map[string]interface{}, numObjects)
+	hitCount := int(float64(numObjects*shaFields) * hitRate)
+	idx := 0
+	for i := 0; i < numObjects; i++ {
+		obj := map[string]interface{}{
+			"id":         i,
+			"created_at": "2024-01-15T10:30:00Z",
+			"url":        fmt.Sprintf("https://github.com/org/repo/pull/%d", i),
+		}
+		for f := 0; f < shaFields; f++ {
+			fieldName := fmt.Sprintf("sha_%d", f)
+			if idx < hitCount && len(keys) > 0 {
+				obj[fieldName] = keys[idx%len(keys)]
+			} else {
+				rand.Read(buf)
+				obj[fieldName] = hex.EncodeToString(buf)
+			}
+			idx++
+		}
+		objects[i] = obj
+	}
+
+	data, _ := json.Marshal(objects)
+	return data
+}
+
+// writeJSONFixtureFiles creates numFiles JSON files in dir, each containing
+// numObjects objects with SHA fields.
+func writeJSONFixtureFiles(tb testing.TB, dir string, prefix string, numFiles, numObjects int, commitMap map[string]string) {
+	tb.Helper()
+	for i := 0; i < numFiles; i++ {
+		name := fmt.Sprintf("%s_%06d.json", prefix, i+1)
+		data := generateJSONWithSHAs(commitMap, numObjects, 3, 0.5)
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0644); err != nil {
+			tb.Fatal(err)
+		}
+	}
+}
+
+// ── Benchmarks ───────────────────────────────────────────────────────────────
+
+// BenchmarkReplaceSHABytes measures the core byte-sliding window replacement.
+// This is the innermost hot loop — called once per metadata file.
+func BenchmarkReplaceSHABytes(b *testing.B) {
+	sizes := []struct {
+		name       string
+		mapSize    int
+		jsonObjs   int
+		shaFields  int
+	}{
+		{"small-map/small-json", 100, 50, 2},
+		{"large-map/small-json", 1_000_000, 50, 2},
+		{"large-map/medium-json", 1_000_000, 500, 3},
+		{"large-map/large-json", 1_000_000, 5000, 3},
+		{"snowflake-scale", 1_834_000, 1000, 4},
+	}
+
+	for _, s := range sizes {
+		b.Run(s.name, func(b *testing.B) {
+			commitMap := generateCommitMap(s.mapSize)
+			data := generateJSONWithSHAs(commitMap, s.jsonObjs, s.shaFields, 0.5)
+			shaLen := 40
+
+			// Pre-allocate a working buffer to avoid measuring make+copy overhead
+			input := make([]byte, len(data))
+			b.SetBytes(int64(len(data)))
+			for b.Loop() {
+				copy(input, data)
+				replaceSHABytes(input, commitMap, shaLen)
+			}
+		})
+	}
+}
+
+// BenchmarkReplaceSHABytes_NoHits measures scanning overhead when no SHAs match.
+func BenchmarkReplaceSHABytes_NoHits(b *testing.B) {
+	commitMap := generateCommitMap(1_834_000)
+	data := generateJSONWithSHAs(commitMap, 1000, 4, 0.0)
+	differentMap := generateCommitMap(1_834_000)
+	shaLen := 40
+
+	input := make([]byte, len(data))
+	b.SetBytes(int64(len(data)))
+	for b.Loop() {
+		copy(input, data)
+		replaceSHABytes(input, differentMap, shaLen)
+	}
+}
+
+// BenchmarkUpdateMetadataFile measures single-file remap (read + replace + write).
+func BenchmarkUpdateMetadataFile(b *testing.B) {
+	commitMap := generateCommitMap(1_834_000)
+	shaLen := 40
+	data := generateJSONWithSHAs(commitMap, 500, 3, 0.5)
+
+	dir := b.TempDir()
+	filePath := filepath.Join(dir, "test_000001.json")
+
+	b.SetBytes(int64(len(data)))
+	for b.Loop() {
+		os.WriteFile(filePath, data, 0644)
+		updateMetadataFile(filePath, commitMap, shaLen)
+	}
+}
+
+// BenchmarkParseCommitMap measures parsing a commit-map file.
+func BenchmarkParseCommitMap(b *testing.B) {
+	sizes := []struct {
+		name string
+		n    int
+	}{
+		{"1K", 1_000},
+		{"100K", 100_000},
+		{"1M", 1_000_000},
+		{"1.8M", 1_834_000},
+	}
+
+	for _, s := range sizes {
+		b.Run(s.name, func(b *testing.B) {
+			commitMap := generateCommitMap(s.n)
+			dir := b.TempDir()
+			filePath := filepath.Join(dir, "commit-map")
+
+			// Write commit-map file
+			f, _ := os.Create(filePath)
+			fmt.Fprintln(f, "old new")
+			for old, new_ := range commitMap {
+				fmt.Fprintf(f, "%s %s\n", old, new_)
+			}
+			f.Close()
+
+			fi, _ := os.Stat(filePath)
+			b.SetBytes(fi.Size())
+			for b.Loop() {
+				ParseCommitMap(filePath)
+			}
+		})
+	}
+}
+
+// BenchmarkProcessFiles measures the full parallel pipeline.
+func BenchmarkProcessFiles(b *testing.B) {
+	configs := []struct {
+		name       string
+		mapSize    int
+		numFiles   int
+		objPerFile int
+		workers    int
+	}{
+		{"10-files/8-workers", 100_000, 10, 200, 8},
+		{"100-files/8-workers", 100_000, 100, 200, 8},
+		{"100-files/16-workers", 100_000, 100, 200, 16},
+	}
+
+	for _, c := range configs {
+		b.Run(c.name, func(b *testing.B) {
+			commitMap := generateCommitMap(c.mapSize)
+
+			// Create fixture dir once
+			baseDir := b.TempDir()
+			writeJSONFixtureFiles(b, baseDir, "pull_requests", c.numFiles, c.objPerFile, commitMap)
+
+			b.ResetTimer()
+			for b.Loop() {
+				b.StopTimer()
+				writeJSONFixtureFiles(b, baseDir, "pull_requests", c.numFiles, c.objPerFile, commitMap)
+				b.StartTimer()
+
+				ProcessFiles(baseDir, []string{"pull_requests"}, commitMap, c.workers)
+			}
+		})
+	}
+}
+
+// BenchmarkIsHexByte measures the hex byte check (called per byte in the hot loop).
+func BenchmarkIsHexByte(b *testing.B) {
+	inputs := []byte("0123456789abcdefABCDEF!@#$%^&*()ghijklmnopqrstuvwxyz")
+	for b.Loop() {
+		for _, c := range inputs {
+			isHexByte(c)
+		}
+	}
+}

pkg/commitremap/commitremap.go

@@ -40,7 +40,7 @@ func ParseCommitMap(filePath string) (map[string]string, error) {
 		return nil, fmt.Errorf("reading commit map %s: %w", filePath, err)
 	}
 
-	for _, line := range strings.Split(string(content), "\n") {
+	for i, line := range strings.Split(string(content), "\n") {
 		if strings.TrimSpace(line) == "" {
 			continue
 		}
@@ -51,6 +51,11 @@ func ParseCommitMap(filePath string) (map[string]string, error) {
 			return nil, fmt.Errorf("invalid commit map line: %w", lineErr)
 		}
 
+		// Skip the header line produced by git-filter-repo ("old new")
+		if i == 0 && fields[0] == "old" && fields[1] == "new" {
+			continue
+		}
+
 		commitMap[fields[0]] = fields[1]
 	}
 
@@ -149,9 +154,21 @@ func updateMetadataFile(filePath string, commitMap map[string]string, shaLen int
 	return count, nil
 }
 
+// hexTable is a branchless lookup table for valid hex bytes.
+// A single array index replaces the 6-comparison branch chain in isHexByte,
+// improving throughput in the per-byte hot loop.
+var hexTable [256]bool
+
+func init() {
+	for _, b := range []byte("0123456789abcdefABCDEF") {
+		hexTable[b] = true
+	}
+}
+
 // isHexByte reports whether b is a valid hexadecimal byte (0-9, a-f, A-F).
+// Uses a precomputed lookup table for branchless evaluation.
 func isHexByte(b byte) bool {
-	return (b >= '0' && b <= '9') || (b >= 'a' && b <= 'f') || (b >= 'A' && b <= 'F')
+	return hexTable[b]
 }
 
 // commitMapSHALen returns the SHA length common to every key in commitMap.
@@ -182,8 +199,9 @@ func commitMapSHALen(commitMap map[string]string) (int, error) {
 //  2. When a non-hex byte is hit, reset the counter — no SHA can span it.
 //  3. Once we have shaLen consecutive hex bytes, extract that window and
 //     look it up in commitMap.
-//  4. On match: replace in-place, reset counter to 0. The next window
-//     starts fresh from the byte after the replacement.
+//  4. On match: replace in-place, skip past the replaced bytes. The next
+//     window starts fresh from the byte after the replacement, avoiding
+//     re-scanning the bytes we just wrote.
 //  5. On no match: keep going. The counter grows past shaLen so the
 //     window slides forward by one byte each step, checking every
 //     overlapping shaLen-sized substring. For example with shaLen=40,
@@ -211,8 +229,12 @@ func replaceSHABytes(data []byte, commitMap map[string]string, shaLen int) ([]by
 			if newSHA, ok := commitMap[candidate]; ok {
 				copy(data[start:i+1], newSHA)
 				count++
-				// Reset so the next window starts after the replacement,
-				// avoiding re-matching bytes we just wrote.
+				// Skip past the replaced bytes. Since we just wrote shaLen
+				// bytes, the next possible SHA starts at i+1. Setting
+				// consecutiveHex to 0 means the loop will begin counting
+				// fresh from the next byte without re-scanning the
+				// replacement. The loop increment (i++) moves us to i+1
+				// automatically.
 				consecutiveHex = 0
 			}
 			// If no match, consecutiveHex keeps growing and the window

pkg/commitremap/commitremap_test.go

@@ -91,6 +91,33 @@ func TestParseCommitMap(t *testing.T) {
 			content:     "oldSHA1 newSHA1\noldSHA2 newSHA2 extra\noldSHA3 newSHA3",
 			errContains: "oldSHA2 newSHA2 extra",
 		},
+		{
+			name: "skips git-filter-repo header line",
+			content: "old new\n" +
+				"abc123 def456\n" +
+				"ghi789 jkl012",
+			expected: map[string]string{
+				"abc123": "def456",
+				"ghi789": "jkl012",
+			},
+		},
+		{
+			name: "header with trailing CRLF",
+			content: "old new\r\n" +
+				"abc123 def456\r\n",
+			expected: map[string]string{
+				"abc123": "def456",
+			},
+		},
+		{
+			name: "old new as data when not on first line",
+			content: "abc123 def456\n" +
+				"old new",
+			expected: map[string]string{
+				"abc123": "def456",
+				"old":    "new",
+			},
+		},
 	}
 
 	for _, tt := range tests {