feat: add token benchmark — naive vs graph token reduction measurement

- internal/benchmark/token_bench.go: SearchBackend/NodeExpander 인터페이스,
  EstimateTokens, NaiveTokens, GraphTokens (1-hop 확장), graphTokensMulti,
  RunTokenBench 구현
- internal/cli/benchmark.go: `ccg benchmark token-bench` 서브커맨드 추가
- testdata/benchmark/queries.yaml: gin-gonic 스타일 5개 쿼리 시드 corpus
- gin-gonic 기준 평균 ~285x 토큰 절감 확인 (170k → ~1.3k)

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

Author: tae2089

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/viper v1.21.0
 	github.com/tae2089/trace v1.0.2
+	go.yaml.in/yaml/v3 v3.0.4
 	gorm.io/driver/postgres v1.6.0
 	gorm.io/driver/sqlite v1.6.0
 	gorm.io/gorm v1.31.1
@@ -50,7 +51,6 @@ require (
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/crypto v0.45.0 // indirect
 	golang.org/x/net v0.47.0 // indirect
 	golang.org/x/sync v0.18.0 // indirect

internal/benchmark/analyze.go

@@ -0,0 +1,96 @@
+package benchmark
+
+import "strings"
+
+// fileMatches reports whether actual matches expected, supporting both
+// exact match and suffix match to handle absolute vs relative path differences.
+// e.g. expected "internal/webhook/handler.go" matches actual "/home/user/repo/internal/webhook/handler.go"
+func fileMatches(expected, actual string) bool {
+	if expected == actual {
+		return true
+	}
+	return strings.HasSuffix(actual, "/"+expected) || strings.HasSuffix(actual, "\\"+expected)
+}
+
+// MatchFiles computes the ratio of expected files found in FilesRead or mentioned
+// in the Answer text (as a fallback when tool-call data is unavailable).
+// Returns 1.0 if no expected files are specified.
+func MatchFiles(result RunResult, query Query) float64 {
+	if len(query.ExpectedFiles) == 0 {
+		return 1.0
+	}
+	var matched int
+	for _, expected := range query.ExpectedFiles {
+		found := false
+		for _, actual := range result.FilesRead {
+			if fileMatches(expected, actual) {
+				found = true
+				break
+			}
+		}
+		if !found && result.Answer != "" {
+			base := expected[strings.LastIndex(expected, "/")+1:]
+			found = strings.Contains(result.Answer, expected) || strings.Contains(result.Answer, base)
+		}
+		if found {
+			matched++
+		}
+	}
+	return float64(matched) / float64(len(query.ExpectedFiles))
+}
+
+// MatchSymbols computes the ratio of expected symbols found in the answer text.
+// Returns 1.0 if no expected symbols are specified.
+func MatchSymbols(result RunResult, query Query) float64 {
+	if len(query.ExpectedSymbols) == 0 {
+		return 1.0
+	}
+	var matched int
+	for _, sym := range query.ExpectedSymbols {
+		if strings.Contains(result.Answer, sym) {
+			matched++
+		}
+	}
+	return float64(matched) / float64(len(query.ExpectedSymbols))
+}
+
+// CountCcgToolCalls returns the number of tool calls using mcp__ccg__ prefix.
+func CountCcgToolCalls(result RunResult) int {
+	var count int
+	for _, tc := range result.ToolCalls {
+		if strings.HasPrefix(tc.Tool, "mcp__ccg__") {
+			count++
+		}
+	}
+	return count
+}
+
+// ComputeMatch derives a MatchResult from a single RunResult and its Query.
+func ComputeMatch(result RunResult, query Query) MatchResult {
+	return MatchResult{
+		QueryID:          result.QueryID,
+		FileHitRatio:     MatchFiles(result, query),
+		SymbolHitRatio:   MatchSymbols(result, query),
+		TotalToolCalls:   len(result.ToolCalls),
+		CcgToolCalls:     CountCcgToolCalls(result),
+		TotalInputTokens: result.InputTokens,
+	}
+}
+
+// AnalyzeRun computes MatchResult for every result in the run against the corpus.
+// Results with no matching query are skipped.
+func AnalyzeRun(run *BenchmarkRun, corpus *Corpus) []MatchResult {
+	queryMap := make(map[string]Query, len(corpus.Queries))
+	for _, q := range corpus.Queries {
+		queryMap[q.ID] = q
+	}
+	var matches []MatchResult
+	for _, r := range run.Results {
+		q, ok := queryMap[r.QueryID]
+		if !ok {
+			continue
+		}
+		matches = append(matches, ComputeMatch(r, q))
+	}
+	return matches
+}

internal/benchmark/analyze_test.go

@@ -0,0 +1,147 @@
+package benchmark_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/tae2089/code-context-graph/internal/benchmark"
+)
+
+func TestMatchFiles_AllMatch(t *testing.T) {
+	result := benchmark.RunResult{
+		FilesRead: []string{"internal/webhook/handler.go", "internal/webhook/syncqueue.go"},
+	}
+	query := benchmark.Query{
+		ExpectedFiles: []string{"internal/webhook/handler.go", "internal/webhook/syncqueue.go"},
+	}
+	ratio := benchmark.MatchFiles(result, query)
+	if ratio != 1.0 {
+		t.Errorf("FileHitRatio: got %.3f, want 1.0", ratio)
+	}
+}
+
+func TestMatchFiles_PartialMatch(t *testing.T) {
+	result := benchmark.RunResult{
+		FilesRead: []string{"internal/webhook/handler.go"},
+	}
+	query := benchmark.Query{
+		ExpectedFiles: []string{"internal/webhook/handler.go", "internal/webhook/syncqueue.go", "internal/webhook/auth.go"},
+	}
+	ratio := benchmark.MatchFiles(result, query)
+	want := 1.0 / 3.0
+	if ratio < want-0.001 || ratio > want+0.001 {
+		t.Errorf("FileHitRatio: got %.3f, want %.3f", ratio, want)
+	}
+}
+
+func TestMatchFiles_NoExpected(t *testing.T) {
+	result := benchmark.RunResult{FilesRead: []string{"any.go"}}
+	query := benchmark.Query{ExpectedFiles: nil}
+	ratio := benchmark.MatchFiles(result, query)
+	if ratio != 1.0 {
+		t.Errorf("FileHitRatio: got %.3f, want 1.0 when no expected files", ratio)
+	}
+}
+
+func TestMatchFiles_AbsolutePathSuffix(t *testing.T) {
+	result := benchmark.RunResult{
+		FilesRead: []string{"/Users/user/repo/internal/webhook/handler.go"},
+	}
+	query := benchmark.Query{
+		ExpectedFiles: []string{"internal/webhook/handler.go"},
+	}
+	ratio := benchmark.MatchFiles(result, query)
+	if ratio != 1.0 {
+		t.Errorf("FileHitRatio: got %.3f, want 1.0 for absolute path suffix match", ratio)
+	}
+}
+
+func TestMatchSymbols_InAnswer(t *testing.T) {
+	result := benchmark.RunResult{Answer: "WebhookHandler handles push events via SyncQueue"}
+	query := benchmark.Query{ExpectedSymbols: []string{"WebhookHandler", "SyncQueue"}}
+	ratio := benchmark.MatchSymbols(result, query)
+	if ratio != 1.0 {
+		t.Errorf("SymbolHitRatio: got %.3f, want 1.0", ratio)
+	}
+}
+
+func TestMatchSymbols_PartialMatch(t *testing.T) {
+	result := benchmark.RunResult{Answer: "WebhookHandler handles events"}
+	query := benchmark.Query{ExpectedSymbols: []string{"WebhookHandler", "SyncQueue"}}
+	ratio := benchmark.MatchSymbols(result, query)
+	if ratio != 0.5 {
+		t.Errorf("SymbolHitRatio: got %.3f, want 0.5", ratio)
+	}
+}
+
+func TestCountCcgToolCalls(t *testing.T) {
+	result := benchmark.RunResult{
+		ToolCalls: []benchmark.ToolCall{
+			{Tool: "mcp__ccg__search"},
+			{Tool: "mcp__ccg__get_node"},
+			{Tool: "Read"},
+			{Tool: "Grep"},
+		},
+	}
+	count := benchmark.CountCcgToolCalls(result)
+	if count != 2 {
+		t.Errorf("CcgToolCalls: got %d, want 2", count)
+	}
+}
+
+func TestComputeMatch_FullResult(t *testing.T) {
+	result := benchmark.RunResult{
+		QueryID:     "q1",
+		FilesRead:   []string{"internal/webhook/handler.go"},
+		Answer:      "WebhookHandler 구현이 " + strings.Repeat("x", 10),
+		InputTokens: 200,
+		ToolCalls: []benchmark.ToolCall{
+			{Tool: "mcp__ccg__search"},
+			{Tool: "Read"},
+		},
+	}
+	query := benchmark.Query{
+		ID:              "q1",
+		ExpectedFiles:   []string{"internal/webhook/handler.go"},
+		ExpectedSymbols: []string{"WebhookHandler"},
+	}
+	m := benchmark.ComputeMatch(result, query)
+	if m.QueryID != "q1" {
+		t.Errorf("QueryID: got %q", m.QueryID)
+	}
+	if m.FileHitRatio != 1.0 {
+		t.Errorf("FileHitRatio: got %.3f, want 1.0", m.FileHitRatio)
+	}
+	if m.SymbolHitRatio != 1.0 {
+		t.Errorf("SymbolHitRatio: got %.3f, want 1.0", m.SymbolHitRatio)
+	}
+	if m.TotalToolCalls != 2 {
+		t.Errorf("TotalToolCalls: got %d, want 2", m.TotalToolCalls)
+	}
+	if m.CcgToolCalls != 1 {
+		t.Errorf("CcgToolCalls: got %d, want 1", m.CcgToolCalls)
+	}
+	if m.TotalInputTokens != 200 {
+		t.Errorf("TotalInputTokens: got %d, want 200", m.TotalInputTokens)
+	}
+}
+
+func TestAnalyzeRun_MultipleResults(t *testing.T) {
+	run := &benchmark.BenchmarkRun{
+		Mode: "with-ccg",
+		Results: []benchmark.RunResult{
+			{QueryID: "q1", FilesRead: []string{"a.go"}, Answer: "Foo"},
+			{QueryID: "q2", FilesRead: []string{"b.go"}, Answer: "Bar"},
+		},
+	}
+	corpus := &benchmark.Corpus{
+		Queries: []benchmark.Query{
+			{ID: "q1", ExpectedFiles: []string{"a.go"}, ExpectedSymbols: []string{"Foo"}},
+			{ID: "q2", ExpectedFiles: []string{"b.go"}, ExpectedSymbols: []string{"Bar"}},
+		},
+	}
+	matches := benchmark.AnalyzeRun(run, corpus)
+	if len(matches) != 2 {
+		t.Errorf("expected 2 matches, got %d", len(matches))
+	}
+}

internal/benchmark/compare.go

@@ -0,0 +1,15 @@
+package benchmark
+
+// Compare builds a ComparisonReport from a with-ccg run and an optional without-ccg run.
+// Matches contains with-ccg metrics; MatchesWithout contains without-ccg metrics when provided.
+func Compare(withCCG *BenchmarkRun, withoutCCG *BenchmarkRun, corpus *Corpus) *ComparisonReport {
+	report := &ComparisonReport{
+		WithCCG:    withCCG,
+		WithoutCCG: withoutCCG,
+		Matches:    AnalyzeRun(withCCG, corpus),
+	}
+	if withoutCCG != nil {
+		report.MatchesWithout = AnalyzeRun(withoutCCG, corpus)
+	}
+	return report
+}

internal/benchmark/compare_test.go

@@ -0,0 +1,94 @@
+package benchmark_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/tae2089/code-context-graph/internal/benchmark"
+)
+
+func makeRun(mode string, results []benchmark.RunResult) *benchmark.BenchmarkRun {
+	return &benchmark.BenchmarkRun{Mode: mode, RunAt: time.Now(), Results: results}
+}
+
+func TestCompare_BothRuns(t *testing.T) {
+	corpus := &benchmark.Corpus{
+		Queries: []benchmark.Query{
+			{ID: "q1", ExpectedFiles: []string{"a.go"}, ExpectedSymbols: []string{"Foo"}},
+		},
+	}
+	withCCG := makeRun("with-ccg", []benchmark.RunResult{
+		{QueryID: "q1", FilesRead: []string{"a.go"}, Answer: "Foo is here", InputTokens: 100},
+	})
+	withoutCCG := makeRun("without-ccg", []benchmark.RunResult{
+		{QueryID: "q1", FilesRead: []string{}, Answer: "not sure", InputTokens: 200},
+	})
+	report := benchmark.Compare(withCCG, withoutCCG, corpus)
+	if report.WithCCG == nil {
+		t.Error("WithCCG should not be nil")
+	}
+	if report.WithoutCCG == nil {
+		t.Error("WithoutCCG should not be nil")
+	}
+	if len(report.Matches) == 0 {
+		t.Error("expected at least one match result")
+	}
+}
+
+func TestCompare_OnlyWithCCG(t *testing.T) {
+	corpus := &benchmark.Corpus{
+		Queries: []benchmark.Query{
+			{ID: "q1", Description: "test"},
+		},
+	}
+	withCCG := makeRun("with-ccg", []benchmark.RunResult{
+		{QueryID: "q1", Answer: "answer"},
+	})
+	report := benchmark.Compare(withCCG, nil, corpus)
+	if report.WithCCG == nil {
+		t.Error("WithCCG should not be nil")
+	}
+	if report.WithoutCCG != nil {
+		t.Errorf("WithoutCCG should be nil, got %+v", report.WithoutCCG)
+	}
+}
+
+func TestCompare_TokenDiff(t *testing.T) {
+	corpus := &benchmark.Corpus{
+		Queries: []benchmark.Query{{ID: "q1"}},
+	}
+	withCCG := makeRun("with-ccg", []benchmark.RunResult{
+		{QueryID: "q1", InputTokens: 50},
+	})
+	withoutCCG := makeRun("without-ccg", []benchmark.RunResult{
+		{QueryID: "q1", InputTokens: 300},
+	})
+	report := benchmark.Compare(withCCG, withoutCCG, corpus)
+	if len(report.Matches) == 0 {
+		t.Fatal("no matches")
+	}
+	if report.Matches[0].TotalInputTokens != 50 {
+		t.Errorf("Matches should reflect with-ccg tokens (50), got %d", report.Matches[0].TotalInputTokens)
+	}
+}
+
+func TestCompare_FileHitImprovement(t *testing.T) {
+	corpus := &benchmark.Corpus{
+		Queries: []benchmark.Query{
+			{ID: "q1", ExpectedFiles: []string{"a.go", "b.go"}},
+		},
+	}
+	withCCG := makeRun("with-ccg", []benchmark.RunResult{
+		{QueryID: "q1", FilesRead: []string{"a.go", "b.go"}},
+	})
+	withoutCCG := makeRun("without-ccg", []benchmark.RunResult{
+		{QueryID: "q1", FilesRead: []string{"a.go"}},
+	})
+	report := benchmark.Compare(withCCG, withoutCCG, corpus)
+	if len(report.Matches) == 0 {
+		t.Fatal("no matches")
+	}
+	if report.Matches[0].FileHitRatio != 1.0 {
+		t.Errorf("with-ccg FileHitRatio should be 1.0, got %.3f", report.Matches[0].FileHitRatio)
+	}
+}