entrygraph 0.1.0__py3-none-any.whl

entrygraph/resolve/symbol_table.py

@@ -0,0 +1,48 @@
+"""In-memory symbol index for pass-2 reference resolution."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from entrygraph.kinds import SymbolKind
+
+
+class SymbolTable:
+    def __init__(self) -> None:
+        self.by_fqn: dict[str, int] = {}
+        self.qname_of: dict[int, str] = {}
+        self.by_name: dict[str, list[int]] = defaultdict(list)
+        self.kinds: dict[int, SymbolKind] = {}
+        self.project_modules: set[str] = set()
+        self.module_symbol_ids: dict[str, int] = {}  # module_path -> module symbol id
+        self.class_bases: dict[str, list[str]] = {}  # class fqn -> raw base texts
+        # class fqn -> resolved parent FQNs (project or external), for the
+        # transitive ancestor walk and class-hierarchy analysis (see hierarchy.py).
+        self.class_parents: dict[str, list[str]] = {}
+        # re-export chains (barrel files): module -> {exported_name: (target_module, target_name)}
+        self.reexports: dict[str, dict[str, tuple[str, str]]] = {}
+        self.star_reexports: dict[str, list[str]] = {}  # module -> [source modules]
+
+    def add_symbol(self, symbol_id: int, qname: str, name: str, kind: SymbolKind) -> None:
+        self.by_fqn[qname] = symbol_id
+        self.qname_of[symbol_id] = qname
+        self.by_name[name].append(symbol_id)
+        self.kinds[symbol_id] = kind
+
+    def add_module(self, module_path: str, symbol_id: int) -> None:
+        self.project_modules.add(module_path)
+        self.module_symbol_ids[module_path] = symbol_id
+        self.add_symbol(symbol_id, module_path, module_path.rsplit(".", 1)[-1], SymbolKind.MODULE)
+
+    def is_project_path(self, dotted: str) -> bool:
+        """True if a dotted path starts with any project module (prefix match)."""
+        if dotted in self.project_modules:
+            return True
+        parts = dotted.split(".")
+        return any(".".join(parts[:i]) in self.project_modules for i in range(1, len(parts)))
+
+    def unique_by_name(self, name: str, kinds: tuple[SymbolKind, ...] | None = None) -> int | None:
+        candidates = self.by_name.get(name, [])
+        if kinds is not None:
+            candidates = [c for c in candidates if self.kinds.get(c) in kinds]
+        return candidates[0] if len(candidates) == 1 else None

entrygraph/results.py

@@ -0,0 +1,138 @@
+"""Public result types.
+
+All query results are frozen, slotted dataclasses detached from any ORM
+session — safe to hold forever and free to serialize with dataclasses.asdict.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True, slots=True)
+class Symbol:
+    id: int
+    kind: str
+    name: str
+    qname: str
+    file: str | None  # repo-relative path; None for external placeholders
+    start_line: int
+    end_line: int
+    signature: str | None = None
+    docstring: str | None = None
+    is_exported: bool = True
+
+    @property
+    def is_external(self) -> bool:
+        return self.kind == "external"
+
+
+@dataclass(frozen=True, slots=True)
+class Edge:
+    id: int
+    kind: str
+    src_qname: str
+    dst_qname: str
+    resolved: bool
+    line: int
+    confidence: int
+    file: str | None = None
+    sink_id: str | None = None
+    arg_preview: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Entrypoint:
+    id: int
+    kind: str
+    framework: str | None
+    symbol: Symbol
+    route: str | None = None
+    http_method: str | None = None
+    extra: dict = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class FileInfo:
+    id: int
+    path: str
+    language: str | None
+    size_bytes: int
+    symbol_count: int = 0
+    skip_reason: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class PathEdge:
+    kind: str
+    line: int
+    confidence: int
+    sink_id: str | None = None
+    via: str | None = None  # "cha" | "dynamic" | "reexport" | None
+    arg_preview: str | None = None
+    constant_args: bool = False  # terminal hop: sink called with literal args only
+    sanitized_by: tuple[str, ...] = ()  # sanitizer ids matched on/around this hop
+
+
+@dataclass(frozen=True, slots=True)
+class CallPath:
+    symbols: tuple[Symbol, ...]  # source ... sink, in order
+    edges: tuple[PathEdge, ...]  # one per hop; len == len(symbols) - 1
+    risk_score: float | None = None  # query-time heuristic, higher = riskier
+    may_continue: bool = False  # a node on this path has out-edges the filter excluded
+
+    @property
+    def min_confidence(self) -> int:
+        return min((e.confidence for e in self.edges), default=0)
+
+    def render(self) -> str:
+        parts = [self.symbols[0].qname]
+        for edge, sym in zip(self.edges, self.symbols[1:]):
+            parts.append(f"-> {sym.qname} (line {edge.line})")
+        return " ".join(parts)
+
+
+@dataclass(frozen=True, slots=True)
+class DetectedLanguage:
+    name: str
+    file_count: int
+    byte_count: int
+    percent: float  # by bytes, of recognized files
+
+
+@dataclass(frozen=True, slots=True)
+class DetectedFramework:
+    name: str
+    language: str
+    confidence: float
+    evidence: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class DetectionReport:
+    languages: tuple[DetectedLanguage, ...]
+    frameworks: tuple[DetectedFramework, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class IndexStats:
+    files_scanned: int
+    files_indexed: int
+    files_skipped: int
+    files_deleted: int
+    symbols: int
+    edges: int
+    entrypoints: int
+    duration_seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class GraphStats:
+    repo_root: str
+    index_generation: int
+    files: int
+    symbols: int
+    edges: int
+    resolved_edges: int
+    entrypoints: int
+    sink_edges: int

entrygraph-0.1.0.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: entrygraph
+Version: 0.1.0
+Summary: Language-agnostic code graph: query symbols, entrypoints, and source-to-sink call paths from a SQLite index
+Project-URL: Repository, https://github.com/brettbergin/entrygraph
+Author-email: Brett Bergin <brettberginbc@yahoo.com>
+License: MIT License
+        
+        Copyright (c) 2026 Brett Bergin
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: call-graph,code-analysis,entrypoints,static-analysis,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Requires-Dist: pathspec<1.0,>=0.12
+Requires-Dist: rich>=13.0
+Requires-Dist: sqlalchemy<3.0,>=2.0.30
+Requires-Dist: tree-sitter-language-pack>=1.10
+Requires-Dist: tree-sitter<0.26,>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# entrygraph
+
+Query your codebase like a graph. `entrygraph` indexes a repository into a
+SQLite database (through the SQLAlchemy ORM) and answers questions about
+**symbols**, **classes/methods**, **entrypoints** (HTTP routes, CLI commands,
+main functions, tasks, lambda handlers), and **source → sink call-graph
+reachability** ("can any HTTP route reach `subprocess.run`?").
+
+Language-agnostic via [tree-sitter](https://tree-sitter.github.io/); first-class
+support for **Python, JavaScript/TypeScript, Go, Java, Ruby, C#, PHP, and
+Rust**, with language *and* framework detection.
+
+Reachability is a heuristic taint tier, not just call-edge closure: paths are
+**risk-ranked**, **sanitizers** prune or discount them, **class-hierarchy
+analysis** recovers virtual dispatch, and confidence flags trade recall for
+precision. Entrypoints include decorator/attribute routes, call-based route
+registration, middleware, and config-file handlers (serverless, SAM, Procfile,
+Dockerfile).
+
+## Install
+
+```bash
+pip install entrygraph        # or: uv pip install entrygraph
+```
+
+Requires Python ≥ 3.11. Depends on `sqlalchemy`, `tree-sitter`,
+`tree-sitter-language-pack`, and `pathspec`.
+
+## Python API
+
+```python
+from entrygraph import CodeGraph
+
+# Index a repo (creates <repo>/.entrygraph.db by default)
+graph = CodeGraph.index("/path/to/repo")
+
+# ...or open an existing index
+graph = CodeGraph.open("graph.db")
+
+# Symbols — glob on name or qualified name, filter by kind or file
+graph.symbols(kind="class", name="User*")
+graph.symbol("app.services.Runner.execute")        # exact; raises if missing
+
+# Detection
+report = graph.detect()
+report.languages      # -> [DetectedLanguage(name="python", percent=96.7, ...), ...]
+report.frameworks     # -> [DetectedFramework(name="flask", confidence=0.94, ...), ...]
+
+# Entrypoints
+graph.entrypoints(framework="flask")
+graph.entrypoints(kind="http_route", route="/api/*")
+
+# Call graph
+graph.callers("app.services.run_report")            # who calls it
+graph.callees("app.services.run_report", depth=3)   # what it (transitively) calls
+graph.references("app.models.CONST")                # inbound edges of any kind
+
+# Source -> sink reachability (paths are risk-ranked, highest first)
+paths = graph.paths(source="app.routes.*", sink_category="command_exec")
+for p in paths:
+    print(p.risk_score, p.render(), "(+may continue)" if p.may_continue else "")
+    # 0.72 app.routes.create_report -> app.services.run_report (line 20)
+    #   -> ...ReportRunner.render_and_execute (line 17) -> py:subprocess.run (line 22)
+
+graph.reachable(source="app.routes.upload", sink="py:subprocess.run")   # -> bool
+
+# Precision/recall dial. By default only EXACT/IMPORT and unique-name FUZZY
+# edges are traversed. Opt into wider (noisier) traversal:
+graph.paths(source="app.routes.*", sink_category="sql",
+            include_unresolved=True)   # follow py:*.execute wildcard-sink guesses
+graph.paths(source="app.routes.*", sink_category="command_exec",
+            include_fuzzy=True)        # follow speculative class-hierarchy (CHA) edges
+graph.paths(source="app.routes.*", sink_category="command_exec",
+            prune_sanitized=True)      # drop paths neutralized by a shlex.quote etc.
+
+# Incremental re-index (only changed/added/deleted files are reparsed)
+graph.refresh()
+
+# Escape hatches
+graph.session()               # raw SQLAlchemy Session
+graph.sql("SELECT ...")       # textual query -> list[dict]
+```
+
+Every result is a frozen, immutable dataclass detached from the DB session, so
+results are safe to hold and trivial to serialize.
+
+## CLI
+
+Human-readable output is rendered with [Rich](https://github.com/Textualize/rich) —
+colored tables, language/confidence bars, a progress spinner while indexing, and
+risk-ranked reachability rendered as call trees (sink nodes highlighted, per-hop
+confidence, sanitizer/const-arg badges). Piped or `--json` output stays plain.
+
+```bash
+entrygraph index PATH [--full] [--paranoid]     # incremental by default
+entrygraph detect
+entrygraph symbols --kind class --name 'User*'
+entrygraph entrypoints --framework flask
+entrygraph callers  app.services.run_report --depth 2
+entrygraph callees  app.services.run_report
+entrygraph paths --source 'app.routes.*' --sink-category command_exec
+entrygraph stats
+```
+
+Add `--json` to any query command for machine-readable output. `entrygraph paths`
+exits 0 when a path is found and 1 when none is — handy in CI:
+
+```bash
+entrygraph paths --source '*' --sink-category command_exec && echo "reachable!"
+```
+
+## How it works
+
+1. **Walk** — `os.scandir` with hard-pruned junk dirs (`node_modules`, `.venv`,
+   …), `.gitignore` rules, and size/binary/minified gates. Every skip is recorded
+   with a reason.
+2. **Extract** — tree-sitter `.scm` queries harvest definitions/imports/calls;
+   small per-language "shaper" modules build qualified names, import maps, and
+   receiver info. Parsing runs across a process pool for large repos.
+3. **Resolve** — a two-pass resolver binds references to symbols with a
+   confidence level (`exact` / `import` / `fuzzy` / `unresolved`). External
+   callees (`subprocess.run`, `child_process.exec`, …) become placeholder nodes
+   so sinks are real graph terminals.
+4. **Detect** — frameworks are scored from manifest dependencies plus code
+   signals (noisy-or); entrypoint rules map framework patterns to route/command
+   records.
+5. **Store** — everything persists to SQLite via the SQLAlchemy 2.0 ORM with
+   bulk inserts and app-assigned keys. Re-indexing is incremental and
+   content-hash driven.
+6. **Query** — reachability runs over an in-memory adjacency cache (BFS/DFS with
+   cycle handling); a recursive-CTE SQL engine is available as a fallback
+   (`engine="sql"`).
+
+## Extending
+
+- **Custom sinks/sources/sanitizers** — drop an `entrygraph.toml` in the repo
+  root with `[[sink]]` / `[[source]]` / `[[sanitizer]]` tables (same schema as
+  the built-in `data/sinks/*.toml`), or call
+  `entrygraph.detect.taint.register_sink(...)` / `register_sanitizer(...)`. A
+  `[[sanitizer]]` with `effect = "neutralizes"` prunes a path for its category;
+  `effect = "reduces"` only discounts the risk score. Third-party wrapper
+  libraries that reach a sink internally are covered by `data/sinks/lib_*.toml`
+  "library summaries" (same schema, with a `library = "..."` tag).
+- **New frameworks / entrypoints** — register a `FrameworkSpec` and an
+  `EntrypointRule`; adding a framework is usually a few lines.
+- **New languages** — add a `<lang>/{definitions,imports,calls}.scm` query set
+  and a shaper implementing the `LanguageExtractor` protocol.
+
+## Releasing
+
+Merging to `main` auto-bumps the patch version (via a git tag) and publishes to
+PyPI through Trusted Publishing — see [RELEASING.md](RELEASING.md). The package
+version is derived from git tags by `hatch-vcs`, so it's never hand-edited.
+
+## License
+
+MIT

entrygraph-0.1.0.dist-info/RECORD

@@ -0,0 +1,102 @@
+entrygraph/__init__.py,sha256=44r5IEkXSoE6ReFDAbQ5C_--yX327RBfIYt_ILvsOWA,2253
+entrygraph/__main__.py,sha256=ZqvsbMeW_cgA0PI8C05d4Z_q38cJiBZokTsApVRZGV8,210
+entrygraph/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+entrygraph/api.py,sha256=w9U7bMJCeoHnM8mmlLo8JLneEfoSVDbNI_FcENFWEXU,22625
+entrygraph/errors.py,sha256=C9FQoCWMdPUmUWzTw3ffWhQX8gn16tjK2n00VHFLoO0,714
+entrygraph/kinds.py,sha256=GN_Z5Sj-uwRvPVwH27FRxTGkTwxLRo5SWGn65_aGO-o,1408
+entrygraph/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/results.py,sha256=3xe-q2F_q_o0W5w5g-uWF5Z3ewK0S3CF1NmtNERt6Sw,3358
+entrygraph/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/cli/main.py,sha256=eir985PXzTcfaQjiWF3rVro3IPj99BXZj82KxDMQR_k,13712
+entrygraph/cli/render.py,sha256=AJEXJc-umHWxwYHogWN0E7zYQoRk8HJ5DlZG-42eVaQ,4060
+entrygraph/data/sinks/csharp.toml,sha256=6eT00T4v6fp16kbPcKzwx9zDEPdkpzmzYG-8VGg2Lrs,3523
+entrygraph/data/sinks/go.toml,sha256=tq9q9Es5w6kTn7yt5AH9OZMLkTH2bRz3nntP8Fdh21w,2418
+entrygraph/data/sinks/java.toml,sha256=C43YXjlTVK5e_R7Nh5X1lSrC-5RHTXGrDJ0hXGYQuQo,2934
+entrygraph/data/sinks/javascript.toml,sha256=WTIK52OPiUFw4qP025ir116fP5OSviIgCfmtbYCXFx8,3144
+entrygraph/data/sinks/lib_javascript.toml,sha256=pRK5NvTbY7Tmze9YEB4XrLx-H7kUKScBnRoKI79qMys,855
+entrygraph/data/sinks/lib_python.toml,sha256=r1XrKSQSc4mMF41qS1VoIfwJusMTrZIc3A0QyyKQ008,1319
+entrygraph/data/sinks/php.toml,sha256=zCH343Vrnagv0yms9E61qgU6ILfgtOYO2CglmXevO00,3469
+entrygraph/data/sinks/python.toml,sha256=rqePUOptZfZoD64UViLHyZBEhShtesDEiqMgCpCz9nw,4537
+entrygraph/data/sinks/ruby.toml,sha256=krGofste9lwQamGEemGL162dUa3YHR-z_B1Etmn4ujQ,2883
+entrygraph/data/sinks/rust.toml,sha256=Oh1aiCFB-odrxU6VNT4q6IoqF9DUdPdGzH3LgqnoV7o,2273
+entrygraph/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/db/engine.py,sha256=xmGl1YnTZTgjir-rTHYnRmWAPtxa6X1QoBvtDb42FqM,1003
+entrygraph/db/meta.py,sha256=sEtLd_x6p69Lg1xAtDb-TTPg5knWc5PKt5HJFnOYO6E,2338
+entrygraph/db/models.py,sha256=DYR54qyFGn0whw0-BPREcb-w5kvAo7TZ2e7sSfb6DUo,7388
+entrygraph/db/queries.py,sha256=mX0ahxPLeJOHN92PuNVRzcRDPoJg3Azd36xf_VjIlYM,4815
+entrygraph/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/detect/frameworks.py,sha256=kg0M642QqeDJWtLG1-tOgFy78f61w6kFuKKvyrQKmeU,13961
+entrygraph/detect/manifests.py,sha256=OjNvcT3NTS6085TE9rGpiQHKmrO113UvEFppgd58NyU,8031
+entrygraph/detect/taint.py,sha256=wBIgqfydgIks9ostRunNcdinJvXT46x7BHTYYYfd3p8,7999
+entrygraph/detect/entrypoints/__init__.py,sha256=RMdraEnOsWVQN1p-8YvOLiXy2KpERuPUwQ-If7DqUGQ,721
+entrygraph/detect/entrypoints/base.py,sha256=Ij0A2i_1_3OJnJi7AUDtPKei2sZKsbrQ3ak68Om-SMc,4035
+entrygraph/detect/entrypoints/configs.py,sha256=wf-wNCyXVRPT_6tBy1CrEiG0obPjKbew5JHeTxogCfE,5093
+entrygraph/detect/entrypoints/csharp.py,sha256=1utRdPv2NGtDdmYRaWP_oeUou1x7vQFuxFtjpKv4R0U,5108
+entrygraph/detect/entrypoints/golang.py,sha256=jC_31R__VrBlDnOThwHqO1rXbExYyxB_tX0Hq1WGZPE,6083
+entrygraph/detect/entrypoints/java.py,sha256=__in3xGMwCEtxV3aFwuP7u52MDStaVqtDsqE-y_bBGc,6979
+entrygraph/detect/entrypoints/javascript.py,sha256=oDVaJ6Ff51iZcWx1ySz7VPlqTUq0Nenb4RGlSOUN7o8,8678
+entrygraph/detect/entrypoints/php.py,sha256=Ja-XAB6p7NE2ROBAIzmyojeDyQYlFIq_ktYZ67pKR8U,5227
+entrygraph/detect/entrypoints/python.py,sha256=6qpVLP_HHv8_pnR-czYvt4aXFUoul5hA-BgDuJruG2A,14046
+entrygraph/detect/entrypoints/ruby.py,sha256=ST_QN1RG7JO9cWmiu9tRs0Izr8EmE6hU-XKrv8SA3Rk,6040
+entrygraph/detect/entrypoints/rust.py,sha256=RO0euL_JH8O8wX8HW-0NndWt5J16qHnjTVLTh1i9RDU,6003
+entrygraph/extract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/extract/base.py,sha256=BvUmz-W7XGSJekdGD5gFzgdZKs-quaHsXeGS103Wcyc,1455
+entrygraph/extract/csharp.py,sha256=0AUP1IXbqC5gzjWpaw72V5UV962ZtIv7RwsNzjzl48U,19846
+entrygraph/extract/golang.py,sha256=-qS9rOuUjF86-tsDLcGDW9DNoxiznzeVepykCYN1Wl4,14172
+entrygraph/extract/ir.py,sha256=izyL150jhFPBNxbcjdCb68CTB_24N52LC3tGhwCRE-M,3832
+entrygraph/extract/java.py,sha256=hOYRKuDRSBmizFgVSCLv56GiOLYhYoV_PnOF19hrsdQ,14466
+entrygraph/extract/javascript.py,sha256=H-l6wyvp7nd5OozGC1ABoGwzNsc3qWprg2VR7QW5AZc,18360
+entrygraph/extract/php.py,sha256=71GK7hjXrmHtey7jctGGbRBso9Zx1oAdLQMYVQOrrUU,18402
+entrygraph/extract/python.py,sha256=4eS3YCEfx1VDkXW2hIzluH7Rg7Yc3p3CjRNUK55Fuf4,16471
+entrygraph/extract/registry.py,sha256=_gIqguYEjlg90YnAyQzm2HA_SI-McPCymchiEpF63Ew,1475
+entrygraph/extract/ruby.py,sha256=7td-dPeUpuZ9OiHYzf30BSfrDtqSPwVSIYa840xK0Qc,13581
+entrygraph/extract/rust.py,sha256=Hva5RIDQHxARwxeGCvMxygQKvgfw86ujTeD6bDRarNY,20189
+entrygraph/fs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/fs/hashing.py,sha256=FGkLUBKwyKGoAJpF_jDSOv31eldx9qLnYktsL2rd8yg,2269
+entrygraph/fs/lang.py,sha256=qIO4kvOYxdLiHa2xs7rZ5ma5Q2V9risde6mzEKQsqMk,3614
+entrygraph/fs/walker.py,sha256=caYkSdX1W4UHqpZQgNLp-MS2ZAQekNmAEmrXKqwFIoA,5943
+entrygraph/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/graph/adjacency.py,sha256=897wzWqZso83e6Rodj6ZAZNGLIXdq--w8MaliU3Nx3A,5401
+entrygraph/graph/cte.py,sha256=tvJ3FrbNM5iD7JNKzfzNy96OFVWvk0Jjezqiagj9AVY,5298
+entrygraph/graph/scoring.py,sha256=abDBgSLsDwcp0sV_LaSwFP7NMXiqzPCAHSFvLTEzbxQ,3328
+entrygraph/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/parsing/parsers.py,sha256=Iqqchki4XKldtpp2WyZs6p7lxc2mlxDD2JO7cvfa6h4,1218
+entrygraph/parsing/queries.py,sha256=vim4IY-WTmiFZgubb4dcvenqDauKE0OrQCHwFn_ATAk,1455
+entrygraph/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/pipeline/scanner.py,sha256=Zlm4KreFXDBXtGsiK59INlyPd1JK_FOlhFodVA_iGEU,20312
+entrygraph/pipeline/worker.py,sha256=CC9Nmmhyp-cCf9FsI6I9y0jYAPlncgOoot-sZ6ikNM8,1694
+entrygraph/pipeline/writer.py,sha256=nzuXGDZ3IBDPXHDdYQdxn9Q18PUgYCGrlZ4CbhU9bvA,1385
+entrygraph/queries/csharp/calls.scm,sha256=DfBWCoDw1QtA0s280titsOpxWTEzhM5y1v8URYLcVlo,211
+entrygraph/queries/csharp/definitions.scm,sha256=JkXuWtJMAdjjL2TZ-lMh1Y_Aq86E8k-OtMrbujbheXg,759
+entrygraph/queries/csharp/imports.scm,sha256=RF7I3saHlcJPym2PBSyUmRPm7fA_LtHlkSaquAyAslU,220
+entrygraph/queries/go/calls.scm,sha256=ZDTfKTiR-6W0C1ioViHm-l3vV7Tn6Ck62qZDdEgWWqc,94
+entrygraph/queries/go/definitions.scm,sha256=Zot2zZgqeQAAvbgLqya1oBxSMTAiicZTmjQ3nFkHgIQ,679
+entrygraph/queries/go/imports.scm,sha256=xdnkdEC6AEfA7elWPwsOyMAF3SvGYoUuy8_-ncgruGk,29
+entrygraph/queries/java/calls.scm,sha256=2Fy4oCvxy8kC8eFCBGv0HiFh86u61OtT_tInZf7BF34,60
+entrygraph/queries/java/definitions.scm,sha256=eT2OGjy-xRIq8o2xo4tlJ_66FDAe2VS6nNJoPAHnUbs,387
+entrygraph/queries/java/imports.scm,sha256=lRsMKoCEdifRBRoZROXWdy_QA94k9aJzLEm4xXbVYiQ,60
+entrygraph/queries/javascript/calls.scm,sha256=BEsbJzu-nX_hmk_NFKJlUyWUHnP5muWNx8BC5cK0HfM,249
+entrygraph/queries/javascript/definitions.scm,sha256=h1n4LSwQ_O_PDq-Dlye2wDj5sP7HNwn-Z09G_vOeCCk,231
+entrygraph/queries/javascript/imports.scm,sha256=VWIvO-cetnyGMa4kvs_axucylz5uCY-Ds9R88M94BeI,280
+entrygraph/queries/php/calls.scm,sha256=cGQ1pNUJgFK655Vr2qULvmHwFiCWxX2hcRLNqfMpQAU,273
+entrygraph/queries/php/definitions.scm,sha256=JyGbdUb4fw9rmNPLMtzDzmh6PEV4axE5lHj9OSMqh24,582
+entrygraph/queries/php/imports.scm,sha256=Xw3s7C9zg2g2wqfXQBuQIPyK-jHssltlWNkdmKb1k6U,36
+entrygraph/queries/python/calls.scm,sha256=Wsk8tKMF0VUKrpP-esO_gjVxgENYGMBG_DrK7cM23j4,36
+entrygraph/queries/python/definitions.scm,sha256=nPUab2zd4NNQlIPCzd7JdW_-IxmJL0EM3lKvebTKEg4,326
+entrygraph/queries/python/imports.scm,sha256=_yr7Nyl7dqlKvIy0ytv6lGO9j4FPz_eIXVZyELSfgPg,64
+entrygraph/queries/ruby/calls.scm,sha256=E-nTwNWzVfNdE-TkHtD_PfurKBJOdDZMYIFbblpyBvY,192
+entrygraph/queries/ruby/definitions.scm,sha256=70N4UQl4qQqzmMm1lRpJ8MhWjF8W6zHpR6_QyPaUkGg,471
+entrygraph/queries/ruby/imports.scm,sha256=8ku0XF6fUflZmKkhBd1cpMx26zBgd22gIBeISSm3klU,278
+entrygraph/queries/rust/calls.scm,sha256=l3pAxfSf2V4ljX2nLq4XFklM8qdNGkFtPjw03jfJBBw,205
+entrygraph/queries/rust/definitions.scm,sha256=KWZ5D_XucNGqTAGaxuc0F822U6g45PqKY2FIty1PmSw,603
+entrygraph/queries/rust/imports.scm,sha256=j-9jeyrDjWEsarSAY8vKjXbbsWRUHHbE9Qlg9D5IaMo,144
+entrygraph/resolve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entrygraph/resolve/externals.py,sha256=F0kox4-9IK9wvJdoAsGVcthXCjqAWGx8ei3YqF2Wr-Y,1907
+entrygraph/resolve/hierarchy.py,sha256=zXD189hbCq1UM-nDzCW5yVGkAt0nbMpdWq2nz409fTg,6126
+entrygraph/resolve/resolver.py,sha256=dQVY12LGoKzYWH4NFT_kjxfblybVaOiNbOXg7UFvFVw,12180
+entrygraph/resolve/symbol_table.py,sha256=d69fqlOYOAMXqvYk6Xnbw7-RcqoOe9ajpxOil1fmRTs,2280
+entrygraph-0.1.0.dist-info/METADATA,sha256=AQL8QtA18e_wvlr1UBevQSm808fEFHXy6yKfMDFTBqw,9228
+entrygraph-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+entrygraph-0.1.0.dist-info/entry_points.txt,sha256=y8Sitwv8ki0DqKj89yfTcavZZL6Chv7SaaRylLs7MRE,56
+entrygraph-0.1.0.dist-info/licenses/LICENSE,sha256=yowSBdgg1AkXtU1Ui5fd4gC8JLxsMWY1jovGzCfrDp4,1069
+entrygraph-0.1.0.dist-info/RECORD,,

entrygraph-0.1.0.dist-info/WHEEL

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

entrygraph-0.1.0.dist-info/entry_points.txt

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

entrygraph-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brett Bergin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.