Skip to content

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.

feat: 13-language AST support and token benchmark

Safi81a43f028ff1
diff --git a/README.md b/README.md
index 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 module
pyproject.toml pip install graphify | pip install graphify[mcp,neo4j,pdf,watch]
```
diff --git a/graphify/__main__.py b/graphify/__main__.py
index 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 json
import shutil
import sys
from 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()
return
cmd = 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.py
new file mode 100644
index 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.py
index 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.py
index 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.md
index 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 sys
from graphify.ingest import ingest
from 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 author
diff --git a/graphify/watch.py b/graphify/watch.py
index 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.toml
index 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.md
index 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 sys
from graphify.ingest import ingest
from 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 author
diff --git a/tests/fixtures/sample.c b/tests/fixtures/sample.c
new file mode 100644
index 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.cpp
new file mode 100644
index 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.cs
new file mode 100644
index 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.java
new file mode 100644
index 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.kt
new file mode 100644
index 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.php
new file mode 100644
index 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.rb
new file mode 100644
index 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)
+end
diff --git a/tests/fixtures/sample.scala b/tests/fixtures/sample.scala
new file mode 100644
index 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.py
new file mode 100644
index 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 out
diff --git a/tests/test_extract.py b/tests/test_extract.py
index 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) > 0
diff --git a/tests/test_languages.py b/tests/test_languages.py
new file mode 100644
index 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)