codeanalyzer-python 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

codeanalyzer/neo4j/bolt.py

@@ -27,11 +27,27 @@ Algorithm (the module subgraph is the unit of idempotent replacement):
   4. upsert edges owned by changed modules (+ the shared edges).
   5. on a FULL run only, prune modules whose source file vanished.
 
+**A push never deletes by default** (#171). Steps 3 and 5 are the only destructive
+ones and both run on ``eager`` (``--eager``) only; a default ``--lazy`` push is purely
+additive — MERGE-upsert of nodes and edges, nothing removed. The cost of the default is
+staleness: a declaration or a call edge the source no longer has stays in the graph until
+an ``--eager`` push reconciles it. That is the deliberate trade — an incremental push into
+a shared database should not be able to destroy anything, and the destructive rebuild is
+opt-in under the same flag that already forces a clean analysis rebuild.
+
 Nodes are MERGE-upserted, never blindly deleted, so a declaration another
 (unchanged) module still references survives and its incoming edges stay valid.
-``:PyExternal`` / ``:PyPackage`` / ``:PyDecorator`` are shared (no ``_module``) and are
+``:PyExternal`` / ``:PyPackage`` / ``:PyDecorator`` have no owning module and are
 MERGE-only.
 
+**Every destructive statement is scoped on the ``can://`` id prefix** (#173). The id is a
+path — ``can://python/<app>/<file>/...`` — so ``id = <module-id> OR id STARTS WITH
+<module-id> + '/'`` is containment, and it is one language, one application and one
+module at once. That is what neither a label anchor nor the retired ``_module`` property
+could give: two python applications sharing ``src/foo.py`` carry identical labels and an
+identical file key, and only the id tells them apart. ``:PyCanNode`` anchors the predicate
+so it seeks an index instead of scanning the store; it carries no safety claim.
+
 The ``neo4j`` driver is imported lazily so it stays an optional dependency and
 off the default (json) output path entirely.
 """
@@ -40,16 +56,34 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
-from codeanalyzer.neo4j.rows import EdgeRow, GraphRows, NodeRow, chunk
+from codeanalyzer.neo4j.rows import (
+    CAN_NODE, EdgeRow, GraphRows, NodeRow, application_prefix, chunk, descendant_prefix,
+)
 from codeanalyzer.neo4j.schema import CONSTRAINTS, INDEXES
 from codeanalyzer.utils import logger
 
-DESCENDANTS = (
-    "[:PY_DECLARES|PY_HAS_METHOD|PY_HAS_ATTRIBUTE|PY_DECLARES_VAR"
-    "|PY_HAS_CALLSITE|PY_HAS_BODY_NODE*1..]"
-)
 BATCH = 1000
 
+# The per-module purge (#173): the module by equality, its subtree by prefix. Anchored
+# on :PyCanNode only so the predicate can seek (see ``rows.CAN_NODE``).
+PURGE_MODULE_EDGES = (
+    f"MATCH (x:{CAN_NODE}) WHERE x.id = $mid OR x.id STARTS WITH $pre "
+    "MATCH (x)-[r]->() DELETE r"
+)
+PURGE_VANISHED_NODES = (
+    f"MATCH (x:{CAN_NODE}) WHERE (x.id = $mid OR x.id STARTS WITH $pre) "
+    "AND NOT x.id IN $keys DETACH DELETE x"
+)
+# The orphan prune: modules inside this application's prefix that the run no longer
+# emits, and everything under each. Batched — deleting a large application in one
+# transaction exhausts dbms.memory.transaction.total.max (typescript#116).
+PRUNE_VANISHED_MODULES = (
+    f"MATCH (m:PyModule:{CAN_NODE}) WHERE m.id STARTS WITH $app AND NOT m.id IN $present "
+    f"CALL {{ WITH m MATCH (x:{CAN_NODE}) WHERE x.id = m.id OR x.id STARTS WITH m.id + '/' "
+    "DETACH DELETE x } IN TRANSACTIONS OF 1000 ROWS "
+    "RETURN count(*) AS pruned"
+)
+
 
 @dataclass
 class BoltConfig:
@@ -59,7 +93,7 @@ class BoltConfig:
     database: Optional[str] = None
 
 
-def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
+def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool, eager: bool = False) -> None:
     try:
         import neo4j  # noqa: WPS433 (lazy, optional dependency)
     except ImportError as exc:  # pragma: no cover - exercised only without the extra
@@ -80,35 +114,44 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
             for stmt in [*CONSTRAINTS, *INDEXES]:
                 s.run(stmt)
 
-        # The application anchor (a shared node) — used to scope the orphan prune
-        # so it never touches modules belonging to a different :PyApplication.
+        # The application anchor. Every destructive statement below is scoped to
+        # ``can://python/<app>/``; an empty application id is refused up front rather
+        # than becoming ``STARTS WITH ''`` (every node in the database).
         app_name = next(
             (n.value for n in rows.nodes if n.labels and n.labels[0] == "PyApplication"),
             None,
         )
+        app_prefix = application_prefix(app_name)
 
-        # Partition nodes by owning module; shared nodes have no _module.
+        # Partition nodes by owning module (an in-memory field, never emitted, #173);
+        # shared nodes have none.
         by_module: Dict[str, List[NodeRow]] = {}
         shared: List[NodeRow] = []
         module_of: Dict[str, str] = {}  # node value → owning module
         for n in rows.nodes:
-            m = n.props.get("_module")
-            if isinstance(m, str):
-                by_module.setdefault(m, []).append(n)
-                module_of[n.value] = m
+            if n.module is not None:
+                by_module.setdefault(n.module, []).append(n)
+                module_of[n.value] = n.module
             else:
                 shared.append(n)
 
-        # 2. diff content_hash.
+        # 2. diff content_hash, keyed by module id inside this application's prefix.
+        # Keyed by file key it was application-blind: a second application whose
+        # module shares the path and the hash looked "unchanged" and was never written.
         db_hash: Dict[str, Optional[str]] = {}
         with session() as s:
-            res = s.run("MATCH (m:PyModule) RETURN m.file_key AS k, m.content_hash AS h")
+            res = s.run(
+                f"MATCH (m:PyModule:{CAN_NODE}) WHERE m.id STARTS WITH $app "
+                "RETURN m.id AS k, m.content_hash AS h",
+                app=app_prefix,
+            )
             for rec in res:
                 db_hash[rec["k"]] = rec["h"]
         changed = set()
         for m, nodes in by_module.items():
-            row_hash = _hash_of(nodes, m)
-            if m not in db_hash or row_hash is None or row_hash != db_hash.get(m):
+            mid = _module_id_of(nodes)
+            row_hash = _hash_of(nodes)
+            if mid not in db_hash or row_hash is None or row_hash != db_hash.get(mid):
                 changed.add(m)
         logger.info(
             f"neo4j(bolt): {len(by_module)} modules ({len(changed)} changed), "
@@ -119,19 +162,26 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
         _upsert_nodes(session, neo4j, shared)
 
         # 4. per changed module: purge owned edges + vanished decls, then upsert its nodes.
+        # The purge is the only destructive step in a push, so it runs on --eager only.
         for m in changed:
             nodes = by_module[m]
             keys = [n.value for n in nodes]
+            if not eager:
+                _upsert_nodes(session, neo4j, nodes)
+                continue
+            # The module id comes from the module's own row, never by splitting a
+            # declaration's id: a file key may itself contain '/'.
+            module_id = _module_id_of(nodes)
+            if module_id is None or not module_id.startswith(app_prefix):
+                raise ValueError(
+                    f"neo4j: module {m!r} has no can:// id under {app_prefix!r}; "
+                    "refusing to purge"
+                )
             with session() as s:
-                def _purge(tx, module=m, node_keys=keys):
-                    tx.run("MATCH (x {_module: $m})-[r]->() DELETE r", m=module)
-                    tx.run(
-                        "MATCH (x {_module: $m}) "
-                        "WHERE NOT coalesce(x.signature, x.id, x.file_key) IN $keys "
-                        "DETACH DELETE x",
-                        m=module,
-                        keys=node_keys,
-                    )
+                def _purge(tx, mid=module_id, node_keys=keys):
+                    params = {"mid": mid, "pre": descendant_prefix(mid)}
+                    tx.run(PURGE_MODULE_EDGES, **params)
+                    tx.run(PURGE_VANISHED_NODES, keys=node_keys, **params)
 
                 s.execute_write(_purge)
             _upsert_nodes(session, neo4j, nodes)
@@ -145,22 +195,21 @@ def bolt_writer(rows: GraphRows, cfg: BoltConfig, full_run: bool) -> None:
         _upsert_edges(session, neo4j, edges)
 
         # 6. orphan prune — only safe on a full run (a targeted run can't tell deleted from untargeted).
-        # Scope to THIS application's anchor so a full run for application B never
-        # deletes application A's modules from a shared database.
-        if full_run and app_name is not None:
-            present = list(by_module.keys())
+        # Scoped to ``can://python/<app>/`` so a full run for application B never deletes
+        # application A's modules from a shared database — even when both are python and
+        # share a module path.
+        if full_run and eager:
+            present = [mid for mid in (_module_id_of(ns) for ns in by_module.values()) if mid]
             with session() as s:
-                res = s.run(
-                    "MATCH (:PyApplication {name: $app})-[:PY_HAS_MODULE]->(m:PyModule) "
-                    "WHERE NOT m.file_key IN $present "
-                    f"OPTIONAL MATCH (m)-{DESCENDANTS}->(x) DETACH DELETE x, m "
-                    "RETURN count(m) AS pruned",
-                    app=app_name,
-                    present=present,
-                )
+                res = s.run(PRUNE_VANISHED_MODULES, app=app_prefix, present=present)
                 pruned = res.single()
                 pruned_count = pruned["pruned"] if pruned else 0
                 logger.info(f"neo4j(bolt): pruned {pruned_count} vanished module(s)")
+        elif not eager:
+            logger.info(
+                "neo4j(bolt): additive push (--lazy) — nothing deleted; "
+                "re-run with --eager to reconcile removed declarations and edges"
+            )
         else:
             logger.info(
                 "neo4j(bolt): targeted run — orphan pruning skipped (deleted files not removed)"
@@ -234,12 +283,19 @@ def _upsert_edges(session, neo4j, edges: List[EdgeRow]) -> None:
 # ----------------------------------------------------------------------------------------------
 
 
-def _hash_of(nodes: List[NodeRow], file_key: str) -> Optional[str]:
-    for n in nodes:
-        if n.labels[0] == "PyModule" and n.value == file_key:
-            h = n.props.get("content_hash")
-            return h if isinstance(h, str) else None
-    return None
+def _module_row(nodes: List[NodeRow]) -> Optional[NodeRow]:
+    return next((n for n in nodes if n.labels[0] == "PyModule"), None)
+
+
+def _module_id_of(nodes: List[NodeRow]) -> Optional[str]:
+    row = _module_row(nodes)
+    return row.value if row is not None else None
+
+
+def _hash_of(nodes: List[NodeRow]) -> Optional[str]:
+    row = _module_row(nodes)
+    h = row.props.get("content_hash") if row is not None else None
+    return h if isinstance(h, str) else None
 
 
 def _to_params(props, neo4j) -> dict:

codeanalyzer/neo4j/cypher.py

@@ -28,9 +28,11 @@ from __future__ import annotations
 from typing import Dict, List
 
 from codeanalyzer.neo4j.rows import (
+    CAN_NODE,
     EdgeRow,
     GraphRows,
     NodeRow,
+    application_prefix,
     chunk,
     cypher_map,
     cypher_value,
@@ -66,13 +68,17 @@ def render_cypher(rows: GraphRows, app_name: str) -> str:
 
 
 def _wipe(app_name: str) -> str:
+    """Everything under ``can://python/<app>/`` plus the application anchor (#173).
+    Scoped by id prefix, so it is one language and one application by construction —
+    a second python app sharing a module path, a sibling analyzer's graph, and the
+    cross-language :Artifact / :Package nodes are all outside it."""
+    prefix = cypher_value(application_prefix(app_name))
     name = cypher_value(app_name)
     return "\n".join(
         [
-            f"MATCH (a:PyApplication {{name: {name}}})",
-            "OPTIONAL MATCH (a)-[:PY_HAS_MODULE]->(m:PyModule)",
-            "OPTIONAL MATCH (m)-[:PY_DECLARES|PY_HAS_METHOD|PY_HAS_ATTRIBUTE|PY_DECLARES_VAR|PY_HAS_CALLSITE*1..]->(x)",
-            "DETACH DELETE x, m, a;",
+            f"MATCH (x:{CAN_NODE}) WHERE x.id STARTS WITH {prefix}",
+            "CALL { WITH x DETACH DELETE x } IN TRANSACTIONS OF 1000 ROWS;",
+            f"MATCH (a:PyApplication {{name: {name}}}) DETACH DELETE a;",
         ]
     )
 

codeanalyzer/neo4j/emit.py

@@ -67,9 +67,10 @@ def emit_neo4j(analysis: Analysis, options: AnalysisOptions) -> None:
             password=options.neo4j_password,
             database=options.neo4j_database,
         )
-        # A full run (no single-file restriction) makes orphan pruning safe.
+        # A full run (no single-file restriction) makes orphan pruning safe; --eager
+        # is what permits any deletion at all (#171).
         full_run = options.file_name is None
-        bolt_writer(rows, cfg, full_run)
+        bolt_writer(rows, cfg, full_run, eager=options.rebuild_analysis)
         return
 
     out_dir = options.output if options.output is not None else Path.cwd()

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, global_ordinal, purl_pypi
 from codeanalyzer.schema.py_schema import PyDecorator
 
 
@@ -70,6 +72,13 @@ def project(app: PyApplication, app_name: str, sig_to_id: dict,
                 "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 +96,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 +120,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 +139,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 +147,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 +216,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
@@ -309,7 +316,6 @@ def _project_artifacts(b: RowBuilder, app: PyApplication, app_name: str, app_ref
                     "size_bytes": art.size_bytes,
                     "sha256": art.sha256,
                     "source": art.source,
-                    "text_truncated": art.text_truncated,
                     "extraction": art.extraction,
                 }
             ),
@@ -400,6 +406,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`).
@@ -429,7 +436,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,
@@ -454,8 +461,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 = f"{app_can_id}/@external/{module}/{name}" if module else f"{app_can_id}/@external/{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
@@ -485,13 +538,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)
 
 
 # ----------------------------------------------------------------------------------------------
@@ -501,16 +548,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)
 
 
@@ -576,7 +624,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)
@@ -588,20 +636,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"],
@@ -615,18 +664,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)
 
@@ -635,10 +688,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

@@ -50,6 +50,35 @@ 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://python/`` 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 language, application and module.
+CAN_NODE = "PyCanNode"
+_PY_CAN_PREFIX = "can://python/"
+
+
+def descendant_prefix(can_id: str) -> str:
+    """The prefix that matches a node's descendants and nothing else. The separator
+    is the point: ``can://python/app/src/foo.py`` is also a prefix of
+    ``can://python/app/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://python/<app>/`` — the scope of every destructive statement. Refuses an
+    empty application: ``STARTS WITH ''`` would match every node in the database."""
+    if not app_name:
+        raise ValueError("neo4j: refusing a destructive statement without an application id")
+    return descendant_prefix(f"{_PY_CAN_PREFIX}{app_name}")
 
 
 @dataclass
@@ -100,14 +129,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(_PY_CAN_PREFIX) 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)