fix(graphrag): filter graph noise from wiki evidence

Author: PorunC

backend/app/services/chunk_builder.py

@@ -2,6 +2,7 @@
 from pathlib import Path
 
 from backend.app.database import CodeChunkRecord
+from backend.app.services.file_roles import is_wiki_noise_file
 from backend.app.services.graph import CodeGraphNode
 from backend.app.services.graphrag.constants import SOURCE_NODE_TYPES
 from backend.app.services.graphrag.utils import estimate_tokens, stable_id
@@ -28,6 +29,8 @@ def build_source_chunks(
         for node in sorted(nodes, key=lambda item: item.type == "file"):
             if node.type not in CHUNK_SOURCE_NODE_TYPES or not node.file_path:
                 continue
+            if is_wiki_noise_file(node.file_path):
+                continue
             lines = line_cache.get(node.file_path)
             if lines is None:
                 file_path = (root / node.file_path).resolve()

backend/app/services/file_roles.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from fnmatch import fnmatch
+from pathlib import PurePosixPath
+
+from backend.app.services.graph.models import CodeGraphEdge, CodeGraphNode
+
+LOCKFILE_NAMES = {"uv.lock", "package-lock.json", "pnpm-lock.yaml", "yarn.lock"}
+GENERATED_DIR_NAMES = {
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    "build",
+    "coverage",
+    "dist",
+    "htmlcov",
+    "out",
+    "target",
+}
+GENERATED_FILE_SUFFIXES = {
+    ".bundle.js",
+    ".bundle.css",
+    ".d.ts",
+    ".generated.py",
+    ".generated.ts",
+    ".generated.tsx",
+    ".min.css",
+    ".min.js",
+}
+GENERATED_FILE_NAMES = LOCKFILE_NAMES
+VENDOR_DIR_NAMES = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".venv",
+    "node_modules",
+    "site-packages",
+    "vendor",
+    "vendors",
+    "venv",
+}
+TEST_DIR_NAMES = {"__tests__", "e2e", "spec", "specs", "test", "tests"}
+
+
+def normalize_file_path(file_path: str) -> str:
+    return file_path.replace("\\", "/").strip("/")
+
+
+def is_test_file(file_path: str, test_glob: str | None = None) -> bool:
+    normalized = normalize_file_path(file_path)
+    lowered = normalized.lower()
+    if test_glob and fnmatch(normalized, test_glob):
+        return True
+    name = lowered.rsplit("/", 1)[-1]
+    parts = set(PurePosixPath(lowered).parts)
+    return (
+        name.startswith("test_")
+        or name.endswith("_test.py")
+        or name.endswith("_test.go")
+        or ".test." in name
+        or ".spec." in name
+        or bool(parts & TEST_DIR_NAMES)
+    )
+
+
+def is_generated_file(file_path: str) -> bool:
+    normalized = normalize_file_path(file_path)
+    lowered = normalized.lower()
+    name = lowered.rsplit("/", 1)[-1]
+    parts = set(PurePosixPath(lowered).parts)
+    return (
+        name in GENERATED_FILE_NAMES
+        or any(name.endswith(suffix) for suffix in GENERATED_FILE_SUFFIXES)
+        or bool(parts & GENERATED_DIR_NAMES)
+    )
+
+
+def is_vendor_file(file_path: str) -> bool:
+    parts = set(PurePosixPath(normalize_file_path(file_path).lower()).parts)
+    return bool(parts & VENDOR_DIR_NAMES)
+
+
+def is_wiki_noise_file(file_path: str) -> bool:
+    return is_test_file(file_path) or is_generated_file(file_path) or is_vendor_file(file_path)
+
+
+def is_wiki_noise_node(node: CodeGraphNode) -> bool:
+    if node.metadata.get("external"):
+        return True
+    return bool(node.file_path and is_wiki_noise_file(node.file_path))
+
+
+def filter_wiki_graph(
+    nodes: list[CodeGraphNode],
+    edges: list[CodeGraphEdge],
+) -> tuple[list[CodeGraphNode], list[CodeGraphEdge]]:
+    filtered_nodes = [node for node in nodes if not is_wiki_noise_node(node)]
+    node_ids = {node.id for node in filtered_nodes}
+    filtered_edges = [
+        edge for edge in edges if edge.source_id in node_ids and edge.target_id in node_ids
+    ]
+    return filtered_nodes, filtered_edges

backend/app/services/graph/affected.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from collections import deque
-from fnmatch import fnmatch
 from typing import Any
 
+from backend.app.services.file_roles import is_test_file as _is_test_file
 from backend.app.services.graph.models import CodeGraphEdge, CodeGraphNode
 
 
@@ -48,22 +48,7 @@ def transitive_file_dependents(
 
 
 def is_test_file(file_path: str, test_glob: str | None) -> bool:
-    normalized = file_path.lower().replace("\\", "/")
-    if test_glob:
-        return fnmatch(file_path, test_glob)
-    name = normalized.rsplit("/", 1)[-1]
-    return (
-        name.startswith("test_")
-        or ".test." in name
-        or ".spec." in name
-        or name.endswith("_test.go")
-        or name.endswith("_test.py")
-        or "/tests/" in normalized
-        or "/test/" in normalized
-        or "/__tests__/" in normalized
-        or "/e2e/" in normalized
-        or "/spec/" in normalized
-    )
+    return _is_test_file(file_path, test_glob)
 
 
 def page_source_files(source_refs: list[dict[str, Any]]) -> set[str]:

backend/app/services/graph/call_resolver.py

@@ -3,7 +3,6 @@
 from backend.app.services.ast_parser import AstSymbol
 from backend.app.services.graph.confidence import EdgeResolution, edge_resolution
 from backend.app.services.graph.models import CodeGraphNode
-from backend.app.services.graph.node_factory import module_node
 
 
 def build_call_index(
@@ -97,9 +96,7 @@ def resolve_type_reference(
         return None
     if not name:
         return None
-    node = module_node(repo_id, name, kind="type_reference")
-    add_node(node)
-    return edge_resolution(node.id, "global", is_inferred=True)
+    return None
 
 
 def file_exports(file_symbols: list[AstSymbol]) -> set[str]:

backend/app/services/graph/import_resolver.py

@@ -3,9 +3,7 @@
 from pathlib import PurePosixPath
 
 from backend.app.services.graph.confidence import CONFIDENCE_TIERS, TIER_REASONS
-from backend.app.services.graph.ids import module_node_id
 from backend.app.services.graph.models import CodeGraphNode
-from backend.app.services.graph.node_factory import module_node
 
 
 def resolve_import_target(
@@ -114,17 +112,3 @@ def add_import_edges(
                 },
             )
             continue
-        add_node(module_node(repo_id, import_name))
-        add_edge(
-            file_node_id,
-            module_node_id(repo_id, import_name),
-            "imports",
-            confidence=CONFIDENCE_TIERS["global"],
-            is_inferred=True,
-            reason=TIER_REASONS["global"],
-            metadata={
-                "import": import_name,
-                "resolved": False,
-                "resolution_tier": "global",
-            },
-        )

backend/app/services/graphrag/context.py

@@ -1,4 +1,5 @@
 from backend.app.database import CodeChunkSearchHit, CodeWikiStore, GraphCommunityRecord
+from backend.app.services.file_roles import is_wiki_noise_file
 from backend.app.services.graph import CodeGraphEdge, CodeGraphNode
 from backend.app.services.graph_provenance import edge_provenance, node_confidence, node_provenance
 from backend.app.services.graphrag.models import ChunkHit
@@ -15,7 +16,7 @@
 
 def _is_ignored_source_file(file_path: str) -> bool:
     normalized = file_path.replace("\\", "/")
-    return normalized.rsplit("/", 1)[-1] in IGNORED_SOURCE_FILES
+    return normalized.rsplit("/", 1)[-1] in IGNORED_SOURCE_FILES or is_wiki_noise_file(file_path)
 
 
 def select_source_chunks(

backend/app/services/graphrag/retriever.py

@@ -1,5 +1,6 @@
 from backend.app.config import Settings, get_settings
 from backend.app.database import CodeChunkRecord, CodeWikiStore, get_store
+from backend.app.services.file_roles import filter_wiki_graph
 from backend.app.services.graph import CodeGraphNode
 from backend.app.services.graphrag.constants import (
     DEFAULT_CONTEXT_TOKENS,
@@ -67,9 +68,10 @@ async def retrieve(
         if repo is None:
             raise ValueError(f"Repository not found: {repo_id}")
 
-        nodes, edges = self.store.get_graph(repo_id)
-        if not nodes:
+        graph_nodes, graph_edges = self.store.get_graph(repo_id)
+        if not graph_nodes:
             raise ValueError("Run analysis before GraphRAG retrieval.")
+        nodes, edges = filter_wiki_graph(graph_nodes, graph_edges)
 
         query = query.strip() or "repository overview"
         max_hops = max(0, min(max_hops, 4))

backend/app/services/graphrag/search.py

@@ -1,5 +1,6 @@
 from backend.app.database import CodeChunkRecord, CodeChunkSearchHit, CodeWikiStore
 from backend.app.services.embedding_index import EmbeddingIndex
+from backend.app.services.file_roles import is_wiki_noise_file, is_wiki_noise_node
 from backend.app.services.graph import CodeGraphNode
 from backend.app.services.graphrag.constants import SEED_NODE_TYPES
 from backend.app.services.graphrag.models import NodeHit
@@ -27,13 +28,17 @@ def seed_from_symbols(
             types=sorted(SEED_NODE_TYPES),
             limit=32,
         ):
+            if is_wiki_noise_node(search_hit.node):
+                continue
             hits[search_hit.node.id] = NodeHit(
                 node_id=search_hit.node.id,
                 score=min(1.3, max(0.35, search_hit.score)),
                 reasons={*search_hit.reasons, "symbol_fts"},
             )
 
     for node in nodes:
+        if is_wiki_noise_node(node):
+            continue
         if node.type not in SEED_NODE_TYPES:
             continue
         haystack = node_haystack(node)
@@ -100,9 +105,13 @@ def merge_chunk_hits_into_seeds(
         if node.type == "file" and node.file_path
     }
     for index, chunk_hit in enumerate(chunk_hits):
+        if is_wiki_noise_file(chunk_hit.chunk.file_path):
+            continue
         node_id = chunk_hit.chunk.node_id or file_nodes_by_path.get(chunk_hit.chunk.file_path)
         if node_id not in node_by_id:
             continue
+        if is_wiki_noise_node(node_by_id[node_id]):
+            continue
         score = max(0.25, chunk_hit.score - index * 0.01)
         existing = seed_hits.get(node_id)
         if existing:
@@ -117,10 +126,14 @@ def add_overview_fallback_seeds(
     nodes: list[CodeGraphNode],
 ) -> None:
     for node in nodes:
+        if is_wiki_noise_node(node):
+            continue
         if node.type == "repository":
             seed_hits[node.id] = NodeHit(node_id=node.id, score=0.4, reasons={"overview"})
             break
     for node in sorted(nodes, key=lambda item: item.file_path):
+        if is_wiki_noise_node(node):
+            continue
         if node.type == "file":
             seed_hits[node.id] = NodeHit(node_id=node.id, score=0.35, reasons={"overview"})
             if len(seed_hits) >= 6:

backend/app/services/wiki/catalog_generator.py

@@ -1,6 +1,7 @@
 from typing import Any
 
 from backend.app.database import DocCatalogRecord, CodeWikiStore
+from backend.app.services.file_roles import filter_wiki_graph
 from backend.app.services.graphrag import GraphRAGRetriever
 from backend.app.services.graph import CodeGraphEdge, CodeGraphNode
 from backend.app.services.llm.gateway import LLMGateway
@@ -50,7 +51,8 @@ async def generate_catalog(
             raise ValueError(f"Repository not found: {repo_id}")
 
         trace = await self.retriever.retrieve(repo_id, "repository overview", max_hops=3)
-        nodes, edges = self.store.get_graph(repo.id)
+        graph_nodes, graph_edges = self.store.get_graph(repo.id)
+        nodes, edges = filter_wiki_graph(graph_nodes, graph_edges)
         catalog_limits = catalog_limits_for_repo(
             nodes,
             edges,

tests/backend/test_analysis_service.py

@@ -47,10 +47,10 @@ def test_analyze_persists_first_code_graph(tmp_path: Path) -> None:
     assert sum(result.community_count_by_level.values()) == result.community_count
     assert result.community_count >= 1
     assert {node.type for node in nodes} >= {"repository", "file", "class", "function", "method"}
-    assert any(node.name == "os" and node.type == "module" for node in nodes)
+    assert not any(node.name == "os" and node.type == "module" for node in nodes)
     assert all("provenance" in node.metadata for node in nodes)
     assert any(edge.type == "contains" for edge in edges)
-    assert any(edge.type == "imports" for edge in edges)
+    assert not any(edge.type == "imports" and edge.metadata.get("resolved") is False for edge in edges)
     assert any(edge.type == "calls" for edge in edges)
     assert all("provenance" in edge.metadata for edge in edges)
     assert all("confidence_level" in edge.metadata for edge in edges)
@@ -264,6 +264,27 @@ def test_analyze_resolves_local_python_imports(tmp_path: Path) -> None:
     assert any(edge.source_id.endswith(":file:api.py") and edge.target_id.endswith(":file:service.py") for edge in local_import_edges)
 
 
+def test_analyze_skips_unresolved_external_type_reference_nodes(tmp_path: Path) -> None:
+    repo_dir = tmp_path / "repo"
+    repo_dir.mkdir()
+    (repo_dir / "worker.ts").write_text("export class Worker extends ExternalBase {}\n")
+
+    store = SQLiteStore(tmp_path / "codewiki.sqlite3")
+    repo = store.upsert_repo(RepoScanner().describe(str(repo_dir)))
+
+    AnalysisService(store=store).analyze(repo.id)
+    nodes, edges = store.get_graph(repo.id)
+
+    worker_node = next(node for node in nodes if node.type == "class" and node.name == "Worker")
+    assert not any(node.type == "module" and node.name == "ExternalBase" for node in nodes)
+    assert not any(
+        edge.type == "inherits"
+        and edge.source_id == worker_node.id
+        and edge.metadata.get("base") == "ExternalBase"
+        for edge in edges
+    )
+
+
 def test_analyze_records_confidence_tiers_and_edge_reasons(tmp_path: Path) -> None:
     repo_dir = tmp_path / "repo"
     repo_dir.mkdir()