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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.10.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
@@ -56,7 +56,7 @@ 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.1**; consumers should use a compatible `<1.0` pin.
 
 ```bash
 # from PyPI
@@ -128,10 +128,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.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

{victor_codegraph-0.10.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.10.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.10.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

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

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

{victor_codegraph-0.10.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.10.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_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.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.10.0 → victor_codegraph-0.10.1}/victor_codegraph/__init__.py

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

{victor_codegraph-0.10.0 → victor_codegraph-0.10.1}/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.1}/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.1}/victor_codegraph/repository_index.py

@@ -5,7 +5,7 @@ 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 .model import (
@@ -245,6 +245,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 +322,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 = RustRepository(root_path, resolution_files)
+    javascript = JavaScriptRepository(resolution_files)
     rust_bindings: dict[str, list] = {}
-    for relative, parsed in files.items():
+    for relative, parsed in resolution_files.items():
         owner = file_symbols[relative]
         for symbol in parsed.symbols:
             if not symbol.scope_chain:
@@ -379,7 +428,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.1}/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.1}/victor_codegraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: victor-codegraph
-Version: 0.10.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
@@ -56,7 +56,7 @@ 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.1**; consumers should use a compatible `<1.0` pin.
 
 ```bash
 # from PyPI
@@ -128,10 +128,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.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

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