fix: apply golangci-lint staticcheck autofixes (#45)

Patel230 · web-flow · commit 21f46e1d58fb · 2026-06-02T10:07:51.000+05:30
diff --git a/advisor.go b/advisor.go
@@ -576,8 +576,8 @@ func (ca *CompressionAdvisor) FormatAdvice() string {
 	var sb strings.Builder
 	sb.WriteString("Compression Advisor:\n")
 	sb.WriteString(strings.Repeat("─", 35) + "\n")
-	sb.WriteString(fmt.Sprintf("Your sessions use avg %sK tokens/session.\n", formatK(avgPerSession)))
-	sb.WriteString(fmt.Sprintf("With optimal compression: ~%sK tokens (%.0f%% savings)\n", formatK(optimalPerSession), savingsPercent))
+	fmt.Fprintf(&sb, "Your sessions use avg %sK tokens/session.\n", formatK(avgPerSession))
+	fmt.Fprintf(&sb, "With optimal compression: ~%sK tokens (%.0f%% savings)\n", formatK(optimalPerSession), savingsPercent)
 	sb.WriteString("\n")
 	sb.WriteString("By content type:\n")
 
@@ -599,9 +599,9 @@ func (ca *CompressionAdvisor) FormatAdvice() string {
 	for _, ts := range typeOrder {
 		if _, present := typeStats[ts.ct]; present {
 			if ts.note != "" {
-				sb.WriteString(fmt.Sprintf("  %-16s %s (%s)\n", ts.label+":", ts.mode, ts.note))
+				fmt.Fprintf(&sb, "  %-16s %s (%s)\n", ts.label+":", ts.mode, ts.note)
 			} else {
-				sb.WriteString(fmt.Sprintf("  %-16s %s (avg %.0f%% savings)\n", ts.label+":", ts.mode, ts.savings*100))
+				fmt.Fprintf(&sb, "  %-16s %s (avg %.0f%% savings)\n", ts.label+":", ts.mode, ts.savings*100)
 			}
 		}
 	}
@@ -614,7 +614,7 @@ func (ca *CompressionAdvisor) FormatAdvice() string {
 		if i >= 3 {
 			break
 		}
-		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, rec))
+		fmt.Fprintf(&sb, "%d. %s\n", i+1, rec)
 	}
 
 	return sb.String()
diff --git a/format.go b/format.go
@@ -35,17 +35,17 @@ func formatNumber(n int) string {
 func FormatStats(stats Stats) string {
 	var b strings.Builder
 
-	b.WriteString(fmt.Sprintf("Tokens: %s → %s (%.1f%% reduction)\n",
+	fmt.Fprintf(&b, "Tokens: %s → %s (%.1f%% reduction)\n",
 		formatNumber(stats.OriginalTokens),
 		formatNumber(stats.FinalTokens),
-		stats.ReductionPercent))
+		stats.ReductionPercent)
 
-	b.WriteString(fmt.Sprintf("Saved: %s tokens", formatNumber(stats.TokensSaved)))
+	fmt.Fprintf(&b, "Saved: %s tokens", formatNumber(stats.TokensSaved))
 
 	if stats.Model != "" {
 		costStr := FormatCostSavings(stats, stats.Model)
 		if costStr != "" {
-			b.WriteString(fmt.Sprintf(" | %s", costStr))
+			fmt.Fprintf(&b, " | %s", costStr)
 		}
 	}
 
diff --git a/internal/filter/cache_breakpoint.go b/internal/filter/cache_breakpoint.go
@@ -52,7 +52,7 @@ func (f *CacheBreakpointFilter) Filter(input string) string {
 		}
 
 		if score >= 0.7 && nextScore < 0.5 {
-			result.WriteString(fmt.Sprintf("\n%s\n", CacheBreakMarker))
+			fmt.Fprintf(&result, "\n%s\n", CacheBreakMarker)
 			breakpoints++
 			lastBreakAt = tokenEstimate
 		}
diff --git a/internal/filter/compaction.go b/internal/filter/compaction.go
@@ -563,7 +563,7 @@ func (c *CompactionLayer) buildCompactionPrompt(snapshot *StateSnapshot, turns [
 		if len(content) > 200 {
 			content = content[:200] + "..."
 		}
-		sb.WriteString(fmt.Sprintf("[%s]: %s\n", turn.Role, content))
+		fmt.Fprintf(&sb, "[%s]: %s\n", turn.Role, content)
 	}
 
 	return sb.String()
diff --git a/internal/filter/crunch_bench.go b/internal/filter/crunch_bench.go
@@ -275,15 +275,15 @@ func (cb *CrunchBench) FormatReport(report *BenchmarkReport) string {
 	sb.WriteString("╔══════════════════════════════════════════════════════════════════╗\n")
 	sb.WriteString("║              CrunchBench - Compression Benchmark Report          ║\n")
 	sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
-	sb.WriteString(fmt.Sprintf("║ Timestamp: %s\n", report.Timestamp.Format("2006-01-02 15:04:05")))
-	sb.WriteString(fmt.Sprintf("║ Tests: %d passed, %d failed, %d total\n", report.Passed, report.Failed, report.TotalTests))
+	fmt.Fprintf(&sb, "║ Timestamp: %s\n", report.Timestamp.Format("2006-01-02 15:04:05"))
+	fmt.Fprintf(&sb, "║ Tests: %d passed, %d failed, %d total\n", report.Passed, report.Failed, report.TotalTests)
 	sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
 	sb.WriteString("║ Aggregate Statistics:\n")
-	sb.WriteString(fmt.Sprintf("║   Avg Compression: %.2f%% (std: %.2f%%)\n", report.OverallStats.AvgCompression, report.OverallStats.StdDevCompression))
-	sb.WriteString(fmt.Sprintf("║   Range: %.2f%% - %.2f%%\n", report.OverallStats.MinCompression, report.OverallStats.MaxCompression))
-	sb.WriteString(fmt.Sprintf("║   Avg Latency: %.2f μs/token\n", report.OverallStats.AvgLatency))
-	sb.WriteString(fmt.Sprintf("║   Avg Quality: %.2f\n", report.OverallStats.AvgQuality))
-	sb.WriteString(fmt.Sprintf("║   Total Time: %v\n", report.OverallStats.TotalTime))
+	fmt.Fprintf(&sb, "║   Avg Compression: %.2f%% (std: %.2f%%)\n", report.OverallStats.AvgCompression, report.OverallStats.StdDevCompression)
+	fmt.Fprintf(&sb, "║   Range: %.2f%% - %.2f%%\n", report.OverallStats.MinCompression, report.OverallStats.MaxCompression)
+	fmt.Fprintf(&sb, "║   Avg Latency: %.2f μs/token\n", report.OverallStats.AvgLatency)
+	fmt.Fprintf(&sb, "║   Avg Quality: %.2f\n", report.OverallStats.AvgQuality)
+	fmt.Fprintf(&sb, "║   Total Time: %v\n", report.OverallStats.TotalTime)
 	sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
 	sb.WriteString("║ Per-Test Results:\n")
 
@@ -292,15 +292,15 @@ func (cb *CrunchBench) FormatReport(report *BenchmarkReport) string {
 		if r.QualityScore < 0.7 {
 			status = "⚠"
 		}
-		sb.WriteString(fmt.Sprintf("║ %s %-20s (%s): %.1f%% in %v [Q:%.2f]\n",
-			status, r.TestName, r.ContentType, r.ReductionPct, r.CompressionTime, r.QualityScore))
+		fmt.Fprintf(&sb, "║ %s %-20s (%s): %.1f%% in %v [Q:%.2f]\n",
+			status, r.TestName, r.ContentType, r.ReductionPct, r.CompressionTime, r.QualityScore)
 	}
 
 	if len(report.Recommendations) > 0 {
 		sb.WriteString("╠══════════════════════════════════════════════════════════════════╣\n")
 		sb.WriteString("║ Recommendations:\n")
 		for _, rec := range report.Recommendations {
-			sb.WriteString(fmt.Sprintf("║   • %s\n", rec))
+			fmt.Fprintf(&sb, "║   • %s\n", rec)
 		}
 	}
 
diff --git a/internal/filter/enhancements.go b/internal/filter/enhancements.go
@@ -101,7 +101,7 @@ func (hg *HeatmapGenerator) Output() string {
 	var sb strings.Builder
 	sb.WriteString("Compression Heatmap:\n")
 	for pos, ratio := range hg.data {
-		sb.WriteString(fmt.Sprintf("  pos %d: %.2f\n", pos, ratio))
+		fmt.Fprintf(&sb, "  pos %d: %.2f\n", pos, ratio)
 	}
 	return sb.String()
 }
diff --git a/internal/filter/file_read_modes.go b/internal/filter/file_read_modes.go
@@ -190,12 +190,12 @@ func ComputeDelta(old, new string) IncrementalDelta {
 // FormatDelta returns a human-readable delta string.
 func FormatDelta(delta IncrementalDelta) string {
 	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("Delta: +%d -%d (unchanged: %d)\n", len(delta.Added), len(delta.Removed), delta.Unchanged))
+	fmt.Fprintf(&sb, "Delta: +%d -%d (unchanged: %d)\n", len(delta.Added), len(delta.Removed), delta.Unchanged)
 	for _, line := range delta.Added {
-		sb.WriteString(fmt.Sprintf("+ %s\n", line))
+		fmt.Fprintf(&sb, "+ %s\n", line)
 	}
 	for _, line := range delta.Removed {
-		sb.WriteString(fmt.Sprintf("- %s\n", line))
+		fmt.Fprintf(&sb, "- %s\n", line)
 	}
 	return sb.String()
 }
diff --git a/internal/filter/pipeline_stats.go b/internal/filter/pipeline_stats.go
@@ -12,9 +12,9 @@ func (s *PipelineStats) String() string {
 	sb.WriteString("╔════════════════════════════════════════════════════╗\n")
 	sb.WriteString("║         Tok 20-Layer Compression Stats          ║\n")
 	sb.WriteString("╠════════════════════════════════════════════════════╣\n")
-	sb.WriteString(fmt.Sprintf("║ Original:  %6d tokens                         ║\n", s.OriginalTokens))
-	sb.WriteString(fmt.Sprintf("║ Final:     %6d tokens                         ║\n", s.FinalTokens))
-	sb.WriteString(fmt.Sprintf("║ Saved:     %6d tokens (%.1f%%)                 ║\n", s.TotalSaved, s.ReductionPercent))
+	fmt.Fprintf(&sb, "║ Original:  %6d tokens                         ║\n", s.OriginalTokens)
+	fmt.Fprintf(&sb, "║ Final:     %6d tokens                         ║\n", s.FinalTokens)
+	fmt.Fprintf(&sb, "║ Saved:     %6d tokens (%.1f%%)                 ║\n", s.TotalSaved, s.ReductionPercent)
 	sb.WriteString("╠════════════════════════════════════════════════════╣\n")
 	sb.WriteString("║ Layer Breakdown:                                   ║\n")
 
@@ -28,7 +28,7 @@ func (s *PipelineStats) String() string {
 
 	for _, layer := range layerOrder {
 		if stat, ok := s.LayerStats[layer]; ok && stat.TokensSaved > 0 {
-			sb.WriteString(fmt.Sprintf("║   %-20s: %6d tokens saved     ║\n", layer, stat.TokensSaved))
+			fmt.Fprintf(&sb, "║   %-20s: %6d tokens saved     ║\n", layer, stat.TokensSaved)
 		}
 	}
 
diff --git a/internal/filter/sketch_store.go b/internal/filter/sketch_store.go
@@ -410,13 +410,11 @@ func (f *SketchStoreFilter) ExportSketches() ([]byte, error) {
 	var buf strings.Builder
 
 	for hash, sketch := range f.sketchCache.TokenSketches {
-		buf.WriteString(fmt.Sprintf(
-			"%s:%s:%d:%.2f\n",
+		fmt.Fprintf(&buf, "%s:%s:%d:%.2f\n",
 			hash,
 			sketch.ContentType,
 			sketch.TokenCount,
-			sketch.Importance,
-		))
+			sketch.Importance)
 	}
 
 	return []byte(buf.String()), nil
diff --git a/internal/filter/toml_filter.go b/internal/filter/toml_filter.go
@@ -397,7 +397,7 @@ func applyMaxLines(s string, maxLines int) string {
 		b.WriteString(lines[i])
 		b.WriteByte('\n')
 	}
-	b.WriteString(fmt.Sprintf("// ... (%d lines omitted) ...", dropped))
+	fmt.Fprintf(&b, "// ... (%d lines omitted) ...", dropped)
 	b.WriteByte('\n')
 	for i := len(lines) - half; i < len(lines); i++ {
 		b.WriteString(lines[i])
diff --git a/optimizer.go b/optimizer.go
@@ -395,14 +395,14 @@ func FormatResult(result *OptimizationResult) string {
 
 	var sb strings.Builder
 	sb.WriteString("Context Optimization:\n")
-	sb.WriteString(fmt.Sprintf("Budget: %s tokens\n", formatNumber(budget)))
+	fmt.Fprintf(&sb, "Budget: %s tokens\n", formatNumber(budget))
 	sb.WriteString("─────────────────────────\n")
 
 	keptTokens := 0
 	for _, b := range result.Kept {
 		keptTokens += b.Tokens
 	}
-	sb.WriteString(fmt.Sprintf("Kept (%d blocks):      %s tokens\n", len(result.Kept), formatNumber(keptTokens)))
+	fmt.Fprintf(&sb, "Kept (%d blocks):      %s tokens\n", len(result.Kept), formatNumber(keptTokens))
 
 	compressedTokens := 0
 	savedFromCompression := 0
@@ -413,18 +413,18 @@ func FormatResult(result *OptimizationResult) string {
 	if savedFromCompression < 0 {
 		savedFromCompression = 0
 	}
-	sb.WriteString(fmt.Sprintf("Compressed (%d blocks): %s tokens (saved %s)\n",
-		len(result.Compressed), formatNumber(compressedTokens), formatNumber(savedFromCompression)))
+	fmt.Fprintf(&sb, "Compressed (%d blocks): %s tokens (saved %s)\n",
+		len(result.Compressed), formatNumber(compressedTokens), formatNumber(savedFromCompression))
 
 	droppedTok := droppedTokens(result)
-	sb.WriteString(fmt.Sprintf("Dropped (%d blocks):    -%s tokens\n", len(result.Dropped), formatNumber(droppedTok)))
+	fmt.Fprintf(&sb, "Dropped (%d blocks):    -%s tokens\n", len(result.Dropped), formatNumber(droppedTok))
 
 	sb.WriteString("─────────────────────────\n")
 
 	pct := result.BudgetUsed * 100
-	sb.WriteString(fmt.Sprintf("Total: %s/%s (%.1f%% utilized)\n",
-		formatNumber(result.TotalTokens), formatNumber(budget), pct))
-	sb.WriteString(fmt.Sprintf("Savings: %s tokens from compression + drops\n", formatNumber(result.Savings)))
+	fmt.Fprintf(&sb, "Total: %s/%s (%.1f%% utilized)\n",
+		formatNumber(result.TotalTokens), formatNumber(budget), pct)
+	fmt.Fprintf(&sb, "Savings: %s tokens from compression + drops\n", formatNumber(result.Savings))
 
 	return sb.String()
 }
diff --git a/ratelimit.go b/ratelimit.go
@@ -353,26 +353,26 @@ func (u *UsageTracker) FormatSummary() string {
 
 	var sb strings.Builder
 	sb.WriteString("Token Usage:\n")
-	sb.WriteString(fmt.Sprintf("  Hourly:  %s / %s (%d%%) %s\n",
+	fmt.Fprintf(&sb, "  Hourly:  %s / %s (%d%%) %s\n",
 		formatNumber(summary.HourlyTokens),
 		formatNumber(u.HourlyLimit),
 		int(summary.HourlyPct),
-		FormatUsageBar(summary.HourlyPct, barWidth)))
-	sb.WriteString(fmt.Sprintf("  Daily:  %s / %s (%d%%) %s\n",
+		FormatUsageBar(summary.HourlyPct, barWidth))
+	fmt.Fprintf(&sb, "  Daily:  %s / %s (%d%%) %s\n",
 		formatNumber(summary.DailyTokens),
 		formatNumber(u.DailyLimit),
 		int(summary.DailyPct),
-		FormatUsageBar(summary.DailyPct, barWidth)))
-	sb.WriteString(fmt.Sprintf("  Session: %s / %s (%d%%) %s\n",
+		FormatUsageBar(summary.DailyPct, barWidth))
+	fmt.Fprintf(&sb, "  Session: %s / %s (%d%%) %s\n",
 		formatNumber(summary.SessionTokens),
 		formatNumber(u.SessionLimit),
 		int(sessionPct),
-		FormatUsageBar(sessionPct, barWidth)))
-	sb.WriteString(fmt.Sprintf("  Cost:   $%.2f / $%.2f (%d%%) %s",
+		FormatUsageBar(sessionPct, barWidth))
+	fmt.Fprintf(&sb, "  Cost:   $%.2f / $%.2f (%d%%) %s",
 		summary.DailyCostUSD,
 		u.CostLimitUSD,
 		int(costPct),
-		FormatUsageBar(costPct, barWidth)))
+		FormatUsageBar(costPct, barWidth))
 
 	return sb.String()
 }

Original file line number	Diff line number	Diff line change
`@@ -576,8 +576,8 @@ func (ca *CompressionAdvisor) FormatAdvice() string {`
`576`	`576`	`var sb strings.Builder`
`577`	`577`	`sb.WriteString("Compression Advisor:\n")`
`578`	`578`	`sb.WriteString(strings.Repeat("─", 35) + "\n")`
`579`		`- sb.WriteString(fmt.Sprintf("Your sessions use avg %sK tokens/session.\n", formatK(avgPerSession)))`
`580`		`- sb.WriteString(fmt.Sprintf("With optimal compression: ~%sK tokens (%.0f%% savings)\n", formatK(optimalPerSession), savingsPercent))`
	`579`	`+ fmt.Fprintf(&sb, "Your sessions use avg %sK tokens/session.\n", formatK(avgPerSession))`
	`580`	`+ fmt.Fprintf(&sb, "With optimal compression: ~%sK tokens (%.0f%% savings)\n", formatK(optimalPerSession), savingsPercent)`
`581`	`581`	`sb.WriteString("\n")`
`582`	`582`	`sb.WriteString("By content type:\n")`
`583`	`583`
`@@ -599,9 +599,9 @@ func (ca *CompressionAdvisor) FormatAdvice() string {`
`599`	`599`	`for _, ts := range typeOrder {`
`600`	`600`	`if _, present := typeStats[ts.ct]; present {`
`601`	`601`	`if ts.note != "" {`
`602`		`- sb.WriteString(fmt.Sprintf(" %-16s %s (%s)\n", ts.label+":", ts.mode, ts.note))`
	`602`	`+ fmt.Fprintf(&sb, " %-16s %s (%s)\n", ts.label+":", ts.mode, ts.note)`
`603`	`603`	`} else {`
`604`		`- sb.WriteString(fmt.Sprintf(" %-16s %s (avg %.0f%% savings)\n", ts.label+":", ts.mode, ts.savings*100))`
	`604`	`+ fmt.Fprintf(&sb, " %-16s %s (avg %.0f%% savings)\n", ts.label+":", ts.mode, ts.savings*100)`
`605`	`605`	`}`
`606`	`606`	`}`
`607`	`607`	`}`
`@@ -614,7 +614,7 @@ func (ca *CompressionAdvisor) FormatAdvice() string {`
`614`	`614`	`if i >= 3 {`
`615`	`615`	`break`
`616`	`616`	`}`
`617`		`- sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, rec))`
	`617`	`+ fmt.Fprintf(&sb, "%d. %s\n", i+1, rec)`
`618`	`618`	`}`
`619`	`619`
`620`	`620`	`return sb.String()`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ func (f *CacheBreakpointFilter) Filter(input string) string {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`if score >= 0.7 && nextScore < 0.5 {`
`55`		`- result.WriteString(fmt.Sprintf("\n%s\n", CacheBreakMarker))`
	`55`	`+ fmt.Fprintf(&result, "\n%s\n", CacheBreakMarker)`
`56`	`56`	`breakpoints++`
`57`	`57`	`lastBreakAt = tokenEstimate`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -563,7 +563,7 @@ func (c CompactionLayer) buildCompactionPrompt(snapshot StateSnapshot, turns [`
`563`	`563`	`if len(content) > 200 {`
`564`	`564`	`content = content[:200] + "..."`
`565`	`565`	`}`
`566`		`- sb.WriteString(fmt.Sprintf("[%s]: %s\n", turn.Role, content))`
	`566`	`+ fmt.Fprintf(&sb, "[%s]: %s\n", turn.Role, content)`
`567`	`567`	`}`
`568`	`568`
`569`	`569`	`return sb.String()`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ func (hg *HeatmapGenerator) Output() string {`
`101`	`101`	`var sb strings.Builder`
`102`	`102`	`sb.WriteString("Compression Heatmap:\n")`
`103`	`103`	`for pos, ratio := range hg.data {`
`104`		`- sb.WriteString(fmt.Sprintf(" pos %d: %.2f\n", pos, ratio))`
	`104`	`+ fmt.Fprintf(&sb, " pos %d: %.2f\n", pos, ratio)`
`105`	`105`	`}`
`106`	`106`	`return sb.String()`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -190,12 +190,12 @@ func ComputeDelta(old, new string) IncrementalDelta {`
`190`	`190`	`// FormatDelta returns a human-readable delta string.`
`191`	`191`	`func FormatDelta(delta IncrementalDelta) string {`
`192`	`192`	`var sb strings.Builder`
`193`		`- sb.WriteString(fmt.Sprintf("Delta: +%d -%d (unchanged: %d)\n", len(delta.Added), len(delta.Removed), delta.Unchanged))`
	`193`	`+ fmt.Fprintf(&sb, "Delta: +%d -%d (unchanged: %d)\n", len(delta.Added), len(delta.Removed), delta.Unchanged)`
`194`	`194`	`for _, line := range delta.Added {`
`195`		`- sb.WriteString(fmt.Sprintf("+ %s\n", line))`
	`195`	`+ fmt.Fprintf(&sb, "+ %s\n", line)`
`196`	`196`	`}`
`197`	`197`	`for _, line := range delta.Removed {`
`198`		`- sb.WriteString(fmt.Sprintf("- %s\n", line))`
	`198`	`+ fmt.Fprintf(&sb, "- %s\n", line)`
`199`	`199`	`}`
`200`	`200`	`return sb.String()`
`201`	`201`	`}`
Original file line number	Diff line number	Diff line change
`@@ -397,7 +397,7 @@ func applyMaxLines(s string, maxLines int) string {`
`397`	`397`	`b.WriteString(lines[i])`
`398`	`398`	`b.WriteByte('\n')`
`399`	`399`	`}`
`400`		`- b.WriteString(fmt.Sprintf("// ... (%d lines omitted) ...", dropped))`
	`400`	`+ fmt.Fprintf(&b, "// ... (%d lines omitted) ...", dropped)`
`401`	`401`	`b.WriteByte('\n')`
`402`	`402`	`for i := len(lines) - half; i < len(lines); i++ {`
`403`	`403`	`b.WriteString(lines[i])`