victor-codegraph 0.10.0__tar.gz → 0.10.2__tar.gz

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.10.0
+Version: 0.10.2
 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
@@ -56,7 +56,11 @@ gaps:
 ## Install
 
 Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/).
-This source tree is version **0.10.0**; consumers should use a compatible `<1.0` pin.
+This source tree is version **0.10.2**; consumers should use a compatible `<1.0` pin.
+It repairs nested Python definition/import shadowing: proven local definitions
+retain their targets, while unmodeled conditional bindings stay unresolved.
+Rebuild derived graphs when adopting the new parser; unchanged source hashes do
+not invalidate old semantic results automatically. Publication is a separate gate.
 
 ```bash
 # from PyPI
@@ -128,10 +132,36 @@ records = to_proxima_records(repository, repo_graph_id="myrepo")
 
 ## Status
 
-`0.10.0` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
+`0.10.2` 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

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/README.md

@@ -25,7 +25,11 @@ gaps:
 ## Install
 
 Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/).
-This source tree is version **0.10.0**; consumers should use a compatible `<1.0` pin.
+This source tree is version **0.10.2**; consumers should use a compatible `<1.0` pin.
+It repairs nested Python definition/import shadowing: proven local definitions
+retain their targets, while unmodeled conditional bindings stay unresolved.
+Rebuild derived graphs when adopting the new parser; unchanged source hashes do
+not invalidate old semantic results automatically. Publication is a separate gate.
 
 ```bash
 # from PyPI
@@ -97,10 +101,36 @@ records = to_proxima_records(repository, repo_graph_id="myrepo")
 
 ## Status
 
-`0.10.0` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
+`0.10.2` 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

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "victor-codegraph"
-version = "0.10.0"
+version = "0.10.2"
 description = "Repository-to-Code-Semantic-Graph compiler with stable identity, bounded chunks, incremental deltas, and ProximaRecord projection."
 readme = "README.md"
 requires-python = ">=3.12"

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/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.10.0 → victor_codegraph-0.10.2}/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.2/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.0 → victor_codegraph-0.10.2}/tests/test_relations_v2.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 
 from victor_codegraph import CodeRelationType, parse, parse_repo, to_proxima_records
@@ -319,6 +321,40 @@ def test_python_enclosing_and_capture_bindings_block_import_guess(tmp_path, body
     assert calls and all(r.target_ref for r in calls)
 
 
+@pytest.mark.parametrize(
+    ("body", "target_scope"),
+    [
+        ("def caller():\n def target(): return 2\n return target()", ["caller"]),
+        ("async def caller():\n async def target(): return 2\n return await target()", ["caller"]),
+        ("def caller():\n class target: pass\n return target()", ["caller"]),
+        ("def outer():\n def target(): return 2\n def caller(): return target()", ["outer"]),
+        ("def caller(flag):\n if flag:\n  def target(): return 2\n return target()", None),
+        (
+            "def outer():\n def target(): return 2\n def caller(flag):\n  if flag:\n   def target(): return 3\n  return target()",
+            None,
+        ),
+        ("def caller(): return target()", []),
+    ],
+)
+def test_python_nearest_definition_precedes_import(
+    tmp_path: Path, body: str, target_scope: list[str] | None
+) -> None:
+    (tmp_path / "a.py").write_text("def target(): return 1\n")
+    (tmp_path / "b.py").write_text("from a import target\n" + body)
+    graph = parse_repo(tmp_path)
+    calls = [r for r in graph.relations if r.relation_type == CodeRelationType.CALLS]
+    assert len(calls) == 1
+    call = calls[0]
+    if target_scope is None:
+        assert call.target_ref is not None
+        assert call.confidence < 1.0
+    else:
+        target = next(s for s in graph.symbols if s.id == call.to_symbol_id)
+        assert call.target_ref is None
+        assert target.scope_chain == target_scope
+        assert target.location.file_path == ("b.py" if target_scope else "a.py")
+
+
 def test_python_reassigned_self_is_not_a_proven_receiver():
     parsed = parse(
         "class A:\n def target(self): pass\n def caller(self):\n  self = external\n  self.target()\n",

victor_codegraph-0.10.2/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.10.0 → victor_codegraph-0.10.2}/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.10.0 → victor_codegraph-0.10.2}/victor_codegraph/__init__.py

@@ -54,7 +54,7 @@ from .repository_index import (
     relation_key,
 )
 
-__version__ = "0.10.0"
+__version__ = "0.10.2"
 
 __all__ = [
     "__version__",

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph/adapter.py

@@ -145,6 +145,15 @@ def symbol_to_record(
         },
         "embeddings": [],
     }
+    # Preserve compiler-owned ambiguity evidence without exposing arbitrary metadata.
+    for key in (
+        "identity_collisions",
+        "projection_status",
+        "omitted_symbol_count",
+        "omitted_relation_count",
+    ):
+        if key in symbol.metadata:
+            record["props"][key] = symbol.metadata[key]
     if embedder is not None and not symbol.metadata.get("embedding_excluded"):
         record["embeddings"].append(
             {
@@ -241,14 +250,24 @@ def to_proxima_records(
 
     id_map: dict[str, str] = {}
     use_stable = _stable_oid_enabled(stable_oid)
+    seen_symbols: set[str] = set()
+    seen_oids: set[str] = set()
     for symbol in parsed.symbols:
         primary = (
             _canonical_symbol_oid(repo_graph_id, symbol)
             if use_stable
             else _legacy_symbol_oid(repo_graph_id, symbol)
         )
+        # Validate before invoking either embedding callback. A legacy OID
+        # preference must not hide ambiguous canonical symbol identities.
+        if symbol.id in seen_symbols or primary in seen_oids:
+            raise ValueError("canonical symbol identity collision in adapter input")
+        seen_symbols.add(symbol.id)
+        seen_oids.add(primary)
         for key in (symbol.id, symbol.legacy_id):
             if key:
+                if key in id_map and id_map[key] != primary:
+                    raise ValueError("symbol alias identity collision in adapter input")
                 id_map[key] = primary
     records = [
         symbol_to_record(
@@ -286,10 +305,6 @@ def to_proxima_records(
                     "values": _validate_vector(values, dim),
                 }
             )
-    by_oid = [r["oid"] for r in records]
-    if len(by_oid) != len(set(by_oid)):
-        raise ValueError("canonical symbol identity collision in adapter input")
-
     external_records: dict[str, dict[str, Any]] = {}
     for relation in parsed.relations:
         if relation.target_ref is None:

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph/parser.py

@@ -16,6 +16,7 @@ from .model import (
     CapabilityTier,
     CodeChunk,
     CodeRelationType,
+    CodeSymbol,
     CodeSymbolType,
     ParseDiagnostic,
     ParsedCode,
@@ -52,7 +53,7 @@ def _finalize_identity(parsed: ParsedCode, content: str) -> ParsedCode:
     """Promote parser-local line IDs to the v2 structural identity contract."""
 
     id_map: dict[str, str] = {}
-    seen: dict[str, str] = {}
+    groups: dict[str, list[CodeSymbol]] = {}
     for symbol in parsed.symbols:
         legacy = symbol.legacy_id or symbol.id
         stable = stable_symbol_key(
@@ -62,22 +63,29 @@ def _finalize_identity(parsed: ParsedCode, content: str) -> ParsedCode:
             symbol.signature,
             symbol.location.file_path,
         )
-        other = seen.get(stable)
-        if other is not None and other != legacy:
-            parsed.status = ParseStatus.PARTIAL
+        groups.setdefault(stable, []).append(symbol)
+        id_map[legacy] = stable
+        symbol.legacy_id = legacy
+        symbol.id = stable
+        symbol.identity_version = "v2"
+
+    for stable, definitions in groups.items():
+        if len(definitions) < 2:
+            continue
+        parsed.status = ParseStatus.PARTIAL
+        for symbol in definitions:
             parsed.diagnostics.append(
                 ParseDiagnostic(
                     code="identity_collision",
-                    message=f"multiple symbols share structural key {stable}",
+                    message=(
+                        f"multiple declarations of {symbol.fully_qualified_name!r} "
+                        f"share structural key {stable}"
+                    ),
                     severity="error",
                     line=symbol.location.start_line,
+                    column=symbol.location.start_column,
                 )
             )
-        seen[stable] = legacy
-        id_map[legacy] = stable
-        symbol.legacy_id = legacy
-        symbol.id = stable
-        symbol.identity_version = "v2"
 
     for relation in parsed.relations:
         relation.from_symbol_id = id_map.get(relation.from_symbol_id, relation.from_symbol_id)

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph/python_parser.py

@@ -8,6 +8,8 @@ signatures, docstrings, decorators, parameters, cyclomatic complexity, and CALLS
 from __future__ import annotations
 
 import ast
+from collections.abc import Iterator, Sequence
+from typing import NotRequired, TypedDict
 
 from .model import (
     CodeRelation,
@@ -47,13 +49,20 @@ def _cyclomatic(node: ast.AST) -> dict[str, int]:
     return {"cyclomatic": count, "lines": end - lineno + 1}
 
 
-def _params(args: ast.arguments) -> list[dict]:
-    out: list[dict] = []
+class _Parameter(TypedDict):
+    name: str
+    type: NotRequired[str]
+    is_variadic: NotRequired[bool]
+    is_kwonly: NotRequired[bool]
+
+
+def _params(args: ast.arguments) -> list[_Parameter]:
+    out: list[_Parameter] = []
     posonly = getattr(args, "posonlyargs", [])
     for a in [*posonly, *args.args]:
         if a.arg in ("self", "cls"):
             continue
-        p: dict = {"name": a.arg}
+        p: _Parameter = {"name": a.arg}
         if a.annotation is not None:
             p["type"] = ast.unparse(a.annotation)
         out.append(p)
@@ -109,7 +118,7 @@ def _callee_ref(call: ast.Call) -> SymbolReference | None:
     return None
 
 
-def _calls_owned_by(node: ast.AST):
+def _calls_owned_by(node: ast.AST) -> Iterator[ast.Call]:
     """Yield calls owned by ``node`` without stealing calls from nested definitions."""
 
     stack = list(ast.iter_child_nodes(node))
@@ -122,13 +131,15 @@ def _calls_owned_by(node: ast.AST):
         stack.extend(ast.iter_child_nodes(child))
 
 
-def _bound_names(nodes: list[ast.AST]) -> set[str]:
-    """Conservative lexical writes, including captures and deletion bindings."""
+def _lexical_bindings(nodes: Sequence[ast.AST]) -> tuple[set[str], set[str]]:
+    """Collect writes and definition bindings without entering nested namespaces."""
     names: set[str] = set()
+    definitions: set[str] = set()
     stack = list(nodes)
     while stack:
         node = stack.pop()
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            definitions.add(node.name)
             continue
         if isinstance(node, ast.arg):
             names.add(node.arg)
@@ -141,7 +152,7 @@ def _bound_names(nodes: list[ast.AST]) -> set[str]:
         if isinstance(node, (ast.Import, ast.ImportFrom)):
             names.update(a.asname or a.name.split(".")[0] for a in node.names)
         stack.extend(ast.iter_child_nodes(node))
-    return names
+    return names, definitions
 
 
 class _Visitor:
@@ -152,6 +163,7 @@ class _Visitor:
         self.relations: list[CodeRelation] = []
         self.imports: list[str] = []
         self._enclosing_bindings: list[set[str]] = []
+        self._definition_scopes: list[dict[str, list[str]]] = [{}]
         self._import_names: set[str] = set()
         self._wildcard_import = False
         self._fqn_prefix = file_path.replace("/", ".").replace("\\", ".")
@@ -190,7 +202,7 @@ class _Visitor:
         symbol_type: CodeSymbolType,
         scope: list[str],
         signature: str | None = None,
-        params: list[dict] | None = None,
+        params: list[_Parameter] | None = None,
         return_type: str | None = None,
         modifiers: list[str] | None = None,
     ) -> CodeSymbol:
@@ -220,7 +232,7 @@ class _Visitor:
             signature=signature,
             modifiers=modifiers or [],
             scope_chain=list(scope),
-            parameters=params or [],
+            parameters=[dict(parameter) for parameter in params or []],
             return_type=return_type,
             complexity=_cyclomatic(node),
         )
@@ -254,10 +266,16 @@ class _Visitor:
             bound.add(node.args.vararg.arg)
         if node.args.kwarg:
             bound.add(node.args.kwarg.arg)
-        writes = _bound_names(node.body)
+        writes, definitions = _lexical_bindings(node.body)
+        inner = [*scope, name]
+        definition_scopes = {
+            **self._definition_scopes[-1],
+            **{definition: inner for definition in definitions},
+        }
         enclosing = set().union(*self._enclosing_bindings)
         sym.metadata["python_bound_names"] = sorted(bound | writes | enclosing)
         sym.metadata["python_rebound_names"] = sorted(writes | enclosing)
+        sym.metadata["python_definition_scopes"] = definition_scopes
         sym.metadata["python_import_names"] = sorted(self._import_names)
         sym.metadata["python_wildcard_import"] = self._wildcard_import
         sym.metadata["python_receiver"] = (
@@ -275,10 +293,10 @@ class _Visitor:
         # and otherwise keeps it as a bare name (so cross-file/external calls — e.g.
         # a CPG's blast radius — are not silently dropped). ``call_site`` records the
         # call line for consumers that need it.
-        for child in _calls_owned_by(node):
-            ref = _callee_ref(child)
+        for call in _calls_owned_by(node):
+            ref = _callee_ref(call)
             if ref:
-                line, col, end_line, end_col, offset, length = self._span(child)
+                line, col, end_line, end_col, offset, length = self._span(call)
                 self.relations.append(
                     CodeRelation(
                         from_symbol_id=sym.id,
@@ -297,8 +315,8 @@ class _Visitor:
                         ),
                     )
                 )
-        inner = [*scope, name]
         self._enclosing_bindings.append(bound | writes)
+        self._definition_scopes.append(definition_scopes)
         for child in node.body:
             nested: CodeSymbol | None = None
             if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
@@ -314,6 +332,7 @@ class _Visitor:
                     )
                 )
         self._enclosing_bindings.pop()
+        self._definition_scopes.pop()
         return sym
 
     def visit_class(self, node: ast.ClassDef, scope: list[str]) -> CodeSymbol:
@@ -322,6 +341,7 @@ class _Visitor:
         if bases:
             mods.append(f"extends({','.join(bases)})")
         cls = self._make_symbol(node, node.name, CodeSymbolType.CLASS, scope, modifiers=mods)
+        cls.metadata["python_definition_scopes"] = self._definition_scopes[-1]
         cls.metadata["python_rebound_names"] = sorted(set().union(*self._enclosing_bindings))
         self.symbols.append(cls)
         for base in bases:
@@ -356,9 +376,11 @@ class _Visitor:
         return cls
 
     def run(self, tree: ast.Module) -> None:
-        self._enclosing_bindings = [
-            _bound_names([n for n in tree.body if not isinstance(n, (ast.Import, ast.ImportFrom))])
-        ]
+        module_writes, _ = _lexical_bindings(
+            [n for n in tree.body if not isinstance(n, (ast.Import, ast.ImportFrom))]
+        )
+        self._enclosing_bindings = [module_writes]
+        self._definition_scopes = [{}]
         self._import_names = set()
         for declaration in tree.body:
             if isinstance(declaration, (ast.Import, ast.ImportFrom)):

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph/repository_index.py

@@ -5,8 +5,12 @@ from __future__ import annotations
 import ast
 import hashlib
 import os
-from dataclasses import dataclass, field, replace
+from dataclasses import asdict, dataclass, field, replace
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .rust_repository import RustBinding
 
 from .model import (
     CodeRelation,
@@ -67,7 +71,7 @@ def _resolve_across_files(
     symbols: list[CodeSymbol],
     relations: list[CodeRelation],
     files: dict[str, ParsedCode],
-    rust_bindings: dict[str, list] | None = None,
+    rust_bindings: dict[str, list[RustBinding]] | None = None,
     javascript: JavaScriptRepository | None = None,
 ) -> list[CodeRelation]:
     """Resolve only unambiguous repository targets; ambiguity remains explicit."""
@@ -147,11 +151,15 @@ def _resolve_across_files(
         if source.language == "python":
             text = ref.text or ref.name
             root, *tail = text.split(".")
-            if not source.metadata.get(
-                "python_wildcard_import"
-            ) and root not in source.metadata.get("python_bound_names", []):
-                for binding, targets in python_bindings.get(source.location.file_path, {}).items():
-                    prefix = binding.split(".")
+            if (
+                not source.metadata.get("python_wildcard_import")
+                and root not in source.metadata.get("python_bound_names", [])
+                and root not in source.metadata.get("python_definition_scopes", {})
+            ):
+                for import_name, targets in python_bindings.get(
+                    source.location.file_path, {}
+                ).items():
+                    prefix = import_name.split(".")
                     parts = text.split(".")
                     if parts[: len(prefix)] != prefix:
                         continue
@@ -198,7 +206,7 @@ def _python_bindings(
             if isinstance(node, ast.ImportFrom):
                 module = "." * node.level + (node.module or "")
                 name = alias.asname or alias.name
-                target = (alias.name,)
+                target: tuple[str, ...] = (alias.name,)
                 options = [
                     (module, target),
                     (module + ("." if node.module else "") + alias.name, ()),
@@ -245,6 +253,40 @@ def _module_candidates(module: str, importer: str) -> tuple[str, ...]:
     return f"{stem}.py", f"{stem}/__init__.py"
 
 
+def _file_projection_metadata(parsed: ParsedCode) -> dict[str, object]:
+    """Keep diagnostic evidence while quarantining ambiguous symbol identities."""
+    quarantined = any(item.code == "identity_collision" for item in parsed.diagnostics)
+    groups: dict[str, list[CodeSymbol]] = {}
+    if quarantined:
+        for symbol in parsed.symbols:
+            groups.setdefault(symbol.id, []).append(symbol)
+    return {
+        "parse_status": parsed.status.value,
+        "capability_tier": parsed.capability_tier.value,
+        "diagnostics": [asdict(item) for item in parsed.diagnostics],
+        "projection_status": "file_marker_only" if quarantined else "symbols",
+        "omitted_symbol_count": len(parsed.symbols) if quarantined else 0,
+        "omitted_relation_count": len(parsed.relations) if quarantined else 0,
+        "identity_collisions": [
+            {
+                "symbol_id": symbol_id,
+                "resolution": "ambiguous",
+                "declarations": [
+                    {
+                        "name": symbol.simple_name,
+                        "qualified_name": symbol.fully_qualified_name,
+                        "symbol_type": symbol.symbol_type.name.lower(),
+                        "source_span": asdict(symbol.location),
+                    }
+                    for symbol in declarations
+                ],
+            }
+            for symbol_id, declarations in groups.items()
+            if len(declarations) > 1
+        ],
+    }
+
+
 def parse_repo(
     root: str | os.PathLike[str],
     *,
@@ -288,18 +330,33 @@ def parse_repo(
             ),
             source_code="",
             language=parsed.language,
-            metadata={"embedding_excluded": True, "content_version": parsed.content_hash},
+            metadata={
+                "embedding_excluded": True,
+                "content_version": parsed.content_hash,
+                **_file_projection_metadata(parsed),
+            },
         )
         file_symbols[relative] = file_symbol
 
-    symbols = [*file_symbols.values(), *(s for parsed in files.values() for s in parsed.symbols)]
-    relations = [relation for parsed in files.values() for relation in parsed.relations]
+    # Retain raw ParsedCode in `files` for diagnostics, but never feed ambiguous
+    # declarations into symbol lookup or cross-file resolution. The canonical
+    # FILE node stays visible, including to healthy files importing this module.
+    resolution_files = {
+        path: parsed
+        for path, parsed in files.items()
+        if file_symbols[path].metadata["projection_status"] != "file_marker_only"
+    }
+    symbols = [
+        *file_symbols.values(),
+        *(symbol for parsed in resolution_files.values() for symbol in parsed.symbols),
+    ]
+    relations = [relation for parsed in resolution_files.values() for relation in parsed.relations]
     from .rust_repository import RustRepository, use_paths
 
-    rust = RustRepository(root_path, files)
-    javascript = JavaScriptRepository(files)
-    rust_bindings: dict[str, list] = {}
-    for relative, parsed in files.items():
+    rust = RustRepository(root_path, resolution_files)
+    javascript = JavaScriptRepository(resolution_files)
+    rust_bindings: dict[str, list[RustBinding]] = {}
+    for relative, parsed in resolution_files.items():
         owner = file_symbols[relative]
         for symbol in parsed.symbols:
             if not symbol.scope_chain:
@@ -379,7 +436,9 @@ def parse_repo(
             )
     # Re-run the scope resolver over the full stable table only for already textual
     # targets, then apply conservative unique-name cross-file linking.
-    relations = _resolve_across_files(symbols, relations, files, rust_bindings, javascript)
+    relations = _resolve_across_files(
+        symbols, relations, resolution_files, rust_bindings, javascript
+    )
     generation_raw = "\n".join(f"{path}\x1f{digest}" for path, digest in sorted(manifest.items()))
     generation_id = hashlib.blake2b(generation_raw.encode(), digest_size=16).hexdigest()
     return ParsedRepository(

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph/resolution.py

@@ -72,6 +72,7 @@ def resolve_relations(
         if source is not None and source.language == "rust":
             candidates = _rust_candidates(source, ref, candidates, symbols)
         elif source is not None and source.language == "python":
+            definition_scope = source.metadata.get("python_definition_scopes", {}).get(ref.name)
             if source.metadata.get("python_wildcard_import"):
                 candidates = []
             elif ref.qualifier in {"self", "cls"}:
@@ -87,7 +88,10 @@ def resolve_relations(
             elif (
                 ref.qualifier
                 or ref.name in source.metadata.get("python_bound_names", [])
-                or ref.name in source.metadata.get("python_import_names", [])
+                or (
+                    ref.name in source.metadata.get("python_import_names", [])
+                    and definition_scope is None
+                )
             ):
                 candidates = []
             else:
@@ -104,6 +108,10 @@ def resolve_relations(
                     and [*source.scope_chain, source.simple_name][: len(c.scope_chain)]
                     == c.scope_chain
                 ]
+                # A lexical definition shadows imports and outer definitions even
+                # when its conditional body is not represented by this parser.
+                if definition_scope is not None:
+                    candidates = [c for c in candidates if c.scope_chain == definition_scope]
                 nearest = max((len(c.scope_chain) for c in candidates), default=-1)
                 candidates = [c for c in candidates if len(c.scope_chain) == nearest]
         elif source is not None and source.language in {"javascript", "typescript", "tsx"}:

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph/treesitter_parser.py

@@ -426,7 +426,9 @@ def _go_receiver_type(node, src: bytes) -> str | None:
 def _walk_collect(node, src, file_path, language, frames, symbols, relations, impl_traits):
     for child in _children(node):
         t = child.type
-        if t == "object" and language in {"javascript", "typescript", "tsx"}:
+        if t == "object" and child.is_named and language in {"javascript", "typescript", "tsx"}:
+            # TypeScript also uses an unnamed `object` keyword in type positions.
+            # Only named object expressions introduce a literal scope.
             # Anonymous object literals have a structural AST path, not a line ID.
             # Comments/whitespace do not participate; inserting a sibling object
             # can change the ordinal and requires a fresh graph generation.

{victor_codegraph-0.10.0 → victor_codegraph-0.10.2}/victor_codegraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.10.0
+Version: 0.10.2
 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
@@ -56,7 +56,11 @@ gaps:
 ## Install
 
 Published on PyPI as [`victor-codegraph`](https://pypi.org/project/victor-codegraph/).
-This source tree is version **0.10.0**; consumers should use a compatible `<1.0` pin.
+This source tree is version **0.10.2**; consumers should use a compatible `<1.0` pin.
+It repairs nested Python definition/import shadowing: proven local definitions
+retain their targets, while unmodeled conditional bindings stay unresolved.
+Rebuild derived graphs when adopting the new parser; unchanged source hashes do
+not invalidate old semantic results automatically. Publication is a separate gate.
 
 ```bash
 # from PyPI
@@ -128,10 +132,36 @@ records = to_proxima_records(repository, repo_graph_id="myrepo")
 
 ## Status
 
-`0.10.0` source version. Python (`ast`) is the full, offline frontend. JS/TS, Go, Rust,
+`0.10.2` 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

victor_codegraph-0.10.0/tests/test_diagnostics_v2.py

@@ -1,26 +0,0 @@
-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 == []

victor_codegraph-0.10.0/tests/test_repository_delta_v2.py

@@ -1,46 +0,0 @@
-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