victor-codegraph 0.0.1__tar.gz

victor_codegraph-0.0.1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: victor-codegraph
+Version: 0.0.1
+Summary: Code->CPG chunker: tree-sitter symbol + relation extraction, size-capped chunks, ProximaRecord projection. Shared by Victor, ProximaDB SDK, and AnvaiOps.
+Author-email: Vijaykumar Singh <singhvjd@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/vjsingh1984/victor
+Project-URL: Repository, https://github.com/vjsingh1984/victor
+Keywords: code-graph,cpg,chunking,tree-sitter,ast,embeddings,rag
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: treesitter
+Requires-Dist: tree-sitter>=0.23; extra == "treesitter"
+Requires-Dist: tree-sitter-language-pack>=1.0; extra == "treesitter"
+Provides-Extra: contracts
+Requires-Dist: victor-contracts<1.0,>=0.7.0; extra == "contracts"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: tree-sitter>=0.23; extra == "dev"
+Requires-Dist: tree-sitter-language-pack>=1.0; extra == "dev"
+
+# victor-codegraph
+
+Shared **code → Code-Property-Graph chunker**: tree-sitter symbol + relation extraction,
+size-capped embeddable chunks, and a `ProximaRecord` projection. One chunker, three
+consumers — Victor (owner), the ProximaDB SDK (`[codegraph]` extra), and AnvaiOps (SaaS
+code-graph vertical).
+
+> Design: ProximaDB `ADR-029` (authoritative) · Victor `ADR-014` (owner/donor) ·
+> AnvaiOps `ADR-0018` (consumer). This package is the **TD-CG1** scaffold.
+
+## Why
+
+The same tree-sitter code→symbol+relation chunker existed twice (ProximaDB SDK `code.py`
+and Victor `victor-coding`) and was about to be written a third time in AnvaiOps. This
+package is the single neutral home. It merges the best of both donors and fixes their two
+gaps:
+
+- **Size-capping** — ProximaDB's `code.py` emitted one chunk per symbol with *no* size
+  bound (a huge function became a huge chunk). Here, oversized symbols are body-split with
+  overlap (LlamaIndex `CodeSplitter` discipline). See `sizing.py`.
+- **Real JS/TS** — the donor JS/TS parser was a stub returning no symbols. Here JS/TS get a
+  real tree-sitter extractor (functions, classes, methods, `const … = () =>`, imports).
+
+## Install
+
+Not yet published to PyPI — use an **editable install** from the monorepo for now. Consumers
+(Victor, the ProximaDB SDK, AnvaiOps) reference it editable until the first `victor-codegraph-v*`
+release is cut.
+
+```bash
+# dev: editable, with tree-sitter grammars + test tooling
+make -C victor-codegraph dev          # = pip install -e ../victor-contracts && pip install -e ".[dev]"
+
+# minimal: Python-only (stdlib ast) path, zero native deps
+pip install -e ./victor-codegraph
+
+# once published:
+#   pip install victor-codegraph                 # Python path
+#   pip install "victor-codegraph[treesitter]"   # + multi-language grammars
+```
+
+### Releasing
+
+CI: `.github/workflows/ci-codegraph.yml` runs the suite (editable install, grammars on) for every
+PR touching `victor-codegraph/**`. Publishing: push a tag `victor-codegraph-v0.1.0` to trigger
+`.github/workflows/release-codegraph.yml`, which builds and publishes via **PyPI Trusted Publishing**
+(OIDC — no API token). Configure the publisher once on PyPI (owner `vjsingh1984`, repo `victor`,
+workflow `release-codegraph.yml`, environments `pypi` / `testpypi`); see the header of that workflow.
+
+## Use
+
+```python
+from victor_codegraph import chunk, parse, to_proxima_records, ChunkConfig
+
+# Size-capped, embeddable chunks:
+chunks = chunk(source, file_path="app/service.py", config=ChunkConfig(max_chunk_tokens=512))
+
+# Symbols + relations:
+parsed = parse(source, file_path="app/service.py")
+
+# Project to the ProximaDB substrate-keystone record shape (one symbol = row+node+vector):
+records = to_proxima_records(parsed, repo_graph_id="myrepo", branch_id="main",
+                             embedder=my_embed_fn)  # embedder optional
+```
+
+## Design principles (the "best posture" this encodes)
+
+1. Chunk at **symbol** granularity (not statement, not fixed-size).
+2. **AST-aligned and size-capped** — never split mid-statement, never exceed the budget.
+3. Extract **relations** (CALLS/EXTENDS/CONTAINS/…) and project to a CPG.
+4. **Deterministic IDs + content hash** → idempotent incremental re-index.
+5. **Graceful fallback chain**: python-ast → tree-sitter → sliding-window.
+6. Token budget **matched to the embedding model** (BGE-small 384-d ≈ 512 tokens).
+
+## Status
+
+`0.1.0` — TD-CG1 scaffold. Python (stdlib `ast`) is the primary, fully-offline path.
+Multi-language extraction is best-effort via tree-sitter; deeper per-language relation
+extraction (the donor parsers' Rust/Go/Java specifics) lands incrementally.

victor_codegraph-0.0.1/README.md

@@ -0,0 +1,79 @@
+# victor-codegraph
+
+Shared **code → Code-Property-Graph chunker**: tree-sitter symbol + relation extraction,
+size-capped embeddable chunks, and a `ProximaRecord` projection. One chunker, three
+consumers — Victor (owner), the ProximaDB SDK (`[codegraph]` extra), and AnvaiOps (SaaS
+code-graph vertical).
+
+> Design: ProximaDB `ADR-029` (authoritative) · Victor `ADR-014` (owner/donor) ·
+> AnvaiOps `ADR-0018` (consumer). This package is the **TD-CG1** scaffold.
+
+## Why
+
+The same tree-sitter code→symbol+relation chunker existed twice (ProximaDB SDK `code.py`
+and Victor `victor-coding`) and was about to be written a third time in AnvaiOps. This
+package is the single neutral home. It merges the best of both donors and fixes their two
+gaps:
+
+- **Size-capping** — ProximaDB's `code.py` emitted one chunk per symbol with *no* size
+  bound (a huge function became a huge chunk). Here, oversized symbols are body-split with
+  overlap (LlamaIndex `CodeSplitter` discipline). See `sizing.py`.
+- **Real JS/TS** — the donor JS/TS parser was a stub returning no symbols. Here JS/TS get a
+  real tree-sitter extractor (functions, classes, methods, `const … = () =>`, imports).
+
+## Install
+
+Not yet published to PyPI — use an **editable install** from the monorepo for now. Consumers
+(Victor, the ProximaDB SDK, AnvaiOps) reference it editable until the first `victor-codegraph-v*`
+release is cut.
+
+```bash
+# dev: editable, with tree-sitter grammars + test tooling
+make -C victor-codegraph dev          # = pip install -e ../victor-contracts && pip install -e ".[dev]"
+
+# minimal: Python-only (stdlib ast) path, zero native deps
+pip install -e ./victor-codegraph
+
+# once published:
+#   pip install victor-codegraph                 # Python path
+#   pip install "victor-codegraph[treesitter]"   # + multi-language grammars
+```
+
+### Releasing
+
+CI: `.github/workflows/ci-codegraph.yml` runs the suite (editable install, grammars on) for every
+PR touching `victor-codegraph/**`. Publishing: push a tag `victor-codegraph-v0.1.0` to trigger
+`.github/workflows/release-codegraph.yml`, which builds and publishes via **PyPI Trusted Publishing**
+(OIDC — no API token). Configure the publisher once on PyPI (owner `vjsingh1984`, repo `victor`,
+workflow `release-codegraph.yml`, environments `pypi` / `testpypi`); see the header of that workflow.
+
+## Use
+
+```python
+from victor_codegraph import chunk, parse, to_proxima_records, ChunkConfig
+
+# Size-capped, embeddable chunks:
+chunks = chunk(source, file_path="app/service.py", config=ChunkConfig(max_chunk_tokens=512))
+
+# Symbols + relations:
+parsed = parse(source, file_path="app/service.py")
+
+# Project to the ProximaDB substrate-keystone record shape (one symbol = row+node+vector):
+records = to_proxima_records(parsed, repo_graph_id="myrepo", branch_id="main",
+                             embedder=my_embed_fn)  # embedder optional
+```
+
+## Design principles (the "best posture" this encodes)
+
+1. Chunk at **symbol** granularity (not statement, not fixed-size).
+2. **AST-aligned and size-capped** — never split mid-statement, never exceed the budget.
+3. Extract **relations** (CALLS/EXTENDS/CONTAINS/…) and project to a CPG.
+4. **Deterministic IDs + content hash** → idempotent incremental re-index.
+5. **Graceful fallback chain**: python-ast → tree-sitter → sliding-window.
+6. Token budget **matched to the embedding model** (BGE-small 384-d ≈ 512 tokens).
+
+## Status
+
+`0.1.0` — TD-CG1 scaffold. Python (stdlib `ast`) is the primary, fully-offline path.
+Multi-language extraction is best-effort via tree-sitter; deeper per-language relation
+extraction (the donor parsers' Rust/Go/Java specifics) lands incrementally.

victor_codegraph-0.0.1/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "victor-codegraph"
+version = "0.0.1"
+description = "Code->CPG chunker: tree-sitter symbol + relation extraction, size-capped chunks, ProximaRecord projection. Shared by Victor, ProximaDB SDK, and AnvaiOps."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "Vijaykumar Singh", email = "singhvjd@gmail.com" },
+]
+keywords = [
+    "code-graph",
+    "cpg",
+    "chunking",
+    "tree-sitter",
+    "ast",
+    "embeddings",
+    "rag",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+
+# Thin + neutral by design (ADR-014 / ProximaDB ADR-029). The base install is
+# ZERO-dependency: the Python path uses the stdlib `ast` and needs no native grammars,
+# so `pip install -e .` works fully offline. Opt-in extras add multi-language grammars
+# (`treesitter`) and the contracts Protocol boundary (`contracts`). victor-contracts
+# becomes a hard dep once the parser is exposed as a contracts Protocol (ADR-014).
+dependencies = []
+
+[project.optional-dependencies]
+treesitter = [
+    "tree-sitter>=0.23",
+    "tree-sitter-language-pack>=1.0",
+]
+contracts = [
+    "victor-contracts>=0.7.0,<1.0",
+]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.5",
+    "tree-sitter>=0.23",
+    "tree-sitter-language-pack>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/vjsingh1984/victor"
+Repository = "https://github.com/vjsingh1984/victor"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["victor_codegraph*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+# Self-contained pytest config so running `pytest` from this package directory uses
+# THIS file as the rootdir/inifile and does NOT inherit the victor monorepo root's
+# `addopts = --cov=victor` (pytest-cov isn't a dep here -> "unrecognized arguments").
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ""

victor_codegraph-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

victor_codegraph-0.0.1/tests/test_adapter.py

@@ -0,0 +1,52 @@
+"""Adapter tests — ProximaRecord shape projection (no DB, no embed by default)."""
+
+from __future__ import annotations
+
+from victor_codegraph import parse, to_proxima_records
+
+SAMPLE = '''\
+def a():
+    return b()
+
+
+def b():
+    return 1
+'''
+
+
+def test_symbol_records_shape():
+    parsed = parse(SAMPLE, file_path="m.py")
+    records = to_proxima_records(parsed, repo_graph_id="repo1")
+    nodes = [r for r in records if "graph_node" in r["labels"]]
+    assert len(nodes) == 2
+    n = nodes[0]
+    assert n["oid"].startswith("graph/repo1/node/")
+    assert n["labels"] == ["graph_node", "code_symbol"]
+    assert n["branch_id"] == "main"
+    assert n["props"]["lang"] == "python"
+    assert n["props"]["ast_kind"] in ("FUNCTION", "METHOD", "CONSTRUCTOR")
+    assert n["embeddings"] == []  # no embedder supplied
+
+
+def test_edge_records_reference_node_oids():
+    parsed = parse(SAMPLE, file_path="m.py")
+    records = to_proxima_records(parsed, repo_graph_id="repo1")
+    edges = [r for r in records if "graph_edge" in r["labels"]]
+    assert edges, "expected a CALLS edge (a -> b)"
+    e = edges[0]
+    assert e["edge"]["from_oid"].startswith("graph/repo1/node/")
+    assert e["edge"]["to_oid"].startswith("graph/repo1/node/")
+    assert e["edge"]["edge_type"] == "CALLS"
+
+
+def test_embedder_populates_embedding_cell():
+    parsed = parse(SAMPLE, file_path="m.py")
+    records = to_proxima_records(
+        parsed, repo_graph_id="repo1", embedder=lambda text: [0.0] * 384
+    )
+    node = next(r for r in records if "graph_node" in r["labels"])
+    assert len(node["embeddings"]) == 1
+    cell = node["embeddings"][0]
+    assert cell["modality"] == "code"
+    assert cell["dim"] == 384
+    assert len(cell["values"]) == 384

victor_codegraph-0.0.1/tests/test_python_parser.py

@@ -0,0 +1,108 @@
+"""Python parser tests — run fully offline (stdlib ast, no grammar needed)."""
+
+from __future__ import annotations
+
+from victor_codegraph import CodeSymbolType, parse
+from victor_codegraph.model import CodeRelationType
+
+SAMPLE = '''\
+"""Module doc."""
+import os
+from typing import Any
+
+
+def top_level(x: int, y: str = "a") -> bool:
+    """A function."""
+    return helper(x)
+
+
+def helper(x: int) -> int:
+    return x + 1
+
+
+class Greeter(Base):
+    """A class."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def greet(self) -> str:
+        return top_level(1)
+'''
+
+
+def test_extracts_functions_classes_methods():
+    parsed = parse(SAMPLE, file_path="pkg/mod.py")
+    names = {s.simple_name for s in parsed.symbols}
+    assert {"top_level", "helper", "Greeter", "__init__", "greet"} <= names
+
+
+def test_symbol_types_and_constructor():
+    parsed = parse(SAMPLE, file_path="pkg/mod.py")
+    by_name = {s.simple_name: s for s in parsed.symbols}
+    assert by_name["top_level"].symbol_type == CodeSymbolType.FUNCTION
+    assert by_name["greet"].symbol_type == CodeSymbolType.METHOD
+    assert by_name["__init__"].symbol_type == CodeSymbolType.CONSTRUCTOR
+    assert by_name["Greeter"].symbol_type == CodeSymbolType.CLASS
+
+
+def test_signature_and_docstring_and_params():
+    parsed = parse(SAMPLE, file_path="pkg/mod.py")
+    fn = next(s for s in parsed.symbols if s.simple_name == "top_level")
+    assert fn.signature == "top_level(x: int, y: str) -> bool"
+    assert fn.documentation == "A function."
+    assert {p["name"] for p in fn.parameters} == {"x", "y"}
+    assert fn.return_type == "bool"
+
+
+def test_imports():
+    parsed = parse(SAMPLE, file_path="pkg/mod.py")
+    assert any("import os" in i for i in parsed.imports)
+    assert any("from typing import Any" in i for i in parsed.imports)
+
+
+def test_calls_relation_resolved_to_ids():
+    parsed = parse(SAMPLE, file_path="pkg/mod.py")
+    ids = {s.id for s in parsed.symbols}
+    calls = [r for r in parsed.relations if r.relation_type == CodeRelationType.CALLS]
+    assert calls, "expected at least one CALLS edge"
+    for r in calls:
+        assert r.from_symbol_id in ids
+        assert r.to_symbol_id in ids  # resolved to a real symbol, not a bare name
+
+
+def test_unresolved_callee_is_retained():
+    """An outgoing call to a symbol not defined in-file is KEPT (bare-name target,
+    confidence < 1.0, with a call_site) so cross-file/external references survive for
+    CPG blast-radius / impact analysis rather than being silently dropped."""
+    parsed = parse("def authenticate():\n    return verify()\n", file_path="svc/auth.py")
+    calls = list(parsed.relations)
+    assert len(calls) == 1
+    r = calls[0]
+    assert r.to_symbol_id == "verify"  # bare name — NOT dropped
+    assert r.confidence < 1.0
+    assert r.call_site is not None
+    assert r.call_site.start_line == 2  # the verify() call line (1-based)
+
+
+def test_recursive_self_call_is_dropped():
+    """A recursive call to the enclosing symbol emits no self-edge."""
+    parsed = parse("def f():\n    return f()\n", file_path="m.py")
+    assert [r for r in parsed.relations] == []
+
+
+def test_extends_relation():
+    parsed = parse(SAMPLE, file_path="pkg/mod.py")
+    cls = next(s for s in parsed.symbols if s.simple_name == "Greeter")
+    assert any("extends(Base)" in m for m in cls.modifiers)
+
+
+def test_deterministic_ids():
+    a = parse(SAMPLE, file_path="pkg/mod.py")
+    b = parse(SAMPLE, file_path="pkg/mod.py")
+    assert [s.id for s in a.symbols] == [s.id for s in b.symbols]
+
+
+def test_syntax_error_falls_back_to_no_symbols():
+    parsed = parse("def broken(:\n", file_path="bad.py")
+    assert parsed.symbols == []

victor_codegraph-0.0.1/tests/test_sizing_and_chunk.py

@@ -0,0 +1,62 @@
+"""Size-capping tests — the headline gap fix vs ProximaDB's donor code.py."""
+
+from __future__ import annotations
+
+from victor_codegraph import ChunkConfig, chunk
+from victor_codegraph.model import (
+    CodeSymbol,
+    CodeSymbolType,
+    SourceLocation,
+)
+from victor_codegraph.sizing import chunks_for_symbol
+
+
+def _big_symbol(n_lines: int) -> CodeSymbol:
+    body = "\n".join(f"    x{i} = compute({i})" for i in range(n_lines))
+    source = f"def big():\n{body}\n"
+    return CodeSymbol(
+        id="sym1",
+        symbol_type=CodeSymbolType.FUNCTION,
+        fully_qualified_name="m::big",
+        simple_name="big",
+        location=SourceLocation(file_path="m.py", start_line=1, end_line=n_lines + 2),
+        source_code=source,
+        language="python",
+    )
+
+
+def test_small_symbol_is_single_chunk():
+    sym = _big_symbol(3)
+    chunks = chunks_for_symbol(sym, ChunkConfig())
+    assert len(chunks) == 1
+    assert chunks[0].metadata["chunk_total"] == 1
+
+
+def test_oversized_symbol_is_body_split():
+    sym = _big_symbol(400)
+    cfg = ChunkConfig(max_chunk_tokens=128, chunk_overlap_tokens=16)
+    chunks = chunks_for_symbol(sym, cfg)
+    assert len(chunks) > 1, "oversized symbol must split"
+    # No chunk exceeds the char budget.
+    for c in chunks:
+        assert len(c.text) <= cfg.max_chunk_chars
+    # All sub-chunks share the parent symbol id and have hierarchical ids.
+    assert all(c.symbol_id == "sym1" for c in chunks)
+    assert all(c.chunk_id.startswith("sym1#body#") for c in chunks)
+    assert all(c.metadata["chunk_total"] == len(chunks) for c in chunks)
+
+
+def test_chunk_end_to_end_python_respects_budget():
+    src = "def f():\n" + "\n".join(f"    a{i} = {i}" for i in range(300)) + "\n"
+    cfg = ChunkConfig(max_chunk_tokens=100)
+    chunks = chunk(src, file_path="big.py", config=cfg)
+    assert chunks
+    for c in chunks:
+        assert len(c.text) <= cfg.max_chunk_chars
+
+
+def test_unknown_language_falls_back_to_sliding_window():
+    src = "\n".join(f"line {i}" for i in range(200))
+    chunks = chunk(src, file_path="notes.unknownext", config=ChunkConfig(max_chunk_tokens=50))
+    assert chunks
+    assert all(c.metadata.get("strategy") == "sliding_window" for c in chunks)

victor_codegraph-0.0.1/tests/test_treesitter_jsts.py

@@ -0,0 +1,74 @@
+"""JS/TS extraction tests — the donor stub fix.
+
+Guarded with importorskip so the suite stays green where the grammar pack isn't
+installed; where it is, these assert the stub is genuinely replaced (non-empty symbols).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("tree_sitter_language_pack")
+
+from victor_codegraph import CodeSymbolType, parse  # noqa: E402
+from victor_codegraph.treesitter_parser import GrammarUnavailable, parse_treesitter  # noqa: E402
+
+JS = """\
+import { x } from "./x";
+
+export function add(a, b) {
+  return a + b;
+}
+
+const mul = (a, b) => a * b;
+
+class Calc {
+  constructor(seed) {
+    this.seed = seed;
+  }
+  run(n) {
+    return add(n, this.seed);
+  }
+}
+"""
+
+TS = """\
+export function greet(name: string): string {
+  return `hi ${name}`;
+}
+
+class Service {
+  handle(req: Request): Response {
+    return new Response();
+  }
+}
+"""
+
+
+def _names(language: str, src: str):
+    try:
+        parsed = parse_treesitter(src, f"f.{language}", language)
+    except GrammarUnavailable:
+        pytest.skip(f"{language} grammar not installed")
+    return {s.simple_name for s in parsed.symbols}, parsed
+
+
+def test_javascript_functions_classes_methods_arrow():
+    names, parsed = _names("javascript", JS)
+    # The donor stub returned []; here we must see real symbols.
+    assert {"add", "Calc", "run"} <= names
+    assert "mul" in names  # const arrow function
+    assert any(s.symbol_type == CodeSymbolType.CLASS for s in parsed.symbols)
+    assert any("import" in i for i in parsed.imports)
+
+
+def test_typescript_functions_and_methods():
+    names, _ = _names("typescript", TS)
+    assert {"greet", "Service", "handle"} <= names
+
+
+def test_chunk_jsts_is_size_capped():
+    parsed = parse(JS, language="javascript", file_path="f.js")
+    if not parsed.symbols:
+        pytest.skip("javascript grammar not installed")
+    assert parsed.symbols  # routed through tree-sitter, not the empty stub

victor_codegraph-0.0.1/victor_codegraph/__init__.py

@@ -0,0 +1,47 @@
+"""victor-codegraph — shared code->CPG chunker.
+
+One tree-sitter symbol+relation chunker, three consumers (Victor, ProximaDB SDK,
+AnvaiOps). See ProximaDB ADR-029 / Victor ADR-014.
+
+    from victor_codegraph import chunk, parse, to_proxima_records, ChunkConfig
+
+    chunks = chunk(source, file_path="foo.py")          # size-capped, embeddable
+    parsed = parse(source, file_path="foo.py")           # symbols + relations
+    records = to_proxima_records(parsed, repo_graph_id="myrepo")
+"""
+
+from __future__ import annotations
+
+from .adapter import relation_to_record, symbol_to_record, to_proxima_records
+from .config import ChunkConfig
+from .languages import detect_language
+from .model import (
+    CodeChunk,
+    CodeRelation,
+    CodeRelationType,
+    CodeSymbol,
+    CodeSymbolType,
+    ParsedCode,
+    SourceLocation,
+)
+from .parser import chunk, parse
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "__version__",
+    "chunk",
+    "parse",
+    "ChunkConfig",
+    "detect_language",
+    "to_proxima_records",
+    "symbol_to_record",
+    "relation_to_record",
+    "CodeChunk",
+    "CodeSymbol",
+    "CodeRelation",
+    "CodeSymbolType",
+    "CodeRelationType",
+    "ParsedCode",
+    "SourceLocation",
+]