codegraph-ir 0.1.0__py3-none-any.whl

cgir/trace/trace_map.py

@@ -0,0 +1,83 @@
+"""Map ``path:line`` source locations to ComponentSpec ids.
+
+Used by ``cgir trace`` to answer "which component owns this line?". For now
+we index by start/end-line ranges per Function/Method. The future PDG pass
+will refine this to statement-level traces.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from cgir.ir.graph import RepoGraph
+from cgir.ir.nodes import NodeKind
+
+
+@dataclass(frozen=True, slots=True)
+class _Span:
+    path: str
+    start: int
+    end: int
+    component_id: str
+
+
+class TraceMap:
+    def __init__(self, spans: list[_Span]) -> None:
+        self._by_path: dict[str, list[_Span]] = {}
+        for span in spans:
+            self._by_path.setdefault(span.path, []).append(span)
+
+    def lookup(self, path: str, line: int) -> str | None:
+        for span in self._by_path.get(path, []):
+            if span.start <= line <= span.end:
+                return span.component_id
+        return None
+
+    def to_jsonable(self) -> list[dict[str, str | int]]:
+        return [
+            {"path": s.path, "start": s.start, "end": s.end, "component_id": s.component_id}
+            for spans in self._by_path.values()
+            for s in spans
+        ]
+
+    @classmethod
+    def from_jsonable(cls, data: list[dict[str, str | int]]) -> TraceMap:
+        spans = [
+            _Span(
+                path=str(d["path"]),
+                start=int(d["start"]),
+                end=int(d["end"]),
+                component_id=str(d["component_id"]),
+            )
+            for d in data
+        ]
+        return cls(spans)
+
+    def write(self, path: Path) -> None:
+        path.write_text(json.dumps(self.to_jsonable(), indent=2, sort_keys=True))
+
+    @classmethod
+    def read(cls, path: Path) -> TraceMap:
+        return cls.from_jsonable(json.loads(path.read_text()))
+
+
+def build_trace_map(graph: RepoGraph) -> TraceMap:
+    spans: list[_Span] = []
+    for node in graph.nodes():
+        if node.kind not in {NodeKind.Function, NodeKind.Method}:
+            continue
+        if node.path is None or node.start_line is None or node.end_line is None:
+            continue
+        qual = node.attrs.get("qualname") if node.attrs else None
+        component_id = str(qual) if isinstance(qual, str) else node.name
+        spans.append(
+            _Span(
+                path=node.path,
+                start=node.start_line,
+                end=node.end_line,
+                component_id=component_id,
+            )
+        )
+    return TraceMap(spans)

cgir/verify.py

@@ -0,0 +1,173 @@
+"""cgir verify — the trust loop for an LLM-written component.
+
+Splice a candidate implementation into a *copy* of the repo at the
+component's span, rescan, and contract-diff the result against the indexed
+spec. Answers the question no compiler or test suite answers directly:
+**did this rewrite change what the component is** — its effects, purity,
+kind, call surface, entrypoint? Optionally also runs the component's
+linked tests (behavior on top of contract).
+
+Deterministic and offline. This is what lets an agent (or a CI gate) trust
+a generated change before it lands.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from cgir.export.json_export import read_specs
+from cgir.ir.graph import RepoGraph
+from cgir.ir.nodes import Node, NodeKind
+from cgir.pipeline import scan_repo
+from cgir.report.diff import compute_diff, violations
+
+_IGNORE = shutil.ignore_patterns(
+    ".git", ".venv", "venv", "node_modules", "__pycache__", ".cgir", "outputs", "site"
+)
+
+
+@dataclass(slots=True)
+class VerifyResult:
+    component_id: str
+    contract_ok: bool
+    violations: list[str] = field(default_factory=list)
+    drift: dict[str, Any] = field(default_factory=dict)
+    tests_ran: list[str] = field(default_factory=list)
+    tests_ok: bool | None = None
+    detail: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def verify(
+    index_dir: Path,
+    component_id: str,
+    candidate: str,
+    repo: Path,
+    fail_on: list[str] | None = None,
+    run_tests: bool = False,
+) -> VerifyResult:
+    old_specs = read_specs(index_dir)
+    if component_id not in {s.id for s in old_specs}:
+        raise KeyError(component_id)
+    node = _find_node(index_dir, component_id)
+    if node is None or node.path is None or node.start_line is None or node.end_line is None:
+        raise KeyError(f"{component_id}: no source span in index")
+
+    shadow = Path(tempfile.mkdtemp(prefix="cgir-verify-"))
+    try:
+        repo = repo.resolve()
+        shutil.copytree(repo, shadow / "repo", ignore=_IGNORE, dirs_exist_ok=True)
+        target_file = shadow / "repo" / node.path
+        _splice(target_file, node.start_line, node.end_line, candidate)
+
+        new_index = shadow / "idx"
+        scan_repo(shadow / "repo", new_index)
+        new_specs = read_specs(new_index)
+
+        diff = compute_diff(old_specs, new_specs)
+        drift: dict[str, Any] = next(
+            (c["fields"] for c in diff["changed"] if c["id"] == component_id), {}
+        )
+        target_diff = {
+            "changed": [c for c in diff["changed"] if c["id"] == component_id],
+            "entrypoints": {
+                key: [e for e in items if e.get("id") == component_id]
+                for key, items in diff["entrypoints"].items()
+            },
+        }
+        viol = violations(target_diff, fail_on or [])
+
+        tests_ran: list[str] = []
+        tests_ok: bool | None = None
+        detail = ""
+        if run_tests:
+            tests_ran = _linked_tests(shadow / "repo", component_id)
+            if tests_ran:
+                tests_ok, detail = _run_tests(shadow / "repo", tests_ran)
+
+        return VerifyResult(
+            component_id=component_id,
+            contract_ok=not drift,
+            violations=viol,
+            drift=drift,
+            tests_ran=tests_ran,
+            tests_ok=tests_ok,
+            detail=detail,
+        )
+    finally:
+        shutil.rmtree(shadow, ignore_errors=True)
+
+
+def _find_node(index_dir: Path, component_id: str) -> Node | None:
+    graph_path = index_dir / "repo_graph.json"
+    if not graph_path.exists():
+        return None
+    import json
+
+    graph = RepoGraph.from_jsonable(json.loads(graph_path.read_text()))
+    for node in graph.nodes():
+        if node.kind in {NodeKind.Function, NodeKind.Method} and (
+            node.attrs.get("qualname") == component_id
+        ):
+            return node
+    return None
+
+
+def _splice(target_file: Path, start_line: int, end_line: int, candidate: str) -> None:
+    lines = target_file.read_text().splitlines()
+    original_def = lines[start_line - 1] if start_line - 1 < len(lines) else ""
+    new_lines = _reindent(candidate, original_def).rstrip("\n").splitlines()
+    spliced = lines[: start_line - 1] + new_lines + lines[end_line:]
+    target_file.write_text("\n".join(spliced) + "\n")
+
+
+def _reindent(candidate: str, expected_def: str) -> str:
+    body = candidate.rstrip("\n").splitlines()
+    if not body:
+        return candidate
+    got = _leading_ws(body[0])
+    want = _leading_ws(expected_def)
+    if got == want:
+        return candidate
+    out = [want + line[len(got) :] if line.startswith(got) else line for line in body]
+    return "\n".join(out)
+
+
+def _leading_ws(line: str) -> str:
+    match = re.match(r"\s*", line)
+    return match.group(0) if match else ""
+
+
+def _linked_tests(repo: Path, component_id: str) -> list[str]:
+    """Test files that name the component (grep fallback until Sprint 25 linkage)."""
+    name = component_id.split(".")[-1]
+    pattern = re.compile(rf"\b{re.escape(name)}\b")
+    hits: list[str] = []
+    for test_dir in (repo / "tests", repo):
+        if not test_dir.is_dir():
+            continue
+        for path in sorted(test_dir.glob("test_*.py")):
+            if pattern.search(path.read_text(errors="replace")):
+                hits.append(str(path.relative_to(repo)))
+    return list(dict.fromkeys(hits))
+
+
+def _run_tests(repo: Path, test_files: list[str]) -> tuple[bool, str]:
+    proc = subprocess.run(
+        [sys.executable, "-m", "pytest", "-q", "-x", *test_files],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+        timeout=300,
+    )
+    tail = "\n".join((proc.stdout + proc.stderr).splitlines()[-5:])
+    return proc.returncode == 0, tail

cgir/watch.py

@@ -0,0 +1,171 @@
+"""Watch mode — keep the ``.cgir`` index live as you (or your agent) edit.
+
+The whole local loop (``pack`` → edit → ``impact`` → ``hook``) reads a
+``.cgir`` index; a stale index feeds stale context and wrong verdicts.
+``cgir watch`` polls the repo, and on a real content change re-scans and
+prints the **contract drift** against the previous index — so "you just
+made this pure function hit the network" shows up a second after you save,
+not in CI.
+
+Change detection is by content hash (``source_hashes``), so editor noise
+and non-source edits are free no-ops. Re-scan cost is amortised by the
+process-wide parse cache in :mod:`cgir.languages.cache` (unchanged files
+are never re-parsed). Per-component incremental *analysis* — recomputing
+only the changed blast radius — is the next step; the machinery for it is
+:func:`cgir.report.impact.compute_typed_impact`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from cgir.export.json_export import read_specs
+from cgir.languages import ADAPTERS
+from cgir.pipeline import scan_repo
+from cgir.report.diff import compute_diff
+from cgir.sources.tree_sitter_source import DEFAULT_IGNORE_DIRS
+
+_SUPPORTED_EXTS: frozenset[str] = frozenset(
+    ext for adapter in ADAPTERS.values() for ext in adapter.file_extensions
+)
+_MANIFEST_NAME = "file_hashes.json"
+
+
+def _skip(rel: Path, extra_ignore: frozenset[str]) -> bool:
+    return any(
+        part.startswith(".") or part in DEFAULT_IGNORE_DIRS or part in extra_ignore
+        for part in rel.parts
+    )
+
+
+def source_hashes(repo: Path, extra_ignore: frozenset[str] = frozenset()) -> dict[str, str]:
+    """Map repo-relative path -> sha256 for every ingestible source file."""
+    repo = repo.resolve()
+    out: dict[str, str] = {}
+    for ext in _SUPPORTED_EXTS:
+        for path in repo.rglob(f"*{ext}"):
+            rel = path.relative_to(repo)
+            if _skip(rel, extra_ignore):
+                continue
+            try:
+                out[str(rel)] = hashlib.sha256(path.read_bytes()).hexdigest()
+            except OSError:
+                continue
+    return out
+
+
+def diff_hashes(old: dict[str, str], new: dict[str, str]) -> tuple[list[str], list[str], list[str]]:
+    """(changed, added, deleted) relative paths."""
+    changed = sorted(k for k in old.keys() & new.keys() if old[k] != new[k])
+    added = sorted(new.keys() - old.keys())
+    deleted = sorted(old.keys() - new.keys())
+    return changed, added, deleted
+
+
+def read_manifest(index_dir: Path) -> dict[str, str]:
+    path = index_dir / _MANIFEST_NAME
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def write_manifest(index_dir: Path, hashes: dict[str, str]) -> None:
+    index_dir.mkdir(parents=True, exist_ok=True)
+    (index_dir / _MANIFEST_NAME).write_text(json.dumps(hashes, indent=2, sort_keys=True))
+
+
+@dataclass
+class Tick:
+    changed: list[str] = field(default_factory=list)
+    added: list[str] = field(default_factory=list)
+    deleted: list[str] = field(default_factory=list)
+    reindexed: bool = False
+    components: int = 0
+    drift: dict[str, Any] | None = None
+    elapsed_ms: float = 0.0
+
+
+def tick(repo: Path, index_dir: Path, prev_hashes: dict[str, str]) -> tuple[Tick, dict[str, str]]:
+    """One iteration: detect content changes and, if any, re-scan + diff."""
+    now = source_hashes(repo)
+    changed, added, deleted = diff_hashes(prev_hashes, now)
+    if not (changed or added or deleted):
+        return Tick(), now
+
+    old_specs = read_specs(index_dir) if (index_dir / "components").exists() else []
+    start = time.perf_counter()
+    result = scan_repo(repo, out=index_dir)
+    elapsed = (time.perf_counter() - start) * 1000
+    write_manifest(index_dir, now)
+    drift = compute_diff(old_specs, result.specs)
+    return (
+        Tick(
+            changed=changed,
+            added=added,
+            deleted=deleted,
+            reindexed=True,
+            components=len(result.specs),
+            drift=drift,
+            elapsed_ms=elapsed,
+        ),
+        now,
+    )
+
+
+def render_tick(t: Tick) -> str:
+    n = len(t.changed) + len(t.added) + len(t.deleted)
+    head = f"↻ {n} file(s) → {t.components} components in {t.elapsed_ms:.0f}ms"
+    lines = [head]
+    drift = t.drift or {}
+    changed = drift.get("changed", [])
+    if changed:
+        lines.append(f"  contract drift ({len(changed)}):")
+        for c in changed:
+            fields = ", ".join(f"{name} {v['old']}→{v['new']}" for name, v in c["fields"].items())
+            lines.append(f"    ~ {c['id']}: {fields}")
+    else:
+        lines.append("  no contract drift")
+    return "\n".join(lines) + "\n"
+
+
+def run_watch(
+    repo: Path,
+    index_dir: Path,
+    interval: float = 0.5,
+    once: bool = False,
+    emit: Any = print,
+) -> None:
+    """Poll ``repo`` and keep ``index_dir`` fresh, printing drift on change."""
+    prev = read_manifest(index_dir) or source_hashes(repo)
+    # Ensure an index exists so the first real edit can diff against it.
+    if not (index_dir / "components").exists():
+        scan_repo(repo, out=index_dir)
+        write_manifest(index_dir, prev)
+    while True:
+        result, prev = tick(repo, index_dir, prev)
+        if result.reindexed:
+            emit(render_tick(result).rstrip("\n"))
+        if once:
+            return
+        time.sleep(interval)
+
+
+__all__ = [
+    "Tick",
+    "diff_hashes",
+    "read_manifest",
+    "render_tick",
+    "run_watch",
+    "source_hashes",
+    "tick",
+    "write_manifest",
+]

codegraph_ir-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: codegraph-ir
+Version: 0.1.0
+Summary: The deterministic contract layer for AI-modified codebases — effects, purity, contracts, and blast radius, with zero LLM calls.
+Project-URL: Homepage, https://github.com/asonkiya/llm-semantic-compilers
+Project-URL: Repository, https://github.com/asonkiya/llm-semantic-compilers
+Project-URL: Issues, https://github.com/asonkiya/llm-semantic-compilers/issues
+Author: Aryaman Sonkiya
+License: MIT License
+        
+        Copyright (c) 2026 Aryaman Sonkiya
+        
+        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: ai-agents,code-graph,code-review,contracts,effects,llm,mcp,purity,static-analysis,tree-sitter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: jsonschema>=4.21
+Requires-Dist: networkx>=3.2
+Requires-Dist: pydantic>=2.6
+Requires-Dist: tree-sitter-python<0.24,>=0.23
+Requires-Dist: tree-sitter-typescript<0.24,>=0.23
+Requires-Dist: tree-sitter<0.25,>=0.23
+Requires-Dist: typer>=0.12
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == 'api'
+Requires-Dist: uvicorn>=0.27; extra == 'api'
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: types-jsonschema; extra == 'dev'
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.40; extra == 'llm'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# CodeGraph IR (CGIR)
+
+**The deterministic contract layer for AI-modified codebases.** Agents write
+more of the code than you can review. CGIR reads a repo and — with **zero LLM
+calls** — tells you what each component *is* (effects, purity, contract,
+entrypoints, call surface) and whether a change *altered* it. Think **ruff,
+but for architecture instead of style**: fast, static, hallucination-free.
+
+Distributed as **`codegraph-ir`**; the command and import package are both
+`cgir`.
+
+## Install
+
+```bash
+uv tool install codegraph-ir      # isolated CLI (recommended); or: pipx install codegraph-ir
+cgir --version
+```
+
+For library/agent use in a project: `uv pip install codegraph-ir`
+(extras: `[mcp]` for the agent server, `[api]` for the HTTP surface,
+`[llm]` for regeneration).
+
+## The local loop
+
+```bash
+cgir scan .                          # build the .cgir index (Python + TypeScript)
+cgir watch .                         # keep it live: re-scan + show contract drift on save
+cgir pack app.service.charge --repo .   # minimal context bundle for one component
+cgir impact app.service.charge          # blast radius: affected callers, entrypoints, tests
+cgir impact app.service.charge --candidate new.py --repo .   # radius narrowed by the real delta
+cgir verify app.service.charge --candidate new.py --repo .   # contract-check an edit
+cgir hook install                    # pre-commit seatbelt: block contract-breaking commits
+```
+
+`pack` → edit → `impact` → `verify` → `hook`, with `watch` keeping the index
+fresh underneath — an always-on membrane you and your agent both consult.
+
+## Gate CI on contract drift
+
+The [GitHub Action](./docs/github-action.md) scans a PR's base and head and
+fails the build on drift — a pure function that starts hitting the network, a
+service that *stops* persisting, a new `POST /admin` route — deterministically,
+with no per-seat LLM cost:
+
+```yaml
+- uses: asonkiya/llm-semantic-compilers@v0
+  with:
+    fail-on: "effect-gain:net effect-gain:fs effect-gain:db effect-loss:net effect-loss:fs effect-loss:db"
+```
+
+The default rule set is [evidence-based](./docs/gate-noise.md): replaying real
+commit history, the I/O effect rules fire on ~0–10% of commits, each a genuine
+change in a component's I/O surface.
+
+## Agents as first-class users
+
+`cgir mcp --index .cgir` serves the index over MCP. Instead of grepping, an
+agent calls `search` / `pack` to load minimal context, `impact` to see what a
+change touches, and `verify` / `impact_of_change` to contract-check its own
+edit before proposing it. See [`examples/`](./examples) for a worked
+agent-PR case study.
+
+## Docs
+
+- [`docs/strategy.md`](./docs/strategy.md) — positioning: the deterministic contract layer
+- [`docs/status.md`](./docs/status.md) — what runs today, test coverage, milestones
+- [`docs/gate-noise.md`](./docs/gate-noise.md) — false-alarm measurement on real history
+- [`docs/github-action.md`](./docs/github-action.md) — CI contract-diff gate
+- [`docs/experiment-log.md`](./docs/experiment-log.md) — rewrite-readiness / contract-preservation benchmarks
+- [`docs/architecture.md`](./docs/architecture.md) — layered pipeline, data model, extension seams
+- [`docs/languages.md`](./docs/languages.md) — adding a language (the `LanguageAdapter` seam)
+- [`Code-IR.md`](./Code-IR.md) — full product specification
+- [`RELEASING.md`](./RELEASING.md) — how to cut a release
+
+## License
+
+MIT — see [`LICENSE`](./LICENSE).

codegraph_ir-0.1.0.dist-info/RECORD

@@ -0,0 +1,63 @@
+cgir/__init__.py,sha256=xDGBKZVfqb2CRu_mkwEOStkQAN_BzPBLNksGAMVzaPI,153
+cgir/cli.py,sha256=omPCEQ_GnhuCOUtpSk83aIdA1-JinoB5hG96ZQQ5MlU,24945
+cgir/config.py,sha256=-PV5vhm_cKdRu5eYZ88GLW1e8FazgczbZ1CWal9rHSk,630
+cgir/hooks.py,sha256=CZmEz6zxpPuSLcA5yAwJBiETCBZnpL4HV_9nMLgaofc,6663
+cgir/manifest.py,sha256=60xXoN4638AmjaVlOYTpCXJ5Ln0C-Aabpw388cUnjb0,2628
+cgir/pipeline.py,sha256=J9ukXzacB4goKTRktQYz2Qf-3WiEYPGIziHPNpzLOYU,2022
+cgir/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cgir/verify.py,sha256=9n2nV70BAdV8EF_vlx_nPKrJdmMXh9n7XuwCbjTfibc,5896
+cgir/watch.py,sha256=OkaXCP45Px0qwnsVLlRWakg4qjEv7x-gWhEFZWdh0fU,5730
+cgir/analyses/__init__.py,sha256=zXyy1sTQ1_vr6ngVp-wHXQ_tvfPMMoqo6Y8VDUzaPJs,298
+cgir/analyses/call_graph.py,sha256=lT_hiaAnNomtkzWcxiXubHLqbhVKzVIwi7LTpgaXNyI,4432
+cgir/analyses/cfg.py,sha256=22qXPTIxR_gfRe7P0SNivfs6haXdPb_vbaiSN-WkkMw,12866
+cgir/analyses/effects.py,sha256=0wjkoK4z3vTEAU1YQg7Du54lo7qbL8M4gDe7GGiMmBg,4051
+cgir/analyses/entrypoints.py,sha256=ZDAbfXpmu1fBwWj7moBEgo9UeEH6NzQJUwAR_I51YkI,2203
+cgir/analyses/param_flow.py,sha256=CGLmylORfT_GG_xk8eNx9RvH8TGVSQ3scSGJlf25a5k,2623
+cgir/analyses/pdg.py,sha256=-iDFxlZPHIqdhZL0gTKiqGyn3KhaS1ZzxPKLuOb8c4Y,2817
+cgir/analyses/purity.py,sha256=jOWYnQAwjlgwHvpJYIS0yrmZv4ZUSppauYRj15CIOIg,1344
+cgir/analyses/reaching_defs.py,sha256=qT_1ZJdY-h5C0Bpn8KblzFbniYTIEgdOmQCgNcPnsDo,4058
+cgir/analyses/symbols.py,sha256=EhGo1M32s_DqBu2EI3VeDWTrmxrJjelraMiCL04s-90,3894
+cgir/api/__init__.py,sha256=-POnqxxzBdUq0bKqENEM_I7o40tfVV59XXPOtn68zXM,75
+cgir/api/mcp_server.py,sha256=ourDxB0hjT1XxLzGJxUctqTrf-huiRP9yJdksUFZ14o,6736
+cgir/api/server.py,sha256=aJitZ4oU5RKpok4MUsrJXdNjg1HVnWap937wS-59GOs,3807
+cgir/export/__init__.py,sha256=hq1RtvEHohA7r9WEYHjpNbswt7aEFl7q2K30LFpyEaw,149
+cgir/export/graphml.py,sha256=vFaWgciM9rebPL6DiHVSEs_NRKSGp277iM6bJ7W8Bp8,1643
+cgir/export/html_viz.py,sha256=AaVC1l8in9iQuJ80NBDUEgYUHlmo8B9lT2q89XwoJxw,41348
+cgir/export/json_export.py,sha256=xmliikhH4jDLUAYEJ5xMIYhKdSSbM8scOlNmLkeHKAY,1284
+cgir/export/mermaid.py,sha256=iBqa8fAc4zDWJ_ir7Jf1mi4b9MJiRcaYvUKsAlU1Hic,2100
+cgir/export/neo4j.py,sha256=FGxJdYULOGlLKSJ3-IUcMDV5UPmJWYC0Uj7FwHvvsL8,250
+cgir/ir/__init__.py,sha256=bGnVcBlM2eWi8S19OJwv9zlBsmtrIMP8Fxvo0Yf2GQw,376
+cgir/ir/component_spec.py,sha256=EBcxB2W_HSf0Ya0i6BmEIke1vw_csQpxNfrF5-fuLMs,3620
+cgir/ir/edges.py,sha256=pDIFgpg4UVx9lcTi8Y7aoAxGYT5yEU6aEqywq-KNa4I,700
+cgir/ir/graph.py,sha256=T18-WS_wi_nDfjd7P7_xjZylkUPrR0JTtpwpJqXBnKs,4592
+cgir/ir/nodes.py,sha256=P5dZ4GqQZwsxANg5e_jYc5uN3R6hkUYqjP7O6n-XDsY,858
+cgir/languages/__init__.py,sha256=4CQavFpRbmfdw9MjIh8nKOv0o3md8E8YC-ECiuUGXdY,779
+cgir/languages/base.py,sha256=ZhZU41q722k-3pmAreHwVqYBQKG9Obun6LCdBKydX1I,7167
+cgir/languages/cache.py,sha256=_wcNLb5OmVBSuIXEIxEvVOT6GA5FzhXxWKOsC1sGCm0,2878
+cgir/languages/python.py,sha256=c7FuEQPUu2k7MM8OsUihnAc5KXkhPD3Yr9C0UZEgnto,41945
+cgir/languages/registry.py,sha256=Fc6cGaG3p-PIy4wi46ZJh4EYN-KqpWkQ7i5StD0mits,836
+cgir/languages/typescript.py,sha256=r4bvnrsYfKV_KKeGbYKtroXwOaT6DejntoyVbC71vSk,32383
+cgir/regenerate/__init__.py,sha256=tES3u6yn28zcxOaKUGli5iqCc0j5W501SS-zxvsy_a8,227
+cgir/regenerate/prompt_pack.py,sha256=wJs9x5Jn7ap09HHF4ULJ2yHiZ56YYhLaQ6uXZEjkDHc,584
+cgir/regenerate/regenerator.py,sha256=DBpufeJItrhBkxt4v45Ltnp8BnV1gAUshxwKa-U8fzA,3517
+cgir/report/__init__.py,sha256=HWO721YukDxO11NBs6kZch7tQLsP8ot1fQrYIhXGEFg,130
+cgir/report/diff.py,sha256=VLvz9IyaWwfOIwOO4_B8czT0IwEPwMWIiVKTEv1ybxM,9337
+cgir/report/flow.py,sha256=kbuYgBdBr36xYNkO24r6EqGFPayJYfcvkzmY0rDEN8Y,2733
+cgir/report/impact.py,sha256=1MfiFWoT5MJcOIbllzJgw_WIpBmoEU61QjDf6Xd8IAA,8497
+cgir/report/lint.py,sha256=ISRGKlRSX-wxbmVLgoihXPC9Wo28FvGyUUiHmcg0IHg,3198
+cgir/report/pack.py,sha256=PHyzoilV5Di3XAhVwTQJVYxF3nodZOLZ65XwCzoBq6w,9212
+cgir/report/stats.py,sha256=o4EQXLREo2xJhNmq-N_2V5ee4ft8S4pkhM44quMnx_I,4587
+cgir/slicing/__init__.py,sha256=KbU8OUrOgXDBCgtwksaX4ueTMIbZVUOGpgp6c64kHzk,138
+cgir/slicing/slicer.py,sha256=M1gTr-CXC1G2DX6MgHw2FLqj535pQJ9cv1Ksv4Rzbhk,6672
+cgir/sources/__init__.py,sha256=EqasptkWdUz0CIoVgBnNOrqHjKc8iGcJcO1T2ji3Vg0,223
+cgir/sources/base.py,sha256=Pp6M3PvQDQhxiC8lJmuFpJT65Sf6l1uy2WAsbMIP9-4,383
+cgir/sources/codeql_source.py,sha256=6nkRedr4G_pD5njUBfJKSywJUVRlACnUo_OmghAx1XU,347
+cgir/sources/joern_source.py,sha256=TeI5Uu7E3vDLLnCDVuHu1U_k1RW7lpdKAwZGzb5OuEc,343
+cgir/sources/tree_sitter_source.py,sha256=oJZk_wR_4ed6sOB4Esg2mgBVC9pFZrxqbGbzHi0Hi_o,9529
+cgir/trace/__init__.py,sha256=vMwb47f70-zpsupyVCC_cq6lEIe2k2Kn2W8Z87-30Hg,153
+cgir/trace/trace_map.py,sha256=x5k46_5CZYPe7PxXmFSKZrbhlg1rXK0_OBHsawE5xWM,2536
+codegraph_ir-0.1.0.dist-info/METADATA,sha256=PblJQXRc1W4E91YRU1xEsV8yzse93tcoyHeZUz2gXVo,6662
+codegraph_ir-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+codegraph_ir-0.1.0.dist-info/entry_points.txt,sha256=-y9moAY3BkNj-4tRQW8JM_xLjioEIsgQFKRECvVZpj0,38
+codegraph_ir-0.1.0.dist-info/licenses/LICENSE,sha256=ZKZDuzSRXDx9ssBTaEKsx97f7j7w5L3LIvns0fVbMLo,1072
+codegraph_ir-0.1.0.dist-info/RECORD,,

codegraph_ir-0.1.0.dist-info/WHEEL

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

codegraph_ir-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cgir = cgir.cli:app

codegraph_ir-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aryaman Sonkiya
+
+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.