victor-codegraph 0.9.0__tar.gz → 0.10.1__tar.gz

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.9.0
+Version: 0.10.1
 Summary: Repository-to-Code-Semantic-Graph compiler with stable identity, bounded chunks, incremental deltas, and ProximaRecord projection.
 Author-email: Vijaykumar Singh <vijay@anvaiops.com>
 License: Apache-2.0
@@ -16,6 +16,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Provides-Extra: embeddings
+Requires-Dist: sentence-transformers<6,>=3; extra == "embeddings"
 Provides-Extra: treesitter
 Requires-Dist: tree-sitter>=0.26.0; extra == "treesitter"
 Requires-Dist: tree-sitter-language-pack>=1.21.3; extra == "treesitter"
@@ -54,7 +56,7 @@ gaps:
 ## Install
 
 Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/).
-This source tree is version **0.9.0**; consumers should use a compatible `<1.0` pin.
+This source tree is version **0.10.1**; consumers should use a compatible `<1.0` pin.
 
 ```bash
 # from PyPI
@@ -126,10 +128,36 @@ records = to_proxima_records(repository, repo_graph_id="myrepo")
 
 ## Status
 
-`0.9.0` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
+`0.10.1` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
 Java, C, and C++ have conformance fixtures; other mapped tree-sitter languages report
 symbols-tier or fallback status rather than implying full fidelity.
 
+### Ambiguous declarations
+
+Duplicate structural identities retain raw declarations in `ParsedRepository.files`
+and report each conflicting source location. Repository projection emits only the
+canonical FILE marker for that file, with typed diagnostics, declaration spans and
+omitted symbol/relation counts in metadata. Calls into its declarations remain
+unresolved; healthy imports can still point to its diagnostic marker. Repairing the
+source restores normal projection through deletion-complete repository deltas.
+Direct record projection rejects duplicate identities before invoking an embedder,
+including when legacy OIDs are selected.
+
+`identity_collisions` groups use the existing `symbol_id` with `resolution: ambiguous`.
+Each declaration retains `name`, `qualified_name`, `symbol_type` and its full
+`source_span`; these are inspectable evidence, not separately resolved graph nodes.
+The record adapter forwards these groups, projection status and omitted counts only
+when present, without copying arbitrary symbol metadata into exported properties.
+
+### TypeScript grammar limitation
+
+The current tree-sitter grammar reports a partial parse for inline import types
+in generic calls, for example `load<typeof import('child_process')>()`, even though
+TypeScript accepts that syntax. A named type alias (`type ChildProcessModule =
+typeof import('child_process')`, then `load<ChildProcessModule>()`) is supported.
+Partial status and syntax diagnostics remain visible; the parser does not rewrite
+source or infer missing relationships.
+
 ### Rust graph fidelity
 
 Rust indexing retains inline module scopes and discriminates same-named trait
@@ -143,4 +171,30 @@ workspace-inherited dependencies, re-export chains, macros and unknown receiver
 types retain unresolved references. Glob imports retain a module dependency but
 do not guess call targets. This is a conservative static graph, not rustc name
 resolution or evidence that a call executes. Publish this package before a Victor
-release that requires its `0.9.0` repository graph contract.
+release that requires its exact repository graph contract.
+
+
+### Embedding conformance (0.10.0)
+
+The accepted FEP-0040 supplies store-neutral
+`EmbeddingProfile`, `SymbolEmbedding`, `embed_symbols` and an optional
+`SentenceTransformerEncoder`. The base compiler stays dependency-free. The
+`embeddings` extra loads sentence-transformers only when explicitly selected;
+private source is not sent to a remote model by default.
+
+The contract uses canonical compiler IDs and `symbol-summary-v1` (name,
+signature and documentation), with an immutable model revision, dimensions,
+token limit, normalization, query prefix and separate input/source hashes.
+Inference errors propagate; hash placeholders, zero vectors and malformed batches
+are not semantic evidence. File/container symbols marked `embedding_excluded`
+remain graph evidence only.
+
+These APIs are introduced in 0.10.0 and are unavailable in 0.9.0. Install the
+exact published `victor-codegraph[treesitter,embeddings]==0.10.0` when selecting
+local model execution; the base package has no mandatory model dependency.
+Current evidence covers
+synthetic document-vector persistence parity and local LanceDB collection/query
+profile enforcement. Labeled relevance and hosted lifecycle remain separate
+acceptance gates. Victor binds a new LanceDB table to the complete profile in its
+Arrow schema and rejects incompatible query encoders and mixed/orphan row markers.
+Legacy tables require a fresh destination; they are never silently relabeled.

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/README.md

@@ -25,7 +25,7 @@ gaps:
 ## Install
 
 Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/).
-This source tree is version **0.9.0**; consumers should use a compatible `<1.0` pin.
+This source tree is version **0.10.1**; consumers should use a compatible `<1.0` pin.
 
 ```bash
 # from PyPI
@@ -97,10 +97,36 @@ records = to_proxima_records(repository, repo_graph_id="myrepo")
 
 ## Status
 
-`0.9.0` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
+`0.10.1` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
 Java, C, and C++ have conformance fixtures; other mapped tree-sitter languages report
 symbols-tier or fallback status rather than implying full fidelity.
 
+### Ambiguous declarations
+
+Duplicate structural identities retain raw declarations in `ParsedRepository.files`
+and report each conflicting source location. Repository projection emits only the
+canonical FILE marker for that file, with typed diagnostics, declaration spans and
+omitted symbol/relation counts in metadata. Calls into its declarations remain
+unresolved; healthy imports can still point to its diagnostic marker. Repairing the
+source restores normal projection through deletion-complete repository deltas.
+Direct record projection rejects duplicate identities before invoking an embedder,
+including when legacy OIDs are selected.
+
+`identity_collisions` groups use the existing `symbol_id` with `resolution: ambiguous`.
+Each declaration retains `name`, `qualified_name`, `symbol_type` and its full
+`source_span`; these are inspectable evidence, not separately resolved graph nodes.
+The record adapter forwards these groups, projection status and omitted counts only
+when present, without copying arbitrary symbol metadata into exported properties.
+
+### TypeScript grammar limitation
+
+The current tree-sitter grammar reports a partial parse for inline import types
+in generic calls, for example `load<typeof import('child_process')>()`, even though
+TypeScript accepts that syntax. A named type alias (`type ChildProcessModule =
+typeof import('child_process')`, then `load<ChildProcessModule>()`) is supported.
+Partial status and syntax diagnostics remain visible; the parser does not rewrite
+source or infer missing relationships.
+
 ### Rust graph fidelity
 
 Rust indexing retains inline module scopes and discriminates same-named trait
@@ -114,4 +140,30 @@ workspace-inherited dependencies, re-export chains, macros and unknown receiver
 types retain unresolved references. Glob imports retain a module dependency but
 do not guess call targets. This is a conservative static graph, not rustc name
 resolution or evidence that a call executes. Publish this package before a Victor
-release that requires its `0.9.0` repository graph contract.
+release that requires its exact repository graph contract.
+
+
+### Embedding conformance (0.10.0)
+
+The accepted FEP-0040 supplies store-neutral
+`EmbeddingProfile`, `SymbolEmbedding`, `embed_symbols` and an optional
+`SentenceTransformerEncoder`. The base compiler stays dependency-free. The
+`embeddings` extra loads sentence-transformers only when explicitly selected;
+private source is not sent to a remote model by default.
+
+The contract uses canonical compiler IDs and `symbol-summary-v1` (name,
+signature and documentation), with an immutable model revision, dimensions,
+token limit, normalization, query prefix and separate input/source hashes.
+Inference errors propagate; hash placeholders, zero vectors and malformed batches
+are not semantic evidence. File/container symbols marked `embedding_excluded`
+remain graph evidence only.
+
+These APIs are introduced in 0.10.0 and are unavailable in 0.9.0. Install the
+exact published `victor-codegraph[treesitter,embeddings]==0.10.0` when selecting
+local model execution; the base package has no mandatory model dependency.
+Current evidence covers
+synthetic document-vector persistence parity and local LanceDB collection/query
+profile enforcement. Labeled relevance and hosted lifecycle remain separate
+acceptance gates. Victor binds a new LanceDB table to the complete profile in its
+Arrow schema and rejects incompatible query encoders and mixed/orphan row markers.
+Legacy tables require a fresh destination; they are never silently relabeled.

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-codegraph"
-version = "0.9.0"
+version = "0.10.1"
 description = "Repository-to-Code-Semantic-Graph compiler with stable identity, bounded chunks, incremental deltas, and ProximaRecord projection."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -40,6 +40,7 @@ classifiers = [
 dependencies = []
 
 [project.optional-dependencies]
+embeddings = ["sentence-transformers>=3,<6"]
 treesitter = [
     "tree-sitter>=0.26.0",
     "tree-sitter-language-pack>=1.21.3",
@@ -77,3 +78,6 @@ select = ["E4", "E7", "E9", "F"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = ""
+
+[tool.setuptools.package-data]
+victor_codegraph = ["py.typed"]

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/tests/test_adapter.py

@@ -26,6 +26,15 @@ def test_symbol_records_shape():
     assert n["props"]["lang"] == "python"
     assert n["props"]["ast_kind"] in ("FUNCTION", "METHOD", "CONSTRUCTOR")
     assert n["embeddings"] == []  # no embedder supplied
+    assert (
+        not {
+            "identity_collisions",
+            "projection_status",
+            "omitted_symbol_count",
+            "omitted_relation_count",
+        }
+        & n["props"].keys()
+    )
 
 
 def test_edge_records_reference_node_oids():

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/tests/test_adapter_validation_v2.py

@@ -40,3 +40,30 @@ def test_legacy_oid_mode_keeps_edge_endpoints_attached():
     edge = next(r for r in records if "graph_edge" in r["labels"])
     assert edge["edge"]["from_oid"] in nodes
     assert edge["edge"]["to_oid"] in nodes
+
+
+@pytest.mark.parametrize("stable_oid", [True, False])
+@pytest.mark.parametrize("embedding_mode", ["embedder", "batch_embedder"])
+def test_duplicate_symbol_ids_fail_before_embedding(stable_oid, embedding_mode):
+    from unittest.mock import Mock
+
+    parsed = parse("def f(): return 1\ndef f(): return 2\n", file_path="duplicate.py")
+    embedder = Mock(
+        return_value=[0.0, 0.0] if embedding_mode == "embedder" else [[0.0, 0.0], [0.0, 0.0]]
+    )
+    with pytest.raises(ValueError, match="identity collision"):
+        to_proxima_records(
+            parsed, "repo", stable_oid=stable_oid, dim=2, **{embedding_mode: embedder}
+        )
+    embedder.assert_not_called()
+
+
+def test_symbol_alias_cannot_rebind_another_canonical_identity():
+    from unittest.mock import Mock
+
+    parsed = parse("def a(): pass\ndef b(): pass\n", file_path="aliases.py")
+    parsed.symbols[1].legacy_id = parsed.symbols[0].id
+    embedder = Mock(return_value=[0.0, 0.0])
+    with pytest.raises(ValueError, match="alias identity collision"):
+        to_proxima_records(parsed, "repo", embedder=embedder, dim=2)
+    embedder.assert_not_called()

victor_codegraph-0.10.1/tests/test_diagnostics_v2.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from victor_codegraph import CapabilityTier, ChunkConfig, ParseStatus, parse
+
+
+def test_syntax_error_reports_fallback_diagnostic():
+    parsed = parse("def broken(:\n", file_path="bad.py")
+    assert parsed.status == ParseStatus.FALLBACK
+    assert parsed.diagnostics
+    assert parsed.diagnostics[0].code == "syntax_error"
+
+
+def test_unknown_language_reports_fallback_instead_of_silent_success():
+    parsed = parse("plain text", language="unknown", file_path="x.unknown")
+    assert parsed.status == ParseStatus.FALLBACK
+    assert parsed.capability_tier == CapabilityTier.FALLBACK
+    assert parsed.diagnostics
+
+
+def test_extract_relations_config_is_effective():
+    parsed = parse(
+        "def f():\n    return g()\n",
+        file_path="m.py",
+        config=ChunkConfig(extract_relations=False),
+    )
+    assert parsed.relations == []
+
+
+def test_shadowed_python_declarations_remain_explicit_identity_collisions():
+    parsed = parse(
+        "class C:\n    @property\n    def value(self): return 1\n"
+        "    @property\n    def value(self): return 2\n",
+        file_path="duplicate.py",
+    )
+    assert parsed.status == ParseStatus.PARTIAL
+    assert [(item.code, item.severity) for item in parsed.diagnostics] == [
+        ("identity_collision", "error"),
+        ("identity_collision", "error"),
+    ]
+    assert [(item.line, item.column) for item in parsed.diagnostics] == [(2, 4), (4, 4)]
+    definitions = [symbol for symbol in parsed.symbols if symbol.simple_name == "value"]
+    assert len(definitions) == 2
+    assert definitions[0].id == definitions[1].id
+    assert definitions[0].legacy_id != definitions[1].legacy_id
+    assert all("duplicate.py::C::value" in item.message for item in parsed.diagnostics)
+    assert all(definitions[0].id in item.message for item in parsed.diagnostics)

victor_codegraph-0.10.1/tests/test_embedding_contract.py

@@ -0,0 +1,145 @@
+"""One semantic input/provenance contract for local and hosted consumers."""
+
+from dataclasses import replace
+import pytest
+from victor_codegraph import parse
+from victor_codegraph.embeddings import (
+    BGE_SMALL_PROFILE,
+    embedding_text,
+    embed_symbols,
+    validate_vectors,
+)
+
+
+def test_same_symbols_produce_store_independent_embedding_evidence():
+    symbols = parse(
+        'def pay(x):\n    """Charge a customer."""\n    return x\n', file_path="billing.py"
+    ).symbols
+    seen = []
+
+    def encode(texts):
+        seen.extend(texts)
+        return [[1.0] + [0.0] * 383 for _ in texts]
+
+    documents = embed_symbols(symbols, encode, BGE_SMALL_PROFILE)
+    assert seen == [embedding_text(s.simple_name, s.signature, s.documentation) for s in symbols]
+    assert [d.symbol_id for d in documents] == [s.id for s in symbols]
+    assert all(d.profile_id == BGE_SMALL_PROFILE.identity for d in documents)
+    assert all(len(d.input_hash) == 64 and len(d.source_hash) == 64 for d in documents)
+    assert all(len(d.values) == 384 for d in documents)
+
+
+@pytest.mark.parametrize(
+    "vectors",
+    [[], [[0.0, 0.0]], [[True, 1.0]], [[float("nan"), 1.0]], [[1.0]], [[float("inf"), 1.0]]],
+)
+def test_invalid_or_missing_vectors_fail_without_substitution(vectors):
+    with pytest.raises(ValueError):
+        validate_vectors(vectors, count=1, dimension=2)
+
+
+def test_model_preprocessing_changes_invalidate_profile_identity():
+    p = BGE_SMALL_PROFILE
+    assert (
+        len(
+            {
+                p.identity,
+                replace(p, revision="a" * 40).identity,
+                replace(p, normalize=True).identity,
+                replace(p, query_prefix="query: ").identity,
+                replace(p, max_tokens=256).identity,
+            }
+        )
+        == 5
+    )
+    with pytest.raises(ValueError, match="revision"):
+        replace(p, revision="main")
+
+
+def test_failed_encoder_propagates_and_duplicate_symbol_ids_are_rejected():
+    symbols = parse("def f(): pass", file_path="m.py").symbols
+
+    def fail(texts):
+        raise RuntimeError("model unavailable")
+
+    with pytest.raises(RuntimeError, match="model unavailable"):
+        embed_symbols(symbols, fail, BGE_SMALL_PROFILE)
+    with pytest.raises(ValueError, match="duplicate"):
+        embed_symbols(symbols * 2, fail, BGE_SMALL_PROFILE)
+
+
+def test_unbounded_encoder_outputs_are_rejected_after_one_overflow_item():
+    from itertools import repeat
+
+    with pytest.raises(ValueError, match="dimension"):
+        validate_vectors([repeat(1.0)], count=1, dimension=2)
+    with pytest.raises(ValueError, match="exactly one"):
+        validate_vectors(repeat([1.0, 2.0]), count=1, dimension=2)
+
+
+def test_optional_encoder_owns_one_pinned_model_and_query_preprocessing(monkeypatch):
+    import asyncio
+    import sys
+    from types import SimpleNamespace
+    from victor_codegraph.embeddings import SentenceTransformerEncoder
+
+    calls = []
+
+    class Model:
+        max_seq_length = 0
+
+        def __init__(self, model_id, **kwargs):
+            calls.append((model_id, kwargs))
+
+        def get_sentence_embedding_dimension(self):
+            return 3
+
+        def encode(self, texts, **kwargs):
+            calls.append((texts, kwargs, self.max_seq_length))
+            return [[1.0, 2.0, 3.0] for _ in texts]
+
+    monkeypatch.setitem(
+        sys.modules, "sentence_transformers", SimpleNamespace(SentenceTransformer=Model)
+    )
+    profile = replace(BGE_SMALL_PROFILE, dimension=3, query_prefix="query: ", max_tokens=256)
+    encoder = SentenceTransformerEncoder(profile)
+    assert encoder.encode([]) == [] and calls == []
+    assert encoder.encode_query("permissions") == [1.0, 2.0, 3.0]
+    assert asyncio.run(encoder.embed_text("symbol")) == [1.0, 2.0, 3.0]
+    assert len(calls) == 3  # one model load, two bounded inference calls
+    assert calls[0] == (
+        profile.model_id,
+        {"revision": profile.revision, "device": "cpu", "trust_remote_code": False},
+    )
+    assert calls[1][0] == ["query: permissions"]
+    assert calls[1][1]["normalize_embeddings"] is False
+    assert calls[1][2] == 256
+    with pytest.raises(ValueError, match="512"):
+        encoder.encode(["x"] * 513)
+    with pytest.raises(ValueError, match="dimension"):
+        SentenceTransformerEncoder(BGE_SMALL_PROFILE).encode(["x"])
+
+
+def test_optional_encoder_missing_dependency_is_explicit(monkeypatch):
+    import sys
+    from victor_codegraph.embeddings import SentenceTransformerEncoder
+
+    monkeypatch.setitem(sys.modules, "sentence_transformers", None)
+    with pytest.raises(ImportError):
+        SentenceTransformerEncoder().encode(["symbol"])
+
+
+@pytest.mark.parametrize(
+    "changes",
+    [
+        {"model_id": ""},
+        {"revision": "main"},
+        {"dimension": True},
+        {"max_tokens": 0},
+        {"text_contract": "body-v1"},
+        {"normalize": 1},
+    ],
+)
+def test_invalid_profile_cannot_claim_semantic_compatibility(changes):
+    with pytest.raises(ValueError):
+        replace(BGE_SMALL_PROFILE, **changes)

victor_codegraph-0.10.1/tests/test_repository_delta_v2.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from dataclasses import replace
+
+import pytest
+
+from victor_codegraph import apply_index_delta, diff_repository, parse_repo
+
+
+def test_repository_delta_deletes_removed_and_replaced_symbols(tmp_path):
+    a = tmp_path / "a.py"
+    b = tmp_path / "b.py"
+    a.write_text("def old_name():\n    return 1\n")
+    b.write_text("def removed():\n    return 2\n")
+    previous = parse_repo(tmp_path, repo_id="repo")
+
+    a.write_text("def new_name():\n    return 1\n")
+    b.unlink()
+    current = parse_repo(tmp_path, repo_id="repo")
+    delta = diff_repository(current, previous)
+
+    old_function_ids = {s.id for s in previous.symbols if s.symbol_type.name == "FUNCTION"}
+    assert old_function_ids <= set(delta.delete_symbol_ids)
+    assert "new_name" in {s.simple_name for s in delta.upsert_symbols}
+
+    rebuilt = apply_index_delta(previous, delta)
+    assert {s.id for s in rebuilt.symbols} == {s.id for s in current.symbols}
+    assert rebuilt.manifest == current.manifest
+    assert delta.base_generation_id == previous.generation_id
+    assert delta.target_generation_id == current.generation_id
+
+    with pytest.raises(ValueError, match="base generation"):
+        apply_index_delta(replace(previous, generation_id="stale"), delta)
+
+
+def test_repository_delta_refreshes_relation_evidence_on_line_shift(tmp_path):
+    path = tmp_path / "m.py"
+    path.write_text("def a():\n    return b()\n\ndef b(): return 1\n")
+    previous = parse_repo(tmp_path, repo_id="repo")
+    path.write_text("\ndef a():\n    return b()\n\ndef b(): return 1\n")
+    current = parse_repo(tmp_path, repo_id="repo")
+
+    delta = diff_repository(current, previous)
+    assert delta.upsert_relations
+    rebuilt = apply_index_delta(previous, delta)
+    assert rebuilt.relations[0].call_site.start_line == current.relations[0].call_site.start_line
+
+
+def test_repository_quarantines_identity_collisions_and_delta_recovers(tmp_path):
+    from victor_codegraph import CodeRelationType, CodeSymbolType, ParseStatus
+
+    ambiguous = tmp_path / "duplicate.py"
+    ambiguous.write_text("def helper(): return 1\n")
+    (tmp_path / "caller.py").write_text(
+        "from duplicate import helper\ndef caller(): return helper()\n"
+    )
+    previous = parse_repo(tmp_path, repo_id="repo")
+    ambiguous.write_text(
+        "def f(): return helper()\ndef f(): return helper()\ndef helper(): return 1\n"
+    )
+    current = parse_repo(tmp_path, repo_id="repo")
+    raw = current.files["duplicate.py"]
+    assert raw.status == ParseStatus.PARTIAL
+    assert len(raw.symbols) == 3  # Keep original evidence, including both definitions.
+    projected = [s for s in current.symbols if s.location.file_path == "duplicate.py"]
+    assert len(projected) == 1
+    marker = projected[0]
+    assert marker.symbol_type == CodeSymbolType.FILE
+    assert marker.metadata["parse_status"] == "partial"
+    assert marker.metadata["projection_status"] == "file_marker_only"
+    assert marker.metadata["omitted_symbol_count"] == 3
+    assert marker.metadata["omitted_relation_count"] == len(raw.relations)
+    assert [d["line"] for d in marker.metadata["diagnostics"]] == [1, 2]
+    collisions = marker.metadata["identity_collisions"]
+    assert len(collisions) == 1 and collisions[0]["symbol_id"] == raw.symbols[0].id
+    assert collisions[0]["resolution"] == "ambiguous"
+    assert [d["qualified_name"] for d in collisions[0]["declarations"]] == [
+        "duplicate.py::f",
+        "duplicate.py::f",
+    ]
+    assert [d["symbol_type"] for d in collisions[0]["declarations"]] == ["function", "function"]
+    assert [d["source_span"]["start_line"] for d in collisions[0]["declarations"]] == [1, 2]
+    from victor_codegraph import to_proxima_records
+
+    marker.metadata["private_source_metadata"] = "must not be exported"
+    records = to_proxima_records(current, repo_graph_id="repo")
+    record = next(
+        r
+        for r in records
+        if r.get("props", {}).get("file") == "duplicate.py"
+        and r.get("props", {}).get("ast_kind") == "FILE"
+    )
+    for key in (
+        "identity_collisions",
+        "projection_status",
+        "omitted_symbol_count",
+        "omitted_relation_count",
+    ):
+        assert record["props"][key] == marker.metadata[key]
+    assert "private_source_metadata" not in record["props"]
+    assert not any(
+        "/external/" not in r["edge"]["to_oid"]
+        for r in records
+        if "graph_edge" in r["labels"] and r["edge"]["edge_type"] == "CALLS"
+    )
+    assert len({s.id for s in current.symbols}) == len(current.symbols)
+    assert not any(r.from_symbol_id == marker.id for r in current.relations)
+    calls = [r for r in current.relations if r.relation_type == CodeRelationType.CALLS]
+    assert len(calls) == 1 and calls[0].target_ref.name == "helper"
+    assert any(
+        r.relation_type == CodeRelationType.IMPORTS and r.to_symbol_id == marker.id
+        for r in current.relations
+    )
+    delta = diff_repository(current, previous)
+    assert delta.delete_symbol_ids and delta.delete_relation_keys
+    rebuilt = apply_index_delta(previous, delta)
+    assert {s.id for s in rebuilt.symbols} == {s.id for s in current.symbols}
+
+    ambiguous.write_text("def helper(): return 2\n")
+    repaired = parse_repo(tmp_path, repo_id="repo")
+    rebuilt = apply_index_delta(current, diff_repository(repaired, current))
+    assert {s.id for s in rebuilt.symbols} == {s.id for s in repaired.symbols}
+    calls = [r for r in rebuilt.relations if r.relation_type == CodeRelationType.CALLS]
+    assert len(calls) == 1 and calls[0].target_ref is None
+    assert (
+        next(s for s in repaired.symbols if s.id == marker.id).metadata["projection_status"]
+        == "symbols"
+    )

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/tests/test_treesitter_jsts.py

@@ -75,3 +75,38 @@ def test_chunk_jsts_is_size_capped():
     if not parsed.symbols:
         pytest.skip("javascript grammar not installed")
     assert parsed.symbols  # routed through tree-sitter, not the empty stub
+
+
+@pytest.mark.parametrize(
+    "annotation",
+    [
+        "export type X<T> = T extends object ? T : never;",
+        "type Options = Record<string, object>;",
+        "function accept(value: object): object { return value; }",
+    ],
+)
+def test_typescript_object_keyword_is_not_an_object_literal_scope(annotation):
+    source = annotation + "\nconst handlers = { run() { return 1; } };"
+    parsed = parse(source, file_path="case.ts")
+    shifted = parse("// heading\n\n" + source, file_path="case.ts")
+    assert parsed.status.value == "success"
+    assert not parsed.diagnostics
+    methods = [symbol for symbol in parsed.symbols if symbol.simple_name == "run"]
+    assert len(methods) == 1
+    assert methods[0].scope_chain
+    assert {symbol.id for symbol in parsed.symbols} == {symbol.id for symbol in shifted.symbols}
+
+
+def test_inline_import_generic_grammar_limitation_stays_explicit():
+    # The pinned grammar rejects this valid TypeScript import type in a generic
+    # call. Do not hide the partial parse; an equivalent named alias is supported.
+    inline = parse("const value = load<typeof import('child_process')>();", file_path="case.ts")
+    assert inline.status.value == "partial"
+    assert "syntax_error" in {diagnostic.code for diagnostic in inline.diagnostics}
+    aliased = parse(
+        "type ChildProcessModule = typeof import('child_process');"
+        "const value = load<ChildProcessModule>();",
+        file_path="case.ts",
+    )
+    assert aliased.status.value == "success"
+    assert not aliased.diagnostics

{victor_codegraph-0.9.0 → victor_codegraph-0.10.1}/victor_codegraph/__init__.py

@@ -14,6 +14,15 @@ from __future__ import annotations
 
 from .adapter import relation_to_record, symbol_to_record, to_proxima_records
 from .config import ChunkConfig
+from .embeddings import (
+    BGE_SMALL_PROFILE,
+    EmbeddingProfile,
+    SymbolEmbedding,
+    SentenceTransformerEncoder,
+    embedding_text,
+    embed_symbols,
+    validate_vectors,
+)
 from .languages import detect_language
 from .model import (
     CapabilityTier,
@@ -45,10 +54,17 @@ from .repository_index import (
     relation_key,
 )
 
-__version__ = "0.9.0"
+__version__ = "0.10.1"
 
 __all__ = [
     "__version__",
+    "BGE_SMALL_PROFILE",
+    "EmbeddingProfile",
+    "SymbolEmbedding",
+    "SentenceTransformerEncoder",
+    "embedding_text",
+    "embed_symbols",
+    "validate_vectors",
     "chunk",
     "parse",
     "chunk_repo",