codeanalyzer-python 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

codeanalyzer/neo4j/project.py

@@ -27,14 +27,15 @@ Modelling decisions (mirror of the TypeScript backend):
   - call-graph endpoints absent from the symbol table become ``:PyExternal`` ghost
     nodes, so RPC / third-party / framework edges are preserved (matching the
     analyzer's own ghost-node behaviour).
-  - every project-owned node carries an internal ``_module`` provenance prop, so
+  - every project-owned node names its owning module (``_module`` in the props it
+    hands RowBuilder, lifted to ``NodeRow.module`` and never emitted, #173), so
     the incremental writer can delete exactly what a re-analyzed module emitted.
 """
 from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from codeanalyzer.neo4j.schema import SCHEMA_VERSION
 from codeanalyzer.neo4j.rows import GraphRows, NodeRef, Props, RowBuilder, prune
@@ -47,7 +48,8 @@ from codeanalyzer.schema import (
     PyModule,
     PyVariableDeclaration,
 )
-from codeanalyzer.schema.ids import application_id, purl_pypi
+from codeanalyzer.schema import model_dump
+from codeanalyzer.schema.ids import application_id, external_id, global_ordinal, purl_pypi
 from codeanalyzer.schema.py_schema import PyDecorator
 
 
@@ -58,18 +60,30 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
     passes it through so the :PyApplication node carries it as props."""
     b = RowBuilder()
 
+    # Keyed on the ``can://<app>`` id, not on ``--app-name``: two applications
+    # analyzed under the same free-text name used to MERGE onto one root, with
+    # no diagnostic. ``name`` survives as a display property.
     app_ref = b.node(
         ["PyApplication"],
-        "name",
-        app_name,
+        "id",
+        application_id(app_name),
         prune(
             {
+                "id": application_id(app_name),
+                "name": app_name,
                 "schema_version": SCHEMA_VERSION,
                 "analyzer_name": analyzer.name if analyzer else None,
                 "analyzer_version": analyzer.version if analyzer else None,
                 "repo_uri": app.repository.uri if app.repository else None,
                 "source_revision": app.repository.revision if app.repository else None,
                 "repo_dirty": app.repository.dirty if app.repository else None,
+                # #177: the entrypoint pass under-approximates by design, so a
+                # graph consumer must be able to tell "no entrypoints" from "the
+                # pass found nothing". Always present, even when empty.
+                "entrypoint_frameworks": list(app.entrypoint_report.frameworks_detected),
+                "entrypoint_report_json": json.dumps(
+                    model_dump(app.entrypoint_report, mode="json"), sort_keys=True
+                ),
             }
         ),
     )
@@ -87,19 +101,21 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
     for file_key, mod in app.symbol_table.items():
         mod_ref = b.node(["PyModule"], "id", mod.id, _module_props(mod, file_key))
         b.edge("PY_HAS_MODULE", app_ref, mod_ref)
-        _project_module_body(b, file_key, mod_ref, mod, externals, sig_to_id, module_id_by_key)
+        _project_module_body(b, file_key, mod_ref, mod, externals, sig_to_id, module_id_by_key,
+                             application_id(app_name))
 
     # The aggregated :PY_CALLS twin.
+    app_can_id = application_id(app_name)
     for e in app.call_graph:
-        src = _call_endpoint(b, e.src, externals, sig_to_id)
-        tgt = _call_endpoint(b, e.dst, externals, sig_to_id)
+        src = _call_endpoint(b, e.src, externals, sig_to_id, app_can_id)
+        tgt = _call_endpoint(b, e.dst, externals, sig_to_id, app_can_id)
         b.edge(
             "PY_CALLS", src, tgt, _call_edge_props(e.weight, list(e.prov or []))
         )
 
     # Level-3 CPG overlay: each callable's v2 body/cfg/cdg/ddg. Idempotent under
     # MERGE — a no-op when no callable carries L3 fields (levels 1/2).
-    _project_program_graphs(b, app, externals, sig_to_id)
+    _project_program_graphs(b, app, externals, sig_to_id, app_can_id)
 
     # Neutral artifact/dependency subgraph (Task 6). L1 data — always present,
     # full-depth-always regardless of -a.
@@ -109,7 +125,7 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
     # _project_program_graphs above) into the config-key subgraph
     # (ConfigKey from _project_artifacts above), plus first-class unresolved
     # reads.
-    _project_config_uses(b, app, app_ref, externals, sig_to_id)
+    _project_config_uses(b, app, app_ref, externals, sig_to_id, app_can_id)
 
     return b.finish()
 
@@ -128,11 +144,7 @@ def _global_ordinal(callable_id: str, local_key: str) -> str:
     This MUST agree with :meth:`IdentityMap.global_id` for the same node, so the
     JSON ``body``/``cfg`` projection and this Neo4j projection land on one node
     identity (two-projection agreement)."""
-    return (
-        f"{callable_id}{local_key}"
-        if local_key.startswith("@")
-        else f"{callable_id}@{local_key}"
-    )
+    return global_ordinal(callable_id, local_key)
 
 
 def _body_ref(callable_id: str, local_key: str) -> NodeRef:
@@ -140,7 +152,7 @@ def _body_ref(callable_id: str, local_key: str) -> NodeRef:
 
 
 def _project_program_graphs(
-    b: RowBuilder, app: PyApplication, externals: dict, sig_to_id: dict
+    b: RowBuilder, app: PyApplication, externals: dict, sig_to_id: dict, app_can_id: str,
 ) -> None:
     """Level-3 CPG overlay, projected off each callable's v2 ``body``/``cfg``/
     ``cdg``/``ddg`` (populated by ``emit_l3_body`` at ``-a 3``; empty otherwise).
@@ -209,7 +221,7 @@ def _project_program_graphs(
                     b.edge(
                         "PY_RESOLVES_TO",
                         ref,
-                        _call_endpoint(b, node.callee, externals, sig_to_id),
+                        _call_endpoint(b, node.callee, externals, sig_to_id, app_can_id),
                     )
             for e in c.cfg or []:
                 # kind-discriminated: a conditional's true/false pair between one
@@ -283,7 +295,7 @@ def _import_ghost(b: RowBuilder, app_can_id: str, name: str) -> NodeRef:
     projected too, both rows collapse onto this one node — correctly, since
     they name the same real-world symbol."""
     return b.node(
-        ["PySymbol", "PyExternal"], "id", f"{app_can_id}/@external/{name}", {"name": name}
+        ["PySymbol", "PyExternal"], "id", external_id(app_can_id, None, name), {"name": name}
     )
 
 
@@ -399,6 +411,7 @@ def _project_artifacts(b: RowBuilder, app: PyApplication, app_name: str, app_ref
 
 def _project_config_uses(
     b: RowBuilder, app: PyApplication, app_ref: NodeRef, externals: dict, sig_to_id: dict,
+    app_can_id: str,
 ) -> None:
     """config_use (#162): PY_USES_CONFIG (`app.config_uses`) and
     PY_READS_CONFIG_UNRESOLVED (`app.config_reads_unresolved`).
@@ -428,7 +441,7 @@ def _project_config_uses(
             prune({"prov": list(e.prov) if e.prov else None}),
         )
     for r in app.config_reads_unresolved:
-        ghost_ref = _call_endpoint(b, r.callee, externals, sig_to_id)
+        ghost_ref = _call_endpoint(b, r.callee, externals, sig_to_id, app_can_id)
         b.edge(
             "PY_READS_CONFIG_UNRESOLVED",
             app_ref,
@@ -453,8 +466,54 @@ def _symbol_ref(signature: str, externals: dict, sig_to_id: dict) -> NodeRef:
     return NodeRef("PySymbol", "signature", signature)
 
 
+def _base_ref_resolver(
+    b: RowBuilder, mod: PyModule, externals: dict, sig_to_id: dict, app_can_id: str,
+) -> Callable[[str], NodeRef]:
+    """Per-module: the written base spelling → the NodeRef PY_EXTENDS lands on (#178).
+
+    ``base_classes`` stores the spelling as written (``Base``, ``views.View``),
+    while ``sig_to_id`` is keyed by signature (``pkg.mod.Base``), so the two never
+    met and every PY_EXTENDS row was dropped as dangling. Resolution order: a class
+    declared in this module (bare name or ``Outer.Inner`` path) → its can:// id; a
+    name the module's import table maps (same resolver the entrypoint pass uses)
+    that is a declared class elsewhere → its can:// id; otherwise an ``@external``
+    ghost with the id shape ``_home_external_symbols`` uses, so a call to the same
+    symbol MERGEs onto the same node."""
+    from codeanalyzer.entrypoints.pipeline import _base_resolver
+
+    local: Dict[str, str] = {}
+
+    def index(cl: PyClass, path: str) -> None:
+        local.setdefault(cl.name, cl.signature)
+        local[path] = cl.signature
+        for ic in (cl.types or {}).values():
+            index(ic, f"{path}.{ic.name}")
+
+    for cl in (mod.types or {}).values():
+        index(cl, cl.name)
+    resolve = _base_resolver(mod)
+
+    def base_ref(written: str) -> NodeRef:
+        sig = local.get(written) or resolve(written)
+        can_id = sig_to_id.get(sig)
+        if can_id is not None:
+            return _sym(can_id)
+        return _external_ghost(b, app_can_id, sig)
+
+    return base_ref
+
+
+def _external_ghost(b: RowBuilder, app_can_id: str, signature: str) -> NodeRef:
+    """A :PyExternal ghost for a dotted signature nobody homed, with the id shape
+    ``_home_external_symbols`` uses — ``<app>/@external/<module>/<name>`` — so it
+    sits inside the application prefix (#173) and MERGEs with a homed twin."""
+    module, name = signature.rsplit(".", 1) if "." in signature else (None, signature)
+    ext_id = external_id(app_can_id, module, name)
+    return b.node(["PySymbol", "PyExternal"], "id", ext_id, prune({"name": name, "module": module}))
+
+
 def _call_endpoint(
-    b: RowBuilder, signature: str, externals: dict, sig_to_id: dict
+    b: RowBuilder, signature: str, externals: dict, sig_to_id: dict, app_can_id: str,
 ) -> NodeRef:
     """A call-graph endpoint: a declared callable already emitted (keyed by its
     canonical ``can://`` id, resolved through ``sig_to_id``), or an external symbol
@@ -484,13 +543,7 @@ def _call_endpoint(
             ext.id or signature,
             prune({"name": ext.name, "module": ext.module}),
         )
-    name = signature.rsplit(".", 1)[-1] if "." in signature else signature
-    return b.node(
-        ["PySymbol", "PyExternal"],
-        "id",
-        signature,
-        prune({"name": name}),
-    )
+    return _external_ghost(b, app_can_id, signature)
 
 
 # ----------------------------------------------------------------------------------------------
@@ -500,16 +553,17 @@ def _call_endpoint(
 
 def _project_module_body(
     b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: PyModule,
-    externals: dict, sig_to_id: dict, module_id_by_key: dict,
+    externals: dict, sig_to_id: dict, module_id_by_key: dict, app_can_id: str,
 ) -> None:
+    base_ref = _base_ref_resolver(b, mod, externals, sig_to_id, app_can_id)
     for fn in (mod.functions or {}).values():
         _project_callable(b, file_key, mod_ref, "PY_DECLARES", fn, externals, sig_to_id,
-                          mod.source)
+                          mod.source, base_ref)
     for cl in (mod.types or {}).values():
         _project_class(b, file_key, mod_ref, "PY_DECLARES", cl, externals, sig_to_id,
-                       mod.source)
+                       mod.source, base_ref)
     for v in mod.variables or []:
-        _project_variable(b, file_key, mod_ref, file_key, v)
+        _project_variable(b, file_key, mod_ref, v)
     _project_imports(b, mod_ref, mod, module_id_by_key)
 
 
@@ -575,7 +629,7 @@ def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule,
 
 def _project_class(
     b: RowBuilder, file_key: str, parent: NodeRef, parent_rel: str, cl: PyClass,
-    externals: dict, sig_to_id: dict, source: str,
+    externals: dict, sig_to_id: dict, source: str, base_ref: Callable[[str], NodeRef],
 ) -> None:
     ref = b.node(
         ["PySymbol", "PyClass"], "id", cl.id, _class_props(cl, file_key, source)
@@ -587,20 +641,21 @@ def _project_class(
 
     for base in cl.base_classes or []:
         if base:
-            b.edge_to_symbol("PY_EXTENDS", ref, _symbol_ref(base, externals, sig_to_id))
+            b.edge_to_symbol("PY_EXTENDS", ref, base_ref(base))
 
     for m in (cl.callables or {}).values():
         _project_callable(b, file_key, ref, "PY_HAS_METHOD", m, externals, sig_to_id,
-                          source)
+                          source, base_ref)
     for a in (cl.attributes or {}).values():
-        _project_attribute(b, file_key, ref, cl.signature, a)
+        _project_attribute(b, file_key, ref, a)
     for ic in (cl.types or {}).values():
-        _project_class(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id, source)
+        _project_class(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id, source,
+                       base_ref)
 
 
 def _project_callable(
     b: RowBuilder, file_key: str, owner: NodeRef, owner_rel: str, c: PyCallable,
-    externals: dict, sig_to_id: dict, source: str,
+    externals: dict, sig_to_id: dict, source: str, base_ref: Callable[[str], NodeRef],
 ) -> None:
     ref = b.node(
         ["PySymbol", "PyCallable"],
@@ -614,18 +669,22 @@ def _project_callable(
         _project_decorator(b, ref, d)
 
     for v in c.local_variables or []:
-        _project_variable(b, file_key, ref, c.signature, v)
+        _project_variable(b, file_key, ref, v)
     for ic in (c.callables or {}).values():
         _project_callable(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id,
-                          source)
+                          source, base_ref)
     for cl in (c.types or {}).values():
-        _project_class(b, file_key, ref, "PY_DECLARES", cl, externals, sig_to_id, source)
+        _project_class(b, file_key, ref, "PY_DECLARES", cl, externals, sig_to_id, source,
+                       base_ref)
 
 
 def _project_attribute(
-    b: RowBuilder, file_key: str, owner: NodeRef, owner_sig: str, a: PyClassAttribute
+    b: RowBuilder, file_key: str, owner: NodeRef, a: PyClassAttribute
 ) -> None:
-    attr_id = f"{owner_sig}.{a.name}"
+    # ``<class can:// id>/<name>`` (#173): minted from the owner's id so it carries
+    # the application segment. The signature-minted ``service.Service.name`` it
+    # replaced was identical across applications, so two apps MERGEd onto one node.
+    attr_id = f"{owner.value}/{a.name}"
     ref = b.node(["PyAttribute"], "id", attr_id, _attribute_props(a, attr_id, file_key))
     b.edge("PY_HAS_ATTRIBUTE", owner, ref)
 
@@ -634,10 +693,12 @@ def _project_variable(
     b: RowBuilder,
     file_key: str,
     owner: NodeRef,
-    owner_id: str,
     v: PyVariableDeclaration,
 ) -> None:
-    var_id = f"{owner_id}#{v.name}@{v.start_line}"
+    # ``<owner can:// id>/<name>@<line>`` (#173) — the owner is the module or the
+    # callable, so a module-level variable sits under ``<module-id>/`` like every
+    # other declaration and the module's prefix purge reaches it.
+    var_id = f"{owner.value}/{v.name}@{v.start_line}"
     ref = b.node(["PyVariable"], "id", var_id, _variable_props(v, var_id, file_key))
     b.edge("PY_DECLARES_VAR", owner, ref)
 

codeanalyzer/neo4j/rows.py

@@ -28,6 +28,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Union
 
+from codeanalyzer.schema.ids import SCHEME, application_id
+
 # A property value: a primitive, or a homogeneous list of primitives.
 Scalar = Union[str, int, float, bool]
 Prop = Union[Scalar, List[str], List[int], List[float], List[bool]]
@@ -50,6 +52,44 @@ class NodeRow:
     key_prop: str
     value: str
     props: Props
+    # The owning module's file key, for the incremental writer's per-module diff.
+    # In memory only (#173): it used to be emitted as ``_module`` and every
+    # destructive statement matched on it, which is application-blind. Scope now
+    # comes from the ``can://`` id prefix; this field only groups rows.
+    module: Optional[str] = None
+
+
+# The marker label on every node keyed by a ``can://`` id (#173). It is an
+# INDEX ANCHOR, nothing more: Neo4j property indexes are label-scoped, so the
+# prefix predicate ``id STARTS WITH $p`` needs a label to seek on. Safety comes
+# from the prefix, which carries application, language and module.
+#
+# The test is the SCHEME, never a language segment: since the app moved outermost
+# an id no longer begins with the language, and ``can://python/`` now means "the
+# application is called python". Testing that here would have quietly stripped the
+# marker off every graph but one, taking the destructive statements' index — and
+# their reach — with it.
+CAN_NODE = "PyCanNode"
+
+
+def descendant_prefix(can_id: str) -> str:
+    """The prefix that matches a node's descendants and nothing else. The separator
+    is the point: ``can://app/python/src/foo.py`` is also a prefix of
+    ``can://app/python/src/foo.pyX``, so descendants match on ``id + '/'`` and the
+    node itself by equality."""
+    return f"{can_id}/"
+
+
+def application_prefix(app_name: Optional[str]) -> str:
+    """``can://<app>/`` — the scope of every destructive statement. Refuses an
+    empty application: ``STARTS WITH ''`` would match every node in the database.
+
+    Since the app is the outermost segment this now covers the application's
+    artifacts and config keys too, which the old language-first prefix left
+    outside every scope and so never cleaned up."""
+    if not app_name:
+        raise ValueError("neo4j: refusing a destructive statement without an application id")
+    return descendant_prefix(application_id(app_name))
 
 
 @dataclass
@@ -100,14 +140,20 @@ class RowBuilder:
         (last write wins) and unions labels — the in-memory analog of
         ``MERGE (n:Label {key}) SET n += props``."""
         node_id = f"{labels[0]} {value}"
+        props = dict(props)
+        module = props.pop("_module", None)  # lifted off the graph (#173)
+        if key_prop == "id" and value.startswith(SCHEME) and CAN_NODE not in labels:
+            labels = [*labels, CAN_NODE]
         existing = self._nodes.get(node_id)
         if existing is not None:
             existing.props.update(props)
+            if module is not None:
+                existing.module = module
             for label in labels:
                 if label not in existing.labels:
                     existing.labels.append(label)
         else:
-            self._nodes[node_id] = NodeRow(list(labels), key_prop, value, dict(props))
+            self._nodes[node_id] = NodeRow(list(labels), key_prop, value, props, module)
         self._keys.add((labels[0], value))
         return NodeRef(labels[0], key_prop, value)
 

codeanalyzer/neo4j/schema.py

@@ -57,7 +57,9 @@ class RelType:
 
 
 # Labels layered onto a node in addition to its primary/specific label.
-MARKER_LABELS: List[str] = []
+# ``PyCanNode`` (#173) rides every node keyed by a ``can://`` id — an index
+# anchor for the prefix-scoped destructive statements (see ``rows.CAN_NODE``).
+MARKER_LABELS: List[str] = ["PyCanNode"]
 
 _SPAN = {"start_line": "integer", "end_line": "integer"}
 
@@ -66,8 +68,9 @@ NODE_LABELS: List[NodeLabel] = [
     NodeLabel(
         "PyApplication",
         "PyApplication",
-        "name",
+        "id",
         {
+            "id": "string",
             "name": "string",
             "schema_version": "string",
             "analyzer_name": "string",
@@ -75,6 +78,8 @@ NODE_LABELS: List[NodeLabel] = [
             "repo_uri": "string",
             "source_revision": "string",
             "repo_dirty": "boolean",
+            "entrypoint_frameworks": "string[]",
+            "entrypoint_report_json": "string",
         },
     ),
     NodeLabel(
@@ -88,7 +93,6 @@ NODE_LABELS: List[NodeLabel] = [
             "content_hash": "string",
             "last_modified": "float",
             "file_size": "integer",
-            "_module": "string",
         },
     ),
     NodeLabel(
@@ -104,7 +108,6 @@ NODE_LABELS: List[NodeLabel] = [
             "decorators": "string[]",
             "docstring": "string",
             **_SPAN,
-            "_module": "string",
             "is_entrypoint": "boolean",
             "entrypoint_frameworks": "string[]",
         },
@@ -128,7 +131,6 @@ NODE_LABELS: List[NodeLabel] = [
             "modifiers": "string[]",
             "parameters_json": "string",
             "accessed_symbols_json": "string",
-            "_module": "string",
             "is_entrypoint": "boolean",
             "entrypoint_frameworks": "string[]",
         },
@@ -157,7 +159,6 @@ NODE_LABELS: List[NodeLabel] = [
             "initializer": "string",
             "docstring": "string",
             **_SPAN,
-            "_module": "string",
         },
     ),
     NodeLabel(
@@ -171,7 +172,6 @@ NODE_LABELS: List[NodeLabel] = [
             "initializer": "string",
             "scope": "string",
             **_SPAN,
-            "_module": "string",
         },
     ),
     # Level-3 CPG overlay (present only at -a 3). The dataflow vocabulary is
@@ -198,7 +198,6 @@ NODE_LABELS: List[NodeLabel] = [
             "is_constructor_call": "boolean",
             "arguments_json": "string",
             **_SPAN,
-            "_module": "string",
         },
     ),
     # Neutral artifact/dependency subgraph (spec 2026-08-27, Task 6). No `Py`
@@ -332,27 +331,14 @@ def uniqueness_constraints() -> list[str]:
 
 CONSTRAINTS: List[str] = uniqueness_constraints()
 
-# The labels this analyzer owns per module -- the ones carrying the internal ``_module``
-# provenance property. Derived from NODE_LABELS so a new module-scoped label is covered
-# without a second list to maintain. `_module` is NOT python-private: codeanalyzer-java
-# and codeanalyzer-typescript set the same property on their nodes, so every statement
-# matching on it must be anchored to these labels or it matches a sibling analyzer's graph
-# in a shared database (#171).
-MODULE_OWNED_LABELS: List[str] = [n.label for n in NODE_LABELS if "_module" in n.properties]
-
-# The label disjunction to anchor such a statement with: ``MATCH (x:PyModule|PyClass|...)``.
-MODULE_OWNED_PATTERN: str = "|".join(MODULE_OWNED_LABELS)
-
 INDEXES: List[str] = [
     "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",
     "CREATE INDEX py_class_name IF NOT EXISTS FOR (c:PyClass) ON (c.name)",
     "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]",
-] + [
-    # One per module-owned label: the incremental writer's per-module purge matches on
-    # `_module` once per changed module, which without these is a label scan per label per
-    # module -- quadratic on a full push (#171).
-    f"CREATE INDEX {label.lower()}_module IF NOT EXISTS FOR (x:{label}) ON (x._module)"
-    for label in MODULE_OWNED_LABELS
+    # #173: every destructive statement is ``MATCH (x:PyCanNode) WHERE x.id STARTS WITH $p``.
+    # A range index on the marker makes that a prefix seek; without it, a store scan per
+    # changed module. STARTS WITH is index-backed; CONTAINS / ENDS WITH are not.
+    "CREATE INDEX py_can_node_id IF NOT EXISTS FOR (n:PyCanNode) ON (n.id)",
 ]
 
 

codeanalyzer/schema/ids.py

@@ -1,17 +1,30 @@
 """Canonical `can://` id construction for schema v2 (durable ids, ≥ callable).
 Ordinal ids (< callable) are `ordinal_id(callable_id, tag)`. Pure functions;
-ids are opaque handles (the <file> segment itself contains '/')."""
+ids are opaque handles (the <file> segment itself contains '/').
+
+The **application is the outermost segment** and the language sits inside it:
+``can://<app>/python/<file>/<type>/<callable-sig>``. So ``can://<app>`` is a
+prefix of every id this analyzer mints for that application — code, externals
+and artifacts alike — which is what the prefix-scoped destructive statements
+(#173) rely on. Nothing may be identified by its *language* prefix any more:
+an application named ``python`` mints ``can://python/python/...``, so a test
+for ``can://python/`` no longer means "a python id"; test the scheme instead."""
 from __future__ import annotations
-from typing import List
+from typing import List, Optional
+
+SCHEME = "can://"
 
-_SCHEME = "can://python"
+# This analyzer's language segment, which sits INSIDE the app rather than above it.
+LANG = "python"
 
 def application_id(app_name: str) -> str:
-    return f"{_SCHEME}/{app_name}"
+    """``can://<app>`` — the application root, and the prefix every id below it shares."""
+    return f"{SCHEME}{app_name}"
 
 def module_id(app_name: str, file_key: str) -> str:
+    """``can://<app>/python/<relative-file-key>`` (separators normalized to ``/``)."""
     rel = file_key.replace("\\", "/").lstrip("./")
-    return f"{application_id(app_name)}/{rel}"
+    return f"{application_id(app_name)}/{LANG}/{rel}"
 
 def child_id(parent_id: str, segment: str) -> str:
     return f"{parent_id}/{segment}"
@@ -23,13 +36,47 @@ def ordinal_id(callable_id: str, tag: str) -> str:
     return f"{callable_id}@{tag}"
 
 
+def external_id(app_id: str, module: Optional[str], name: str) -> str:
+    """``can://<app>/@external/<module>/<name>`` — the home of a call-graph
+    endpoint that is not declared in the symbol table (an imported library or
+    builtin member). ``module`` is ``None`` for a dot-less signature, which drops
+    the segment.
+
+    Language-NEUTRAL, like ``artifact``: ``@external`` sits in the position the
+    language occupies for code nodes, so sibling analyzers over the same ``<app>``
+    name a library symbol identically and it is one node in a merged graph. The
+    cost is real and was accepted deliberately — two analyzers' notions of
+    ``os.getcwd`` are not necessarily the same thing, and merging them says they
+    are. TypeScript's form; java follows it."""
+    base = f"{app_id}/@external"
+    return f"{base}/{module}/{name}" if module else f"{base}/{name}"
+
+
+def global_ordinal(callable_id: str, local_key: str) -> str:
+    """The GLOBAL ordinal id of a body node from its LOCAL key: synthetic keys
+    (`@entry`, `@formal_in:0`) already carry the `@`; positional keys (`15:2`,
+    `15:2/actual_in:0`) get one. This is the :PyBodyNode merge key and, since
+    #176, `BodyNode.id` — the one implementation both projections share."""
+    return f"{callable_id}{local_key}" if local_key.startswith("@") else f"{callable_id}@{local_key}"
+
+
+def stamp_body_ids(callable) -> None:
+    """Stamp `id` on every body node and parameter of one callable (#176).
+    Idempotent; each body emitter calls it after writing its nodes."""
+    for key, node in callable.body.items():
+        node.id = global_ordinal(callable.id, key)
+    for i, p in enumerate(callable.parameters or []):
+        p.id = ordinal_id(callable.id, f"formal_in:{i}")
+
+
 def artifact_id(app_name: str, rel_path: str) -> str:
-    """Language-neutral artifact id: ``can://artifact/<app>/<rel-path>``.
+    """Language-neutral artifact id: ``can://<app>/artifact/<rel-path>``.
 
-    The first segment is a namespace (a language for code nodes, the literal
-    ``artifact`` for files), so sibling analyzers over the same repo emit the
-    same id for the same file."""
-    return f"can://artifact/{app_name}/{rel_path}"
+    ``artifact`` is a reserved segment in the same position the language
+    occupies for code nodes, so sibling analyzers over the same repo (same
+    ``<app>``) still emit the same id for the same file — and, unlike the old
+    ``can://artifact/<app>/...``, it now sits inside the application prefix."""
+    return f"{application_id(app_name)}/artifact/{rel_path}"
 
 
 def config_key_id(artifact_id: str, dotted_key: str) -> str:

codeanalyzer/schema/l1_body.py

@@ -1,6 +1,7 @@
 """L1 body population: materialize `call` nodes from existing call sites.
 `callee` is left None here — the sanctioned null→id refinement happens at L2."""
 from __future__ import annotations
+from codeanalyzer.schema.ids import stamp_body_ids
 from codeanalyzer.schema.py_schema import PyApplication, PyClass, PyCallable, BodyNode, Span, byte_offsets
 
 def _do_callable(source: str, c: PyCallable) -> None:
@@ -20,6 +21,7 @@ def _do_callable(source: str, c: PyCallable) -> None:
             is_constructor_call=cs.is_constructor_call,
             arguments=list(cs.arguments or []),
         )
+    stamp_body_ids(c)
     for ic in (c.callables or {}).values():
         _do_callable(source, ic)
     for icl in (c.types or {}).values():

codeanalyzer/schema/py_schema.py

@@ -128,6 +128,9 @@ class BodyNode(BaseModel):
     """A node in a callable's `body`: an AST region (statement/call/branch/…) or
     a synthetic analysis vertex (entry/exit/formal_in/out/actual_in/out)."""
     kind: str
+    # #176: the GLOBAL ordinal id — `<callable-id>@<local>` — the same value the
+    # Neo4j projection merges :PyBodyNode on. Stamped by `ids.stamp_body_ids`.
+    id: str = ""
     span: Optional[Span] = None
     callee: Optional[str] = None   # only on `call` nodes; the sanctioned null→id slot
     of: Optional[str] = None       # param vertices: the variable/return they carry
@@ -287,6 +290,9 @@ class PyCallableParameter(BaseModel):
     """Represents a parameter of a Python callable (function/method)."""
 
     name: str
+    # #176: `<callable-id>@formal_in:<i>` for position i — the L4 formal_in vertex
+    # that carries this parameter. A forward reference below level 4.
+    id: str = ""
     type: Optional[str] = None
     default_value: Optional[str] = None
     decorators: List[PyDecorator] = []
@@ -475,7 +481,7 @@ class PyExternalSymbol(BaseModel):
     builtin member. An edge-endpoint id home, not a tree node: keyed in
     ``PyApplication.external_symbols`` by its ``can://…/@external/…`` id."""
 
-    id: str = ""  # can://python/<app>/@external/<module>/<name>
+    id: str = ""  # can://<app>/@external/<module>/<name>
     kind: str = "external"
     name: str  # the member/short name, e.g. "get" for "requests.get"
     module: Optional[str] = None  # best-effort owning module, e.g. "requests"
@@ -504,7 +510,7 @@ class PyArtifact(BaseModel):
     plain data/binary) -- never dropped from the walk. Captured broadly (node
     + verbatim ``source``); *meaning* is extracted narrowly -- only
     ``dependency-manifest`` roles feed ``dependencies`` today. ``id`` is
-    language-neutral (``can://artifact/<app>/<path>``)."""
+    language-neutral (``can://<app>/artifact/<path>``)."""
 
     id: str = ""
     kind: str = "artifact"