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

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.1.1
+Version: 0.8.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
+Project-URL: Homepage, https://github.com/anvai-labs/victor
+Project-URL: Repository, https://github.com/anvai-labs/victor
 Keywords: code-graph,cpg,chunking,tree-sitter,ast,embeddings,rag
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -53,20 +53,18 @@ gaps:
 
 ## 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.
+Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/)
+(current release **0.1.2**). Consumers pin the PyPI release — the ProximaDB SDK's
+`proximadb[codegraph]` extra and AnvaiOps both require `victor-codegraph>=0.1.2`.
 
 ```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
+# from PyPI
+pip install victor-codegraph                 # Python-only (stdlib ast) path, zero native deps
+pip install "victor-codegraph[treesitter]"   # + multi-language tree-sitter grammars
 
-# once published:
-#   pip install victor-codegraph                 # Python path
-#   pip install "victor-codegraph[treesitter]"   # + multi-language grammars
+# dev (monorepo): editable, with tree-sitter grammars + test tooling
+make -C victor-codegraph dev          # = pip install -e ../victor-contracts && pip install -e ".[dev]"
+pip install -e ./victor-codegraph     # minimal editable install
 ```
 
 ### Releasing
@@ -104,6 +102,6 @@ records = to_proxima_records(parsed, repo_graph_id="myrepo", branch_id="main",
 
 ## Status
 
-`0.1.0` — TD-CG1 scaffold. Python (stdlib `ast`) is the primary, fully-offline path.
+`0.1.2` (PyPI). 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.1.1 → victor_codegraph-0.8.1}/README.md

@@ -23,20 +23,18 @@ gaps:
 
 ## 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.
+Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/)
+(current release **0.1.2**). Consumers pin the PyPI release — the ProximaDB SDK's
+`proximadb[codegraph]` extra and AnvaiOps both require `victor-codegraph>=0.1.2`.
 
 ```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
+# from PyPI
+pip install victor-codegraph                 # Python-only (stdlib ast) path, zero native deps
+pip install "victor-codegraph[treesitter]"   # + multi-language tree-sitter grammars
 
-# once published:
-#   pip install victor-codegraph                 # Python path
-#   pip install "victor-codegraph[treesitter]"   # + multi-language grammars
+# dev (monorepo): editable, with tree-sitter grammars + test tooling
+make -C victor-codegraph dev          # = pip install -e ../victor-contracts && pip install -e ".[dev]"
+pip install -e ./victor-codegraph     # minimal editable install
 ```
 
 ### Releasing
@@ -74,6 +72,6 @@ records = to_proxima_records(parsed, repo_graph_id="myrepo", branch_id="main",
 
 ## Status
 
-`0.1.0` — TD-CG1 scaffold. Python (stdlib `ast`) is the primary, fully-offline path.
+`0.1.2` (PyPI). 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.1.1 → victor_codegraph-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-codegraph"
-version = "0.1.1"
+version = "0.8.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"
@@ -55,8 +55,8 @@ dev = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/vjsingh1984/victor"
-Repository = "https://github.com/vjsingh1984/victor"
+Homepage = "https://github.com/anvai-labs/victor"
+Repository = "https://github.com/anvai-labs/victor"
 
 [tool.setuptools.packages.find]
 where = ["."]
@@ -66,6 +66,11 @@ include = ["victor_codegraph*"]
 line-length = 100
 target-version = "py310"
 
+# Pin the rule set explicitly: the CI workflow installs the latest ruff, whose
+# evolving defaults must not be able to red a path-filtered pipeline overnight.
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F"]
+
 # 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").

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

@@ -4,14 +4,14 @@ from __future__ import annotations
 
 from victor_codegraph import parse, to_proxima_records
 
-SAMPLE = '''\
+SAMPLE = """\
 def a():
     return b()
 
 
 def b():
     return 1
-'''
+"""
 
 
 def test_symbol_records_shape():
@@ -45,12 +45,46 @@ def test_edge_records_reference_node_oids():
 
 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
-    )
+    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
+
+
+def test_batch_embedder_single_call_populates_all_nodes():
+    parsed = parse(SAMPLE, file_path="m.py")
+    calls: list[list[str]] = []
+
+    def batch(texts: list[str]) -> list[list[float]]:
+        calls.append(texts)
+        return [[0.5] * 8 for _ in texts]
+
+    records = to_proxima_records(parsed, repo_graph_id="repo1", batch_embedder=batch, dim=8)
+    nodes = [r for r in records if "graph_node" in r["labels"]]
+
+    assert len(calls) == 1  # ONE call for the whole file
+    assert len(calls[0]) == len(nodes)
+    for n in nodes:
+        assert len(n["embeddings"]) == 1
+        assert n["embeddings"][0]["dim"] == 8
+        assert n["embeddings"][0]["values"] == [0.5] * 8
+
+
+def test_batch_embedder_wins_over_per_symbol_embedder():
+    parsed = parse(SAMPLE, file_path="m.py")
+    per_symbol_calls: list[str] = []
+
+    records = to_proxima_records(
+        parsed,
+        repo_graph_id="repo1",
+        embedder=lambda text: per_symbol_calls.append(text) or [0.0] * 8,
+        batch_embedder=lambda texts: [[1.0] * 8 for _ in texts],
+        dim=8,
+    )
+    nodes = [r for r in records if "graph_node" in r["labels"]]
+
+    assert per_symbol_calls == []  # per-symbol path not used
+    assert all(n["embeddings"][0]["values"] == [1.0] * 8 for n in nodes)

{victor_codegraph-0.1.1 → victor_codegraph-0.8.1}/tests/test_line_base_contract.py

@@ -16,7 +16,10 @@ def test_line_base_is_one():
 
 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")
+    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

victor_codegraph-0.8.1/tests/test_manifest.py

@@ -0,0 +1,127 @@
+"""Incremental manifest contract + encoding fallback (offline, tmp_path only)."""
+
+from __future__ import annotations
+
+from victor_codegraph import (
+    build_manifest,
+    diff_manifest,
+    iter_changed_files,
+    parse_path,
+    read_source_text,
+)
+
+
+def _seed(tmp_path):
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "a.py").write_text("def a():\n    return 1\n")
+    (tmp_path / "pkg" / "b.py").write_text("def b():\n    return 2\n")
+    (tmp_path / "README.md").write_text("# not source\n")  # unrecognized: excluded
+    return tmp_path
+
+
+def test_build_manifest_relative_posix_keys(tmp_path):
+    manifest = build_manifest(_seed(tmp_path))
+    assert set(manifest) == {"pkg/a.py", "pkg/b.py"}
+    assert all("\\" not in k for k in manifest)
+    assert all(len(v) == 64 for v in manifest.values())  # sha-256 hex
+
+
+def test_manifest_hash_matches_parse_path(tmp_path):
+    root = _seed(tmp_path)
+    manifest = build_manifest(root)
+    parsed = parse_path(root / "pkg" / "a.py")
+    assert parsed is not None
+    assert manifest["pkg/a.py"] == parsed.content_hash
+
+
+def test_diff_manifest_classifies_all_states(tmp_path):
+    root = _seed(tmp_path)
+    previous = build_manifest(root)
+
+    (root / "pkg" / "a.py").write_text("def a():\n    return 42\n")  # changed
+    (root / "pkg" / "b.py").unlink()  # removed
+    (root / "pkg" / "c.py").write_text("def c():\n    return 3\n")  # added
+
+    current = build_manifest(root)
+    diff = diff_manifest(current, previous)
+    assert diff.added == ["pkg/c.py"]
+    assert diff.changed == ["pkg/a.py"]
+    assert diff.removed == ["pkg/b.py"]
+    assert diff.unchanged == []
+
+
+def test_diff_manifest_unchanged(tmp_path):
+    root = _seed(tmp_path)
+    manifest = build_manifest(root)
+    diff = diff_manifest(manifest, dict(manifest))
+    assert diff.added == diff.changed == diff.removed == []
+    assert set(diff.unchanged) == {"pkg/a.py", "pkg/b.py"}
+
+
+def test_iter_changed_files_none_previous_yields_all(tmp_path):
+    root = _seed(tmp_path)
+    changed = list(iter_changed_files(root, None))
+    assert {p.name for p, _ in changed} == {"a.py", "b.py"}
+    # Yielded hashes ARE the next manifest's values.
+    assert {h for _, h in changed} == set(build_manifest(root).values())
+
+
+def test_iter_changed_files_skips_unchanged(tmp_path):
+    root = _seed(tmp_path)
+    previous = build_manifest(root)
+    assert list(iter_changed_files(root, previous)) == []
+
+    (root / "pkg" / "a.py").write_text("def a():\n    return 99\n")
+    changed = list(iter_changed_files(root, previous))
+    assert [p.name for p, _ in changed] == ["a.py"]
+    # The yielded hash reflects the NEW content.
+    assert changed[0][1] == build_manifest(root)["pkg/a.py"]
+
+
+def test_single_file_root(tmp_path):
+    f = tmp_path / "solo.py"
+    f.write_text("def solo():\n    return 0\n")
+    manifest = build_manifest(f)
+    assert set(manifest) == {"solo.py"}
+
+
+# ── encoding fallback ────────────────────────────────────────────────────────
+
+
+def test_latin1_file_no_longer_skipped(tmp_path):
+    f = tmp_path / "legacy.py"
+    f.write_bytes("# caf\xe9\ndef caf():\n    return 1\n".encode("latin-1"))
+    text = read_source_text(f)
+    assert text is not None
+    assert "caf\xe9" in text
+
+    parsed = parse_path(f)
+    assert parsed is not None
+    assert [s.simple_name for s in parsed.symbols] == ["caf"]
+
+    # And it participates in manifests deterministically.
+    manifest = build_manifest(tmp_path)
+    assert manifest["legacy.py"] == parsed.content_hash
+
+
+def test_utf8_bom_stripped(tmp_path):
+    f = tmp_path / "bom.py"
+    f.write_bytes(b"\xef\xbb\xbf" + b"def bom():\n    return 1\n")
+    text = read_source_text(f)
+    assert text is not None
+    assert not text.startswith("")
+    parsed = parse_path(f)
+    assert parsed is not None
+    assert [s.simple_name for s in parsed.symbols] == ["bom"]
+
+
+def test_fallback_disabled_restores_skip_behavior(tmp_path):
+    f = tmp_path / "legacy.py"
+    f.write_bytes("# caf\xe9\n".encode("latin-1"))
+    assert read_source_text(f, encoding_fallback=False) is None
+    assert parse_path(f, encoding_fallback=False) is None
+
+
+def test_unreadable_file_returns_none(tmp_path):
+    assert read_source_text(tmp_path / "missing.py") is None
+    assert parse_path(tmp_path / "missing.py") is None

victor_codegraph-0.8.1/tests/test_sizing_overlap.py

@@ -0,0 +1,132 @@
+"""Overlap correctness and no-data-loss guarantees for body-splitting.
+
+Pins the fix for the minified-line hard-cut: a single line over the char budget
+used to be truncated (``ln[:max_chars]``), silently dropping the remainder.
+"""
+
+from __future__ import annotations
+
+from victor_codegraph.config import ChunkConfig
+from victor_codegraph.model import CodeSymbol, CodeSymbolType, SourceLocation
+from victor_codegraph.sizing import chunks_for_symbol
+
+
+def _cfg(max_tokens: int = 40, overlap_tokens: int = 8) -> ChunkConfig:
+    # Small budgets so tests exercise splitting with tiny fixtures.
+    return ChunkConfig(max_chunk_tokens=max_tokens, chunk_overlap_tokens=overlap_tokens)
+
+
+def _symbol(source: str, start_line: int = 10) -> CodeSymbol:
+    line_count = source.count("\n") + (0 if source.endswith("\n") else 1)
+    return CodeSymbol(
+        id="sym1",
+        symbol_type=CodeSymbolType.FUNCTION,
+        fully_qualified_name="f.py::big",
+        simple_name="big",
+        location=SourceLocation(
+            file_path="f.py",
+            start_line=start_line,
+            end_line=start_line + line_count - 1,
+        ),
+        source_code=source,
+        language="python",
+    )
+
+
+def _multiline_source(n_lines: int = 120) -> str:
+    return "".join(f"    value_{i} = compute_{i}(x)\n" for i in range(n_lines))
+
+
+def test_no_chunk_exceeds_budget():
+    cfg = _cfg()
+    chunks = chunks_for_symbol(_symbol(_multiline_source()), cfg)
+    assert len(chunks) > 1
+    assert all(len(c.text) <= cfg.max_chunk_chars for c in chunks)
+
+
+def test_every_source_line_appears_in_some_chunk():
+    cfg = _cfg()
+    source = _multiline_source()
+    chunks = chunks_for_symbol(_symbol(source), cfg)
+    joined = [c.text for c in chunks]
+    for line in source.splitlines():
+        assert any(line in text for text in joined), f"line lost: {line!r}"
+
+
+def test_consecutive_windows_overlap_by_whole_lines():
+    # Overlap is whole-line granular: give it budget for at least one line.
+    cfg = _cfg(max_tokens=40, overlap_tokens=16)
+    chunks = chunks_for_symbol(_symbol(_multiline_source()), cfg)
+    assert len(chunks) > 1
+    for a, b in zip(chunks, chunks[1:]):
+        # The next window begins with whole lines that terminate the previous one:
+        # some non-empty line-suffix of `a` is a prefix of `b`, within budget.
+        a_lines = a.text.splitlines(keepends=True)
+        overlap = 0
+        for k in range(len(a_lines)):
+            suffix = "".join(a_lines[k:])
+            if b.text.startswith(suffix):
+                overlap = len(suffix)
+                break
+        assert overlap > 0
+        assert overlap <= cfg.chunk_overlap_chars
+
+
+def test_body_split_window_line_metadata():
+    cfg = _cfg()
+    sym = _symbol(_multiline_source(), start_line=10)
+    chunks = chunks_for_symbol(sym, cfg)
+    for c in chunks:
+        start = c.metadata["start_line"]
+        end = c.metadata["end_line"]
+        assert start >= 10
+        assert end >= start
+        # end_line reflects THIS window, not the symbol's overall end.
+        spanned = c.text.count("\n") + (0 if c.text.endswith("\n") else 1)
+        assert end == start + spanned - 1
+    assert chunks[0].metadata["start_line"] == 10
+
+
+def test_minified_line_is_not_truncated():
+    """A single line 10x over budget must be fully preserved across chunks."""
+    cfg = _cfg()
+    long_line = "x=1;" * (cfg.max_chunk_chars * 10 // 4)
+    source = long_line + "\n"
+    chunks = chunks_for_symbol(_symbol(source), cfg)
+
+    assert len(chunks) > 1
+    assert all(len(c.text) <= cfg.max_chunk_chars for c in chunks)
+    assert all(c.metadata.get("is_line_split") for c in chunks)
+
+    # Consecutive pieces advance by (max - overlap); every char offset is covered
+    # and the full line (incl. trailing newline) is reconstructible.
+    full = long_line + "\n"
+    step = cfg.max_chunk_chars - cfg.chunk_overlap_chars
+    buf = [""] * len(full)
+    for idx, c in enumerate(chunks):
+        start = idx * step
+        for j, ch in enumerate(c.text):
+            buf[start + j] = ch
+    assert "".join(buf) == full
+
+
+def test_minified_line_mixed_with_normal_lines():
+    cfg = _cfg()
+    long_line = "y=2;" * (cfg.max_chunk_chars // 2)
+    source = "def big():\n" + f"    a = {long_line}\n" + "    return a\n"
+    sym = _symbol(source)
+    chunks = chunks_for_symbol(sym, cfg)
+    text_all = "".join(c.text for c in chunks)
+    assert "def big():" in text_all
+    assert "return a" in text_all
+    # The long middle line's tail must not be lost.
+    assert text_all.count("y=2;") >= source.count("y=2;")
+
+
+def test_small_symbol_single_chunk_has_no_line_split_flag():
+    cfg = _cfg(max_tokens=512, overlap_tokens=64)
+    sym = _symbol("def small():\n    return 1\n")
+    chunks = chunks_for_symbol(sym, cfg)
+    assert len(chunks) == 1
+    assert "is_line_split" not in chunks[0].metadata
+    assert "is_body_split" not in chunks[0].metadata

victor_codegraph-0.8.1/tests/test_symbol_oid_contract.py

@@ -0,0 +1,81 @@
+"""Pins the ADR-044 stable, line-independent symbol-oid contract.
+
+The correlated-CPG join key must survive edits that don't change *what a symbol is*:
+a line move keeps the oid; a rename / signature change mints a new one; a body edit
+bumps ``content_version`` but not the oid. Every cross-surface consumer (Victor, the
+ProximaDB SDK, the AnvaiOps connector) derives identity from this one function, so if it
+ever drifts this test fails loudly.
+"""
+
+from __future__ import annotations
+
+from victor_codegraph import parse, stable_symbol_oid, to_proxima_records
+
+
+def _node(records, name):
+    for r in records:
+        if "graph_node" in r.get("labels", []) and r["props"].get("name") == name:
+            return r
+    raise AssertionError(f"no node record for {name!r}")
+
+
+def _records(content, *, repo="repo1", stable=True):
+    return to_proxima_records(
+        parse(content, file_path="m.py"), repo_graph_id=repo, stable_oid=stable
+    )
+
+
+def _oid_of(content, name):
+    return _node(_records(content), name)["oid"]
+
+
+def test_stable_oid_unchanged_when_symbol_moves_lines():
+    base = "def first():\n    return second()\n\n\ndef second():\n    return 1\n"
+    moved = "\n\n\n" + base  # both symbols pushed down; identity must not churn
+    assert _oid_of(base, "second") == _oid_of(moved, "second"), "line move must not churn the oid"
+    assert _oid_of(base, "first") == _oid_of(moved, "first")
+
+
+def test_stable_oid_changes_on_rename():
+    a = "def alpha():\n    return 1\n"
+    b = "def beta():\n    return 1\n"
+    assert _oid_of(a, "alpha") != _oid_of(b, "beta"), "rename must mint a new identity"
+
+
+def test_stable_oid_changes_on_signature_change():
+    one = "def f(x):\n    return x\n"
+    two = "def f(x, y):\n    return x\n"
+    assert _oid_of(one, "f") != _oid_of(two, "f"), "signature change must mint a new identity"
+
+
+def test_body_edit_bumps_content_version_not_oid():
+    a = _node(_records("def f(x):\n    return x\n"), "f")
+    b = _node(_records("def f(x):\n    return x + 1  # changed body\n"), "f")
+    assert a["oid"] == b["oid"], "body edit must not churn the oid"
+    assert (
+        a["props"]["content_version"] != b["props"]["content_version"]
+    ), "body edit must bump content_version"
+
+
+def test_dual_emit_and_default_on_gate(monkeypatch):
+    monkeypatch.delenv("VICTOR_CODEGRAPH_STABLE_OID", raising=False)
+    parsed = parse("def f(x):\n    return x\n", file_path="m.py")
+    # P2 cutover — default ON: the record oid is the canonical stable id; BOTH ids are
+    # always emitted for mixed-read.
+    on = _node(to_proxima_records(parsed, repo_graph_id="r"), "f")
+    assert on["oid"] == on["props"]["stable_oid"]
+    assert on["props"]["stable_oid"] != on["props"]["legacy_oid"]
+    # Explicit opt-out → legacy line-coupled id (existing collections stay byte-identical).
+    off = _node(to_proxima_records(parsed, repo_graph_id="r", stable_oid=False), "f")
+    assert off["oid"] == off["props"]["legacy_oid"]
+    assert off["props"]["stable_oid"] == on["props"]["stable_oid"]
+
+
+def test_stable_symbol_oid_is_pure_and_structural():
+    # The pure derivation depends only on structural coordinates — never on line/col.
+    k = stable_symbol_oid("repo1", "python", "m.py::f", "(x)")
+    assert k == stable_symbol_oid("repo1", "python", "m.py::f", "(x)")  # deterministic
+    assert k != stable_symbol_oid("repo2", "python", "m.py::f", "(x)")  # repo
+    assert k != stable_symbol_oid("repo1", "rust", "m.py::f", "(x)")  # language
+    assert k != stable_symbol_oid("repo1", "python", "m.py::g", "(x)")  # name (FQN)
+    assert k != stable_symbol_oid("repo1", "python", "m.py::f", "(x, y)")  # overload

victor_codegraph-0.8.1/tests/test_symbol_oid_parity.py

@@ -0,0 +1,77 @@
+"""ADR-044 P2 cutover **parity ratchet**.
+
+The canonical oid becomes the default only if it is a SAFE, non-lossy replacement for the
+legacy one. This ratchet pins the invariants that gate the cutover, over a representative
+multi-symbol corpus:
+
+  1. **No collisions** — distinct symbols get distinct canonical oids (else the cutover
+     would merge two symbols into one record and lose data).
+  2. **Completeness** — every symbol gets a non-empty canonical oid + a legacy alias +
+     a content_version.
+  3. **Line-shift stability** — no symbol's canonical oid changes when lines move
+     (the incremental-re-index property the whole ADR exists for).
+  4. **Determinism** — re-parsing yields identical oids.
+
+If any of these regresses, the cutover is unsafe and CI fails.
+"""
+
+from __future__ import annotations
+
+from victor_codegraph import parse, to_proxima_records
+
+_CORPUS = """\
+import os
+
+
+class Auth:
+    def login(self, user):
+        return self._check(user)
+
+    def _check(self, user):
+        return bool(user)
+
+
+def helper(x):
+    return x + 1
+
+
+def helper2(x, y):
+    return x + y
+"""
+
+
+def _nodes(records):
+    return [r for r in records if "graph_node" in r["labels"]]
+
+
+def _canonical_nodes(src):
+    return _nodes(
+        to_proxima_records(parse(src, file_path="auth.py"), repo_graph_id="r", stable_oid=True)
+    )
+
+
+def test_no_collisions_distinct_symbols_distinct_oids():
+    recs = _canonical_nodes(_CORPUS)
+    oids = [r["oid"] for r in recs]
+    assert len(recs) >= 5, "Auth, login, _check, helper, helper2 expected"
+    assert len(oids) == len(set(oids)), "canonical oids must be unique per symbol (no merge)"
+
+
+def test_completeness_every_symbol_has_canonical_legacy_and_version():
+    for r in _canonical_nodes(_CORPUS):
+        assert r["props"]["stable_oid"], "missing canonical oid"
+        assert r["props"]["legacy_oid"], "missing legacy alias"
+        assert r["props"]["content_version"], "missing content_version"
+        assert r["oid"] == r["props"]["stable_oid"], "gated record oid must be the canonical one"
+
+
+def test_line_shift_stable_for_all_symbols():
+    base = {r["props"]["name"]: r["oid"] for r in _canonical_nodes(_CORPUS)}
+    moved = {r["props"]["name"]: r["oid"] for r in _canonical_nodes("\n\n\n" + _CORPUS)}
+    assert base == moved, "no symbol's canonical oid may change on a line shift"
+
+
+def test_deterministic_reparse():
+    a = {r["props"]["name"]: r["oid"] for r in _canonical_nodes(_CORPUS)}
+    b = {r["props"]["name"]: r["oid"] for r in _canonical_nodes(_CORPUS)}
+    assert a == b

{victor_codegraph-0.1.1 → victor_codegraph-0.8.1}/tests/test_treesitter_jsts.py

@@ -11,7 +11,10 @@ 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
+from victor_codegraph.treesitter_parser import (
+    GrammarUnavailable,
+    parse_treesitter,
+)  # noqa: E402
 
 JS = """\
 import { x } from "./x";