From 6b261fd846aad5b7db96134f5d2b25e6e0d95a23 Mon Sep 17 00:00:00 2001 From: Adhitya Ravi Date: Sun, 1 Mar 2026 22:51:54 +0100 Subject: [PATCH 1/2] feat: adds a codegraph query tool --- .coveragerc-unit | 7 + README.md | 15 + pyproject.toml | 5 + src/theow/_codegraph/README.md | 106 ++++ src/theow/_codegraph/__init__.py | 5 + src/theow/_codegraph/_graph.py | 457 ++++++++++++++++++ src/theow/_codegraph/_models.py | 113 +++++ src/theow/_codegraph/_visitors/__init__.py | 50 ++ src/theow/_codegraph/_visitors/_go.py | 302 ++++++++++++ src/theow/_codegraph/_visitors/_python.py | 289 +++++++++++ src/theow/_codegraph/_visitors/_utils.py | 27 ++ .../_codegraph/examples/theow_graph.html | 258 ++++++++++ src/theow/_codegraph/examples/theow_graph.png | Bin 0 -> 219561 bytes src/theow/_codegraph/examples/visualize.py | 63 +++ src/theow/_core/_logging.py | 1 + src/theow/codegraph.py | 13 + tests/codegraph/__init__.py | 0 tests/codegraph/conftest.py | 22 + tests/codegraph/test_graph.py | 241 +++++++++ tests/codegraph/test_models.py | 95 ++++ tests/codegraph/test_tool.py | 87 ++++ tests/codegraph/test_visitor.py | 322 ++++++++++++ tests/core/test_logging.py | 1 + tox.ini | 13 +- uv.lock | 66 ++- 25 files changed, 2553 insertions(+), 5 deletions(-) create mode 100644 .coveragerc-unit create mode 100644 src/theow/_codegraph/README.md create mode 100644 src/theow/_codegraph/__init__.py create mode 100644 src/theow/_codegraph/_graph.py create mode 100644 src/theow/_codegraph/_models.py create mode 100644 src/theow/_codegraph/_visitors/__init__.py create mode 100644 src/theow/_codegraph/_visitors/_go.py create mode 100644 src/theow/_codegraph/_visitors/_python.py create mode 100644 src/theow/_codegraph/_visitors/_utils.py create mode 100644 src/theow/_codegraph/examples/theow_graph.html create mode 100644 src/theow/_codegraph/examples/theow_graph.png create mode 100644 src/theow/_codegraph/examples/visualize.py create mode 100644 src/theow/codegraph.py create mode 100644 tests/codegraph/__init__.py create mode 100644 tests/codegraph/conftest.py create mode 100644 tests/codegraph/test_graph.py create mode 100644 tests/codegraph/test_models.py create mode 100644 tests/codegraph/test_tool.py create mode 100644 tests/codegraph/test_visitor.py diff --git a/.coveragerc-unit b/.coveragerc-unit new file mode 100644 index 0000000..b5d5a89 --- /dev/null +++ b/.coveragerc-unit @@ -0,0 +1,7 @@ +[run] +omit = + src/theow/_codegraph/* + src/theow/codegraph.py + +[report] +fail_under = 85 diff --git a/README.md b/README.md index 06401df..9fea54d 100644 --- a/README.md +++ b/README.md @@ -391,6 +391,21 @@ def run_safe_command(cmd: str) -> dict: This is the key to secure automation. You define the blast radius. The LLM operates within those boundaries. +### CodeGraph + +CodeGraph gives the explorer structural awareness of your codebase. Instead of reading entire files to orient, the LLM queries a tree-sitter based graph for symbols, call chains, imports, and class hierarchies. + +```python +from theow.codegraph import CodeGraph + +graph = CodeGraph(root="./src") +pipeline_agent.tool()(graph.search_code) +``` + +The LLM gets a single `search_code` tool that supports multiple scopes: find symbols by name, trace callers/callees, list file contents, follow class hierarchies, and find paths between symbols. + +CodeGraph is an optional dependency — install with `pip install theow[codegraph]`. See the [CodeGraph README](src/theow/_codegraph/README.md) for full documentation. + ## LLM Based Actions Rules can invoke the LLM directly on match instead of running a deterministic action. Useful for failures that need dynamic investigation rather than a fixed fix. diff --git a/pyproject.toml b/pyproject.toml index ddeacc4..1bad36e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,6 +24,11 @@ theow = "theow._cli:app" daemon = [ # Future: trio, httpx, etc. for server mode ] +codegraph = [ + "tree-sitter>=0.23", + "tree-sitter-python>=0.23", + "tree-sitter-go>=0.23", +] [dependency-groups] dev = [ diff --git a/src/theow/_codegraph/README.md b/src/theow/_codegraph/README.md new file mode 100644 index 0000000..27cb9c3 --- /dev/null +++ b/src/theow/_codegraph/README.md @@ -0,0 +1,106 @@ +
+ +# CodeGraph + +Tree-sitter based code structure graph for Theow's LLM explorer. Instead of reading entire files to orient (~4000+ tokens), the explorer queries the graph for symbols, call chains, imports, and class hierarchies (~260 tokens). + +
+ +
+Theow CodeGraph +
+Theow's own code graph — generated with examples/visualize.py +
+ +## Install + +CodeGraph is an optional dependency: + +```bash +pip install theow[codegraph] +``` + +## Usage + +```python +from theow import Theow +from theow.codegraph import CodeGraph + +graph = CodeGraph(root="./src") + +engine = Theow(theow_dir=".theow", llm="anthropic/claude-sonnet-4-20250514") +engine.tool()(graph.search_code) +``` + +The graph builds automatically on first `search_code` call. The LLM gets a single tool that covers all navigation needs. + +## `search_code` API + +| Parameter | Description | +|-----------|-------------| +| `query` | Symbol name or substring to search for | +| `kind` | Filter by type: `"function"`, `"class"`, `"module"` | +| `scope` | What to search (see below) | +| `file` | Filter to a specific file | +| `line` | Find the symbol at this line number in file | +| `target` | Target symbol for `"path"` scope | + +### Scopes + +| Scope | Description | Example | +|-------|-------------|---------| +| `symbol` | Find symbols by name (default) | `search_code(query="Rule", kind="class")` | +| `callers` | Who calls this symbol? | `search_code(query="matches", scope="callers")` | +| `callees` | What does this symbol call? | `search_code(query="build", scope="callees")` | +| `references` | All incoming/outgoing relationships | `search_code(query="LLMGateway", scope="references")` | +| `definition` | Where is this symbol defined? | `search_code(scope="definition", file="models.py", line=42)` | +| `file` | List all symbols in a file | `search_code(scope="file", file="_core/_models.py")` | +| `path` | Find relationship path between two symbols | `search_code(query="module.py", scope="path", target="Rule")` | + +## Language Support + +Visitors extract structure from source files using tree-sitter. Currently supported: + +- **Python** — functions, classes, methods, imports, calls, decorators, docstrings +- **Go** — functions, methods with receivers, structs, interfaces, imports, calls, struct embedding + +Languages are configured explicitly: + +```python +graph = CodeGraph(root="./src", languages=["python", "go"]) +``` + +Defaults to `["python"]` if not specified. + +## Configuration + +```python +graph = CodeGraph( + root="./src", + languages=["python", "go"], # languages to parse + excludes={"vendor", "testdata"}, # directories to skip + max_file_size=1_000_000, # skip files larger than this (bytes) +) +``` + +Default excludes: `__pycache__`, `.git`, `.tox`, `.venv`, `venv`, `node_modules`, `dist`, `build`, `.mypy_cache`, `.ruff_cache`, `.pytest_cache`. + +## Serialization + +```python +# Save to JSON +graph.to_json("graph.json") + +# Load from cache +graph = CodeGraph.from_json("graph.json") + +# Get JSON string +json_str = graph.to_json() +``` + +## How It Works + +1. **Parse**: Tree-sitter visitors walk source files and extract `Node` (symbols) and `Edge` (relationships) objects +2. **Index**: Nodes are indexed by file path and short name for fast lookup +3. **Resolve**: Symbolic call targets (short names like `helper`) are resolved to fully qualified node IDs, preferring same-file matches +4. **Query**: `search_code` navigates the graph using adjacency lists and BFS — no external graph library needed diff --git a/src/theow/_codegraph/__init__.py b/src/theow/_codegraph/__init__.py new file mode 100644 index 0000000..7e631d9 --- /dev/null +++ b/src/theow/_codegraph/__init__.py @@ -0,0 +1,5 @@ +"""CodeGraph: tree-sitter based code structure graph for LLM exploration.""" + +from theow._codegraph._graph import CodeGraph + +__all__ = ["CodeGraph"] diff --git a/src/theow/_codegraph/_graph.py b/src/theow/_codegraph/_graph.py new file mode 100644 index 0000000..85b4a92 --- /dev/null +++ b/src/theow/_codegraph/_graph.py @@ -0,0 +1,457 @@ +"""CodeGraph: tree-sitter based code structure graph.""" + +import json +from collections import deque +from pathlib import Path + +from theow._codegraph._models import Edge, Node, SearchResult +from theow._codegraph._visitors import LanguageVisitor, load_visitors +from theow._core._logging import get_logger + +logger = get_logger(__name__) + +DEFAULT_EXCLUDES = frozenset( + { + "__pycache__", + ".git", + ".tox", + ".venv", + "venv", + "node_modules", + "dist", + "build", + ".mypy_cache", + ".ruff_cache", + ".pytest_cache", + } +) + + +class CodeGraph: + """A queryable graph of code symbols and relationships. + + Parses source files with tree-sitter visitors and builds a directed graph + of modules, classes, functions, and their relationships (calls, imports, + inheritance, containment). + + Args: + root: Root directory of the codebase to index. + languages: Language names to load visitors for (e.g. ["python", "go"]). + Defaults to ["python"]. + visitors: Pre-built visitor instances. Overrides ``languages`` if given. + excludes: Directory names to skip during traversal. + max_file_size: Skip files larger than this (bytes). + """ + + def __init__( + self, + root: str | Path, + languages: list[str] | None = None, + visitors: list[LanguageVisitor] | None = None, + excludes: set[str] | None = None, + max_file_size: int = 1_000_000, + ) -> None: + self._root = Path(root).resolve() + self._excludes = excludes if excludes is not None else set(DEFAULT_EXCLUDES) + self._max_file_size = max_file_size + self._built = False + + if visitors is not None: + self._visitors = list(visitors) + else: + self._visitors = load_visitors(languages or ["python"]) + + # Build extension -> visitor lookup + self._ext_map: dict[str, LanguageVisitor] = {} + for v in self._visitors: + for ext in v.extensions: + self._ext_map[ext] = v + + # Internal state — adjacency lists for directed edges + self._fwd: dict[str, dict[str, dict]] = {} # source -> {target -> edge_data} + self._rev: dict[str, dict[str, dict]] = {} # target -> {source -> edge_data} + self._nodes: dict[str, Node] = {} + self._file_index: dict[str, list[str]] = {} + self._name_index: dict[str, list[str]] = {} + + def build(self) -> None: + """Parse all files and build the graph. Idempotent.""" + if self._built: + self._fwd.clear() + self._rev.clear() + self._nodes.clear() + self._file_index.clear() + self._name_index.clear() + + files_parsed = 0 + for path in self._iter_files(): + self.build_file(path) + files_parsed += 1 + + resolved, unresolved = self._resolve_edges() + self._built = True + logger.info( + "Code graph built", + files=files_parsed, + nodes=len(self._nodes), + edges=self._edge_count(), + resolved_refs=resolved, + unresolved_refs=unresolved, + ) + + def build_file(self, path: Path) -> None: + """Parse a single file and add its nodes/edges to the graph.""" + try: + source = path.read_text(encoding="utf-8", errors="replace") + except OSError: + return + + relative_path = str(path.relative_to(self._root)) + ext = path.suffix + visitor = self._ext_map.get(ext) + if not visitor: + return + + try: + nodes, edges = visitor.parse_file(path, source, relative_path) + except Exception as e: + logger.warning("Parse failed", file=relative_path, error=str(e)) + return + + for node in nodes: + self._nodes[node.id] = node + self._file_index.setdefault(node.file, []).append(node.id) + self._name_index.setdefault(node.name, []).append(node.id) + + for edge in edges: + self._add_edge(edge.source, edge.target, kind=edge.kind, line=edge.line) + + def _iter_files(self): + """Walk root directory, yielding files that match visitor extensions.""" + for path in sorted(self._root.rglob("*")): + if not path.is_file(): + continue + if any(part in self._excludes for part in path.parts): + continue + if path.stat().st_size > self._max_file_size: + logger.debug("Skipping large file", file=str(path.relative_to(self._root))) + continue + if path.suffix in self._ext_map: + yield path + + def _resolve_edges(self) -> tuple[int, int]: + """Resolve symbolic call/import targets to fully qualified node IDs. + + For call edges where the target is a short name (e.g. "helper"), + try to resolve it to a fully qualified node ID. Same-file preference + breaks ambiguity. + + Returns: + (resolved_count, unresolved_count) tuple. + """ + edges_to_resolve = [] + for source, targets in self._fwd.items(): + for target, data in targets.items(): + if data.get("kind") in ("calls", "inherits") and target not in self._nodes: + edges_to_resolve.append((source, target, data)) + + resolved_count = 0 + for source, target, data in edges_to_resolve: + resolved = self._resolve_name(target, source) + if resolved and resolved != target: + self._remove_edge(source, target) + self._add_edge(source, resolved, **data) + resolved_count += 1 + + return resolved_count, len(edges_to_resolve) - resolved_count + + def _resolve_name(self, name: str, context_id: str) -> str | None: + """Resolve a short name to a node ID, preferring same-file matches.""" + # For attribute access like "self.method" or "obj.method", use the last part + short = name.rsplit(".", 1)[-1] if "." in name else name + + candidates = self._name_index.get(short, []) + if not candidates: + return None + if len(candidates) == 1: + return candidates[0] + + # Prefer same-file + context_file = self._nodes[context_id].file if context_id in self._nodes else "" + for cid in candidates: + if cid in self._nodes and self._nodes[cid].file == context_file: + return cid + + return candidates[0] + + def _add_edge(self, source: str, target: str, **data) -> None: + self._fwd.setdefault(source, {})[target] = data + self._rev.setdefault(target, {})[source] = data + + def _remove_edge(self, source: str, target: str) -> None: + if source in self._fwd: + self._fwd[source].pop(target, None) + if target in self._rev: + self._rev[target].pop(source, None) + + def _edge_count(self) -> int: + return sum(len(targets) for targets in self._fwd.values()) + + def _bfs_path(self, source: str, target: str) -> list[str] | None: + """BFS shortest path from source to target.""" + if source == target: + return [source] + visited = {source} + queue: deque[list[str]] = deque([[source]]) + while queue: + path = queue.popleft() + for neighbor in self._fwd.get(path[-1], {}): + if neighbor == target: + return path + [neighbor] + if neighbor not in visited: + visited.add(neighbor) + queue.append(path + [neighbor]) + return None + + def search_code( + self, + query: str = "", + kind: str = "", + scope: str = "symbol", + file: str = "", + line: int = 0, + target: str = "", + ) -> list[dict]: + """Search the codebase structure. Navigate classes, functions, imports, and call relationships. + + Args: + query: Symbol name or substring to search for. + kind: Filter by type: "function", "class", "module", or "import". + scope: What to search for: + - "symbol": Find symbols by name (default) + - "callers": Who calls this symbol? + - "callees": What does this symbol call? + - "references": All incoming/outgoing relationships + - "definition": Where is this symbol defined? + - "file": List all symbols in a file + - "path": Find relationship path between query and target + file: Filter to a specific file, or target file for "file" scope. + line: Find the symbol at this line number in file. + target: Target symbol for "path" scope. + """ + if not self._built: + self.build() + + logger.debug("search_code", scope=scope, query=query, kind=kind, file=file) + + if scope == "file": + return self._search_file(file or query) + if scope == "callers": + return self._search_callers(query, kind) + if scope == "callees": + return self._search_callees(query, kind) + if scope == "references": + return self._search_references(query) + if scope == "definition": + return self._search_definition(query, file, line) + if scope == "path": + return self._search_path(query, target) + # Default: symbol search + return self._search_symbol(query, kind, file) + + def _search_symbol(self, query: str, kind: str, file: str) -> list[dict]: + """Find symbols matching query by name.""" + results: list[SearchResult] = [] + for node_id, node in self._nodes.items(): + if kind and node.kind != kind: + continue + if file and node.file != file: + continue + if query and query.lower() not in node.name.lower() and query.lower() not in node_id.lower(): + continue + relevance = "exact" if node.name == query else "substring" + results.append(SearchResult(node=node, relevance=relevance)) + + # Sort: exact matches first, then by file + line + results.sort(key=lambda r: (r.relevance != "exact", r.node.file, r.node.line)) + return [r.to_dict() for r in results[:50]] + + def _search_file(self, file: str) -> list[dict]: + """List all symbols in a file.""" + node_ids = self._file_index.get(file, []) + results = [] + for nid in node_ids: + node = self._nodes[nid] + results.append(SearchResult(node=node).to_dict()) + results.sort(key=lambda r: r["line"]) + return results + + def _search_callers(self, query: str, kind: str) -> list[dict]: + """Find symbols that call the queried symbol.""" + target_ids = self._find_node_ids(query, kind) + results: list[dict] = [] + for tid in target_ids: + for pred, edge_data in self._rev.get(tid, {}).items(): + if edge_data.get("kind") == "calls" and pred in self._nodes: + results.append( + SearchResult( + node=self._nodes[pred], + context=f"calls {tid}", + relevance="caller", + ).to_dict() + ) + return results + + def _search_callees(self, query: str, kind: str) -> list[dict]: + """Find symbols that the queried symbol calls.""" + source_ids = self._find_node_ids(query, kind) + results: list[dict] = [] + for sid in source_ids: + for succ, edge_data in self._fwd.get(sid, {}).items(): + if edge_data.get("kind") == "calls" and succ in self._nodes: + results.append( + SearchResult( + node=self._nodes[succ], + context=f"called by {sid}", + relevance="callee", + ).to_dict() + ) + return results + + def _search_references(self, query: str) -> list[dict]: + """Find all incoming/outgoing relationships for a symbol.""" + node_ids = self._find_node_ids(query, "") + results: list[dict] = [] + for nid in node_ids: + # Incoming + for pred, edge_data in self._rev.get(nid, {}).items(): + edge_kind = edge_data.get("kind", "unknown") + if pred in self._nodes: + results.append( + SearchResult( + node=self._nodes[pred], + context=f"{edge_kind} -> {nid}", + relevance="incoming", + ).to_dict() + ) + # Outgoing + for succ, edge_data in self._fwd.get(nid, {}).items(): + edge_kind = edge_data.get("kind", "unknown") + if succ in self._nodes: + results.append( + SearchResult( + node=self._nodes[succ], + context=f"{nid} {edge_kind} ->", + relevance="outgoing", + ).to_dict() + ) + return results + + def _search_definition(self, query: str, file: str, line: int) -> list[dict]: + """Find the definition of a symbol.""" + if file and line: + # Find symbol at file:line + node_ids = self._file_index.get(file, []) + for nid in node_ids: + node = self._nodes[nid] + if node.line <= line <= (node.end_line or node.line): + if node.kind != "module": + return [SearchResult(node=node, relevance="exact").to_dict()] + + # Fall back to name search + return self._search_symbol(query, "", file) + + def _search_path(self, query: str, target: str) -> list[dict]: + """Find relationship path between two symbols.""" + source_ids = self._find_node_ids(query, "") + target_ids = self._find_node_ids(target, "") + + for sid in source_ids: + for tid in target_ids: + path = self._bfs_path(sid, tid) + if path is None: + continue + + results: list[dict] = [] + for i, nid in enumerate(path): + if nid in self._nodes: + ctx = "" + if i < len(path) - 1: + edge_data = self._fwd.get(nid, {}).get(path[i + 1], {}) + ctx = f"--{edge_data.get('kind', '?')}--> {path[i + 1]}" + results.append( + SearchResult( + node=self._nodes[nid], + context=ctx, + relevance=f"step {i}", + ).to_dict() + ) + return results + + return [] + + def _find_node_ids(self, query: str, kind: str) -> list[str]: + """Find node IDs matching a query string.""" + # Exact ID match + if query in self._nodes: + return [query] + + # Exact name match + candidates = self._name_index.get(query, []) + if candidates: + if kind: + candidates = [c for c in candidates if self._nodes[c].kind == kind] + return candidates + + # Substring search + results = [] + for nid, node in self._nodes.items(): + if kind and node.kind != kind: + continue + if query.lower() in node.name.lower(): + results.append(nid) + return results + + def to_json(self, path: str | Path | None = None) -> str: + """Serialize graph to JSON.""" + edges = [] + for source, targets in self._fwd.items(): + for target, data in targets.items(): + edges.append( + Edge( + source=source, + target=target, + kind=data.get("kind", ""), + line=data.get("line", 0), + ).to_dict() + ) + data = { + "root": str(self._root), + "nodes": [n.to_dict() for n in self._nodes.values()], + "edges": edges, + } + result = json.dumps(data, indent=2) + if path: + Path(path).write_text(result) + return result + + @classmethod + def from_json(cls, path: str | Path) -> "CodeGraph": + """Load a cached graph from JSON.""" + raw = json.loads(Path(path).read_text()) + graph = cls(root=raw["root"], visitors=[]) + for node_data in raw["nodes"]: + node = Node.from_dict(node_data) + graph._nodes[node.id] = node + graph._file_index.setdefault(node.file, []).append(node.id) + graph._name_index.setdefault(node.name, []).append(node.id) + for edge_data in raw["edges"]: + edge = Edge.from_dict(edge_data) + graph._add_edge(edge.source, edge.target, kind=edge.kind, line=edge.line) + graph._built = True + logger.info( + "Code graph loaded from cache", + nodes=len(graph._nodes), + edges=graph._edge_count(), + ) + return graph diff --git a/src/theow/_codegraph/_models.py b/src/theow/_codegraph/_models.py new file mode 100644 index 0000000..2301a54 --- /dev/null +++ b/src/theow/_codegraph/_models.py @@ -0,0 +1,113 @@ +"""Data models for the code graph.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any + + +@dataclass(frozen=True) +class Node: + """A symbol in the code graph (module, class, or function).""" + + id: str + kind: str # "module" | "class" | "function" + name: str + file: str + line: int + end_line: int = 0 + signature: str = "" + docstring: str = "" + parent: str = "" + + def to_dict(self) -> dict[str, Any]: + """Convert to dictionary.""" + d: dict[str, Any] = { + "id": self.id, + "kind": self.kind, + "name": self.name, + "file": self.file, + "line": self.line, + } + if self.end_line: + d["end_line"] = self.end_line + if self.signature: + d["signature"] = self.signature + if self.docstring: + d["docstring"] = self.docstring + if self.parent: + d["parent"] = self.parent + return d + + @classmethod + def from_dict(cls, data: dict[str, Any]) -> Node: + """Create Node from dictionary.""" + return cls( + id=data["id"], + kind=data["kind"], + name=data["name"], + file=data["file"], + line=data["line"], + end_line=data.get("end_line", 0), + signature=data.get("signature", ""), + docstring=data.get("docstring", ""), + parent=data.get("parent", ""), + ) + + +@dataclass(frozen=True) +class Edge: + """A relationship between two nodes in the code graph.""" + + source: str + target: str + kind: str # "defines" | "contains" | "calls" | "imports" | "inherits" + line: int = 0 + + def to_dict(self) -> dict[str, Any]: + """Convert to dictionary.""" + d: dict[str, Any] = { + "source": self.source, + "target": self.target, + "kind": self.kind, + } + if self.line: + d["line"] = self.line + return d + + @classmethod + def from_dict(cls, data: dict[str, Any]) -> Edge: + """Create Edge from dictionary.""" + return cls( + source=data["source"], + target=data["target"], + kind=data["kind"], + line=data.get("line", 0), + ) + + +@dataclass(frozen=True) +class SearchResult: + """A search result wrapping a Node with context.""" + + node: Node + context: str = "" + relevance: str = "" + + def to_dict(self) -> dict[str, Any]: + """Convert to dictionary.""" + d: dict[str, Any] = self.node.to_dict() + if self.context: + d["context"] = self.context + if self.relevance: + d["relevance"] = self.relevance + return d + + @classmethod + def from_dict(cls, data: dict[str, Any]) -> SearchResult: + """Create SearchResult from dictionary.""" + return cls( + node=Node.from_dict(data), + context=data.get("context", ""), + relevance=data.get("relevance", ""), + ) diff --git a/src/theow/_codegraph/_visitors/__init__.py b/src/theow/_codegraph/_visitors/__init__.py new file mode 100644 index 0000000..f77bdde --- /dev/null +++ b/src/theow/_codegraph/_visitors/__init__.py @@ -0,0 +1,50 @@ +"""Language visitor protocol and registry.""" + +from __future__ import annotations + +import importlib +from pathlib import Path +from typing import Protocol + +from theow._codegraph._models import Edge, Node + + +class LanguageVisitor(Protocol): + """Protocol for language-specific tree-sitter visitors.""" + + extensions: list[str] + + def parse_file( + self, path: Path, source: str, relative_path: str + ) -> tuple[list[Node], list[Edge]]: ... + + +# Registry mapping language name -> (module_path, class_name) +BUILTIN_VISITORS: dict[str, tuple[str, str]] = { + "python": ("theow._codegraph._visitors._python", "PythonVisitor"), + "go": ("theow._codegraph._visitors._go", "GoVisitor"), +} + + +def load_visitors(languages: list[str]) -> list[LanguageVisitor]: + """Load visitors for the specified languages. + + Args: + languages: Language names to load (e.g. ["python", "go"]). + + Raises: + ValueError: If a language name is not in the registry. + ImportError: If a language's tree-sitter grammar is not installed. + """ + visitors: list[LanguageVisitor] = [] + for lang in languages: + entry = BUILTIN_VISITORS.get(lang) + if entry is None: + raise ValueError( + f"Unknown language: {lang!r}. Available: {sorted(BUILTIN_VISITORS)}" + ) + module_path, class_name = entry + module = importlib.import_module(module_path) + cls = getattr(module, class_name) + visitors.append(cls()) + return visitors diff --git a/src/theow/_codegraph/_visitors/_go.py b/src/theow/_codegraph/_visitors/_go.py new file mode 100644 index 0000000..8791525 --- /dev/null +++ b/src/theow/_codegraph/_visitors/_go.py @@ -0,0 +1,302 @@ +"""Go language visitor using tree-sitter.""" + +from __future__ import annotations + +from pathlib import Path + +import tree_sitter_go as tsgo +from tree_sitter import Language, Node as TSNode, Parser + +from theow._codegraph._models import Edge, Node +from theow._codegraph._visitors._utils import child_by_type, last_child_by_type, text + +GO_LANGUAGE = Language(tsgo.language()) + + +class GoVisitor: + """Extract nodes and edges from Go source files.""" + + extensions: list[str] = [".go"] + + def __init__(self) -> None: + self._parser = Parser(GO_LANGUAGE) + + def parse_file( + self, path: Path, source: str, relative_path: str + ) -> tuple[list[Node], list[Edge]]: + """Parse a Go file and extract structural nodes and edges.""" + tree = self._parser.parse(source.encode()) + nodes: list[Node] = [] + edges: list[Edge] = [] + + module_id = relative_path + nodes.append( + Node( + id=module_id, + kind="module", + name=Path(relative_path).stem, + file=relative_path, + line=1, + end_line=source.count("\n") + 1, + ) + ) + + for child in tree.root_node.children: + if child.type == "function_declaration": + self._extract_function(child, module_id, relative_path, nodes, edges) + elif child.type == "method_declaration": + self._extract_method(child, module_id, relative_path, nodes, edges) + elif child.type == "type_declaration": + self._extract_type_declaration(child, module_id, relative_path, nodes, edges) + elif child.type == "import_declaration": + self._extract_imports(child, module_id, relative_path, edges) + + return nodes, edges + + def _extract_function( + self, + node: TSNode, + parent_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + name_node = child_by_type(node, "identifier") + if not name_node: + return + + name = text(name_node) + func_id = f"{parent_id}::{name}" + + params = child_by_type(node, "parameter_list") + result = child_by_type(node, "result") + sig = f"func {name}" + if params: + sig += text(params) + if result: + sig += " " + text(result) + + start_line = node.start_point[0] + 1 + end_line = node.end_point[0] + 1 + + nodes.append( + Node( + id=func_id, + kind="function", + name=name, + file=relative_path, + line=start_line, + end_line=end_line, + signature=sig, + parent=parent_id, + ) + ) + edges.append(Edge(source=parent_id, target=func_id, kind="contains", line=start_line)) + + body = child_by_type(node, "block") + if body: + self._extract_calls_in_body(body, func_id, relative_path, edges) + + def _extract_method( + self, + node: TSNode, + module_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + name_node = child_by_type(node, "field_identifier") + if not name_node: + return + + name = text(name_node) + + receiver_node = child_by_type(node, "parameter_list") + receiver_type = "" + if receiver_node: + for ch in receiver_node.children: + if ch.type == "parameter_declaration": + type_node = last_child_by_type( + ch, "type_identifier" + ) or last_child_by_type(ch, "pointer_type") + if type_node: + receiver_type = text(type_node).lstrip("*") + break + + receiver_id = f"{module_id}::{receiver_type}" if receiver_type else module_id + method_id = f"{receiver_id}::{name}" + + params_nodes = [c for c in node.children if c.type == "parameter_list"] + params_text = text(params_nodes[1]) if len(params_nodes) > 1 else "()" + result = child_by_type(node, "result") + sig = f"func ({receiver_type}) {name}{params_text}" + if result: + sig += " " + text(result) + + start_line = node.start_point[0] + 1 + end_line = node.end_point[0] + 1 + + nodes.append( + Node( + id=method_id, + kind="function", + name=name, + file=relative_path, + line=start_line, + end_line=end_line, + signature=sig, + parent=receiver_id, + ) + ) + edges.append( + Edge(source=receiver_id, target=method_id, kind="contains", line=start_line) + ) + + body = child_by_type(node, "block") + if body: + self._extract_calls_in_body(body, method_id, relative_path, edges) + + def _extract_type_declaration( + self, + node: TSNode, + parent_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + for child in node.children: + if child.type == "type_spec": + self._extract_type_spec(child, parent_id, relative_path, nodes, edges) + + def _extract_type_spec( + self, + node: TSNode, + parent_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + name_node = child_by_type(node, "type_identifier") + if not name_node: + return + + name = text(name_node) + type_id = f"{parent_id}::{name}" + + struct_type = child_by_type(node, "struct_type") + kind = "class" + + start_line = node.start_point[0] + 1 + end_line = node.end_point[0] + 1 + + nodes.append( + Node( + id=type_id, + kind=kind, + name=name, + file=relative_path, + line=start_line, + end_line=end_line, + parent=parent_id, + ) + ) + edges.append(Edge(source=parent_id, target=type_id, kind="contains", line=start_line)) + + if struct_type: + field_list = child_by_type(struct_type, "field_declaration_list") + if field_list: + for field in field_list.children: + if field.type == "field_declaration": + children = [c for c in field.children if c.type != "comment"] + if len(children) == 1 and children[0].type == "type_identifier": + embedded = text(children[0]) + edges.append( + Edge( + source=type_id, + target=embedded, + kind="inherits", + line=field.start_point[0] + 1, + ) + ) + + def _extract_imports( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Extract import declarations.""" + for child in node.children: + if child.type == "import_spec": + path_node = child_by_type(child, "interpreted_string_literal") + if path_node: + import_path = text(path_node).strip('"') + edges.append( + Edge( + source=parent_id, + target=import_path, + kind="imports", + line=child.start_point[0] + 1, + ) + ) + elif child.type == "import_spec_list": + for spec in child.children: + if spec.type == "import_spec": + path_node = child_by_type(spec, "interpreted_string_literal") + if path_node: + import_path = text(path_node).strip('"') + edges.append( + Edge( + source=parent_id, + target=import_path, + kind="imports", + line=spec.start_point[0] + 1, + ) + ) + + def _extract_calls_in_body( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Recursively find call expressions in a body block.""" + for child in node.children: + if child.type == "call_expression": + self._extract_call(child, parent_id, relative_path, edges) + else: + self._extract_calls_in_body(child, parent_id, relative_path, edges) + + def _extract_call( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Extract a call expression into an edge.""" + func = node.children[0] if node.children else None + if not func: + return + + if func.type == "identifier": + target = text(func) + elif func.type == "selector_expression": + target = text(func) + else: + return + + edges.append( + Edge( + source=parent_id, + target=target, + kind="calls", + line=node.start_point[0] + 1, + ) + ) + + arg_list = child_by_type(node, "argument_list") + if arg_list: + self._extract_calls_in_body(arg_list, parent_id, relative_path, edges) diff --git a/src/theow/_codegraph/_visitors/_python.py b/src/theow/_codegraph/_visitors/_python.py new file mode 100644 index 0000000..ef8c955 --- /dev/null +++ b/src/theow/_codegraph/_visitors/_python.py @@ -0,0 +1,289 @@ +"""Python language visitor using tree-sitter.""" + +from __future__ import annotations + +from pathlib import Path + +import tree_sitter_python as tspython +from tree_sitter import Language, Node as TSNode, Parser + +from theow._codegraph._models import Edge, Node +from theow._codegraph._visitors._utils import child_by_type, text + +PY_LANGUAGE = Language(tspython.language()) + + +class PythonVisitor: + """Extract nodes and edges from Python source files.""" + + extensions: list[str] = [".py"] + + def __init__(self) -> None: + self._parser = Parser(PY_LANGUAGE) + + def parse_file( + self, path: Path, source: str, relative_path: str + ) -> tuple[list[Node], list[Edge]]: + """Parse a Python file and extract structural nodes and edges.""" + tree = self._parser.parse(source.encode()) + nodes: list[Node] = [] + edges: list[Edge] = [] + + module_id = relative_path + nodes.append( + Node( + id=module_id, + kind="module", + name=Path(relative_path).stem, + file=relative_path, + line=1, + end_line=source.count("\n") + 1, + ) + ) + + self._walk(tree.root_node, module_id, relative_path, nodes, edges) + return nodes, edges + + def _walk( + self, + node: TSNode, + parent_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + """Recursively walk the AST and extract symbols.""" + for child in node.children: + if child.type == "function_definition": + self._extract_function(child, parent_id, relative_path, nodes, edges) + elif child.type == "decorated_definition": + for inner in child.children: + if inner.type == "function_definition": + self._extract_function( + inner, parent_id, relative_path, nodes, edges + ) + elif inner.type == "class_definition": + self._extract_class( + inner, parent_id, relative_path, nodes, edges + ) + elif child.type == "class_definition": + self._extract_class(child, parent_id, relative_path, nodes, edges) + elif child.type == "import_statement": + self._extract_import(child, parent_id, relative_path, edges) + elif child.type == "import_from_statement": + self._extract_import_from(child, parent_id, relative_path, edges) + elif child.type == "expression_statement": + expr = child.children[0] if child.children else None + if expr and expr.type == "call": + self._extract_call(expr, parent_id, relative_path, edges) + + def _extract_function( + self, + node: TSNode, + parent_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + name_node = child_by_type(node, "identifier") + if not name_node: + return + + name = text(name_node) + func_id = f"{parent_id}::{name}" + + params_node = child_by_type(node, "parameters") + signature = f"def {name}{text(params_node)}" if params_node else f"def {name}()" + + docstring = _extract_docstring(node) + + start_line = node.start_point[0] + 1 + end_line = node.end_point[0] + 1 + + nodes.append( + Node( + id=func_id, + kind="function", + name=name, + file=relative_path, + line=start_line, + end_line=end_line, + signature=signature, + docstring=docstring, + parent=parent_id, + ) + ) + edges.append(Edge(source=parent_id, target=func_id, kind="contains", line=start_line)) + + body = child_by_type(node, "block") + if body: + self._extract_calls_in_body(body, func_id, relative_path, edges) + + def _extract_class( + self, + node: TSNode, + parent_id: str, + relative_path: str, + nodes: list[Node], + edges: list[Edge], + ) -> None: + name_node = child_by_type(node, "identifier") + if not name_node: + return + + name = text(name_node) + class_id = f"{parent_id}::{name}" + + arg_list = child_by_type(node, "argument_list") + if arg_list: + for arg in arg_list.children: + if arg.type == "identifier": + edges.append( + Edge( + source=class_id, + target=text(arg), + kind="inherits", + line=arg.start_point[0] + 1, + ) + ) + + docstring = _extract_docstring(node) + start_line = node.start_point[0] + 1 + end_line = node.end_point[0] + 1 + + nodes.append( + Node( + id=class_id, + kind="class", + name=name, + file=relative_path, + line=start_line, + end_line=end_line, + docstring=docstring, + parent=parent_id, + ) + ) + edges.append(Edge(source=parent_id, target=class_id, kind="contains", line=start_line)) + + body = child_by_type(node, "block") + if body: + self._walk(body, class_id, relative_path, nodes, edges) + + def _extract_import( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Extract `import foo` statements.""" + for child in node.children: + if child.type == "dotted_name": + edges.append( + Edge( + source=parent_id, + target=text(child), + kind="imports", + line=node.start_point[0] + 1, + ) + ) + + def _extract_import_from( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Extract `from foo import bar` statements.""" + module_name = "" + for child in node.children: + if child.type == "dotted_name" and not module_name: + module_name = text(child) + elif child.type == "relative_import": + module_name = text(child) + + if module_name: + edges.append( + Edge( + source=parent_id, + target=module_name, + kind="imports", + line=node.start_point[0] + 1, + ) + ) + + def _extract_calls_in_body( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Recursively find call expressions in a body block.""" + for child in node.children: + if child.type == "call": + self._extract_call(child, parent_id, relative_path, edges) + elif child.type == "expression_statement": + for inner in child.children: + if inner.type == "call": + self._extract_call(inner, parent_id, relative_path, edges) + else: + self._extract_calls_in_body(inner, parent_id, relative_path, edges) + else: + self._extract_calls_in_body(child, parent_id, relative_path, edges) + + def _extract_call( + self, + node: TSNode, + parent_id: str, + relative_path: str, + edges: list[Edge], + ) -> None: + """Extract a call expression into an edge.""" + func = node.children[0] if node.children else None + if not func: + return + + if func.type == "identifier": + target = text(func) + elif func.type == "attribute": + target = text(func) + else: + return + + edges.append( + Edge( + source=parent_id, + target=target, + kind="calls", + line=node.start_point[0] + 1, + ) + ) + + +def _extract_docstring(node: TSNode) -> str: + """Extract docstring from a function or class definition.""" + body = child_by_type(node, "block") + if not body: + return "" + + children = body.children + if not children: + return "" + + first_stmt = children[0] + if first_stmt.type == "expression_statement": + expr = first_stmt.children[0] if first_stmt.children else None + if expr and expr.type == "string": + raw = text(expr) + # Strip triple quotes + for q in ('"""', "'''"): + if raw.startswith(q) and raw.endswith(q): + return raw[3:-3].strip() + # Strip single quotes + for q in ('"', "'"): + if raw.startswith(q) and raw.endswith(q): + return raw[1:-1].strip() + return raw + return "" diff --git a/src/theow/_codegraph/_visitors/_utils.py b/src/theow/_codegraph/_visitors/_utils.py new file mode 100644 index 0000000..bbf1fec --- /dev/null +++ b/src/theow/_codegraph/_visitors/_utils.py @@ -0,0 +1,27 @@ +"""Shared tree-sitter utilities for language visitors.""" + +from __future__ import annotations + +from tree_sitter import Node as TSNode + + +def text(node: TSNode) -> str: + """Get node text as a decoded string.""" + return node.text.decode() if node.text else "" + + +def child_by_type(node: TSNode, type_name: str) -> TSNode | None: + """Find first child of a given type.""" + for child in node.children: + if child.type == type_name: + return child + return None + + +def last_child_by_type(node: TSNode, type_name: str) -> TSNode | None: + """Find last child of a given type.""" + result = None + for child in node.children: + if child.type == type_name: + result = child + return result diff --git a/src/theow/_codegraph/examples/theow_graph.html b/src/theow/_codegraph/examples/theow_graph.html new file mode 100644 index 0000000..05ae2a5 --- /dev/null +++ b/src/theow/_codegraph/examples/theow_graph.html @@ -0,0 +1,258 @@ + + + + + + + + + +
+

+
+ + + + + + +
+

+
+ + + + + +
+ + +
+
+ + +
+
+
0%
+
+
+
+
+
+ + + + + + \ No newline at end of file diff --git a/src/theow/_codegraph/examples/theow_graph.png b/src/theow/_codegraph/examples/theow_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..4c5946ce2140ee12a5a108d932647a48d1aa2d6e GIT binary patch literal 219561 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 z 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 mZoB8&LbjI&?Vnqe|2O!H5v5_!orp=V<(; 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νWr!G? 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%0D@)OFTUJjllzD5Z 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 literal 0 HcmV?d00001 diff --git a/src/theow/_codegraph/examples/visualize.py b/src/theow/_codegraph/examples/visualize.py new file mode 100644 index 0000000..e2083f0 --- /dev/null +++ b/src/theow/_codegraph/examples/visualize.py @@ -0,0 +1,63 @@ +"""Visualize theow's code graph with pyvis. Run: uv run --extra codegraph src/theow/_codegraph/examples/visualize.py""" + +from pathlib import Path + +from pyvis.network import Network + +from theow.codegraph import CodeGraph + +COLORS = { + "module": "#bd93f9", + "class": "#ffb86c", + "function": "#50fa7b", +} + +EDGE_COLORS = { + "contains": "#6272a4", + "calls": "#f1fa8c", + "imports": "#6272a4", + "inherits": "#ff5555", +} + +graph = CodeGraph(root=Path(__file__).resolve().parent.parent.parent.parent.parent / "src" / "theow") +graph.build() + +net = Network(height="100vh", width="100%", directed=True, bgcolor="#282a36", font_color="#f8f8f2") +net.barnes_hut(gravity=-3000, spring_length=150) + +for node in graph._nodes.values(): + label = node.name + title = f"{node.id}\n{node.kind}\n{node.file}:{node.line}" + if node.signature: + title += f"\n{node.signature}" + if node.docstring: + title += f"\n\n{node.docstring[:200]}" + + size = {"module": 25, "class": 18, "function": 12}.get(node.kind, 10) + net.add_node( + node.id, + label=label, + title=title, + color=COLORS.get(node.kind, "#999"), + size=size, + group=node.kind, + ) + +for source, targets in graph._fwd.items(): + for target, data in targets.items(): + if target not in graph._nodes: + continue + kind = data.get("kind", "") + net.add_edge( + source, + target, + title=kind, + color=EDGE_COLORS.get(kind, "#ccc"), + arrows="to", + width=2 if kind in ("calls", "inherits") else 1, + ) + +out = Path(__file__).resolve().parent / "theow_graph.html" +net.save_graph(str(out)) +print(f"Graph saved to {out}") +print(f"Nodes: {len(graph._nodes)}, Edges: {graph._edge_count()}") diff --git a/src/theow/_core/_logging.py b/src/theow/_core/_logging.py index a4b1e5c..e247cef 100644 --- a/src/theow/_core/_logging.py +++ b/src/theow/_core/_logging.py @@ -20,6 +20,7 @@ "theow._core._chroma_store": "chroma", "theow._core._recover": "recovery", "theow._cli._run": "cli", + "theow._codegraph._graph": "codegraph", } diff --git a/src/theow/codegraph.py b/src/theow/codegraph.py new file mode 100644 index 0000000..959208a --- /dev/null +++ b/src/theow/codegraph.py @@ -0,0 +1,13 @@ +"""Code graph for consumer opt-in registration. + +Usage: + from theow.codegraph import CodeGraph + + graph = CodeGraph(root="./src") + engine = Theow(theow_dir=".theow", llm="anthropic/claude-sonnet-4-20250514") + engine.tool()(graph.search_code) +""" + +from theow._codegraph import CodeGraph + +__all__ = ["CodeGraph"] diff --git a/tests/codegraph/__init__.py b/tests/codegraph/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/codegraph/conftest.py b/tests/codegraph/conftest.py new file mode 100644 index 0000000..e734360 --- /dev/null +++ b/tests/codegraph/conftest.py @@ -0,0 +1,22 @@ +"""Shared fixtures for codegraph tests.""" + +import tempfile +from pathlib import Path + +import pytest + +# Theow's own source tree as test corpus +THEOW_SRC = Path(__file__).resolve().parent.parent.parent / "src" / "theow" + + +@pytest.fixture +def theow_src(): + """Path to theow's own source tree.""" + return THEOW_SRC + + +@pytest.fixture +def empty_project(): + """Empty directory for edge-case tests.""" + with tempfile.TemporaryDirectory() as tmpdir: + yield Path(tmpdir) diff --git a/tests/codegraph/test_graph.py b/tests/codegraph/test_graph.py new file mode 100644 index 0000000..6d98abd --- /dev/null +++ b/tests/codegraph/test_graph.py @@ -0,0 +1,241 @@ +"""Tests for CodeGraph using theow's own source.""" + +import json +import tempfile +from pathlib import Path + +from theow._codegraph._graph import CodeGraph + + +def test_build_on_theow_src(theow_src): + """Building a graph on theow's source should produce real nodes and edges.""" + graph = CodeGraph(root=theow_src) + graph.build() + + assert len(graph._nodes) > 50 + assert graph._edge_count() > 50 + assert graph._built is True + + +def test_build_idempotent(theow_src): + """Calling build() twice should produce the same graph.""" + graph = CodeGraph(root=theow_src) + graph.build() + count_1 = len(graph._nodes) + + graph.build() + count_2 = len(graph._nodes) + + assert count_1 == count_2 + + +def test_build_empty_project(empty_project): + """Empty directory should build an empty graph without errors.""" + graph = CodeGraph(root=empty_project) + graph.build() + assert len(graph._nodes) == 0 + + +def test_auto_build_on_first_search(theow_src): + """search_code should trigger build() if not already built.""" + graph = CodeGraph(root=theow_src) + assert graph._built is False + + results = graph.search_code(query="Rule", kind="class") + assert graph._built is True + assert len(results) > 0 + + +def test_search_symbol_exact(theow_src): + """Exact name match for a known class.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="Rule", kind="class") + + assert any(r["name"] == "Rule" for r in results) + assert results[0]["relevance"] == "exact" + + +def test_search_symbol_substring(theow_src): + """Substring match should find partial name matches.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="Gateway") + + names = {r["name"] for r in results} + assert "LLMGateway" in names + + +def test_search_symbol_by_kind(theow_src): + """Filtering by kind should only return that kind.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="", kind="class") + + for r in results: + assert r["kind"] == "class" + + +def test_search_file_scope(theow_src): + """File scope should list all symbols in a specific file.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(scope="file", file="_core/_models.py") + + assert len(results) > 5 + assert all(r["file"] == "_core/_models.py" for r in results) + # Should be sorted by line number + lines = [r["line"] for r in results] + assert lines == sorted(lines) + + +def test_search_callers(theow_src): + """Callers scope should find functions that call the target.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="matches", scope="callers") + + # Something should call matches() + assert len(results) > 0 + assert all(r.get("relevance") == "caller" for r in results) + + +def test_search_callees(theow_src): + """Callees scope should find functions that the target calls.""" + graph = CodeGraph(root=theow_src) + # Fact.matches calls re.search — look for callees of matches + results = graph.search_code(query="matches", scope="callees") + + # matches() should call something + assert len(results) >= 0 # may or may not resolve depending on edge resolution + + +def test_search_references(theow_src): + """References scope should show both incoming and outgoing edges.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="Rule", scope="references") + + # Rule has both incoming (contains) and outgoing edges + assert len(results) > 0 + + +def test_search_definition_by_file_line(theow_src): + """Definition scope with file+line should find the symbol at that location.""" + graph = CodeGraph(root=theow_src) + graph.build() + + # Find Rule's line number first + rule_node = graph._nodes.get("_core/_models.py::Rule") + assert rule_node is not None + + results = graph.search_code( + scope="definition", file="_core/_models.py", line=rule_node.line + ) + assert len(results) > 0 + assert results[0]["name"] == "Rule" + + +def test_search_path(theow_src): + """Path scope should find a relationship chain between two symbols.""" + graph = CodeGraph(root=theow_src) + graph.build() + + # _core/_models.py module contains Rule class + results = graph.search_code( + query="_core/_models.py", scope="path", target="Rule" + ) + # Should find a path (module --contains--> Rule) + assert len(results) >= 2 + + +def test_search_no_results(theow_src): + """Searching for a nonexistent symbol returns empty list.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="XyzNonExistent12345") + assert results == [] + + +def test_excludes(theow_src): + """Excluded directories should not appear in the graph.""" + graph = CodeGraph(root=theow_src) + graph.build() + + for node in graph._nodes.values(): + assert "__pycache__" not in node.file + + +def test_max_file_size(theow_src): + """Files above max_file_size should be skipped.""" + graph = CodeGraph(root=theow_src, max_file_size=100) + graph.build() + + # With 100 byte limit, most files should be skipped + assert len(graph._nodes) < 10 + + +def test_file_index(theow_src): + """File index should map files to their node IDs.""" + graph = CodeGraph(root=theow_src) + graph.build() + + assert "_core/_models.py" in graph._file_index + node_ids = graph._file_index["_core/_models.py"] + assert any("Rule" in nid for nid in node_ids) + + +def test_name_index(theow_src): + """Name index should map short names to node IDs.""" + graph = CodeGraph(root=theow_src) + graph.build() + + assert "Rule" in graph._name_index + assert len(graph._name_index["Rule"]) >= 1 + + +def test_json_roundtrip(theow_src): + """Graph should survive JSON serialization and deserialization.""" + graph = CodeGraph(root=theow_src) + graph.build() + + with tempfile.NamedTemporaryFile(suffix=".json", mode="w", delete=False) as f: + json_path = f.name + + graph.to_json(json_path) + loaded = CodeGraph.from_json(json_path) + + assert len(loaded._nodes) == len(graph._nodes) + assert loaded._edge_count() == graph._edge_count() + assert loaded._built is True + + Path(json_path).unlink() + + +def test_json_to_string(theow_src): + """to_json without path should return a JSON string.""" + graph = CodeGraph(root=theow_src) + graph.build() + + result = graph.to_json() + data = json.loads(result) + assert "nodes" in data + assert "edges" in data + assert len(data["nodes"]) == len(graph._nodes) + + +def test_custom_excludes(theow_src): + """Custom excludes should override defaults.""" + graph = CodeGraph(root=theow_src, excludes={"_core"}) + graph.build() + + for node in graph._nodes.values(): + assert "_core" not in node.file + + +def test_edge_resolution(theow_src): + """Edge resolution should resolve some symbolic names to node IDs.""" + graph = CodeGraph(root=theow_src) + graph.build() + + # After resolution, some call edges should point to known nodes + resolved_calls = 0 + for source, targets in graph._fwd.items(): + for target, data in targets.items(): + if data.get("kind") == "calls" and target in graph._nodes: + resolved_calls += 1 + + assert resolved_calls > 0 diff --git a/tests/codegraph/test_models.py b/tests/codegraph/test_models.py new file mode 100644 index 0000000..8d00818 --- /dev/null +++ b/tests/codegraph/test_models.py @@ -0,0 +1,95 @@ +"""Tests for codegraph data models.""" + +from theow._codegraph._models import Edge, Node, SearchResult + + +def test_node_to_dict_minimal(): + node = Node(id="mod.py::func", kind="function", name="func", file="mod.py", line=10) + d = node.to_dict() + assert d["id"] == "mod.py::func" + assert d["kind"] == "function" + assert d["line"] == 10 + assert "end_line" not in d + assert "signature" not in d + assert "docstring" not in d + assert "parent" not in d + + +def test_node_to_dict_full(): + node = Node( + id="mod.py::Cls.method", + kind="function", + name="method", + file="mod.py", + line=5, + end_line=15, + signature="def method(self, x)", + docstring="Do stuff.", + parent="mod.py::Cls", + ) + d = node.to_dict() + assert d["end_line"] == 15 + assert d["signature"] == "def method(self, x)" + assert d["docstring"] == "Do stuff." + assert d["parent"] == "mod.py::Cls" + + +def test_node_roundtrip(): + node = Node( + id="a.py::X", kind="class", name="X", file="a.py", line=1, + end_line=20, signature="", docstring="A class.", parent="a.py", + ) + assert Node.from_dict(node.to_dict()) == node + + +def test_node_frozen(): + node = Node(id="x", kind="module", name="x", file="x.py", line=1) + try: + node.name = "y" # type: ignore[misc] + assert False, "Should be frozen" + except AttributeError: + pass + + +def test_edge_to_dict_minimal(): + edge = Edge(source="a", target="b", kind="calls") + d = edge.to_dict() + assert d == {"source": "a", "target": "b", "kind": "calls"} + assert "line" not in d + + +def test_edge_to_dict_with_line(): + edge = Edge(source="a", target="b", kind="imports", line=7) + d = edge.to_dict() + assert d["line"] == 7 + + +def test_edge_roundtrip(): + edge = Edge(source="a", target="b", kind="contains", line=3) + assert Edge.from_dict(edge.to_dict()) == edge + + +def test_search_result_to_dict(): + node = Node(id="f.py::go", kind="function", name="go", file="f.py", line=1) + sr = SearchResult(node=node, context="called by main", relevance="caller") + d = sr.to_dict() + assert d["id"] == "f.py::go" + assert d["context"] == "called by main" + assert d["relevance"] == "caller" + + +def test_search_result_to_dict_no_extras(): + node = Node(id="f.py", kind="module", name="f", file="f.py", line=1) + sr = SearchResult(node=node) + d = sr.to_dict() + assert "context" not in d + assert "relevance" not in d + + +def test_search_result_roundtrip(): + node = Node(id="x.py::Y", kind="class", name="Y", file="x.py", line=2) + sr = SearchResult(node=node, context="ctx", relevance="exact") + restored = SearchResult.from_dict(sr.to_dict()) + assert restored.node == node + assert restored.context == "ctx" + assert restored.relevance == "exact" diff --git a/tests/codegraph/test_tool.py b/tests/codegraph/test_tool.py new file mode 100644 index 0000000..af596db --- /dev/null +++ b/tests/codegraph/test_tool.py @@ -0,0 +1,87 @@ +"""Tests for codegraph tool registration using theow's own source.""" + +import inspect + +from theow._codegraph._graph import CodeGraph +from theow._gateway._base import build_tool_declaration + + +def test_search_code_callable(theow_src): + """graph.search_code should be a callable that returns list[dict].""" + graph = CodeGraph(root=theow_src) + assert callable(graph.search_code) + + results = graph.search_code(query="Rule") + assert isinstance(results, list) + assert all(isinstance(r, dict) for r in results) + + +def test_search_code_has_docstring(theow_src): + """search_code should have a docstring for LLM tool schema.""" + graph = CodeGraph(root=theow_src) + doc = inspect.getdoc(graph.search_code) + assert doc is not None + assert "symbol" in doc.lower() + + +def test_build_tool_declaration_skips_self(theow_src): + """build_tool_declaration should skip self for bound methods.""" + graph = CodeGraph(root=theow_src) + decl = build_tool_declaration("search_code", graph.search_code) + + props = decl["input_schema"]["properties"] + assert "self" not in props + assert "query" in props + assert "scope" in props + assert "kind" in props + assert "file" in props + assert "line" in props + assert "target" in props + + +def test_build_tool_declaration_types(theow_src): + """Tool declaration should have correct JSON schema types.""" + graph = CodeGraph(root=theow_src) + decl = build_tool_declaration("search_code", graph.search_code) + + props = decl["input_schema"]["properties"] + assert props["query"]["type"] == "string" + assert props["line"]["type"] == "integer" + assert props["scope"]["type"] == "string" + + +def test_build_tool_declaration_no_required(theow_src): + """All search_code params have defaults, so none should be required.""" + graph = CodeGraph(root=theow_src) + decl = build_tool_declaration("search_code", graph.search_code) + + assert decl["input_schema"]["required"] == [] + + +def test_build_tool_declaration_has_description(theow_src): + """Tool declaration should carry the docstring as description.""" + graph = CodeGraph(root=theow_src) + decl = build_tool_declaration("search_code", graph.search_code) + + assert len(decl["description"]) > 50 + + +def test_public_import(): + """CodeGraph should be importable from the public API.""" + from theow.codegraph import CodeGraph as PublicCodeGraph + + assert PublicCodeGraph is CodeGraph + + +def test_search_code_returns_dicts_with_expected_keys(theow_src): + """Results should contain the standard node fields.""" + graph = CodeGraph(root=theow_src) + results = graph.search_code(query="Rule", kind="class") + + assert len(results) > 0 + r = results[0] + assert "id" in r + assert "kind" in r + assert "name" in r + assert "file" in r + assert "line" in r diff --git a/tests/codegraph/test_visitor.py b/tests/codegraph/test_visitor.py new file mode 100644 index 0000000..95d5f57 --- /dev/null +++ b/tests/codegraph/test_visitor.py @@ -0,0 +1,322 @@ +"""Tests for language visitors using theow's own source.""" + +import tempfile +from pathlib import Path + +from theow._codegraph._visitors._go import GoVisitor +from theow._codegraph._visitors._python import PythonVisitor + +GO_SOURCE = '''\ +package main + +import ( +\t"fmt" +\t"strings" +) + +type Animal interface { +\tSpeak() string +} + +type Base struct { +\tName string +} + +type Dog struct { +\tBase +\tBreed string +} + +func NewDog(name string, breed string) *Dog { +\treturn &Dog{Base: Base{Name: name}, Breed: breed} +} + +func (d *Dog) Speak() string { +\treturn fmt.Sprintf("Woof! I am %s", d.Name) +} + +func (d *Dog) Fetch(item string) string { +\treturn strings.ToUpper(item) +} + +func main() { +\tdog := NewDog("Rex", "Labrador") +\tfmt.Println(dog.Speak()) +\tfmt.Println(dog.Fetch("ball")) +} +''' + + +def test_python_visitor_parses_models(theow_src): + """Parse theow's _core/_models.py — has classes, methods, imports.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + nodes, edges = visitor.parse_file(path, source, relative) + + names = {n.name for n in nodes} + assert "Rule" in names + assert "Fact" in names + assert "Action" in names + assert "LLMConfig" in names + + # Module node exists + kinds = {n.kind for n in nodes} + assert "module" in kinds + assert "class" in kinds + assert "function" in kinds + + +def test_python_visitor_extracts_methods(theow_src): + """Methods inside classes should have the class as parent.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + nodes, _ = visitor.parse_file(path, source, relative) + + # to_dict should be a method of Fact + fact_methods = [n for n in nodes if n.parent == f"{relative}::Fact"] + method_names = {n.name for n in fact_methods} + assert "to_dict" in method_names + assert "from_dict" in method_names + assert "matches" in method_names + + +def test_python_visitor_extracts_imports(theow_src): + """Module-level imports should produce import edges.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + _, edges = visitor.parse_file(path, source, relative) + + import_edges = [e for e in edges if e.kind == "imports"] + import_targets = {e.target for e in import_edges} + assert "yaml" in import_targets + assert "re" in import_targets + + +def test_python_visitor_extracts_inheritance(theow_src): + """Classes with bases should produce inherits edges.""" + visitor = PythonVisitor() + # _gateway/_base.py has LLMGateway(ABC) + path = theow_src / "_gateway" / "_base.py" + source = path.read_text() + relative = "_gateway/_base.py" + + _, edges = visitor.parse_file(path, source, relative) + + inherits = [e for e in edges if e.kind == "inherits"] + assert any(e.target == "ABC" for e in inherits) + + +def test_python_visitor_extracts_docstrings(theow_src): + """Functions and classes should have docstrings extracted.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + nodes, _ = visitor.parse_file(path, source, relative) + + rule_node = next(n for n in nodes if n.name == "Rule") + assert "production rule" in rule_node.docstring.lower() + + +def test_python_visitor_extracts_signatures(theow_src): + """Functions should have their signature extracted.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + nodes, _ = visitor.parse_file(path, source, relative) + + matches_node = next(n for n in nodes if n.name == "matches" and "Fact" in n.parent) + assert "def matches" in matches_node.signature + assert "self" in matches_node.signature + + +def test_python_visitor_extracts_calls(theow_src): + """Call sites should produce call edges.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + _, edges = visitor.parse_file(path, source, relative) + + call_edges = [e for e in edges if e.kind == "calls"] + call_targets = {e.target for e in call_edges} + # Fact.matches uses re.search + assert any("re.search" in t for t in call_targets) + + +def test_python_visitor_line_numbers(theow_src): + """Node line numbers should be positive and end_line >= line.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + nodes, _ = visitor.parse_file(path, source, relative) + + for node in nodes: + assert node.line >= 1 + if node.end_line: + assert node.end_line >= node.line + + +def test_python_visitor_decorated_functions(theow_src): + """Decorated definitions should still be extracted.""" + visitor = PythonVisitor() + path = theow_src / "_core" / "_models.py" + source = path.read_text() + relative = "_core/_models.py" + + nodes, _ = visitor.parse_file(path, source, relative) + + # @property is_ephemeral on Rule + node_names = {n.name for n in nodes} + assert "is_ephemeral" in node_names + + +def test_python_visitor_extensions(): + visitor = PythonVisitor() + assert visitor.extensions == [".py"] + + +def test_load_visitors_python(): + from theow._codegraph._visitors import load_visitors + + visitors = load_visitors(["python"]) + assert len(visitors) == 1 + assert visitors[0].extensions == [".py"] + + +def test_load_visitors_unknown(): + import pytest + from theow._codegraph._visitors import load_visitors + + with pytest.raises(ValueError, match="Unknown language"): + load_visitors(["rust"]) + + +# --- Go visitor tests --- + + +def _parse_go(source=GO_SOURCE, filename="main.go"): + visitor = GoVisitor() + with tempfile.NamedTemporaryFile(suffix=".go", mode="w", delete=False) as f: + f.write(source) + path = Path(f.name) + nodes, edges = visitor.parse_file(path, source, filename) + path.unlink() + return nodes, edges + + +def test_go_visitor_extensions(): + assert GoVisitor().extensions == [".go"] + + +def test_go_visitor_extracts_functions(): + nodes, _ = _parse_go() + names = {n.name for n in nodes if n.kind == "function"} + assert "NewDog" in names + assert "main" in names + + +def test_go_visitor_extracts_methods(): + """Methods should have the receiver type as parent.""" + nodes, _ = _parse_go() + speak = next(n for n in nodes if n.name == "Speak") + assert "Dog" in speak.parent + assert "func (*Dog) Speak" in speak.signature or "func (Dog) Speak" in speak.signature + + +def test_go_visitor_extracts_structs(): + nodes, _ = _parse_go() + struct_names = {n.name for n in nodes if n.kind == "class"} + assert "Dog" in struct_names + assert "Base" in struct_names + + +def test_go_visitor_extracts_interfaces(): + nodes, _ = _parse_go() + assert any(n.name == "Animal" and n.kind == "class" for n in nodes) + + +def test_go_visitor_extracts_imports(): + _, edges = _parse_go() + import_edges = [e for e in edges if e.kind == "imports"] + targets = {e.target for e in import_edges} + assert "fmt" in targets + assert "strings" in targets + + +def test_go_visitor_extracts_calls(): + _, edges = _parse_go() + call_edges = [e for e in edges if e.kind == "calls"] + targets = {e.target for e in call_edges} + assert "NewDog" in targets + # Method calls like dog.Speak() + assert any("Speak" in t for t in targets) + + +def test_go_visitor_extracts_embedding(): + """Struct embedding (Base in Dog) should produce inherits edge.""" + _, edges = _parse_go() + inherits = [e for e in edges if e.kind == "inherits"] + assert any(e.target == "Base" and "Dog" in e.source for e in inherits) + + +def test_go_visitor_function_signatures(): + nodes, _ = _parse_go() + new_dog = next(n for n in nodes if n.name == "NewDog") + assert "func NewDog" in new_dog.signature + assert "string" in new_dog.signature + + +def test_go_visitor_method_signatures(): + nodes, _ = _parse_go() + fetch = next(n for n in nodes if n.name == "Fetch") + assert "func" in fetch.signature + assert "Dog" in fetch.signature + assert "item" in fetch.signature + + +def test_go_visitor_line_numbers(): + nodes, _ = _parse_go() + for node in nodes: + assert node.line >= 1 + if node.end_line: + assert node.end_line >= node.line + + +def test_go_visitor_contains_edges(): + """Module should contain functions and types.""" + _, edges = _parse_go() + contains = [e for e in edges if e.kind == "contains"] + assert len(contains) > 0 + # Module contains functions + assert any(e.source == "main.go" for e in contains) + + +def test_load_visitors_go(): + from theow._codegraph._visitors import load_visitors + + visitors = load_visitors(["go"]) + assert len(visitors) == 1 + assert visitors[0].extensions == [".go"] + + +def test_load_visitors_both(): + from theow._codegraph._visitors import load_visitors + + visitors = load_visitors(["python", "go"]) + assert len(visitors) == 2 diff --git a/tests/core/test_logging.py b/tests/core/test_logging.py index d00d2c6..eaab811 100644 --- a/tests/core/test_logging.py +++ b/tests/core/test_logging.py @@ -78,6 +78,7 @@ def test_component_map_coverage(): "engine", "chroma", "cli", + "codegraph", } actual_components = set(COMPONENT_MAP.values()) assert actual_components == expected_components diff --git a/tox.ini b/tox.ini index 366ffc4..bd8d0ed 100644 --- a/tox.ini +++ b/tox.ini @@ -1,7 +1,7 @@ [tox] no_package = True skip_missing_interpreters = True -env_list = fmt,lint,static,unit +env_list = fmt,lint,static,unit,codegraph min_version = 4.0.0 [vars] @@ -29,9 +29,14 @@ commands = [testenv:static] description = Run static type checking with ty commands = - uv run {[vars]uv_flags} ty check {[vars]src} + uv run {[vars]uv_flags} --all-extras ty check {[vars]src} [testenv:unit] -description = Run unit tests with coverage +description = Run core unit tests with coverage commands = - uv run {[vars]uv_flags} pytest {[vars]tests} -v --cov={[vars]src}/theow --cov-report=term-missing + uv run {[vars]uv_flags} pytest {[vars]tests}/core {[vars]tests}/gateway {[vars]tests}/cli -v --cov={[vars]src}/theow --cov-report=term-missing --cov-config={tox_root}/.coveragerc-unit + +[testenv:codegraph] +description = Run codegraph tests with coverage +commands = + uv run {[vars]uv_flags} --extra codegraph pytest {[vars]tests}/codegraph -v --cov={[vars]src}/theow/_codegraph --cov-report=term-missing diff --git a/uv.lock b/uv.lock index 9f3ecb5..f1a9d3c 100644 --- a/uv.lock +++ b/uv.lock @@ -1876,6 +1876,13 @@ dependencies = [ { name = "typer" }, ] +[package.optional-dependencies] +codegraph = [ + { name = "tree-sitter" }, + { name = "tree-sitter-go" }, + { name = "tree-sitter-python" }, +] + [package.dev-dependencies] dev = [ { name = "pytest" }, @@ -1896,9 +1903,12 @@ requires-dist = [ { name = "pyyaml", specifier = ">=6.0" }, { name = "rich", specifier = ">=13.0" }, { name = "structlog", specifier = ">=24.0" }, + { name = "tree-sitter", marker = "extra == 'codegraph'", specifier = ">=0.23" }, + { name = "tree-sitter-go", marker = "extra == 'codegraph'", specifier = ">=0.23" }, + { name = "tree-sitter-python", marker = "extra == 'codegraph'", specifier = ">=0.23" }, { name = "typer", specifier = ">=0.12" }, ] -provides-extras = ["daemon"] +provides-extras = ["codegraph", "daemon"] [package.metadata.requires-dev] dev = [ @@ -1982,6 +1992,60 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" }, ] +[[package]] +name = "tree-sitter" +version = "0.25.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/7c/0350cfc47faadc0d3cf7d8237a4e34032b3014ddf4a12ded9933e1648b55/tree-sitter-0.25.2.tar.gz", hash = "sha256:fe43c158555da46723b28b52e058ad444195afd1db3ca7720c59a254544e9c20", size = 177961, upload-time = "2025-09-25T17:37:59.751Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/9e/20c2a00a862f1c2897a436b17edb774e831b22218083b459d0d081c9db33/tree_sitter-0.25.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ddabfff809ffc983fc9963455ba1cecc90295803e06e140a4c83e94c1fa3d960", size = 146941, upload-time = "2025-09-25T17:37:34.813Z" }, + { url = "https://files.pythonhosted.org/packages/ef/04/8512e2062e652a1016e840ce36ba1cc33258b0dcc4e500d8089b4054afec/tree_sitter-0.25.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c0c0ab5f94938a23fe81928a21cc0fac44143133ccc4eb7eeb1b92f84748331c", size = 137699, upload-time = "2025-09-25T17:37:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/47/8a/d48c0414db19307b0fb3bb10d76a3a0cbe275bb293f145ee7fba2abd668e/tree_sitter-0.25.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd12d80d91d4114ca097626eb82714618dcdfacd6a5e0955216c6485c350ef99", size = 607125, upload-time = "2025-09-25T17:37:37.725Z" }, + { url = "https://files.pythonhosted.org/packages/39/d1/b95f545e9fc5001b8a78636ef942a4e4e536580caa6a99e73dd0a02e87aa/tree_sitter-0.25.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b43a9e4c89d4d0839de27cd4d6902d33396de700e9ff4c5ab7631f277a85ead9", size = 635418, upload-time = "2025-09-25T17:37:38.922Z" }, + { url = "https://files.pythonhosted.org/packages/de/4d/b734bde3fb6f3513a010fa91f1f2875442cdc0382d6a949005cd84563d8f/tree_sitter-0.25.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fbb1706407c0e451c4f8cc016fec27d72d4b211fdd3173320b1ada7a6c74c3ac", size = 631250, upload-time = "2025-09-25T17:37:40.039Z" }, + { url = "https://files.pythonhosted.org/packages/46/f2/5f654994f36d10c64d50a192239599fcae46677491c8dd53e7579c35a3e3/tree_sitter-0.25.2-cp312-cp312-win_amd64.whl", hash = "sha256:6d0302550bbe4620a5dc7649517c4409d74ef18558276ce758419cf09e578897", size = 127156, upload-time = "2025-09-25T17:37:41.132Z" }, + { url = "https://files.pythonhosted.org/packages/67/23/148c468d410efcf0a9535272d81c258d840c27b34781d625f1f627e2e27d/tree_sitter-0.25.2-cp312-cp312-win_arm64.whl", hash = "sha256:0c8b6682cac77e37cfe5cf7ec388844957f48b7bd8d6321d0ca2d852994e10d5", size = 113984, upload-time = "2025-09-25T17:37:42.074Z" }, + { url = "https://files.pythonhosted.org/packages/8c/67/67492014ce32729b63d7ef318a19f9cfedd855d677de5773476caf771e96/tree_sitter-0.25.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0628671f0de69bb279558ef6b640bcfc97864fe0026d840f872728a86cd6b6cd", size = 146926, upload-time = "2025-09-25T17:37:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/4e/9c/a278b15e6b263e86c5e301c82a60923fa7c59d44f78d7a110a89a413e640/tree_sitter-0.25.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f5ddcd3e291a749b62521f71fc953f66f5fd9743973fd6dd962b092773569601", size = 137712, upload-time = "2025-09-25T17:37:44.039Z" }, + { url = "https://files.pythonhosted.org/packages/54/9a/423bba15d2bf6473ba67846ba5244b988cd97a4b1ea2b146822162256794/tree_sitter-0.25.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd88fbb0f6c3a0f28f0a68d72df88e9755cf5215bae146f5a1bdc8362b772053", size = 607873, upload-time = "2025-09-25T17:37:45.477Z" }, + { url = "https://files.pythonhosted.org/packages/ed/4c/b430d2cb43f8badfb3a3fa9d6cd7c8247698187b5674008c9d67b2a90c8e/tree_sitter-0.25.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b878e296e63661c8e124177cc3084b041ba3f5936b43076d57c487822426f614", size = 636313, upload-time = "2025-09-25T17:37:46.68Z" }, + { url = "https://files.pythonhosted.org/packages/9d/27/5f97098dbba807331d666a0997662e82d066e84b17d92efab575d283822f/tree_sitter-0.25.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d77605e0d353ba3fe5627e5490f0fbfe44141bafa4478d88ef7954a61a848dae", size = 631370, upload-time = "2025-09-25T17:37:47.993Z" }, + { url = "https://files.pythonhosted.org/packages/d4/3c/87caaed663fabc35e18dc704cd0e9800a0ee2f22bd18b9cbe7c10799895d/tree_sitter-0.25.2-cp313-cp313-win_amd64.whl", hash = "sha256:463c032bd02052d934daa5f45d183e0521ceb783c2548501cf034b0beba92c9b", size = 127157, upload-time = "2025-09-25T17:37:48.967Z" }, + { url = "https://files.pythonhosted.org/packages/d5/23/f8467b408b7988aff4ea40946a4bd1a2c1a73d17156a9d039bbaff1e2ceb/tree_sitter-0.25.2-cp313-cp313-win_arm64.whl", hash = "sha256:b3f63a1796886249bd22c559a5944d64d05d43f2be72961624278eff0dcc5cb8", size = 113975, upload-time = "2025-09-25T17:37:49.922Z" }, +] + +[[package]] +name = "tree-sitter-go" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/05/727308adbbc79bcb1c92fc0ea10556a735f9d0f0a5435a18f59d40f7fd77/tree_sitter_go-0.25.0.tar.gz", hash = "sha256:a7466e9b8d94dda94cae8d91629f26edb2d26166fd454d4831c3bf6dfa2e8d68", size = 93890, upload-time = "2025-08-29T06:20:25.044Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/aa/0984707acc2b9bb461fe4a41e7e0fc5b2b1e245c32820f0c83b3c602957c/tree_sitter_go-0.25.0-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b852993063a3429a443e7bd0aa376dd7dd329d595819fabf56ac4cf9d7257b54", size = 47117, upload-time = "2025-08-29T06:20:14.286Z" }, + { url = "https://files.pythonhosted.org/packages/32/16/dd4cb124b35e99239ab3624225da07d4cb8da4d8564ed81d03fcb3a6ba9f/tree_sitter_go-0.25.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:503b81a2b4c31e302869a1de3a352ad0912ccab3df9ac9950197b0a9ceeabd8f", size = 48674, upload-time = "2025-08-29T06:20:17.557Z" }, + { url = "https://files.pythonhosted.org/packages/86/fb/b30d63a08044115d8b8bd196c6c2ab4325fb8db5757249a4ef0563966e2e/tree_sitter_go-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04b3b3cb4aff18e74e28d49b716c6f24cb71ddfdd66768987e26e4d0fa812f74", size = 66418, upload-time = "2025-08-29T06:20:18.345Z" }, + { url = "https://files.pythonhosted.org/packages/26/21/d3d88a30ad007419b2c97b3baeeef7431407faf9f686195b6f1cad0aedf9/tree_sitter_go-0.25.0-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:148255aca2f54b90d48c48a9dbb4c7faad6cad310a980b2c5a5a9822057ed145", size = 72006, upload-time = "2025-08-29T06:20:19.14Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d0/0dd6442353ced8a88bbda9e546f4ea29e381b59b5a40b122e5abb586bb6c/tree_sitter_go-0.25.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4d338116cdf8a6c6ff990d2441929b41323ef17c710407abe0993c13417d6aad", size = 70603, upload-time = "2025-08-29T06:20:21.544Z" }, + { url = "https://files.pythonhosted.org/packages/01/e2/ee5e09f63504fc286539535d374d2eaa0e7d489b80f8f744bb3962aff22a/tree_sitter_go-0.25.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5608e089d2a29fa8d2b327abeb2ad1cdb8e223c440a6b0ceab0d3fa80bdeebae", size = 66088, upload-time = "2025-08-29T06:20:22.336Z" }, + { url = "https://files.pythonhosted.org/packages/6e/b6/d9142583374720e79aca9ccb394b3795149a54c012e1dfd80738df2d984e/tree_sitter_go-0.25.0-cp310-abi3-win_amd64.whl", hash = "sha256:30d4ada57a223dfc2c32d942f44d284d40f3d1215ddcf108f96807fd36d53022", size = 48152, upload-time = "2025-08-29T06:20:23.089Z" }, + { url = "https://files.pythonhosted.org/packages/9e/00/9a2638e7339236f5b01622952a4d71c1474dd3783d1982a89555fc1f03b1/tree_sitter_go-0.25.0-cp310-abi3-win_arm64.whl", hash = "sha256:d5d62362059bf79997340773d47cc7e7e002883b527a05cca829c46e40b70ded", size = 46752, upload-time = "2025-08-29T06:20:24.235Z" }, +] + +[[package]] +name = "tree-sitter-python" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b8/8b/c992ff0e768cb6768d5c96234579bf8842b3a633db641455d86dd30d5dac/tree_sitter_python-0.25.0.tar.gz", hash = "sha256:b13e090f725f5b9c86aa455a268553c65cadf325471ad5b65cd29cac8a1a68ac", size = 159845, upload-time = "2025-09-11T06:47:58.159Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/64/a4e503c78a4eb3ac46d8e72a29c1b1237fa85238d8e972b063e0751f5a94/tree_sitter_python-0.25.0-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:14a79a47ddef72f987d5a2c122d148a812169d7484ff5c75a3db9609d419f361", size = 73790, upload-time = "2025-09-11T06:47:47.652Z" }, + { url = "https://files.pythonhosted.org/packages/e6/1d/60d8c2a0cc63d6ec4ba4e99ce61b802d2e39ef9db799bdf2a8f932a6cd4b/tree_sitter_python-0.25.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:480c21dbd995b7fe44813e741d71fed10ba695e7caab627fb034e3828469d762", size = 76691, upload-time = "2025-09-11T06:47:49.038Z" }, + { url = "https://files.pythonhosted.org/packages/aa/cb/d9b0b67d037922d60cbe0359e0c86457c2da721bc714381a63e2c8e35eba/tree_sitter_python-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:86f118e5eecad616ecdb81d171a36dde9bef5a0b21ed71ea9c3e390813c3baf5", size = 108133, upload-time = "2025-09-11T06:47:50.499Z" }, + { url = "https://files.pythonhosted.org/packages/40/bd/bf4787f57e6b2860f3f1c8c62f045b39fb32d6bac4b53d7a9e66de968440/tree_sitter_python-0.25.0-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be71650ca2b93b6e9649e5d65c6811aad87a7614c8c1003246b303f6b150f61b", size = 110603, upload-time = "2025-09-11T06:47:51.985Z" }, + { url = "https://files.pythonhosted.org/packages/5d/25/feff09f5c2f32484fbce15db8b49455c7572346ce61a699a41972dea7318/tree_sitter_python-0.25.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e6d5b5799628cc0f24691ab2a172a8e676f668fe90dc60468bee14084a35c16d", size = 108998, upload-time = "2025-09-11T06:47:53.046Z" }, + { url = "https://files.pythonhosted.org/packages/75/69/4946da3d6c0df316ccb938316ce007fb565d08f89d02d854f2d308f0309f/tree_sitter_python-0.25.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:71959832fc5d9642e52c11f2f7d79ae520b461e63334927e93ca46cd61cd9683", size = 107268, upload-time = "2025-09-11T06:47:54.388Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a2/996fc2dfa1076dc460d3e2f3c75974ea4b8f02f6bc925383aaae519920e8/tree_sitter_python-0.25.0-cp310-abi3-win_amd64.whl", hash = "sha256:9bcde33f18792de54ee579b00e1b4fe186b7926825444766f849bf7181793a76", size = 76073, upload-time = "2025-09-11T06:47:55.773Z" }, + { url = "https://files.pythonhosted.org/packages/07/19/4b5569d9b1ebebb5907d11554a96ef3fa09364a30fcfabeff587495b512f/tree_sitter_python-0.25.0-cp310-abi3-win_arm64.whl", hash = "sha256:0fbf6a3774ad7e89ee891851204c2e2c47e12b63a5edbe2e9156997731c128bb", size = 74169, upload-time = "2025-09-11T06:47:56.747Z" }, +] + [[package]] name = "ty" version = "0.0.18" From e2e7c7010579c226c91e85f6d2f4ae7e398e6050 Mon Sep 17 00:00:00 2001 From: Adhitya Ravi Date: Sun, 1 Mar 2026 23:08:03 +0100 Subject: [PATCH 2/2] fix: ignore ty checks for examples --- pyproject.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 1bad36e..7e7b6ca 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,9 @@ path = "src/theow/_version.py" [tool.hatch.build.targets.wheel] packages = ["src/theow"] +[tool.ty.src] +exclude = ["src/theow/_codegraph/examples/"] + [tool.ruff] line-length = 100 target-version = "py312"