chore: remove dead Analyze/PruneTree APIs, migrate tests to live paths (#22)

Two internal APIs were unused in production and exercised only by their own
tests:

- changes.Analyze (non-paged) + its private helpers sortRiskEntries /
  computeRiskScores / computeRiskCandidates. Production uses AnalyzePage. The
  8 test call-sites now go through a small analyzeAll helper backed by
  AnalyzePage (full window), so the risk-score / namespace / ordering coverage
  moves onto the live path instead of a dead parallel implementation.
- ragindex.PruneTree + pruneNode + their TestPruneTree_* tests — never used in
  production.

The pagination-ordering test was rewritten to pin concrete expected node IDs
(descending risk) rather than compare against AnalyzePage itself, keeping it a
real, non-tautological check (per review). ragindex.LoadIndex is kept — it
verifies live wikiindex builder output in tests.

No behavior change; -150 lines. Independently reviewed.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: tae2089

internal/analysis/changes/service.go

@@ -55,35 +55,6 @@ func New(db *gorm.DB, git GitClient) *Service {
 	return &Service{db: db, git: git}
 }
 
-// Analyze detects changed functions and calculates risk scores.
-// Called from review_changes and pre_merge_check MCP prompts.
-//
-// @param repoDir git repository root path
-// @param baseRef git base reference for diff comparison
-// @return risk entries with hunk count and risk score per changed function
-// @intent identify high-risk code changes before merge
-// @domainRule risk score equals hunk count multiplied by outgoing edge count plus one
-// @sideEffect executes git diff via GitClient
-// @see impact.Analyzer.ImpactRadius
-func (s *Service) Analyze(ctx context.Context, repoDir, baseRef string) ([]RiskEntry, error) {
-	hunksByFile, files, err := s.collectDiffHunks(ctx, repoDir, baseRef)
-	if err != nil || hunksByFile == nil {
-		return nil, err
-	}
-
-	hits, err := matchHunksToNodes(s.db, ctx, files, hunksByFile)
-	if err != nil || len(hits) == 0 {
-		return nil, err
-	}
-
-	risks, err := computeRiskScores(s.db, ctx, hits)
-	if err != nil {
-		return nil, err
-	}
-	sortRiskEntries(risks)
-	return risks, nil
-}
-
 // AnalyzePage detects changed functions and returns one bounded page of risk entries.
 // @intent bound handler response allocation while preserving the same sorted risk window that legacy Analyze would expose.
 // @domainRule pagination limits returned items, but compute cost still scales with scoring every changed node to preserve legacy ordering.
@@ -149,23 +120,6 @@ func (s *Service) changedNodeHits(ctx context.Context, repoDir, baseRef string)
 	return matchHunksToNodes(s.db, ctx, files, hunksByFile)
 }
 
-// sortRiskEntries orders entries deterministically for stable pagination windows.
-// @intent guarantee identical limit/offset slices regardless of map iteration order in computeRiskScores.
-func sortRiskEntries(entries []RiskEntry) {
-	sort.SliceStable(entries, func(i, j int) bool {
-		if entries[i].RiskScore != entries[j].RiskScore {
-			return entries[i].RiskScore > entries[j].RiskScore
-		}
-		if entries[i].Node.FilePath != entries[j].Node.FilePath {
-			return entries[i].Node.FilePath < entries[j].Node.FilePath
-		}
-		if entries[i].Node.StartLine != entries[j].Node.StartLine {
-			return entries[i].Node.StartLine < entries[j].Node.StartLine
-		}
-		return entries[i].Node.QualifiedName < entries[j].Node.QualifiedName
-	})
-}
-
 // sortNodesForChangeOrder orders changed nodes deterministically for downstream set consumers.
 // @intent prevent flow lookups from depending on database or map iteration order.
 func sortNodesForChangeOrder(nodes []model.Node) {
@@ -262,22 +216,6 @@ type riskCandidate struct {
 	riskScore float64
 }
 
-// computeRiskScores calculates risk for each hit node based on outgoing edge count.
-// @intent weight changed nodes by both diff overlap and graph connectivity to prioritize risky edits.
-func computeRiskScores(db *gorm.DB, ctx context.Context, hits map[uint]*hitInfo) ([]RiskEntry, error) {
-	candidates, err := computeRiskCandidates(db, ctx, hits)
-	if err != nil {
-		return nil, err
-	}
-	return riskCandidatesToEntries(candidates), nil
-}
-
-// computeRiskCandidates calculates sortable risk candidates for each hit node.
-// @intent allow paged callers to sort and slice before converting candidates into wire-facing risk entries.
-func computeRiskCandidates(db *gorm.DB, ctx context.Context, hits map[uint]*hitInfo) ([]riskCandidate, error) {
-	return computeTopRiskCandidates(db, ctx, hits, len(hits))
-}
-
 // selectTopRiskCandidates returns the best N risk candidates without materializing the full candidate slice.
 // @intent preserve AnalyzePage ordering while capping page-path memory and sort work to the requested window.
 func selectTopRiskCandidates(db *gorm.DB, ctx context.Context, hits map[uint]*hitInfo, limit int) ([]riskCandidate, error) {

internal/analysis/changes/service_test.go

@@ -89,7 +89,7 @@ func TestAnalyze_ChangedFunction(t *testing.T) {
 		hunks: []Hunk{{FilePath: "a.go", StartLine: 15, EndLine: 20}},
 	}
 	svc := New(db, git)
-	got, err := svc.Analyze(context.Background(), ".", "main")
+	got, err := analyzeAll(svc, context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -110,7 +110,7 @@ func TestAnalyze_NoOverlap(t *testing.T) {
 		hunks: []Hunk{{FilePath: "a.go", StartLine: 1, EndLine: 5}},
 	}
 	svc := New(db, git)
-	got, err := svc.Analyze(context.Background(), ".", "main")
+	got, err := analyzeAll(svc, context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -132,7 +132,7 @@ func TestAnalyze_MultipleHunks(t *testing.T) {
 		},
 	}
 	svc := New(db, git)
-	got, err := svc.Analyze(context.Background(), ".", "main")
+	got, err := analyzeAll(svc, context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -159,7 +159,7 @@ func TestAnalyze_RiskScoreCalculation(t *testing.T) {
 		},
 	}
 	svc := New(db, git)
-	got, err := svc.Analyze(context.Background(), ".", "main")
+	got, err := analyzeAll(svc, context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -177,7 +177,7 @@ func TestAnalyze_EmptyDiff(t *testing.T) {
 
 	git := &mockGit{files: nil, hunks: nil}
 	svc := New(db, git)
-	got, err := svc.Analyze(context.Background(), ".", "main")
+	got, err := analyzeAll(svc, context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -198,7 +198,7 @@ func TestAnalyze_RespectsNamespace(t *testing.T) {
 	svc := New(db, git)
 
 	ctxA := ctxns.WithNamespace(context.Background(), "ns-a")
-	got, err := svc.Analyze(ctxA, ".", "main")
+	got, err := analyzeAll(svc, ctxA)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -288,10 +288,9 @@ func TestAnalyzePage_PreservesAnalyzeOrderingForPagedConsumers(t *testing.T) {
 	}
 	svc := New(db, &mockGit{files: files, hunks: hunks})
 
-	legacy, err := svc.Analyze(context.Background(), ".", "main")
-	if err != nil {
-		t.Fatal(err)
-	}
+	// Node i has i outgoing edges, so risk increases with i; the full descending
+	// order is 4,3,2,1. The {Limit:2, Offset:1} window must therefore be [3, 2],
+	// pinned to concrete node IDs so the check is independent of AnalyzePage itself.
 	page, err := svc.AnalyzePage(context.Background(), ".", "main", paging.Request{Limit: 2, Offset: 1})
 	if err != nil {
 		t.Fatal(err)
@@ -300,10 +299,15 @@ func TestAnalyzePage_PreservesAnalyzeOrderingForPagedConsumers(t *testing.T) {
 	if len(page.Items) != 2 {
 		t.Fatalf("items = %d, want 2", len(page.Items))
 	}
+	if page.Items[0].Node.ID != 3 || page.Items[1].Node.ID != 2 {
+		t.Fatalf("window node IDs = [%d, %d], want [3, 2]", page.Items[0].Node.ID, page.Items[1].Node.ID)
+	}
+	if !(page.Items[0].RiskScore > page.Items[1].RiskScore) {
+		t.Fatalf("expected descending risk across the window, got %.1f then %.1f", page.Items[0].RiskScore, page.Items[1].RiskScore)
+	}
 	for i, item := range page.Items {
-		want := legacy[i+1]
-		if item.Node.ID != want.Node.ID || item.RiskScore != want.RiskScore || item.HunkCount != want.HunkCount {
-			t.Fatalf("page item %d = %+v, want legacy slice item %+v", i, item, want)
+		if item.HunkCount != 1 {
+			t.Fatalf("item %d HunkCount = %d, want 1", i, item.HunkCount)
 		}
 	}
 }
@@ -328,7 +332,7 @@ func TestAnalyzePage_MatchesAnalyzeAcrossRepresentativeWindows(t *testing.T) {
 	}
 	svc := New(db, &mockGit{files: files, hunks: hunks})
 
-	legacy, err := svc.Analyze(context.Background(), ".", "main")
+	legacy, err := analyzeAll(svc, context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -417,3 +421,10 @@ func TestAnalyzePage_OffsetBeyondTotalReturnsEmpty(t *testing.T) {
 		t.Fatal("has_more = true, want false")
 	}
 }
+
+// analyzeAll returns the full, unpaged risk-entry ordering via AnalyzePage,
+// used as the reference for verifying paged windows.
+func analyzeAll(svc *Service, ctx context.Context) ([]RiskEntry, error) {
+	page, err := svc.AnalyzePage(ctx, ".", "main", paging.Request{Limit: 500, Offset: 0})
+	return page.Items, err
+}

internal/ragindex/builder.go

@@ -196,44 +196,6 @@ func FindNode(root *TreeNode, id string) *TreeNode {
 	return nil
 }
 
-// PruneTree는 root 트리를 maxDepth 깊이까지만 포함한 새 트리를 반환한다.
-// maxDepth <= 0이면 전체 트리를 반환한다. 원본 트리는 변경하지 않는다.
-// depth 계산: root는 depth 0, root의 직계 자식은 depth 1.
-// @intent 대형 인덱스를 요약 응답에 맞게 깊이 제한된 복사본으로 축약한다.
-// @ensures 원본 트리는 수정되지 않는다.
-func PruneTree(root *TreeNode, maxDepth int) *TreeNode {
-	if root == nil {
-		return nil
-	}
-	return pruneNode(root, 0, maxDepth)
-}
-
-// pruneNode copies one subtree while enforcing the depth limit.
-// @intent PruneTree의 재귀 복사 작업을 깊이 기준으로 수행한다.
-// @return 자식이 제한된 새로운 TreeNode 복사본을 반환한다.
-func pruneNode(n *TreeNode, currentDepth, maxDepth int) *TreeNode {
-	copied := &TreeNode{
-		ID:          n.ID,
-		Label:       n.Label,
-		Kind:        n.Kind,
-		Summary:     n.Summary,
-		DocPath:     n.DocPath,
-		SearchText:  n.SearchText,
-		HasChildren: len(n.Children) > 0 || n.HasChildren,
-		FieldTexts:  n.FieldTexts,
-		Details:     n.Details,
-	}
-	if maxDepth <= 0 || currentDepth < maxDepth {
-		copied.Children = make([]*TreeNode, 0, len(n.Children))
-		for _, child := range n.Children {
-			copied.Children = append(copied.Children, pruneNode(child, currentDepth+1, maxDepth))
-		}
-	} else {
-		copied.Children = []*TreeNode{}
-	}
-	return copied
-}
-
 // LoadIndex reads a persisted Index (e.g. wiki-index.json) from disk.
 // @intent let the wiki index round-trip its written tree without the RAG-index builder.
 func LoadIndex(path string) (*Index, error) {

internal/ragindex/builder_test.go

@@ -34,63 +34,6 @@ func setupDB(t *testing.T) *gorm.DB {
 	return db
 }
 
-// TestPruneTree_Depth1: depth=1이면 root와 직계 자식만 반환, 손자 노드 없음.
-func TestPruneTree_Depth1(t *testing.T) {
-	root := &ragindex.TreeNode{
-		ID:    "root",
-		Label: "Root",
-		Children: []*ragindex.TreeNode{
-			{
-				ID:    "c1",
-				Label: "Community 1",
-				Children: []*ragindex.TreeNode{
-					{ID: "f1", Label: "file.go"},
-				},
-			},
-		},
-	}
-
-	result := ragindex.PruneTree(root, 1)
-	if len(result.Children) != 1 {
-		t.Fatalf("expected 1 child, got %d", len(result.Children))
-	}
-	if len(result.Children[0].Children) != 0 {
-		t.Fatalf("expected 0 grandchildren at depth=1, got %d", len(result.Children[0].Children))
-	}
-	// 원본 트리는 변경되지 않아야 함
-	if len(root.Children[0].Children) != 1 {
-		t.Fatal("PruneTree must not modify the original tree")
-	}
-}
-
-// TestPruneTree_NegativeDepth: depth <= 0이면 트리 전체를 반환한다.
-func TestPruneTree_NegativeDepth(t *testing.T) {
-	root := &ragindex.TreeNode{
-		ID: "root",
-		Children: []*ragindex.TreeNode{
-			{ID: "c1", Children: []*ragindex.TreeNode{{ID: "f1"}}},
-		},
-	}
-
-	for _, depth := range []int{0, -1} {
-		result := ragindex.PruneTree(root, depth)
-		if len(result.Children) != 1 {
-			t.Fatalf("depth=%d: expected 1 child, got %d", depth, len(result.Children))
-		}
-		if len(result.Children[0].Children) != 1 {
-			t.Fatalf("depth=%d: expected 1 grandchild (unlimited), got %d", depth, len(result.Children[0].Children))
-		}
-	}
-}
-
-// TestPruneTree_NilRoot: nil 입력 → nil 반환.
-func TestPruneTree_NilRoot(t *testing.T) {
-	result := ragindex.PruneTree(nil, 2)
-	if result != nil {
-		t.Fatal("expected nil for nil root")
-	}
-}
-
 // TestSearch_MatchesLabel: query가 label에 매칭되면 결과를 반환한다.
 func TestSearch_MatchesLabel(t *testing.T) {
 	root := &ragindex.TreeNode{