victor-codegraph 0.0.1__tar.gz → 0.1.1__tar.gz

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.0.1
+Version: 0.1.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

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-codegraph"
-version = "0.0.1"
+version = "0.1.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"

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/tests/test_adapter.py

@@ -37,6 +37,10 @@ def test_edge_records_reference_node_oids():
     assert e["edge"]["from_oid"].startswith("graph/repo1/node/")
     assert e["edge"]["to_oid"].startswith("graph/repo1/node/")
     assert e["edge"]["edge_type"] == "CALLS"
+    # edge props always carry a call-site line (0 when unknown; >0 once the parser
+    # preserves call_site through resolution — see the call-site-fidelity change).
+    assert "line" in e["props"]
+    assert isinstance(e["props"]["line"], int)
 
 
 def test_embedder_populates_embedding_cell():

victor_codegraph-0.1.1/tests/test_line_base_contract.py

@@ -0,0 +1,30 @@
+"""Pins the canonical 1-based line-number contract (see model.LINE_BASE).
+
+This is the cross-surface contract — Victor, the ProximaDB SDK, and AnvaiOps all
+consume this package and must agree on a symbol's (file, name, line) coordinate.
+If a refactor ever shifts line numbers, this test fails loudly.
+"""
+
+from __future__ import annotations
+
+from victor_codegraph import LINE_BASE, parse
+
+
+def test_line_base_is_one():
+    assert LINE_BASE == 1
+
+
+def test_parse_emits_1_based_lines():
+    # The def is on the FIRST line → start_line must be 1 (not 0).
+    parsed = parse("def first():\n    return second()\n\n\ndef second():\n    return 1\n", file_path="m.py")
+    by_name = {s.simple_name: s for s in parsed.symbols}
+    assert by_name["first"].location.start_line == 1
+    assert by_name["second"].location.start_line == 5  # 1-based line of the 2nd def
+
+
+def test_call_site_line_is_1_based():
+    parsed = parse("def a():\n    return b()\n\n\ndef b():\n    return 1\n", file_path="m.py")
+    calls = [r for r in parsed.relations if r.relation_type.name == "CALLS"]
+    assert calls
+    # the b() call is on line 2 (1-based), not 1
+    assert any(r.call_site is not None and r.call_site.start_line == 2 for r in calls)

victor_codegraph-0.1.1/tests/test_repo.py

@@ -0,0 +1,62 @@
+"""Repo-walk tests — fully offline (tmp tree + stdlib ast for the .py files)."""
+
+from __future__ import annotations
+
+from victor_codegraph import chunk_path, chunk_repo, iter_source_files, parse_path
+
+
+def _make_tree(root):
+    (root / "pkg").mkdir()
+    (root / "pkg" / "a.py").write_text("def a():\n    return b()\ndef b():\n    return 1\n")
+    (root / "pkg" / "notes.txt").write_text("not source")  # unknown extension
+    (root / "README.md").write_text("# docs")  # markdown is not in the language map
+    # noise dirs that must be skipped
+    (root / "node_modules").mkdir()
+    (root / "node_modules" / "dep.py").write_text("def vendored():\n    pass\n")
+    (root / ".git").mkdir()
+    (root / ".git" / "hook.py").write_text("def hook():\n    pass\n")
+    return root
+
+
+def test_iter_source_files_filters_and_skips_noise(tmp_path):
+    _make_tree(tmp_path)
+    found = {p.name for p in iter_source_files(tmp_path)}
+    assert found == {"a.py"}  # .txt/.md skipped; node_modules/.git pruned
+
+
+def test_iter_source_files_language_filter(tmp_path):
+    _make_tree(tmp_path)
+    assert {p.name for p in iter_source_files(tmp_path, languages=["python"])} == {"a.py"}
+    assert list(iter_source_files(tmp_path, languages=["rust"])) == []
+
+
+def test_iter_single_file(tmp_path):
+    f = tmp_path / "solo.py"
+    f.write_text("def f():\n    return 1\n")
+    assert [p.name for p in iter_source_files(f)] == ["solo.py"]
+
+
+def test_chunk_path(tmp_path):
+    f = tmp_path / "m.py"
+    f.write_text("def f():\n    return 1\n")
+    chunks = chunk_path(f)
+    assert chunks and any(c.metadata.get("simple_name") == "f" for c in chunks)
+
+
+def test_chunk_path_unreadable_returns_empty(tmp_path):
+    assert chunk_path(tmp_path / "does_not_exist.py") == []
+
+
+def test_parse_path(tmp_path):
+    f = tmp_path / "m.py"
+    f.write_text("def a():\n    return b()\ndef b():\n    return 1\n")
+    parsed = parse_path(f)
+    assert parsed is not None
+    assert {s.simple_name for s in parsed.symbols} == {"a", "b"}
+
+
+def test_chunk_repo_streams_all_files(tmp_path):
+    _make_tree(tmp_path)
+    chunks = list(chunk_repo(tmp_path))
+    names = {c.metadata.get("simple_name") for c in chunks}
+    assert {"a", "b"} <= names  # symbols from pkg/a.py, vendored dirs excluded

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/victor_codegraph/__init__.py

@@ -16,6 +16,7 @@ from .adapter import relation_to_record, symbol_to_record, to_proxima_records
 from .config import ChunkConfig
 from .languages import detect_language
 from .model import (
+    LINE_BASE,
     CodeChunk,
     CodeRelation,
     CodeRelationType,
@@ -25,14 +26,20 @@ from .model import (
     SourceLocation,
 )
 from .parser import chunk, parse
+from .repo import chunk_path, chunk_repo, iter_source_files, parse_path
 
-__version__ = "0.0.1"
+__version__ = "0.1.1"
 
 __all__ = [
     "__version__",
     "chunk",
     "parse",
+    "chunk_repo",
+    "chunk_path",
+    "parse_path",
+    "iter_source_files",
     "ChunkConfig",
+    "LINE_BASE",
     "detect_language",
     "to_proxima_records",
     "symbol_to_record",

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/victor_codegraph/adapter.py

@@ -73,7 +73,12 @@ def relation_to_record(relation: CodeRelation, repo_graph_id: str, branch_id: st
             "to_oid": f"graph/{repo_graph_id}/node/{relation.to_symbol_id}",
             "edge_type": relation.relation_type.name,
         },
-        "props": {"confidence": relation.confidence, "context": relation.context},
+        "props": {
+            "confidence": relation.confidence,
+            "context": relation.context,
+            # call-site line (0 when unknown) — lets the graph carry where the edge fires.
+            "line": relation.call_site.start_line if relation.call_site is not None else 0,
+        },
     }
 
 

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/victor_codegraph/model.py

@@ -13,6 +13,23 @@ from dataclasses import dataclass, field
 from enum import IntEnum
 from typing import Any
 
+# ─────────────────────────────────────────────────────────────────────────────
+# CANONICAL LINE-NUMBER CONTRACT
+#
+# Every line number this package emits (``SourceLocation.start_line`` / ``end_line``,
+# ``CodeChunk.metadata['start_line']``/``['end_line']``, the ``call_site`` line on a
+# ``CodeRelation``) is **1-based** — line 1 is the first line of the file. This matches
+# editors (Monaco/VS Code), pgwire, and how humans reference code.
+#
+# victor-codegraph is the SHARED parser across Victor, the ProximaDB SDK, and AnvaiOps,
+# so this convention is the cross-surface contract: a symbol's ``(file, name, line)``
+# coordinate must be identical in every consumer for the correlated code-graph to
+# reconcile. Consumers MUST pass these line numbers through unchanged — do NOT convert
+# to 0-based (a `- 1` shift) for an internal/tree-sitter-compat convention; that breaks
+# cross-surface reconciliation. Byte offsets (``byte_offset``/``start_pos``) are 0-based.
+LINE_BASE = 1
+# ─────────────────────────────────────────────────────────────────────────────
+
 
 class CodeSymbolType(IntEnum):
     """Kinds of code symbol that can be extracted (superset across languages)."""
@@ -62,7 +79,13 @@ class CodeRelationType(IntEnum):
 
 @dataclass
 class SourceLocation:
-    """Where a symbol lives in source. Lines are 1-based; bytes are 0-based."""
+    """Where a symbol lives in source.
+
+    Lines (``start_line``/``end_line``) are **1-based** (see ``LINE_BASE`` and the
+    canonical line-number contract at the top of this module); byte offsets
+    (``byte_offset``/``byte_length``) are 0-based. Pass line numbers through
+    unchanged — do not convert to 0-based.
+    """
 
     file_path: str
     start_line: int = 0

victor_codegraph-0.1.1/victor_codegraph/repo.py

@@ -0,0 +1,113 @@
+"""Repo-walking convenience — iterate source files and chunk/parse a whole tree.
+
+Every consumer (Victor codebase indexing, AnvaiOps code-graph-sync) needs the same
+loop: walk a repository, skip noise directories, and chunk/parse each source file
+whose extension maps to a known language. This puts that loop in one place.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterator
+from pathlib import Path
+
+from .config import ChunkConfig
+from .languages import detect_language
+from .model import CodeChunk, ParsedCode
+from .parser import chunk as _chunk
+from .parser import parse as _parse
+
+# Directories never worth indexing (VCS, caches, vendored deps, build output).
+DEFAULT_EXCLUDE_DIRS: frozenset[str] = frozenset(
+    {
+        ".git",
+        ".hg",
+        ".svn",
+        "node_modules",
+        "__pycache__",
+        ".venv",
+        "venv",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".tox",
+        "dist",
+        "build",
+        "target",
+        ".idea",
+        ".gradle",
+        ".next",
+        "site-packages",
+        "vendor",
+    }
+)
+
+
+def iter_source_files(
+    root: str | os.PathLike[str],
+    *,
+    languages: list[str] | None = None,
+    exclude_dirs: frozenset[str] | set[str] = DEFAULT_EXCLUDE_DIRS,
+    follow_symlinks: bool = False,
+) -> Iterator[Path]:
+    """Yield files under ``root`` whose extension maps to a known language.
+
+    Skips ``exclude_dirs`` and dot-directories. If ``root`` is itself a file, yields it
+    (when its extension is recognized). ``languages`` restricts to those language names.
+    """
+    root_path = Path(root)
+    if root_path.is_file():
+        if detect_language(str(root_path)) is not None:
+            yield root_path
+        return
+    allowed = set(languages) if languages else None
+    excl = set(exclude_dirs)
+    for dirpath, dirnames, filenames in os.walk(root_path, followlinks=follow_symlinks):
+        # Prune in place so os.walk does not descend into excluded/hidden dirs.
+        dirnames[:] = [d for d in dirnames if d not in excl and not d.startswith(".")]
+        for fn in sorted(filenames):
+            p = Path(dirpath) / fn
+            lang = detect_language(str(p))
+            if lang is None:
+                continue
+            if allowed is not None and lang not in allowed:
+                continue
+            yield p
+
+
+def parse_path(
+    path: str | os.PathLike[str], *, encoding: str = "utf-8"
+) -> ParsedCode | None:
+    """Parse a single file into symbols + relations. Returns ``None`` if unreadable."""
+    p = Path(path)
+    try:
+        content = p.read_text(encoding=encoding)
+    except (OSError, UnicodeDecodeError):
+        return None
+    return _parse(content, file_path=str(p))
+
+
+def chunk_path(
+    path: str | os.PathLike[str],
+    config: ChunkConfig | None = None,
+    *,
+    encoding: str = "utf-8",
+) -> list[CodeChunk]:
+    """Read + chunk a single file. Returns an empty list if it can't be read."""
+    p = Path(path)
+    try:
+        content = p.read_text(encoding=encoding)
+    except (OSError, UnicodeDecodeError):
+        return []
+    return _chunk(content, file_path=str(p), config=config)
+
+
+def chunk_repo(
+    root: str | os.PathLike[str],
+    config: ChunkConfig | None = None,
+    *,
+    languages: list[str] | None = None,
+) -> Iterator[CodeChunk]:
+    """Walk ``root`` and yield chunks for every source file (streaming, low-memory)."""
+    for p in iter_source_files(root, languages=languages):
+        yield from chunk_path(p, config)

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/victor_codegraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.0.1
+Version: 0.1.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

{victor_codegraph-0.0.1 → victor_codegraph-0.1.1}/victor_codegraph.egg-info/SOURCES.txt

@@ -1,7 +1,9 @@
 README.md
 pyproject.toml
 tests/test_adapter.py
+tests/test_line_base_contract.py
 tests/test_python_parser.py
+tests/test_repo.py
 tests/test_sizing_and_chunk.py
 tests/test_treesitter_jsts.py
 victor_codegraph/__init__.py
@@ -11,6 +13,7 @@ victor_codegraph/languages.py
 victor_codegraph/model.py
 victor_codegraph/parser.py
 victor_codegraph/python_parser.py
+victor_codegraph/repo.py
 victor_codegraph/sizing.py
 victor_codegraph/treesitter_parser.py
 victor_codegraph.egg-info/PKG-INFO