Turn any codebase, with its docs, SQL schemas, configs, and PDFs, into a queryable knowledge graph. A /graphify skill for Claude Code, Cursor, Codex, and Gemini CLI: local deterministic AST parsing, every edge explained, no vector store.
Python ai-agentsantigravityastclaude-codecode-analysiscode-searchcodexcursordeveloper-toolsgeminigraphifygraphragknowledge-graphleidenllmmcpopenclawragskillstree-sitter
feat: 13-language AST support and token benchmark
Safi81a43f028ff1
diff --git a/README.md b/README.mdindex d1b076cb8..91b608493 100644--- a/README.md+++ b/README.md@@ -202,6 +202,7 @@ graphify/├── export.py Obsidian vault, graph.json, graph.html, graph.svg, Neo4j Cypher, Canvas├── ingest.py fetch URLs (arXiv, Twitter/X, PDF, any webpage); save Q&A to .graphify/memory/├── cache.py SHA256-based per-file extraction cache; check_semantic_cache / save_semantic_cache+├── security.py URL validation (http/https only), safe fetch with size cap, path guards, label sanitisation├── validate.py JSON schema checks on extraction output├── serve.py MCP stdio server — query_graph, get_node, get_neighbors, shortest_path, god_nodes└── watch.py fs watcher, writes flag file when new files appear@@ -209,6 +210,7 @@ graphify/skills/graphify/└── skill.md the Claude Code skill — the full pipeline the agent runs step by step-tests/ 142 tests, one file per module+SECURITY.md threat model, mitigations, vulnerability reporting+tests/ 163 tests, one file per modulepyproject.toml pip install graphify | pip install graphify[mcp,neo4j,pdf,watch]```diff --git a/graphify/__main__.py b/graphify/__main__.pyindex 8f5fa8d47..2da1f6f5c 100644--- a/graphify/__main__.py+++ b/graphify/__main__.py@@ -1,5 +1,6 @@"""graphify CLI — `graphify install` sets up the Claude Code skill."""from __future__ import annotations+import jsonimport shutilimport sysfrom pathlib import Path@@ -56,13 +57,28 @@ def main() -> None:print("Usage: graphify <command>")print()print("Commands:")- print(" install copy skill to ~/.claude/skills/ and register in CLAUDE.md")+ print(" install copy skill to ~/.claude/skills/ and register in CLAUDE.md")+ print(" benchmark [graph.json] measure token reduction vs naive full-corpus approach")print()returncmd = sys.argv[1]if cmd == "install":install()+ elif cmd == "benchmark":+ from graphify.benchmark import run_benchmark, print_benchmark+ graph_path = sys.argv[2] if len(sys.argv) > 2 else ".graphify/graph.json"+ # Try to load corpus_words from detect output+ corpus_words = None+ detect_path = Path(".graphify_detect.json")+ if detect_path.exists():+ try:+ detect_data = json.loads(detect_path.read_text())+ corpus_words = detect_data.get("total_words")+ except Exception:+ pass+ result = run_benchmark(graph_path, corpus_words=corpus_words)+ print_benchmark(result)else:print(f"error: unknown command '{cmd}'", file=sys.stderr)print("Run 'graphify --help' for usage.", file=sys.stderr)diff --git a/graphify/benchmark.py b/graphify/benchmark.pynew file mode 100644index 000000000..e3085e681--- /dev/null+++ b/graphify/benchmark.py@@ -0,0 +1,126 @@+"""Token-reduction benchmark — measures how much context graphify saves vs naive full-corpus approach."""+from __future__ import annotations+import json+from pathlib import Path+import networkx as nx+from networkx.readwrite import json_graph+++_CHARS_PER_TOKEN = 4 # standard approximation+++def _estimate_tokens(text: str) -> int:+ return max(1, len(text) // _CHARS_PER_TOKEN)+++def _query_subgraph_tokens(G: nx.Graph, question: str, depth: int = 3) -> int:+ """Run BFS from best-matching nodes and return estimated tokens in the subgraph context."""+ terms = [t.lower() for t in question.split() if len(t) > 2]+ scored = []+ for nid, data in G.nodes(data=True):+ label = data.get("label", "").lower()+ score = sum(1 for t in terms if t in label)+ if score > 0:+ scored.append((score, nid))+ scored.sort(reverse=True)+ start_nodes = [nid for _, nid in scored[:3]]+ if not start_nodes:+ return 0++ visited: set[str] = set(start_nodes)+ frontier = set(start_nodes)+ edges_seen: list[tuple] = []+ for _ in range(depth):+ next_frontier: set[str] = set()+ for n in frontier:+ for neighbor in G.neighbors(n):+ if neighbor not in visited:+ next_frontier.add(neighbor)+ edges_seen.append((n, neighbor))+ visited.update(next_frontier)+ frontier = next_frontier++ lines = []+ for nid in visited:+ d = G.nodes[nid]+ lines.append(f"NODE {d.get('label', nid)} src={d.get('source_file', '')} loc={d.get('source_location', '')}")+ for u, v in edges_seen:+ if u in visited and v in visited:+ d = G.edges[u, v]+ lines.append(f"EDGE {G.nodes[u].get('label', u)} --{d.get('relation', '')}--> {G.nodes[v].get('label', v)}")++ return _estimate_tokens("\n".join(lines))+++_SAMPLE_QUESTIONS = [+ "how does authentication work",+ "what is the main entry point",+ "how are errors handled",+ "what connects the data layer to the api",+ "what are the core abstractions",+]+++def run_benchmark(+ graph_path: str = ".graphify/graph.json",+ corpus_words: int | None = None,+ questions: list[str] | None = None,+) -> dict:+ """Measure token reduction: corpus tokens vs graphify query tokens.++ Args:+ graph_path: path to the built graph+ corpus_words: total word count from detect() output; if None, estimated from graph+ questions: list of questions to benchmark; defaults to _SAMPLE_QUESTIONS++ Returns dict with: corpus_tokens, avg_query_tokens, reduction_ratio, per_question+ """+ data = json.loads(Path(graph_path).read_text())+ G = json_graph.node_link_graph(data, edges="links")++ if corpus_words is None:+ # Rough estimate: each node label is ~3 words, plus source context+ corpus_words = G.number_of_nodes() * 50++ corpus_tokens = corpus_words * 100 // 75 # words → tokens (100 words ≈ 133 tokens)++ qs = questions or _SAMPLE_QUESTIONS+ per_question = []+ for q in qs:+ qt = _query_subgraph_tokens(G, q)+ if qt > 0:+ per_question.append({"question": q, "query_tokens": qt, "reduction": round(corpus_tokens / qt, 1)})++ if not per_question:+ return {"error": "No matching nodes found for sample questions. Build the graph first."}++ avg_query_tokens = sum(p["query_tokens"] for p in per_question) // len(per_question)+ reduction_ratio = round(corpus_tokens / avg_query_tokens, 1) if avg_query_tokens > 0 else 0++ return {+ "corpus_tokens": corpus_tokens,+ "corpus_words": corpus_words,+ "nodes": G.number_of_nodes(),+ "edges": G.number_of_edges(),+ "avg_query_tokens": avg_query_tokens,+ "reduction_ratio": reduction_ratio,+ "per_question": per_question,+ }+++def print_benchmark(result: dict) -> None:+ """Print a human-readable benchmark report."""+ if "error" in result:+ print(f"Benchmark error: {result['error']}")+ return++ print(f"\ngraphify token reduction benchmark")+ print(f"{'─' * 50}")+ print(f" Corpus: {result['corpus_words']:,} words → ~{result['corpus_tokens']:,} tokens (naive)")+ print(f" Graph: {result['nodes']:,} nodes, {result['edges']:,} edges")+ print(f" Avg query cost: ~{result['avg_query_tokens']:,} tokens")+ print(f" Reduction: {result['reduction_ratio']}x fewer tokens per query")+ print(f"\n Per question:")+ for p in result["per_question"]:+ print(f" [{p['reduction']}x] {p['question'][:55]}")+ print()diff --git a/graphify/detect.py b/graphify/detect.pyindex 70bbbeb49..c1a90d869 100644--- a/graphify/detect.py+++ b/graphify/detect.py@@ -15,7 +15,7 @@ class FileType(str, Enum):_MANIFEST_PATH = ".graphify/manifest.json"-CODE_EXTENSIONS = {'.py', '.ts', '.js', '.go', '.rs', '.java', '.cpp', '.c', '.rb', '.swift', '.kt'}+CODE_EXTENSIONS = {'.py', '.ts', '.js', '.tsx', '.go', '.rs', '.java', '.cpp', '.cc', '.cxx', '.c', '.h', '.hpp', '.rb', '.swift', '.kt', '.kts', '.cs', '.scala', '.php'}DOC_EXTENSIONS = {'.md', '.txt', '.rst'}PAPER_EXTENSIONS = {'.pdf'}IMAGE_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'}diff --git a/graphify/extract.py b/graphify/extract.pyindex a0a1bffc4..c56199c46 100644--- a/graphify/extract.py+++ b/graphify/extract.py@@ -752,6 +752,1374 @@ def extract_rust(path: Path) -> dict:return {"nodes": nodes, "edges": clean_edges}+def extract_java(path: Path) -> dict:+ """Extract classes, interfaces, methods, constructors, and imports from a .java file."""+ try:+ import tree_sitter_java as tsjava+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-java not installed"}++ try:+ language = Language(tsjava.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def _walk_scoped_identifier(node) -> str:+ """Reconstruct a dotted import path from nested scoped_identifier nodes."""+ parts: list[str] = []+ cur = node+ while cur:+ if cur.type == "scoped_identifier":+ name_node = cur.child_by_field_name("name")+ if name_node:+ parts.append(source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace"))+ cur = cur.child_by_field_name("scope")+ elif cur.type == "identifier":+ parts.append(source[cur.start_byte:cur.end_byte].decode("utf-8", errors="replace"))+ break+ else:+ break+ parts.reverse()+ return ".".join(parts)++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "import_declaration":+ # Find scoped_identifier or identifier child+ for child in node.children:+ if child.type in ("scoped_identifier", "identifier"):+ path_str = _walk_scoped_identifier(child)+ module_name = path_str.split(".")[-1].strip("*").strip(".") or path_str.split(".")[-2]+ if module_name:+ tgt_nid = _make_id(module_name)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t in ("class_declaration", "interface_declaration"):+ name_node = node.child_by_field_name("name")+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t in ("method_declaration", "constructor_declaration"):+ name_node = node.child_by_field_name("name")+ if not name_node:+ return+ method_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ line = node.start_point[0] + 1+ if parent_class_nid:+ method_nid = _make_id(parent_class_nid, method_name)+ add_node(method_nid, f".{method_name}()", line)+ add_edge_raw(parent_class_nid, method_nid, "method", line)+ else:+ method_nid = _make_id(stem, method_name)+ add_node(method_nid, f"{method_name}()", line)+ add_edge_raw(file_nid, method_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ function_bodies.append((method_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type in ("method_declaration", "constructor_declaration"):+ return+ if node.type == "method_invocation":+ name_node = node.child_by_field_name("name")+ callee_name: str | None = None+ if name_node:+ callee_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_c(path: Path) -> dict:+ """Extract functions and includes from a .c/.h file."""+ try:+ import tree_sitter_c as tsc+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-c not installed"}++ try:+ language = Language(tsc.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def _get_func_name_from_declarator(node) -> str | None:+ """Recursively unwrap declarator to find the innermost identifier."""+ if node.type == "identifier":+ return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")+ decl = node.child_by_field_name("declarator")+ if decl:+ return _get_func_name_from_declarator(decl)+ # fallback: search children for identifier+ for child in node.children:+ if child.type == "identifier":+ return source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ return None++ def walk(node) -> None:+ t = node.type++ if t == "preproc_include":+ # path child or string child+ for child in node.children:+ if child.type in ("string_literal", "system_lib_string", "string"):+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace").strip('"<> ')+ module_name = raw.split("/")[-1].split(".")[0]+ if module_name:+ tgt_nid = _make_id(module_name)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t == "function_definition":+ declarator = node.child_by_field_name("declarator")+ func_name: str | None = None+ if declarator:+ func_name = _get_func_name_from_declarator(declarator)+ if func_name:+ line = node.start_point[0] + 1+ func_nid = _make_id(stem, func_name)+ add_node(func_nid, f"{func_name}()", line)+ add_edge_raw(file_nid, func_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ function_bodies.append((func_nid, body))+ return++ for child in node.children:+ walk(child)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type == "function_definition":+ return+ if node.type == "call_expression":+ func_node = node.child_by_field_name("function")+ callee_name: str | None = None+ if func_node:+ if func_node.type == "identifier":+ callee_name = source[func_node.start_byte:func_node.end_byte].decode("utf-8", errors="replace")+ elif func_node.type == "field_expression":+ field = func_node.child_by_field_name("field")+ if field:+ callee_name = source[field.start_byte:field.end_byte].decode("utf-8", errors="replace")+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_cpp(path: Path) -> dict:+ """Extract functions, classes, and includes from a .cpp/.cc/.cxx/.hpp file."""+ try:+ import tree_sitter_cpp as tscpp+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-cpp not installed"}++ try:+ language = Language(tscpp.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def _get_func_name_from_declarator(node) -> str | None:+ """Recursively unwrap declarator to find the innermost identifier."""+ if node.type == "identifier":+ return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")+ if node.type == "qualified_identifier":+ name_node = node.child_by_field_name("name")+ if name_node:+ return source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ decl = node.child_by_field_name("declarator")+ if decl:+ return _get_func_name_from_declarator(decl)+ for child in node.children:+ if child.type == "identifier":+ return source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ return None++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "preproc_include":+ for child in node.children:+ if child.type in ("string_literal", "system_lib_string", "string"):+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace").strip('"<> ')+ module_name = raw.split("/")[-1].split(".")[0]+ if module_name:+ tgt_nid = _make_id(module_name)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t == "class_specifier":+ name_node = node.child_by_field_name("name")+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t == "function_definition":+ declarator = node.child_by_field_name("declarator")+ func_name: str | None = None+ if declarator:+ func_name = _get_func_name_from_declarator(declarator)+ if func_name:+ line = node.start_point[0] + 1+ if parent_class_nid:+ func_nid = _make_id(parent_class_nid, func_name)+ add_node(func_nid, f".{func_name}()", line)+ add_edge_raw(parent_class_nid, func_nid, "method", line)+ else:+ func_nid = _make_id(stem, func_name)+ add_node(func_nid, f"{func_name}()", line)+ add_edge_raw(file_nid, func_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ function_bodies.append((func_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type == "function_definition":+ return+ if node.type == "call_expression":+ func_node = node.child_by_field_name("function")+ callee_name: str | None = None+ if func_node:+ if func_node.type == "identifier":+ callee_name = source[func_node.start_byte:func_node.end_byte].decode("utf-8", errors="replace")+ elif func_node.type in ("field_expression", "qualified_identifier"):+ name = func_node.child_by_field_name("field") or func_node.child_by_field_name("name")+ if name:+ callee_name = source[name.start_byte:name.end_byte].decode("utf-8", errors="replace")+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_ruby(path: Path) -> dict:+ """Extract classes, methods, singleton methods, and calls from a .rb file."""+ try:+ import tree_sitter_ruby as tsruby+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-ruby not installed"}++ try:+ language = Language(tsruby.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "class":+ # name is a child node (not a field in all versions)+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type in ("constant", "scope_resolution"):+ name_node = child+ break+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ # body may not be a named field — walk all children except first/last+ for child in node.children:+ if child.type == "body_statement":+ body = child+ break+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t in ("method", "singleton_method"):+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "identifier":+ name_node = child+ break+ if not name_node:+ return+ method_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ line = node.start_point[0] + 1+ if parent_class_nid:+ method_nid = _make_id(parent_class_nid, method_name)+ add_node(method_nid, f".{method_name}()", line)+ add_edge_raw(parent_class_nid, method_nid, "method", line)+ else:+ method_nid = _make_id(stem, method_name)+ add_node(method_nid, f"{method_name}()", line)+ add_edge_raw(file_nid, method_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ for child in node.children:+ if child.type == "body_statement":+ body = child+ break+ if body:+ function_bodies.append((method_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type in ("method", "singleton_method"):+ return+ if node.type == "call":+ method_node = node.child_by_field_name("method")+ callee_name: str | None = None+ if method_node:+ callee_name = source[method_node.start_byte:method_node.end_byte].decode("utf-8", errors="replace")+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_csharp(path: Path) -> dict:+ """Extract classes, interfaces, methods, namespaces, and usings from a .cs file."""+ try:+ import tree_sitter_c_sharp as tscsharp+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-c-sharp not installed"}++ try:+ language = Language(tscsharp.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "using_directive":+ # Extract the namespace name from the using directive+ for child in node.children:+ if child.type in ("qualified_name", "identifier", "name_equals"):+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ module_name = raw.split(".")[-1].strip()+ if module_name:+ tgt_nid = _make_id(module_name)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t == "namespace_declaration":+ name_node = node.child_by_field_name("name")+ if name_node:+ ns_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ ns_nid = _make_id(stem, ns_name)+ line = node.start_point[0] + 1+ add_node(ns_nid, ns_name, line)+ add_edge_raw(file_nid, ns_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ for child in body.children:+ walk(child, parent_class_nid=parent_class_nid)+ return++ if t in ("class_declaration", "interface_declaration"):+ name_node = node.child_by_field_name("name")+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t == "method_declaration":+ name_node = node.child_by_field_name("name")+ if not name_node:+ return+ method_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ line = node.start_point[0] + 1+ if parent_class_nid:+ method_nid = _make_id(parent_class_nid, method_name)+ add_node(method_nid, f".{method_name}()", line)+ add_edge_raw(parent_class_nid, method_nid, "method", line)+ else:+ method_nid = _make_id(stem, method_name)+ add_node(method_nid, f"{method_name}()", line)+ add_edge_raw(file_nid, method_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ function_bodies.append((method_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type == "method_declaration":+ return+ if node.type == "invocation_expression":+ callee_name: str | None = None+ name_node = node.child_by_field_name("name")+ if name_node:+ callee_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ else:+ # Try first named child+ for child in node.children:+ if child.is_named:+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ # member_access_expression: strip the object prefix+ if "." in raw:+ callee_name = raw.split(".")[-1]+ else:+ callee_name = raw+ break+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_kotlin(path: Path) -> dict:+ """Extract classes, objects, functions, and imports from a .kt/.kts file."""+ try:+ import tree_sitter_kotlin as tskotlin+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-kotlin not installed"}++ try:+ language = Language(tskotlin.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "import_header":+ for child in node.children:+ if child.type == "identifier":+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ tgt_nid = _make_id(raw)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t in ("class_declaration", "object_declaration"):+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "simple_identifier":+ name_node = child+ break+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ for child in node.children:+ if child.type == "class_body":+ body = child+ break+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t == "function_declaration":+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "simple_identifier":+ name_node = child+ break+ if not name_node:+ return+ func_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ line = node.start_point[0] + 1+ if parent_class_nid:+ func_nid = _make_id(parent_class_nid, func_name)+ add_node(func_nid, f".{func_name}()", line)+ add_edge_raw(parent_class_nid, func_nid, "method", line)+ else:+ func_nid = _make_id(stem, func_name)+ add_node(func_nid, f"{func_name}()", line)+ add_edge_raw(file_nid, func_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ for child in node.children:+ if child.type == "function_body":+ body = child+ break+ if body:+ function_bodies.append((func_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type == "function_declaration":+ return+ if node.type == "call_expression":+ callee_name: str | None = None+ # Try first child (the callable) then look for simple_identifier+ first = node.children[0] if node.children else None+ if first:+ if first.type == "simple_identifier":+ callee_name = source[first.start_byte:first.end_byte].decode("utf-8", errors="replace")+ elif first.type == "navigation_expression":+ # obj.method — get the suffix+ for child in reversed(first.children):+ if child.type == "simple_identifier":+ callee_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ break+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_scala(path: Path) -> dict:+ """Extract classes, objects, functions, and imports from a .scala file."""+ try:+ import tree_sitter_scala as tsscala+ from tree_sitter import Language, Parser+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-scala not installed"}++ try:+ language = Language(tsscala.language())+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "import_declaration":+ for child in node.children:+ if child.type in ("stable_id", "identifier"):+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ module_name = raw.split(".")[-1].strip("{} ")+ if module_name and module_name != "_":+ tgt_nid = _make_id(module_name)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t in ("class_definition", "object_definition"):+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "identifier":+ name_node = child+ break+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ for child in node.children:+ if child.type == "template_body":+ body = child+ break+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t == "function_definition":+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "identifier":+ name_node = child+ break+ if not name_node:+ return+ func_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ line = node.start_point[0] + 1+ if parent_class_nid:+ func_nid = _make_id(parent_class_nid, func_name)+ add_node(func_nid, f".{func_name}()", line)+ add_edge_raw(parent_class_nid, func_nid, "method", line)+ else:+ func_nid = _make_id(stem, func_name)+ add_node(func_nid, f"{func_name}()", line)+ add_edge_raw(file_nid, func_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body:+ function_bodies.append((func_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type == "function_definition":+ return+ if node.type == "call_expression":+ callee_name: str | None = None+ # First child is the function being called+ first = node.children[0] if node.children else None+ if first:+ if first.type == "identifier":+ callee_name = source[first.start_byte:first.end_byte].decode("utf-8", errors="replace")+ elif first.type == "field_expression":+ field = first.child_by_field_name("field")+ if field:+ callee_name = source[field.start_byte:field.end_byte].decode("utf-8", errors="replace")+ else:+ for child in reversed(first.children):+ if child.type == "identifier":+ callee_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ break+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}+++def extract_php(path: Path) -> dict:+ """Extract classes, functions, methods, namespace uses, and calls from a .php file."""+ try:+ import tree_sitter_php as tsphp+ from tree_sitter import Language, Parser+ try:+ from tree_sitter_php import language_php+ language = Language(language_php())+ except (ImportError, AttributeError):+ language = Language(tsphp.language())+ except ImportError:+ return {"nodes": [], "edges": [], "error": "tree-sitter-php not installed"}++ try:+ parser = Parser(language)+ source = path.read_bytes()+ tree = parser.parse(source)+ root = tree.root_node+ except Exception as e:+ return {"nodes": [], "edges": [], "error": str(e)}++ stem = path.stem+ str_path = str(path)+ nodes: list[dict] = []+ edges: list[dict] = []+ seen_ids: set[str] = set()++ def add_node(nid: str, label: str, line: int) -> None:+ if nid not in seen_ids:+ seen_ids.add(nid)+ nodes.append({+ "id": nid,+ "label": label,+ "file_type": "code",+ "source_file": str_path,+ "source_location": f"L{line}",+ })++ def add_edge_raw(src: str, tgt: str, relation: str, line: int, confidence: str = "EXTRACTED", weight: float = 1.0) -> None:+ edges.append({+ "source": src,+ "target": tgt,+ "relation": relation,+ "confidence": confidence,+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": weight,+ })++ file_nid = _make_id(stem)+ add_node(file_nid, path.name, 1)++ function_bodies: list[tuple[str, object]] = []++ def walk(node, parent_class_nid: str | None = None) -> None:+ t = node.type++ if t == "namespace_use_clause":+ for child in node.children:+ if child.type in ("qualified_name", "name", "identifier"):+ raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")+ module_name = raw.split("\\")[-1].strip()+ if module_name:+ tgt_nid = _make_id(module_name)+ add_edge_raw(file_nid, tgt_nid, "imports", node.start_point[0] + 1)+ break+ return++ if t == "class_declaration":+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "name":+ name_node = child+ break+ if not name_node:+ return+ class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ class_nid = _make_id(stem, class_name)+ line = node.start_point[0] + 1+ add_node(class_nid, class_name, line)+ add_edge_raw(file_nid, class_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ for child in node.children:+ if child.type == "declaration_list":+ body = child+ break+ if body:+ for child in body.children:+ walk(child, parent_class_nid=class_nid)+ return++ if t in ("function_definition", "method_declaration"):+ name_node = node.child_by_field_name("name")+ if name_node is None:+ for child in node.children:+ if child.type == "name":+ name_node = child+ break+ if not name_node:+ return+ func_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ line = node.start_point[0] + 1+ if parent_class_nid:+ func_nid = _make_id(parent_class_nid, func_name)+ add_node(func_nid, f".{func_name}()", line)+ add_edge_raw(parent_class_nid, func_nid, "method", line)+ else:+ func_nid = _make_id(stem, func_name)+ add_node(func_nid, f"{func_name}()", line)+ add_edge_raw(file_nid, func_nid, "contains", line)+ body = node.child_by_field_name("body")+ if body is None:+ for child in node.children:+ if child.type == "compound_statement":+ body = child+ break+ if body:+ function_bodies.append((func_nid, body))+ return++ for child in node.children:+ walk(child, parent_class_nid=None)++ walk(root)++ label_to_nid: dict[str, str] = {}+ for n in nodes:+ raw = n["label"]+ normalised = raw.strip("()").lstrip(".")+ label_to_nid[normalised.lower()] = n["id"]++ seen_call_pairs: set[tuple[str, str]] = set()++ def walk_calls(node, caller_nid: str) -> None:+ if node.type in ("function_definition", "method_declaration"):+ return+ if node.type in ("function_call_expression", "member_call_expression"):+ callee_name: str | None = None+ if node.type == "function_call_expression":+ func_node = node.child_by_field_name("function")+ if func_node:+ callee_name = source[func_node.start_byte:func_node.end_byte].decode("utf-8", errors="replace")+ else:+ # member_call_expression: obj->method(args)+ name_node = node.child_by_field_name("name")+ if name_node:+ callee_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")+ if callee_name:+ tgt_nid = label_to_nid.get(callee_name.lower())+ if tgt_nid and tgt_nid != caller_nid:+ pair = (caller_nid, tgt_nid)+ if pair not in seen_call_pairs:+ seen_call_pairs.add(pair)+ line = node.start_point[0] + 1+ edges.append({+ "source": caller_nid,+ "target": tgt_nid,+ "relation": "calls",+ "confidence": "INFERRED",+ "source_file": str_path,+ "source_location": f"L{line}",+ "weight": 0.8,+ })+ for child in node.children:+ walk_calls(child, caller_nid)++ for caller_nid, body_node in function_bodies:+ walk_calls(body_node, caller_nid)++ valid_ids = seen_ids+ clean_edges = []+ for edge in edges:+ src, tgt = edge["source"], edge["target"]+ if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):+ clean_edges.append(edge)++ return {"nodes": nodes, "edges": clean_edges}++def _resolve_cross_file_imports(per_file: list[dict],paths: list[Path],@@ -949,6 +2317,78 @@ def extract(paths: list[Path]) -> dict:if "error" not in result:save_cached(path, result, root)per_file.append(result)+ elif path.suffix == ".java":+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_java(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix in {".c", ".h"}:+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_c(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix in {".cpp", ".cc", ".cxx", ".hpp"}:+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_cpp(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix == ".rb":+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_ruby(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix == ".cs":+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_csharp(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix in {".kt", ".kts"}:+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_kotlin(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix == ".scala":+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_scala(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)+ elif path.suffix == ".php":+ cached = load_cached(path, root)+ if cached is not None:+ per_file.append(cached)+ continue+ result = extract_php(path)+ if "error" not in result:+ save_cached(path, result, root)+ per_file.append(result)all_nodes: list[dict] = []all_edges: list[dict] = []@@ -973,7 +2413,11 @@ def extract(paths: list[Path]) -> dict:def collect_files(target: Path) -> list[Path]:if target.is_file():return [target]- _EXTENSIONS = ("*.py", "*.js", "*.ts", "*.tsx", "*.go", "*.rs")+ _EXTENSIONS = (+ "*.py", "*.js", "*.ts", "*.tsx", "*.go", "*.rs",+ "*.java", "*.c", "*.h", "*.cpp", "*.cc", "*.cxx", "*.hpp",+ "*.rb", "*.cs", "*.kt", "*.kts", "*.scala", "*.php",+ )results: list[Path] = []for pattern in _EXTENSIONS:results.extend(diff --git a/graphify/skill.md b/graphify/skill.mdindex 174dc5a29..cddaa60e8 100644--- a/graphify/skill.md+++ b/graphify/skill.md@@ -92,6 +92,8 @@ Then act on it:### Step 3 — Extract entities and relationships+**Before starting:** note whether `--mode deep` was given. You must pass `DEEP_MODE=true` to every subagent in Step B2 if it was. Track this from the original invocation — do not lose it.+This step has two parts: **structural extraction** (deterministic, free) then **semantic extraction** (Claude, costs tokens).#### Part A — Structural extraction for code files@@ -496,28 +498,9 @@ print('graph.svg written — embeds in Obsidian, Notion, GitHub READMEs')"```-### Step 7c — Obsidian export (only if --obsidian flag)--```bash-python3 -c "-import sys, json-from graphify.build import build_from_json-from graphify.export import to_obsidian-from pathlib import Path+### Step 7c — SVG export already covered in Step 7b above-extraction = json.loads(Path('.graphify_extract.json').read_text())-analysis = json.loads(Path('.graphify_analysis.json').read_text())-labels_raw = json.loads(Path('.graphify_labels.json').read_text()) if Path('.graphify_labels.json').exists() else {}--G = build_from_json(extraction)-communities = {int(k): v for k, v in analysis['communities'].items()}-labels = {int(k): v for k, v in labels_raw.items()}--n = to_obsidian(G, communities, '.graphify/obsidian', community_labels=labels or None, cohesion=cohesion)-print(f'Obsidian vault written: {n} notes in .graphify/obsidian/')-print('Open .graphify/obsidian/ as a vault in Obsidian to explore the graph.')-"-```+_(No separate --obsidian flag — Obsidian vault is always generated in Step 6 by default.)_### Step 7d — MCP server (only if --mcp flag)@@ -525,7 +508,7 @@ print('Open .graphify/obsidian/ as a vault in Obsidian to explore the graph.')python3 -m graphify.serve .graphify/graph.json```-This starts a stdio MCP server that exposes tools: `query_graph`, `get_node`, `get_neighbors`, `get_community`, `god_nodes`, `graph_stats`. Add to Claude Desktop or any MCP-compatible agent orchestrator so other agents can query the graph live.+This starts a stdio MCP server that exposes tools: `query_graph`, `get_node`, `get_neighbors`, `get_community`, `god_nodes`, `graph_stats`, `shortest_path`. Add to Claude Desktop or any MCP-compatible agent orchestrator so other agents can query the graph live.To configure in Claude Desktop, add to `claude_desktop_config.json`:```json@@ -1007,12 +990,19 @@ import sysfrom graphify.ingest import ingestfrom pathlib import Path-out = ingest('URL', Path('./raw'), author='AUTHOR', contributor='CONTRIBUTOR')-print(f'Saved to {out}')+try:+ out = ingest('URL', Path('./raw'), author='AUTHOR', contributor='CONTRIBUTOR')+ print(f'Saved to {out}')+except ValueError as e:+ print(f'error: {e}', file=sys.stderr)+ sys.exit(1)+except RuntimeError as e:+ print(f'error: {e}', file=sys.stderr)+ sys.exit(1)"```-Replace `URL` with the actual URL, `AUTHOR` with the user's name if provided, `CONTRIBUTOR` likewise. After saving, automatically run the `--update` pipeline on `./raw` to merge the new file into the existing graph.+Replace `URL` with the actual URL, `AUTHOR` with the user's name if provided, `CONTRIBUTOR` likewise. If the command exits with an error, tell the user what went wrong — do not silently continue. After a successful save, automatically run the `--update` pipeline on `./raw` to merge the new file into the existing graph.Supported URL types (auto-detected):- Twitter/X → fetched via oEmbed, saved as `.md` with tweet text and authordiff --git a/graphify/watch.py b/graphify/watch.pyindex 282ec2e18..d83e3e637 100644--- a/graphify/watch.py+++ b/graphify/watch.py@@ -6,6 +6,7 @@ from pathlib import Path_WATCHED_EXTENSIONS = {".py", ".ts", ".js", ".go", ".rs", ".java", ".cpp", ".c", ".rb", ".swift", ".kt",+ ".cs", ".scala", ".php", ".cc", ".cxx", ".hpp", ".h", ".kts",".md", ".txt", ".rst", ".pdf",".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg",}diff --git a/pyproject.toml b/pyproject.tomlindex e9ba9e58c..a350a405b 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -19,6 +19,14 @@ dependencies = ["tree-sitter-typescript","tree-sitter-go","tree-sitter-rust",+ "tree-sitter-java",+ "tree-sitter-c",+ "tree-sitter-cpp",+ "tree-sitter-ruby",+ "tree-sitter-c-sharp",+ "tree-sitter-kotlin",+ "tree-sitter-scala",+ "tree-sitter-php",][project.optional-dependencies]diff --git a/skills/graphify/skill.md b/skills/graphify/skill.mdindex 174dc5a29..cddaa60e8 100644--- a/skills/graphify/skill.md+++ b/skills/graphify/skill.md@@ -92,6 +92,8 @@ Then act on it:### Step 3 — Extract entities and relationships+**Before starting:** note whether `--mode deep` was given. You must pass `DEEP_MODE=true` to every subagent in Step B2 if it was. Track this from the original invocation — do not lose it.+This step has two parts: **structural extraction** (deterministic, free) then **semantic extraction** (Claude, costs tokens).#### Part A — Structural extraction for code files@@ -496,28 +498,9 @@ print('graph.svg written — embeds in Obsidian, Notion, GitHub READMEs')"```-### Step 7c — Obsidian export (only if --obsidian flag)--```bash-python3 -c "-import sys, json-from graphify.build import build_from_json-from graphify.export import to_obsidian-from pathlib import Path+### Step 7c — SVG export already covered in Step 7b above-extraction = json.loads(Path('.graphify_extract.json').read_text())-analysis = json.loads(Path('.graphify_analysis.json').read_text())-labels_raw = json.loads(Path('.graphify_labels.json').read_text()) if Path('.graphify_labels.json').exists() else {}--G = build_from_json(extraction)-communities = {int(k): v for k, v in analysis['communities'].items()}-labels = {int(k): v for k, v in labels_raw.items()}--n = to_obsidian(G, communities, '.graphify/obsidian', community_labels=labels or None, cohesion=cohesion)-print(f'Obsidian vault written: {n} notes in .graphify/obsidian/')-print('Open .graphify/obsidian/ as a vault in Obsidian to explore the graph.')-"-```+_(No separate --obsidian flag — Obsidian vault is always generated in Step 6 by default.)_### Step 7d — MCP server (only if --mcp flag)@@ -525,7 +508,7 @@ print('Open .graphify/obsidian/ as a vault in Obsidian to explore the graph.')python3 -m graphify.serve .graphify/graph.json```-This starts a stdio MCP server that exposes tools: `query_graph`, `get_node`, `get_neighbors`, `get_community`, `god_nodes`, `graph_stats`. Add to Claude Desktop or any MCP-compatible agent orchestrator so other agents can query the graph live.+This starts a stdio MCP server that exposes tools: `query_graph`, `get_node`, `get_neighbors`, `get_community`, `god_nodes`, `graph_stats`, `shortest_path`. Add to Claude Desktop or any MCP-compatible agent orchestrator so other agents can query the graph live.To configure in Claude Desktop, add to `claude_desktop_config.json`:```json@@ -1007,12 +990,19 @@ import sysfrom graphify.ingest import ingestfrom pathlib import Path-out = ingest('URL', Path('./raw'), author='AUTHOR', contributor='CONTRIBUTOR')-print(f'Saved to {out}')+try:+ out = ingest('URL', Path('./raw'), author='AUTHOR', contributor='CONTRIBUTOR')+ print(f'Saved to {out}')+except ValueError as e:+ print(f'error: {e}', file=sys.stderr)+ sys.exit(1)+except RuntimeError as e:+ print(f'error: {e}', file=sys.stderr)+ sys.exit(1)"```-Replace `URL` with the actual URL, `AUTHOR` with the user's name if provided, `CONTRIBUTOR` likewise. After saving, automatically run the `--update` pipeline on `./raw` to merge the new file into the existing graph.+Replace `URL` with the actual URL, `AUTHOR` with the user's name if provided, `CONTRIBUTOR` likewise. If the command exits with an error, tell the user what went wrong — do not silently continue. After a successful save, automatically run the `--update` pipeline on `./raw` to merge the new file into the existing graph.Supported URL types (auto-detected):- Twitter/X → fetched via oEmbed, saved as `.md` with tweet text and authordiff --git a/tests/fixtures/sample.c b/tests/fixtures/sample.cnew file mode 100644index 000000000..0768cac21--- /dev/null+++ b/tests/fixtures/sample.c@@ -0,0 +1,27 @@+#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#define MAX_SIZE 256++static int validate(const char *input) {+ return input != NULL && strlen(input) > 0;+}++char *process(const char *input) {+ if (!validate(input)) {+ return NULL;+ }+ char *result = malloc(MAX_SIZE);+ strncpy(result, input, MAX_SIZE - 1);+ return result;+}++int main(int argc, char *argv[]) {+ char *out = process("hello");+ if (out) {+ printf("%s\n", out);+ free(out);+ }+ return 0;+}diff --git a/tests/fixtures/sample.cpp b/tests/fixtures/sample.cppnew file mode 100644index 000000000..88f4013b2--- /dev/null+++ b/tests/fixtures/sample.cpp@@ -0,0 +1,30 @@+#include <iostream>+#include <string>+#include <vector>++class HttpClient {+public:+ HttpClient(const std::string& baseUrl) : baseUrl_(baseUrl) {}++ std::string get(const std::string& path) {+ return buildRequest("GET", path);+ }++ std::string post(const std::string& path, const std::string& body) {+ return buildRequest("POST", path);+ }++private:+ std::string baseUrl_;++ std::string buildRequest(const std::string& method, const std::string& path) {+ return method + " " + baseUrl_ + path;+ }+};++int main() {+ HttpClient client("https://api.example.com");+ std::string response = client.get("/users");+ std::cout << response << std::endl;+ return 0;+}diff --git a/tests/fixtures/sample.cs b/tests/fixtures/sample.csnew file mode 100644index 000000000..11fa5b0e7--- /dev/null+++ b/tests/fixtures/sample.cs@@ -0,0 +1,37 @@+using System;+using System.Collections.Generic;+using System.Net.Http;++namespace GraphifyDemo+{+ public interface IProcessor+ {+ List<string> Process(List<string> items);+ }++ public class DataProcessor : IProcessor+ {+ private readonly HttpClient _client;++ public DataProcessor()+ {+ _client = new HttpClient();+ }++ public List<string> Process(List<string> items)+ {+ return Validate(items);+ }++ private List<string> Validate(List<string> items)+ {+ var result = new List<string>();+ foreach (var item in items)+ {+ if (!string.IsNullOrEmpty(item))+ result.Add(item.Trim());+ }+ return result;+ }+ }+}diff --git a/tests/fixtures/sample.java b/tests/fixtures/sample.javanew file mode 100644index 000000000..f161f74eb--- /dev/null+++ b/tests/fixtures/sample.java@@ -0,0 +1,32 @@+import java.util.List;+import java.util.ArrayList;++public class DataProcessor {+ private List<String> items;++ public DataProcessor() {+ this.items = new ArrayList<>();+ }++ public void addItem(String item) {+ items.add(item);+ }++ public List<String> process() {+ return validate(items);+ }++ private List<String> validate(List<String> data) {+ List<String> result = new ArrayList<>();+ for (String s : data) {+ if (s != null && !s.isEmpty()) {+ result.add(s.trim());+ }+ }+ return result;+ }+}++interface Processor {+ List<String> process();+}diff --git a/tests/fixtures/sample.kt b/tests/fixtures/sample.ktnew file mode 100644index 000000000..0f6284631--- /dev/null+++ b/tests/fixtures/sample.kt@@ -0,0 +1,23 @@+import kotlinx.coroutines.delay+import kotlin.math.max++data class Config(val baseUrl: String, val timeout: Int)++class HttpClient(private val config: Config) {+ fun get(path: String): String {+ return buildRequest("GET", path)+ }++ fun post(path: String, body: String): String {+ return buildRequest("POST", path)+ }++ private fun buildRequest(method: String, path: String): String {+ return "$method ${config.baseUrl}$path"+ }+}++fun createClient(baseUrl: String): HttpClient {+ val config = Config(baseUrl, 30)+ return HttpClient(config)+}diff --git a/tests/fixtures/sample.php b/tests/fixtures/sample.phpnew file mode 100644index 000000000..636d49f85--- /dev/null+++ b/tests/fixtures/sample.php@@ -0,0 +1,39 @@+<?php++namespace App\Http;++use App\Auth\Authenticator;+use App\Cache\CacheManager;++class ApiClient+{+ private string $baseUrl;+ private Authenticator $auth;++ public function __construct(string $baseUrl)+ {+ $this->baseUrl = $baseUrl;+ $this->auth = new Authenticator();+ }++ public function get(string $path): string+ {+ return $this->fetch($path, 'GET');+ }++ public function post(string $path, string $body): string+ {+ return $this->fetch($path, 'POST');+ }++ private function fetch(string $path, string $method): string+ {+ $token = $this->auth->getToken();+ return $method . ' ' . $this->baseUrl . $path;+ }+}++function parseResponse(string $raw): array+{+ return json_decode($raw, true);+}diff --git a/tests/fixtures/sample.rb b/tests/fixtures/sample.rbnew file mode 100644index 000000000..429bf78c7--- /dev/null+++ b/tests/fixtures/sample.rb@@ -0,0 +1,27 @@+require 'json'+require 'net/http'++class ApiClient+ def initialize(base_url)+ @base_url = base_url+ end++ def get(path)+ fetch(path, 'GET')+ end++ def post(path, body)+ fetch(path, 'POST')+ end++ private++ def fetch(path, method)+ uri = URI(@base_url + path)+ Net::HTTP.get(uri)+ end+end++def parse_response(raw)+ JSON.parse(raw)+enddiff --git a/tests/fixtures/sample.scala b/tests/fixtures/sample.scalanew file mode 100644index 000000000..fe23724fa--- /dev/null+++ b/tests/fixtures/sample.scala@@ -0,0 +1,23 @@+import scala.collection.mutable.ListBuffer++case class Config(baseUrl: String, timeout: Int)++class HttpClient(config: Config) {+ def get(path: String): String = {+ buildRequest("GET", path)+ }++ def post(path: String, body: String): String = {+ buildRequest("POST", path)+ }++ private def buildRequest(method: String, path: String): String = {+ s"$method ${config.baseUrl}$path"+ }+}++object HttpClientFactory {+ def create(baseUrl: String): HttpClient = {+ new HttpClient(Config(baseUrl, 30))+ }+}diff --git a/tests/test_benchmark.py b/tests/test_benchmark.pynew file mode 100644index 000000000..d5e18084a--- /dev/null+++ b/tests/test_benchmark.py@@ -0,0 +1,119 @@+"""Tests for graphify/benchmark.py."""+from __future__ import annotations+import json+import pytest+import networkx as nx+from networkx.readwrite import json_graph++from graphify.benchmark import run_benchmark, print_benchmark, _query_subgraph_tokens, _SAMPLE_QUESTIONS+++def _make_graph() -> nx.Graph:+ G = nx.Graph()+ G.add_node("n1", label="authentication", source_file="auth.py", source_location="L1", community=0)+ G.add_node("n2", label="api_handler", source_file="api.py", source_location="L5", community=0)+ G.add_node("n3", label="main_entry", source_file="main.py", source_location="L1", community=1)+ G.add_node("n4", label="error_handler", source_file="errors.py", source_location="L1", community=1)+ G.add_node("n5", label="database_layer", source_file="db.py", source_location="L1", community=2)+ G.add_edge("n1", "n2", relation="calls", confidence="INFERRED")+ G.add_edge("n2", "n3", relation="imports", confidence="EXTRACTED")+ G.add_edge("n3", "n4", relation="uses", confidence="EXTRACTED")+ G.add_edge("n5", "n2", relation="provides", confidence="EXTRACTED")+ return G+++def _write_graph(G: nx.Graph, path) -> None:+ data = json_graph.node_link_data(G, edges="links")+ path.write_text(json.dumps(data))+++# --- _query_subgraph_tokens ---++def test_query_returns_positive_for_matching_question():+ G = _make_graph()+ tokens = _query_subgraph_tokens(G, "how does authentication work")+ assert tokens > 0++def test_query_returns_zero_for_no_match():+ G = _make_graph()+ tokens = _query_subgraph_tokens(G, "xyzzy plugh zorkmid")+ assert tokens == 0++def test_query_bfs_expands_neighbors():+ G = _make_graph()+ # "authentication" matches n1, BFS depth=3 should reach n2, n3, n4+ tokens_deep = _query_subgraph_tokens(G, "authentication", depth=3)+ tokens_shallow = _query_subgraph_tokens(G, "authentication", depth=1)+ assert tokens_deep >= tokens_shallow+++# --- run_benchmark ---++def test_run_benchmark_returns_reduction(tmp_path):+ G = _make_graph()+ graph_file = tmp_path / "graph.json"+ _write_graph(G, graph_file)+ result = run_benchmark(str(graph_file), corpus_words=10_000)+ assert "reduction_ratio" in result+ assert result["reduction_ratio"] > 1.0++def test_run_benchmark_corpus_tokens_proportional(tmp_path):+ G = _make_graph()+ graph_file = tmp_path / "graph.json"+ _write_graph(G, graph_file)+ r1 = run_benchmark(str(graph_file), corpus_words=1_000)+ r2 = run_benchmark(str(graph_file), corpus_words=10_000)+ # corpus_tokens scales linearly with corpus_words (within integer-division rounding)+ assert abs(r2["corpus_tokens"] - r1["corpus_tokens"] * 10) <= r1["corpus_tokens"]++def test_run_benchmark_per_question_list(tmp_path):+ G = _make_graph()+ graph_file = tmp_path / "graph.json"+ _write_graph(G, graph_file)+ result = run_benchmark(str(graph_file), corpus_words=5_000,+ questions=["how does authentication work", "what is the main entry"])+ assert len(result["per_question"]) >= 1+ for p in result["per_question"]:+ assert "question" in p+ assert "query_tokens" in p+ assert "reduction" in p++def test_run_benchmark_estimates_corpus_if_no_words(tmp_path):+ G = _make_graph()+ graph_file = tmp_path / "graph.json"+ _write_graph(G, graph_file)+ result = run_benchmark(str(graph_file), corpus_words=None)+ assert result["corpus_words"] > 0++def test_run_benchmark_error_on_empty_graph(tmp_path):+ G = nx.Graph()+ graph_file = tmp_path / "empty.json"+ _write_graph(G, graph_file)+ result = run_benchmark(str(graph_file), corpus_words=1_000)+ assert "error" in result++def test_run_benchmark_includes_node_edge_counts(tmp_path):+ G = _make_graph()+ graph_file = tmp_path / "graph.json"+ _write_graph(G, graph_file)+ result = run_benchmark(str(graph_file), corpus_words=5_000)+ assert result["nodes"] == G.number_of_nodes()+ assert result["edges"] == G.number_of_edges()+++# --- print_benchmark ---++def test_print_benchmark_no_crash(tmp_path, capsys):+ G = _make_graph()+ graph_file = tmp_path / "graph.json"+ _write_graph(G, graph_file)+ result = run_benchmark(str(graph_file), corpus_words=5_000)+ print_benchmark(result)+ out = capsys.readouterr().out+ assert "reduction" in out.lower()+ assert "x" in out++def test_print_benchmark_error_message(capsys):+ print_benchmark({"error": "test error message"})+ out = capsys.readouterr().out+ assert "test error message" in outdiff --git a/tests/test_extract.py b/tests/test_extract.pyindex 9ec9faa13..2dd2e3e9d 100644--- a/tests/test_extract.py+++ b/tests/test_extract.py@@ -58,7 +58,9 @@ def test_extract_merges_multiple_files():def test_collect_files_from_dir():files = collect_files(FIXTURES)- supported = {".py", ".js", ".ts", ".tsx", ".go", ".rs"}+ supported = {".py", ".js", ".ts", ".tsx", ".go", ".rs",+ ".java", ".c", ".cpp", ".cc", ".cxx", ".rb",+ ".cs", ".kt", ".kts", ".scala", ".php", ".h", ".hpp"}assert all(f.suffix in supported for f in files)assert len(files) > 0diff --git a/tests/test_languages.py b/tests/test_languages.pynew file mode 100644index 000000000..3bd2d56ac--- /dev/null+++ b/tests/test_languages.py@@ -0,0 +1,219 @@+"""Tests for the 8 new language extractors: Java, C, C++, Ruby, C#, Kotlin, Scala, PHP."""+from __future__ import annotations+from pathlib import Path+import pytest+from graphify.extract import (+ extract_java, extract_c, extract_cpp, extract_ruby,+ extract_csharp, extract_kotlin, extract_scala, extract_php,+)++FIXTURES = Path(__file__).parent / "fixtures"+++def _labels(r):+ return [n["label"] for n in r["nodes"]]++def _relations(r):+ return {e["relation"] for e in r["edges"]}++def _calls(r):+ node_by_id = {n["id"]: n["label"] for n in r["nodes"]}+ return {+ (node_by_id.get(e["source"], e["source"]), node_by_id.get(e["target"], e["target"]))+ for e in r["edges"] if e["relation"] == "calls"+ }+++# ── Java ──────────────────────────────────────────────────────────────────────++def test_java_no_error():+ r = extract_java(FIXTURES / "sample.java")+ assert "error" not in r++def test_java_finds_class():+ r = extract_java(FIXTURES / "sample.java")+ assert any("DataProcessor" in l for l in _labels(r))++def test_java_finds_interface():+ r = extract_java(FIXTURES / "sample.java")+ assert any("Processor" in l for l in _labels(r))++def test_java_finds_methods():+ r = extract_java(FIXTURES / "sample.java")+ labels = _labels(r)+ assert any("addItem" in l for l in labels)+ assert any("process" in l for l in labels)++def test_java_finds_imports():+ r = extract_java(FIXTURES / "sample.java")+ assert "imports" in _relations(r)++def test_java_no_dangling_edges():+ r = extract_java(FIXTURES / "sample.java")+ node_ids = {n["id"] for n in r["nodes"]}+ for e in r["edges"]:+ assert e["source"] in node_ids+++# ── C ────────────────────────────────────────────────────────────────────────++def test_c_no_error():+ r = extract_c(FIXTURES / "sample.c")+ assert "error" not in r++def test_c_finds_functions():+ r = extract_c(FIXTURES / "sample.c")+ labels = _labels(r)+ assert any("process" in l for l in labels)+ assert any("main" in l for l in labels)++def test_c_finds_includes():+ r = extract_c(FIXTURES / "sample.c")+ assert "imports" in _relations(r)++def test_c_emits_calls():+ r = extract_c(FIXTURES / "sample.c")+ assert any(e["relation"] == "calls" for e in r["edges"])++def test_c_calls_are_inferred():+ r = extract_c(FIXTURES / "sample.c")+ for e in r["edges"]:+ if e["relation"] == "calls":+ assert e["confidence"] == "INFERRED"+++# ── C++ ───────────────────────────────────────────────────────────────────────++def test_cpp_no_error():+ r = extract_cpp(FIXTURES / "sample.cpp")+ assert "error" not in r++def test_cpp_finds_class():+ r = extract_cpp(FIXTURES / "sample.cpp")+ assert any("HttpClient" in l for l in _labels(r))++def test_cpp_finds_methods():+ r = extract_cpp(FIXTURES / "sample.cpp")+ labels = _labels(r)+ # C++ extractor captures the constructor and public-visible methods+ assert any("HttpClient" in l for l in labels)++def test_cpp_finds_includes():+ r = extract_cpp(FIXTURES / "sample.cpp")+ assert "imports" in _relations(r)+++# ── Ruby ─────────────────────────────────────────────────────────────────────++def test_ruby_no_error():+ r = extract_ruby(FIXTURES / "sample.rb")+ assert "error" not in r++def test_ruby_finds_class():+ r = extract_ruby(FIXTURES / "sample.rb")+ assert any("ApiClient" in l for l in _labels(r))++def test_ruby_finds_methods():+ r = extract_ruby(FIXTURES / "sample.rb")+ labels = _labels(r)+ assert any("get" in l for l in labels)+ assert any("post" in l for l in labels)++def test_ruby_finds_function():+ r = extract_ruby(FIXTURES / "sample.rb")+ assert any("parse_response" in l for l in _labels(r))+++# ── C# ───────────────────────────────────────────────────────────────────────++def test_csharp_no_error():+ r = extract_csharp(FIXTURES / "sample.cs")+ assert "error" not in r++def test_csharp_finds_class():+ r = extract_csharp(FIXTURES / "sample.cs")+ assert any("DataProcessor" in l for l in _labels(r))++def test_csharp_finds_interface():+ r = extract_csharp(FIXTURES / "sample.cs")+ assert any("IProcessor" in l for l in _labels(r))++def test_csharp_finds_methods():+ r = extract_csharp(FIXTURES / "sample.cs")+ labels = _labels(r)+ assert any("Process" in l for l in labels)++def test_csharp_finds_usings():+ r = extract_csharp(FIXTURES / "sample.cs")+ assert "imports" in _relations(r)+++# ── Kotlin ───────────────────────────────────────────────────────────────────++def test_kotlin_no_error():+ r = extract_kotlin(FIXTURES / "sample.kt")+ assert "error" not in r++def test_kotlin_finds_class():+ r = extract_kotlin(FIXTURES / "sample.kt")+ assert any("HttpClient" in l for l in _labels(r))++def test_kotlin_finds_data_class():+ r = extract_kotlin(FIXTURES / "sample.kt")+ assert any("Config" in l for l in _labels(r))++def test_kotlin_finds_methods():+ r = extract_kotlin(FIXTURES / "sample.kt")+ labels = _labels(r)+ assert any("get" in l for l in labels)+ assert any("post" in l for l in labels)++def test_kotlin_finds_function():+ r = extract_kotlin(FIXTURES / "sample.kt")+ assert any("createClient" in l for l in _labels(r))+++# ── Scala ─────────────────────────────────────────────────────────────────────++def test_scala_no_error():+ r = extract_scala(FIXTURES / "sample.scala")+ assert "error" not in r++def test_scala_finds_class():+ r = extract_scala(FIXTURES / "sample.scala")+ assert any("HttpClient" in l for l in _labels(r))++def test_scala_finds_object():+ r = extract_scala(FIXTURES / "sample.scala")+ assert any("HttpClientFactory" in l for l in _labels(r))++def test_scala_finds_methods():+ r = extract_scala(FIXTURES / "sample.scala")+ labels = _labels(r)+ assert any("get" in l for l in labels)+ assert any("post" in l for l in labels)+++# ── PHP ───────────────────────────────────────────────────────────────────────++def test_php_no_error():+ r = extract_php(FIXTURES / "sample.php")+ assert "error" not in r++def test_php_finds_class():+ r = extract_php(FIXTURES / "sample.php")+ assert any("ApiClient" in l for l in _labels(r))++def test_php_finds_methods():+ r = extract_php(FIXTURES / "sample.php")+ labels = _labels(r)+ assert any("get" in l for l in labels)+ assert any("post" in l for l in labels)++def test_php_finds_function():+ r = extract_php(FIXTURES / "sample.php")+ assert any("parseResponse" in l for l in _labels(r))++def test_php_finds_imports():+ r = extract_php(FIXTURES / "sample.php")+ assert "imports" in _relations(r)