sentinel-codegraph 0.3.0__py3-none-any.whl

codegraph/tree.py

@@ -0,0 +1,230 @@
+"""Hierarchy-tree snapshot + renderer for the code graph.
+
+:func:`load_snapshot` reads one root's rows; :func:`render_tree` turns
+them into a nested unicode tree (pure, no I/O — unit-testable).
+``contains`` edges drive the nesting (file → def, class → method,
+function → nested def); ``calls`` edges (caller → callee) render as a
+``calls (N)`` subgroup under each function; ``imports`` edges render as
+a leaf group carrying each edge's ``target_module``.
+"""
+
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from codegraph.models import Edge, EdgeKind, Node, NodeKind
+
+if TYPE_CHECKING:
+    from codegraph.graph_store import LadybugStore
+
+
+@dataclass(frozen=True, slots=True)
+class GraphSnapshot:
+    """All rows of one indexed root, ready to render."""
+
+    root: str
+    nodes: tuple[Node, ...]
+    edges: tuple[Edge, ...]
+
+
+async def load_snapshot(store: LadybugStore, root: str) -> GraphSnapshot:
+    """Load every node/edge of ``root`` into a :class:`GraphSnapshot`."""
+    nodes: list[Node] = await store.list_nodes(root=root)
+    edges: list[Edge] = await store.list_edges(root=root)
+    return GraphSnapshot(root=root, nodes=tuple(nodes), edges=tuple(edges))
+
+
+def kind_label(kind: NodeKind | EdgeKind | str) -> str:
+    """Normalise a kind to its plain lowercase value (``file``, …)."""
+    if isinstance(kind, enum.Enum):
+        return str(kind.value).lower()
+    text: str = str(kind)
+    if "." in text:
+        text = text.rsplit(".", 1)[-1]
+    return text.lower()
+
+
+def _span(node: Node) -> str:
+    """Format a node's line range as ``(Lstart-Lend)``."""
+    return f"(L{node.start_line}-L{node.end_line})"
+
+
+def render_tree(snapshot: GraphSnapshot, *, use_unicode: bool = True) -> str:
+    """Render ``snapshot`` as a nested hierarchy tree.
+
+    ``use_unicode=False`` selects an ASCII-safe glyph set for consoles
+    whose encoding cannot represent box-drawing characters (e.g. the
+    Windows cp1252 console).
+    """
+    branch_last: str = "└── " if use_unicode else "`-- "
+    branch_mid: str = "├── " if use_unicode else "|-- "
+    stem_last: str = "    "
+    stem_mid: str = "│   " if use_unicode else "|   "
+    files: list[Node] = sorted(
+        (n for n in snapshot.nodes if kind_label(n.kind) == "file"),
+        key=lambda n: n.file_path,
+    )
+    by_id: dict[str, Node] = {n.id: n for n in snapshot.nodes}
+    contains: dict[str, list[str]] = {}
+    calls: dict[str, list[Edge]] = {}
+    import_targets: dict[str, str | None] = {}
+    for edge in snapshot.edges:
+        label: str = kind_label(edge.kind)
+        if label == "contains":
+            contains.setdefault(edge.src_id, []).append(edge.dst_id)
+        elif label == "calls":
+            calls.setdefault(edge.src_id, []).append(edge)
+        elif label == "imports":
+            contains.setdefault(edge.src_id, []).append(edge.dst_id)
+            import_targets[edge.dst_id] = edge.target_module
+
+    def ordered(node_ids: list[str]) -> list[Node]:
+        """Resolve ids to nodes, ordered by start line."""
+        resolved: list[Node] = [by_id[i] for i in node_ids if i in by_id]
+        resolved.sort(key=lambda n: (n.start_line, n.name))
+        return resolved
+
+    def _callee_sort_key(call: Edge) -> tuple[int, int, int, str]:
+        """Order callees by implementation order: call-site line first.
+
+        Edges without a site line (non-Python path, older rows) fall
+        back to the callee def's start line, then name — never worse
+        than the old alphabetical order.
+        """
+        node: Node | None = by_id.get(call.dst_id)
+        def_start: int = node.start_line if node is not None else 1 << 30
+        if call.site_line is not None:
+            return (0, call.site_line, def_start, "")
+        return (1, def_start, 1 << 30, node.name if node is not None else call.dst_id)
+
+    def ordered_callees(call_edges: list[Edge]) -> list[str]:
+        """Render each calls dst in implementation order (dsts are real ids).
+
+        Returns display lines. A dst missing from the snapshot renders
+        as ``<id> (missing)`` (defensive — the build never emits
+        dangling edges).
+        """
+        lines: list[str] = []
+        for call in sorted(call_edges, key=_callee_sort_key):
+            dst_id: str = call.dst_id
+            node: Node | None = by_id.get(dst_id)
+            if node is not None:
+                lines.append(f"{kind_label(node.kind)} {node.name} {_span(node)}")
+            else:
+                lines.append(f"{dst_id} (missing)")
+        return lines
+
+    def render_children(prefix: str, node: Node, lines: list[str]) -> None:
+        """Render the subtree under one def node.
+
+        Classes and interfaces show methods as leaves; functions and
+        methods show nested classes as nested blocks plus a
+        ``calls (N)`` subgroup. Type aliases are leaves.
+        Every node appears exactly once.
+        """
+        label: str = kind_label(node.kind)
+        if label in ("class", "interface"):
+            methods: list[Node] = [
+                m
+                for m in ordered(contains.get(node.id, []))
+                if kind_label(m.kind) == "method"
+            ]
+            for method_index, method in enumerate(methods):
+                last: bool = method_index == len(methods) - 1
+                branch: str = branch_last if last else branch_mid
+                lines.append(f"{prefix}{branch}method {method.name} {_span(method)}")
+                render_children_calls_only(f"{prefix}{stem_last if last else stem_mid}", method, lines)
+        elif label in ("function", "method"):
+            nested: list[Node] = [
+                n
+                for n in ordered(contains.get(node.id, []))
+                if kind_label(n.kind) == "class"
+            ]
+            callee_lines: list[str] = ordered_callees(calls.get(node.id, []))
+            # Each block is (header, nested node XOR leaf lines).
+            blocks: list[tuple[str, Node | None, list[str]]] = [
+                (f"class {n.name} {_span(n)}", n, []) for n in nested
+            ]
+            if callee_lines:
+                blocks.append((f"calls ({len(callee_lines)})", None, callee_lines))
+            for block_index, (header, nested_node, leaves) in enumerate(blocks):
+                last_block: bool = block_index == len(blocks) - 1
+                branch = branch_last if last_block else branch_mid
+                lines.append(f"{prefix}{branch}{header}")
+                stem: str = stem_last if last_block else stem_mid
+                if nested_node is not None:
+                    render_children(f"{prefix}{stem}", nested_node, lines)
+                else:
+                    for leaf_index, leaf in enumerate(leaves):
+                        leaf_branch: str = (
+                            branch_last
+                            if leaf_index == len(leaves) - 1
+                            else branch_mid
+                        )
+                        lines.append(f"{prefix}{stem}{leaf_branch}{leaf}")
+
+    def render_children_calls_only(prefix: str, node: Node, lines: list[str]) -> None:
+        """Render only the ``calls`` subgroup under a method leaf."""
+        callee_lines: list[str] = ordered_callees(calls.get(node.id, []))
+        if not callee_lines:
+            return
+        lines.append(f"{prefix}{branch_last}calls ({len(callee_lines)})")
+        for leaf_index, leaf in enumerate(callee_lines):
+            leaf_branch = branch_last if leaf_index == len(callee_lines) - 1 else branch_mid
+            lines.append(f"{prefix}{stem_last}{leaf_branch}{leaf}")
+
+    lines: list[str] = [
+        f"root: {snapshot.root}  "
+        f"(files={len(files)} nodes={len(snapshot.nodes)} "
+        f"edges={len(snapshot.edges)})"
+    ]
+    for file_index, file_node in enumerate(files):
+        if file_index > 0:
+            lines.append("")
+        lines.append(
+            f"file {file_node.file_path} [{file_node.language}] {_span(file_node)}"
+        )
+        contained: list[Node] = ordered(contains.get(file_node.id, []))
+        classes: list[Node] = [n for n in contained if kind_label(n.kind) == "class"]
+        interfaces: list[Node] = [
+            n for n in contained if kind_label(n.kind) == "interface"
+        ]
+        top_functions: list[Node] = [
+            n for n in contained if kind_label(n.kind) == "function"
+        ]
+        top_methods: list[Node] = [
+            n for n in contained if kind_label(n.kind) == "method"
+        ]
+        type_nodes: list[Node] = [n for n in contained if kind_label(n.kind) == "type"]
+        imports: list[Node] = [
+            n for n in contained if kind_label(n.kind) == "import"
+        ]
+        def_blocks: list[Node] = (
+            classes + interfaces + top_functions + top_methods + type_nodes
+        )
+        has_imports: bool = len(imports) > 0
+        for block_index, def_node in enumerate(def_blocks):
+            last_block: bool = block_index == len(def_blocks) - 1 and not has_imports
+            branch = branch_last if last_block else branch_mid
+            lines.append(
+                f"{branch}{kind_label(def_node.kind)} {def_node.name} "
+                f"{_span(def_node)}"
+            )
+            stem = stem_last if last_block else stem_mid
+            render_children(stem, def_node, lines)
+        if imports:
+            lines.append(f"{branch_last}imports ({len(imports)})")
+            for leaf_index, node in enumerate(imports):
+                leaf_branch = (
+                    branch_last if leaf_index == len(imports) - 1 else branch_mid
+                )
+                lines.append(
+                    f"{stem_last}{leaf_branch}{node.name} -> "
+                    f"{import_targets.get(node.id) or '?'} (L{node.start_line})"
+                )
+    return "\n".join(lines)
+
+
+__all__ = ["GraphSnapshot", "kind_label", "load_snapshot", "render_tree"]

codegraph/walk.py

@@ -0,0 +1,114 @@
+"""File discovery for the CLI.
+
+Maps extensions to tree-sitter language names, prunes noise
+directories, and skips oversized / undecodable / empty files.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+EXT_TO_LANGUAGE: dict[str, str] = {
+    ".py": "python",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".go": "go",
+}
+
+SKIP_DIRS: frozenset[str] = frozenset(
+    {
+        ".git",
+        ".github",
+        ".idea",
+        ".vscode",
+        ".next",
+        "__pycache__",
+        "build",
+        "dist",
+        "node_modules",
+        "target",
+        "venv",
+        ".venv",
+    }
+)
+
+MAX_FILE_BYTES: int = 20 * 1024 * 1024
+"""Skip files larger than this — the graph is for source, not dumps."""
+
+
+@dataclass(frozen=True, slots=True)
+class DiscoveredFile:
+    """A supported source file found under the scan root."""
+
+    abs_path: Path
+    rel_path: str
+    language: str
+
+
+def normalise_root(path: Path) -> Path:
+    """Return the resolved absolute scan root."""
+    return path.expanduser().resolve()
+
+
+def to_rel_posix(abs_path: Path, root: Path) -> str:
+    """Return the ``/``-separated path of ``abs_path`` relative to ``root``."""
+    return abs_path.relative_to(root).as_posix()
+
+
+def discover_files(target: Path, root: Path) -> list[DiscoveredFile]:
+    """List supported files for ``target`` (file or dir) under ``root``.
+
+    Directory walks are pruned at ``SKIP_DIRS`` and sorted for stable
+    output. Files that are unsupported, oversized, or empty are skipped.
+    """
+    candidates: list[Path] = []
+    if target.is_file():
+        candidates = [target]
+    else:
+        for parent, dirs, filenames in os.walk(target):
+            dirs[:] = sorted(d for d in dirs if d not in SKIP_DIRS)
+            for filename in sorted(filenames):
+                candidates.append(Path(parent) / filename)
+
+    found: list[DiscoveredFile] = []
+    for abs_path in candidates:
+        language: str | None = EXT_TO_LANGUAGE.get(abs_path.suffix.lower())
+        if language is None:
+            continue
+        try:
+            if abs_path.stat().st_size > MAX_FILE_BYTES:
+                continue
+        except OSError:
+            continue
+        try:
+            if not abs_path.is_relative_to(root):
+                continue
+            rel: str = to_rel_posix(abs_path.resolve(), root)
+        except (OSError, ValueError):
+            continue
+        found.append(
+            DiscoveredFile(abs_path=abs_path, rel_path=rel, language=language)
+        )
+    return found
+
+
+async def adiscover_files(target: Path, root: Path) -> list[DiscoveredFile]:
+    """Async wrapper over :func:`discover_files` (runs off the loop)."""
+    return await asyncio.to_thread(discover_files, target, root)
+
+
+__all__ = [
+    "DiscoveredFile",
+    "EXT_TO_LANGUAGE",
+    "MAX_FILE_BYTES",
+    "SKIP_DIRS",
+    "adiscover_files",
+    "discover_files",
+    "normalise_root",
+    "to_rel_posix",
+]

sentinel_codegraph-0.3.0.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.5
+Name: sentinel-codegraph
+Version: 0.3.0
+Summary: Sentinel code graph CLI: tree-sitter nodes/edges into SQL
+Author: Sentinel
+Requires-Python: >=3.13
+Requires-Dist: ladybug==0.19.1
+Requires-Dist: tree-sitter-language-pack>=1.20.0
+Description-Content-Type: text/markdown
+
+# Sentinel Code Graph CLI
+
+Async CLI that scans a directory or file, extracts structural nodes
+(files, classes, functions, methods, interfaces, types, imports) and
+edges (contains, imports, calls) with raw tree-sitter, and stores them
+in Ladybug (embedded property graph, zero setup).
+
+- Default database is a known-location Ladybug file
+  (`~/.codegraph/graph.lbdb`), so query time never guesses where the
+  index lives. Pass `--db` to any command to override it.
+- `--db :memory:` indexes ephemerally (lost when the process exits).
+- Scope: **Python, TypeScript/JavaScript, Go**. (`queries.py` stays on
+  disk, unwired.)
+- One database holds exactly one index: `--overwrite` flushes the
+  whole db first, so re-indexing is idempotent.
+- `--no-persist` dry-runs the pipeline (parse → nodes → edges → print,
+  no DB writes).
+
+## Install
+
+From the repo root (workspace member, latest pinned deps in `uv.lock`):
+
+```powershell
+uv sync
+```
+
+## Usage
+
+```powershell
+# index a tree into the default DB (re-runnable; --overwrite flushes first)
+uv run --package codegraph python -m codegraph.cli index ./packages/api/src --overwrite
+
+# index a single file (root = its parent dir; must be a supported language)
+uv run --package codegraph python -m codegraph.cli index ./packages/api/main.py
+
+# inspect the database
+uv run --package codegraph python -m codegraph.cli stats
+
+# index and print the hierarchy tree of the indexed root
+uv run --package codegraph python -m codegraph.cli index ./src --output tree
+
+# dump every collected node (kind, lines, parent, children, callees)
+uv run --package codegraph python -m codegraph.cli index ./src --output nodes
+
+# list every calls edge (caller -> callee, implementation order)
+uv run --package codegraph python -m codegraph.cli index ./src --output calls
+
+# dry-run: print without persisting
+uv run --package codegraph python -m codegraph.cli index ./src --no-persist --output tree
+
+# Ephemeral index (no file written)
+uv run --package codegraph python -m codegraph.cli index ./src --db :memory: --output tree
+
+# explore the index (read-only; works from anywhere — default DB is known)
+uv run --package codegraph python -m codegraph.cli query overview
+uv run --package codegraph python -m codegraph.cli query files
+uv run --package codegraph python -m codegraph.cli query search --name reviewWorkflowV2
+uv run --package codegraph python -m codegraph.cli query callees --name reviewWorkflowV2 --json
+```
+
+## Flow
+
+`amain` parses args, then three linear stages in `pipeline.py`:
+
+```
+read(target) -> build_graph(root, items) -> out(db, root, graph, ...)
+```
+
+- **read** — discover (`walk`: suffix → language, prune noise dirs,
+  skip oversize/undecodable) + read off the loop → `ScannedSources(root,
+  items)`. I/O.
+- **build_graph** — pure, two passes: (1) collect — `parse_file_input`
+  per file (blank source or unsupported language → skip, counted)
+  into nodes + `contains` / `imports` plus buffered call sites; (2)
+  link — `resolve_call_edges` joins sites against the `(file, name)`
+  definition registry + per-file import maps (alias-aware, joined on
+  a single candidate: the defining-module original when the import
+  carries one, else the bound name; Go dot-imported files are a
+  fallback) into `calls` with real node ids, dropping unresolvable
+  sites. Merge → `BuiltGraph(root, files, skipped, nodes, edges)`.
+  No I/O, no DB.
+- **out** — persist (`create_all`, `clear_all` when `--overwrite`,
+  `add_all`) then print (`summary` | `tree` | `nodes` | `calls`) →
+  `IndexResult`. I/O.
+
+`cli.py` holds only arg parsing + `amain` wiring + `run_stats`;
+`__main__.py` calls `cli.main()`.
+
+## Python emitter
+
+Each Python file is walked once (`collect_python_file`):
+`Node` + `Edge(CONTAINS)` with `base:name:start:end` ids for defs,
+`Node(IMPORT)` + `Edge(IMPORTS)` per imported name (keeping the
+`as`-alias original, e.g. `from utils import helper as h` records bound
+`h` + original `helper`), and bare-name calls buffered unresolved with
+their call-site line. The link phase then joins each site — same-file
+hit first, else the import map's resolved file + original name — into
+`calls` edges with real node ids. Absolute imports tolerate a
+root-relative prefix on indexed paths (`src/app/…` satisfies
+`import app.…`). Builtins, stdlib, third-party, star-import calls,
+attribute calls (`obj.method(…)`, `self.x(…)`), and module-level call
+sites yield no edges. Decorator applications (`@retry`,
+`@with_logging(…)`) buffer as call sites on the decorated def/class
+with the @-line and resolve like ordinary calls (attribute decorators
+such as `@app.get(…)` are skipped). One edge per caller → callee pair,
+each stamped with its call-site line. Calls render in implementation
+order, not alphabetical.
+
+## TypeScript / JavaScript collector
+
+Each TS/JS file is walked once (`collect_ts_file`): classes,
+functions, methods, interfaces, type aliases, and arrow-bound consts
+(`export` wrappers are transparent) → `Node` + `Edge(CONTAINS)`;
+imports keep alias originals (`import {a as b}` → bound `b` +
+original `a`; default imports join on the bound name); bare calls and
+`new C()` constructions buffer unresolved. Relative specifiers resolve
+with extension + `/index` fallbacks; bare (npm) specifiers never
+resolve. Member calls (`obj.m()`), builtins, and module-level sites
+yield no edges.
+
+## Go collector
+
+Each Go file is walked once (`collect_go_file`): funcs, methods
+(reparented to their receiver struct when same-file), struct types →
+`class`, interface types → `interface` (with `method_elem` children as
+methods), other named types → `type`. Blank imports bind `*`, dot
+imports bind `.` (their target files are searched for otherwise
+unresolved bare sites). Import tails match indexed `.go` stems;
+selector calls (`pkg.Fn()`), builtins, and package-level sites yield
+no edges.
+
+## Schema (Ladybug)
+
+- `CodeNode`: `id (PK), root, file_path, kind (file|class|function|method|interface|type|import),
+  name, language, start_line, end_line, parent_id, is_placeholder`
+- `Contains` / `Imports` / `Calls`: rels between `CodeNode` rows
+  (`target_module` on `Imports`, `site_line` on `Calls`).
+
+`site_line` is the 1-based call-site line inside the caller (`Calls`
+rels only; `NULL` = unknown). Callees sort by it.
+
+## Node ids (all languages)
+
+- file node: `base` (path anchored at the CLI root, e.g. `workflows/review.py`)
+- def node: `base:name:start:end` (e.g. `workflows/review.py:helper:10:15`)
+- import node: `base:import:<name>:<line>`
+
+Every stored `Calls` edge points at real node ids — unresolvable call
+sites are dropped at build time, so no placeholder rows exist
+(`is_placeholder` stays on the schema for old databases only).
+Querier's check:
+
+```cypher
+// 1. file's nodes (find the caller)
+MATCH (f:CodeNode {id: '<file>'})-[:Contains]->(n) RETURN n;
+// 2. caller's callees, in implementation order
+MATCH (c:CodeNode {id: '<caller id>'})-[e:Calls]->(d) RETURN d ORDER BY e.site_line;
+```
+
+Tables are created with `create_all` (`IF NOT EXISTS`): after a
+schema change, delete the `.lbdb` file and re-index.
+
+## Querying (agent ladder)
+
+The `query` verbs are read-only and built for agents that don't know
+node id shapes — every step returns the ids the next step needs:
+
+1. `query overview` — what's indexed (counts by kind/edge/language).
+2. `query files` — rel paths (a file node id *is* its rel path).
+3. `query search --name <fragment> [--kind …] [--file …] [--limit N]` —
+   substring-match def names → full rows with ids. Zero hits and
+   truncation (`truncated: true`) tell the agent to rephrase/narrow.
+4. `query node|callees|callers|children --id <id>` (or `--name` exact +
+   optional `--file`; ambiguity is an error listing hits) and
+   `query imports --file <rel>` — drill down; new names chain back
+   to `search`.
+
+`--root` narrows to one indexed root (default: all), `--json` emits
+the stable chaining envelope
+(`{root, verb, count, truncated, items[]}` with
+`{id, kind, name, file_path, language, start_line, end_line,
+parent_id}` plus `site_line` on calls items and `target_module` on
+imports items). Querying a database that was never indexed exits 1
+with a hint instead of an empty result — and read paths never create
+files or directories (only `index` persistence creates
+`~/.codegraph/`).
+
+## Module map
+
+- `cli.py` — arg parsing, `amain` wiring (`read → build_graph → out`), `main`, `run_stats`, `run_query`
+- `query.py` — pure exploration shaping: `search_nodes`, `exact_matches`, JSON envelope, human rendering
+- `pipeline.py` — `read` / `build_graph` / `out`, `ScannedSources` / `BuiltGraph` / `IndexResult`, `OutputMode`, `print_tree` / `print_nodes` / `print_calls`
+- `parser/__init__.py` — barrel: re-exports only, no logic
+- `parser/rows.py` — `FileRows`, `build_file_rows`, `build_python_file_rows`
+- `parser/links.py` — `ImportEntry`, `build_file_import_map`, `build_dot_import_targets`, `resolve_call_edges` (+ per-language module-specifier resolvers)
+- `parser/lang_python.py` — Python collect phase (`collect_python_file`)
+- `parser/lang_typescript.py` — TS/JS collect phase (`collect_ts_file`)
+- `parser/lang_go.py` — Go collect phase (`collect_go_file`)
+- `parser/queries.py` — kept, unwired
+- `parser/base.py` — `ParsedFile` / `ParsedDefinition` / `ParsedImport` / `ParsedCall` IR types
+- `parser/raw_core.py` — tree-sitter `parse`, `walk`, `span`, text helpers
+- `models.py` — `Node` / `Edge` dataclasses (+ `NodeKind`, `EdgeKind`)
+- `graph_store.py` — `LadybugStore` (UNWIND ingest, `clear_all`, `add_all`, count/list queries, narrow `get_node` / `callees` / `callers` / `children` / `file_imports` / `list_files` reads)
+- `tree.py` — `GraphSnapshot`, `render_tree` (nesting by `contains`, calls in `site_line` order)
+- `walk.py` — suffix → language discovery, noise-dir pruning
+- `config.py` — `DEFAULT_DB` (`~/.codegraph/graph.lbdb`) + `--db` path resolution: file path or `:memory:` (`ResolvedDb`)
+
+## Design notes
+
+- Pipeline is functional: `read -> build_graph -> out`. Extractors and
+  builders are pure; I/O lives only at the edge (discover + read,
+  persist, print).
+- Build output is a simple flat graph: `BuiltGraph` carries merged
+  `nodes` + `edges` tuples only. Every consumer (persist, snapshot,
+  printers) derives what it needs from those two lists.
+- Graph values are frozen dataclasses holding tuples — immutable
+  snapshots, safe to share between build and out.
+- Parsing uses raw `tree_sitter_language_pack.get_parser().parse()`.
+  Import *names* are recovered from the statement source text in pure
+  Python.
+- Parsing runs on the event-loop thread (tree-sitter objects are not
+  thread-safe); only file I/O goes through `asyncio.to_thread`.
+- Ladybug is embedded: one `AsyncConnection` per store, and `out()`
+  holds a single store from persist through the snapshot reads, so
+  `:memory:` databases stay alive for the whole call.
+- Calls are bare-name only (`name(…)`), alias-aware via the import
+  map (`from utils import helper as h` + `h()` resolves to `helper`;
+  TS `import {a as b}` + `b()` resolves to `a`; TS default imports
+  join on the bound name; Go dot-imported files are a fallback);
+  `new C()` in TS counts as a call. Attribute / member calls
+  (`obj.method()`, `self.x()`, `pkg.Fn()`), builtins, stdlib,
+  third-party, star-import calls, and module-level call sites yield
+  no edges.
+- Files with unsupported suffixes are discovered, then skipped
+  (`(N skipped)` in the summary).
+
+## Tests
+
+```powershell
+uv run --package codegraph pytest tests
+```

sentinel_codegraph-0.3.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+codegraph/__init__.py,sha256=l_Bq2tU9-2aT9I-e0T312qr7WXUvIeWvNY-X2YJIzVo,144
+codegraph/__main__.py,sha256=Psd_CiHcSc6H-s0rvJkRAisDCtSEiZBtzJ_oRHRhqXg,130
+codegraph/cli.py,sha256=3-PCb2bUt9K88C5XnmV5j6zZujI0OCdDg3JJfnLfUh4,15952
+codegraph/config.py,sha256=wY7VNPA4HPl54VvipcM6k3K3oa997zqc3767WhftlfU,1655
+codegraph/graph_store.py,sha256=7t8l0UWVDqxpHEkhQ0Upbln9IV3MAUw0gvPUNobGhLI,18028
+codegraph/models.py,sha256=4eVVjfxDx5azV1glE9zMNpYOVPXDFCN-MURyXfZBG8k,2390
+codegraph/pipeline.py,sha256=TgM9W5yp-Hj8DM0Qy-LGTur3Yan99Ri1yqN3StwZEZs,12413
+codegraph/query.py,sha256=FKOC-kDCDqHZ6mNxDk5PHcBok68Gp5D9kFy_OxyNnHs,4121
+codegraph/tree.py,sha256=7QLvS5JEMm6NjAqf3te2iSqnKu86e_oHZ5XZG4hXgu8,9933
+codegraph/walk.py,sha256=nNFcPxqFvC5TSseqToDNBLbfBLjTcW7qj--T3G16uIw,3038
+codegraph/parser/__init__.py,sha256=lXBQLLiV6RPeKIuNrHH0yyCByUzBnagf2YfO88UBOM4,770
+codegraph/parser/base.py,sha256=kVYxqGqy0pA8qISjg9TUEppJTQP7LHMKDaqdEMm_RPY,3633
+codegraph/parser/lang_go.py,sha256=1ISMiH-B9Bg_FlwcG8Qd1rqs_zfieGrUIz9xWfJ9HdM,18197
+codegraph/parser/lang_python.py,sha256=neG9DB30-X7DHHnWdTTu-pyNEBTHMcKTQu5vtXQsF_U,16833
+codegraph/parser/lang_typescript.py,sha256=TwXqN_-Xu1bRRfUyEc70thdHKCwSvbNNWkqbJobMxxM,19550
+codegraph/parser/links.py,sha256=TruNiQ6Br02rwjVJD6X2vyS6EZOYNJpAFBFg0jEF5_0,12050
+codegraph/parser/queries.py,sha256=B9ojYeQMmuhWWkMuF3JpcPNeOZeYDZBGPstzmhkjqSI,4052
+codegraph/parser/raw_core.py,sha256=i7RgDV06k14quLlA-Kfx8BQpo3kaDsN6a3Iwtkq7AJA,2023
+codegraph/parser/rows.py,sha256=FI3GZl3Zi3GPJZ4VO2Ll9HQbJ46qFicY2XsjI1ATKuM,6054
+sentinel_codegraph-0.3.0.dist-info/METADATA,sha256=usLeWHdmDBYTyvbyk_VWNtCTIWr7nT-dxHan2n5qhpQ,11890
+sentinel_codegraph-0.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+sentinel_codegraph-0.3.0.dist-info/entry_points.txt,sha256=3f2dJK7oR3dBzP21qRk_KuQa6Li8MVbVXeKcx3UjQ6c,49
+sentinel_codegraph-0.3.0.dist-info/RECORD,,

sentinel_codegraph-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

sentinel_codegraph-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codegraph = codegraph.cli:main