⚡ Bolt: Optimize i18n KeyExtractor agent regex compilation and string slicing

.jules/bolt.md

@@ -1,3 +1,7 @@
+## 2024-10-24 - Avoid strings.Split for simple line parsing when performance matters
+**Learning:** Found several places where `strings.Split` is used on strings (e.g., `strings.Split(a.diff, "\n")` in `KeyExtractor`). When allocating many strings, `strings.Index` and manual slicing is faster and creates fewer allocations. The memory context mentions this specifically: "Performance convention: When parsing command output for specific markers (e.g., 'HEAD branch:'), prefer using 'strings.Index' and manual slicing over 'strings.Split' or 'strings.Scanner' to minimize allocations and processing time."
+**Action:** Replace `strings.Split` with manual slicing via `strings.Index` when processing potentially large strings like diffs.
+
 ## 2026-02-25 - [Go Regex Performance]
 **Learning:** Compiling regex inside a function that is called frequently causes significant performance degradation (re-compilation). In `internal/cli/i18n/agents.go`, moving regexes to package-level variables reduced allocations by ~75% and latency by ~37% for small diffs.
 **Action:** Ensure all static regex patterns are compiled using `regexp.MustCompile` at package level or in `init()`/`sync.Once`.

bench2_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+)
+
+var diff2 = strings.Repeat("+ t('hello')\n- ignored\n+ i18n.t(\"world\")\n", 100)
+
+func BenchmarkRegexCurrent(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		patterns := []*regexp.Regexp{
+			regexp.MustCompile(`(?:^|[^a-zA-Z0-9_])t\((?:'([^']+)'|"([^"]+)")\)`),
+			regexp.MustCompile(`i18n\.t\((?:'([^']+)'|"([^"]+)")\)`),
+			regexp.MustCompile(`\$t\((?:'([^']+)'|"([^"]+)")\)`),
+			regexp.MustCompile(`<T[^>]+key=(?:'([^']+)'|"([^"]+)")`),
+			regexp.MustCompile(`<T[^>]+keyName=(?:'([^']+)'|"([^"]+)")`),
+		}
+		for _, p := range patterns {
+			p.MatchString(diff2)
+		}
+	}
+}
+
+var globalPatterns2 = []*regexp.Regexp{
+	regexp.MustCompile(`(?:^|[^a-zA-Z0-9_])t\((?:'([^']+)'|"([^"]+)")\)`),
+	regexp.MustCompile(`i18n\.t\((?:'([^']+)'|"([^"]+)")\)`),
+	regexp.MustCompile(`\$t\((?:'([^']+)'|"([^"]+)")\)`),
+	regexp.MustCompile(`<T[^>]+key=(?:'([^']+)'|"([^"]+)")`),
+	regexp.MustCompile(`<T[^>]+keyName=(?:'([^']+)'|"([^"]+)")`),
+}
+
+func BenchmarkRegexOptimized(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, p := range globalPatterns2 {
+			p.MatchString(diff2)
+		}
+	}
+}

bench_test.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+)
+
+var diff = strings.Repeat("+ t('hello')\n- ignored\n+ i18n.t(\"world\")\n", 1000)
+
+var globalPatterns = []*regexp.Regexp{
+	regexp.MustCompile(`(?:^|[^a-zA-Z0-9_])t\((?:'([^']+)'|"([^"]+)")\)`),
+	regexp.MustCompile(`i18n\.t\((?:'([^']+)'|"([^"]+)")\)`),
+	regexp.MustCompile(`\$t\((?:'([^']+)'|"([^"]+)")\)`),
+	regexp.MustCompile(`<T[^>]+key=(?:'([^']+)'|"([^"]+)")`),
+	regexp.MustCompile(`<T[^>]+keyName=(?:'([^']+)'|"([^"]+)")`),
+}
+
+func BenchmarkCurrent(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		lines := strings.Split(diff, "\n")
+		patterns := []*regexp.Regexp{
+			regexp.MustCompile(`(?:^|[^a-zA-Z0-9_])t\((?:'([^']+)'|"([^"]+)")\)`),
+			regexp.MustCompile(`i18n\.t\((?:'([^']+)'|"([^"]+)")\)`),
+			regexp.MustCompile(`\$t\((?:'([^']+)'|"([^"]+)")\)`),
+			regexp.MustCompile(`<T[^>]+key=(?:'([^']+)'|"([^"]+)")`),
+			regexp.MustCompile(`<T[^>]+keyName=(?:'([^']+)'|"([^"]+)")`),
+		}
+
+		for _, line := range lines {
+			if !strings.HasPrefix(line, "+") {
+				continue
+			}
+			content := line[1:]
+			for _, pattern := range patterns {
+				pattern.FindAllStringSubmatch(content, -1)
+			}
+		}
+	}
+}
+
+func BenchmarkOptimized(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		remaining := diff
+		for len(remaining) > 0 {
+			var line string
+			idx := strings.IndexByte(remaining, '\n')
+			if idx >= 0 {
+				line = remaining[:idx]
+				remaining = remaining[idx+1:]
+			} else {
+				line = remaining
+				remaining = ""
+			}
+
+			if !strings.HasPrefix(line, "+") {
+				continue
+			}
+			content := line[1:]
+			for _, pattern := range globalPatterns {
+				pattern.FindAllStringSubmatch(content, -1)
+			}
+		}
+	}
+}

internal/cli/i18n/agents.go

@@ -61,17 +61,25 @@ func (a *KeyExtractor) WaitForResults() []string {
 
 func (a *KeyExtractor) Execute(input map[string]string) (string, error) {
 	var keys []I18nKey
-	lines := strings.Split(a.diff, "\n")
-
-	for _, line := range lines {
+	// Use strings.IndexByte and manual slicing instead of strings.Split to avoid allocating a large string slice.
+	remaining := a.diff
+	for len(remaining) > 0 {
+		var line string
+		idx := strings.IndexByte(remaining, '\n')
+		if idx >= 0 {
+			line = remaining[:idx]
+			remaining = remaining[idx+1:]
+		} else {
+			line = remaining
+			remaining = ""
+		}
 		// We only care about added lines
 		if !strings.HasPrefix(line, "+") {
 			continue
 		}
 
 		// Remove the "+" prefix
 		content := line[1:]
-
 		for _, pattern := range keyExtractorPatterns {
 			matches := pattern.FindAllStringSubmatch(content, -1)
 			for _, match := range matches {