feat(neo4j): namespace all node labels (Py*) and relationship types (PY_*)

In a shared Neo4j instance, unprefixed labels and relationship types from
different language analyzers collide: `MERGE (:Application {name})` and
`:Symbol`/`HAS_MODULE` from a future Java/JS backend would fuse with Python's.
Labels and relationship types are separate Neo4j namespaces, so both are
prefixed — every node label gets `Py` (e.g. `:PyClass`, shared MERGE label
`:PySymbol`) and every relationship type gets `PY_` (e.g. `PY_CALLS`).
Constraint/index names are also globally unique per-DB, so they get a `py_`
prefix too.

- catalog.py: the source-of-truth labels, merge labels, and rel types
- schema.py: DDL label refs + constraint/index names
- project.py, cypher.py, bolt.py, rows.py: emitter + both writers
- tests, sample app, README, CHANGELOG, --app-name help, schema.neo4j.json
- neo4j-schema.drawio: new property-graph diagram; schema-uml.drawio: relayout

SCHEMA_VERSION stays 1.0.0 (the schema is new on this branch — no released
consumer has seen the unprefixed 1.0.0).

Author: rahlk

CHANGELOG.md

@@ -8,10 +8,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.2.0] - 2026-06-20
 
 ### Added
-- **Neo4j property-graph output** (`--emit neo4j`). The same in-memory analysis (`PyApplication`) is projected to a labeled property graph, mirroring the `codeanalyzer-typescript` backend. Two writers:
+- **Neo4j property-graph output** (`--emit neo4j`). The same in-memory analysis (`PyApplication`) is projected to a labeled property graph, mirroring the `codeanalyzer-typescript` backend. Node labels are `Py`-prefixed and relationship types are `PY_`-prefixed (e.g. `:PyClass`, `PY_CALLS`) so multiple language analyzers can coexist in one database without label or relationship-type collisions. Two writers:
   - **`graph.cypher` snapshot** (default) — a self-contained Cypher script (constraints + indexes, a scoped wipe of the project's prior subgraph, then batched `UNWIND … MERGE`). Load it with `cypher-shell < graph.cypher`. Needs no extra dependencies.
   - **Live Bolt push** (`--neo4j-uri`) — an **incremental** writer: only modules whose `content_hash` changed are rewritten, and on a full run modules whose source file vanished are pruned. Requires the optional `neo4j` driver (`pip install 'codeanalyzer-python[neo4j]'`).
-- **`--emit schema`** — emit the machine-readable, version-stamped Neo4j schema contract (`schema.json`: node labels, relationships, properties, constraints, indexes). Needs no project; bundled in every release as a GitHub Release asset and checked in as `schema.neo4j.json`. A `schema_version` (`1.0.0`) is stamped onto every graph's `:Application` node.
+- **`--emit schema`** — emit the machine-readable, version-stamped Neo4j schema contract (`schema.json`: node labels, relationships, properties, constraints, indexes). Needs no project; bundled in every release as a GitHub Release asset and checked in as `schema.neo4j.json`. A `schema_version` (`1.0.0`) is stamped onto every graph's `:PyApplication` node.
 - **New CLI options** mirroring the TypeScript analyzer's entrypoints: `--emit {json,neo4j,schema}`, `--app-name`, `--neo4j-uri`, `--neo4j-user`, `--neo4j-password`, `--neo4j-database`. `-i/--input` is now optional (not required for `--emit schema`). The four Neo4j connection options also read from the standard `NEO4J_URI` / `NEO4J_USERNAME` / `NEO4J_PASSWORD` / `NEO4J_DATABASE` environment variables when the flag is omitted (an explicit flag wins), so the password need not appear in shell history or the process list.
 - **`codeanalyzer.neo4j`** package: `catalog` (the single source-of-truth schema catalog), `project` (pure IR → graph rows), `cypher` (snapshot writer), `bolt` (incremental writer), and `rows` (the output-agnostic intermediate).
 - **Schema conformance test** (`test/test_neo4j_schema.py`, always runs) — asserts the emitter never produces a label/relationship/property the catalog doesn't declare, and that the checked-in `schema.neo4j.json` is regenerated.

README.md

@@ -94,7 +94,7 @@ To view the available options and commands, run `codeanalyzer --help`. You shoul
 │    --format          -f                  [json|msgpack]  Output format for --emit json: json or msgpack. [default: json]      │
 │    --emit                                [json|neo4j|    Output target: json (analysis.json) | neo4j (graph.cypher or live    │
 │                                           schema]         Bolt push) | schema (the Neo4j schema.json contract). [default: json]│
-│    --app-name                            TEXT            Logical application name for the graph :Application anchor.          │
+│    --app-name                            TEXT            Logical application name for the graph :PyApplication anchor.          │
 │    --neo4j-uri                           TEXT            Push the graph to a live Neo4j over Bolt. [env: NEO4J_URI]            │
 │    --neo4j-user                          TEXT            Neo4j username. [env: NEO4J_USERNAME] [default: neo4j]               │
 │    --neo4j-password                      TEXT            Neo4j password. [env: NEO4J_PASSWORD] [default: neo4j]               │
@@ -176,12 +176,12 @@ By default this is printed to stdout in JSON; with `--output` it is written to `
 
 ### Neo4j graph
 
-`--emit neo4j` projects the same analysis into a labeled property graph (declarations keyed by their signature under a shared `:Symbol` label; calls, imports, inheritance, decorators, and call sites as relationships):
+`--emit neo4j` projects the same analysis into a labeled property graph. Every node label is `Py`-prefixed and every relationship type is `PY_`-prefixed (e.g. `:PyClass`, `PY_CALLS`) so multiple language analyzers can share one database without label or relationship-type collisions. Declarations are keyed by their signature under a shared `:PySymbol` label; calls, imports, inheritance, decorators, and call sites are relationships:
 
 - **Without `--neo4j-uri`** — writes a self-contained `graph.cypher` (constraints + indexes, a scoped wipe, then batched `MERGE`s). Load it with `cypher-shell < graph.cypher`. Needs no extra dependencies.
-- **With `--neo4j-uri`** — pushes to a live Neo4j over Bolt **incrementally**: only modules whose content hash changed are rewritten, and on a full run modules whose source file vanished are pruned. Requires the `neo4j` extra. Every graph carries a `schema_version` on its `:Application` node.
+- **With `--neo4j-uri`** — pushes to a live Neo4j over Bolt **incrementally**: only modules whose content hash changed are rewritten, and on a full run modules whose source file vanished are pruned. Requires the `neo4j` extra. Every graph carries a `schema_version` on its `:PyApplication` node.
 
-Call-graph endpoints that aren't present in the symbol table (third-party / framework / RPC targets) are materialized as `:External` ghost nodes, mirroring the analyzer's own ghost-node behaviour.
+Call-graph endpoints that aren't present in the symbol table (third-party / framework / RPC targets) are materialized as `:PyExternal` ghost nodes, mirroring the analyzer's own ghost-node behaviour.
 
 The connection options also read from the standard Neo4j environment variables — `NEO4J_URI`, `NEO4J_USERNAME`, `NEO4J_PASSWORD`, `NEO4J_DATABASE` — when the corresponding flag is omitted (an explicit flag wins). Prefer the env var for the password so it doesn't land in shell history or the process list:
 

codeanalyzer/__main__.py

@@ -45,7 +45,7 @@ def main(
         Optional[str],
         typer.Option(
             "--app-name",
-            help="Logical application name for the graph :Application anchor "
+            help="Logical application name for the graph :PyApplication anchor "
             "(default: input dir name).",
         ),
     ] = None,

codeanalyzer/neo4j/bolt.py

@@ -29,7 +29,7 @@
 
 Nodes are MERGE-upserted, never blindly deleted, so a declaration another
 (unchanged) module still references survives and its incoming edges stay valid.
-``:External`` / ``:Package`` / ``:Decorator`` are shared (no ``_module``) and are
+``:PyExternal`` / ``:PyPackage`` / ``:PyDecorator`` are shared (no ``_module``) and are
 MERGE-only.
 
 The ``neo4j`` driver is imported lazily so it stays an optional dependency and
@@ -44,7 +44,7 @@
 from codeanalyzer.neo4j.schema import CONSTRAINTS, INDEXES
 from codeanalyzer.utils import logger
 
-DESCENDANTS = "[:DECLARES|HAS_METHOD|HAS_ATTRIBUTE|DECLARES_VAR|HAS_CALLSITE*1..]"
+DESCENDANTS = "[:PY_DECLARES|PY_HAS_METHOD|PY_HAS_ATTRIBUTE|PY_DECLARES_VAR|PY_HAS_CALLSITE*1..]"
 BATCH = 1000
 
 
@@ -92,7 +92,7 @@ def session():
         # 2. diff content_hash.
         db_hash: Dict[str, Optional[str]] = {}
         with session() as s:
-            res = s.run("MATCH (m:Module) RETURN m.file_key AS k, m.content_hash AS h")
+            res = s.run("MATCH (m:PyModule) RETURN m.file_key AS k, m.content_hash AS h")
             for rec in res:
                 db_hash[rec["k"]] = rec["h"]
         changed = set()
@@ -139,7 +139,7 @@ def _purge(tx, module=m, node_keys=keys):
             present = list(by_module.keys())
             with session() as s:
                 res = s.run(
-                    "MATCH (m:Module) WHERE NOT m.file_key IN $present "
+                    "MATCH (m:PyModule) WHERE NOT m.file_key IN $present "
                     f"OPTIONAL MATCH (m)-{DESCENDANTS}->(x) DETACH DELETE x, m "
                     "RETURN count(m) AS pruned",
                     present=present,
@@ -210,7 +210,7 @@ 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] == "Module" and n.value == file_key:
+        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

codeanalyzer/neo4j/catalog.py

@@ -24,7 +24,7 @@
 
 SCHEMA_VERSION is the contract version: bump MAJOR on a breaking change
 (renamed/removed label, relationship or key), MINOR on an additive change (new
-label/rel/property). It is stamped onto the ``:Application`` node of every
+label/rel/property). It is stamped onto the ``:PyApplication`` node of every
 emitted graph so any consumer can detect a producer/consumer mismatch at runtime.
 """
 from __future__ import annotations
@@ -63,14 +63,14 @@ class RelType:
 
 NODE_LABELS: List[NodeLabel] = [
     NodeLabel(
-        "Application",
-        "Application",
+        "PyApplication",
+        "PyApplication",
         "name",
         {"name": "string", "schema_version": "string"},
     ),
     NodeLabel(
-        "Module",
-        "Module",
+        "PyModule",
+        "PyModule",
         "file_key",
         {
             "file_key": "string",
@@ -82,8 +82,8 @@ class RelType:
         },
     ),
     NodeLabel(
-        "Class",
-        "Symbol",
+        "PyClass",
+        "PySymbol",
         "signature",
         {
             "signature": "string",
@@ -96,8 +96,8 @@ class RelType:
         },
     ),
     NodeLabel(
-        "Callable",
-        "Symbol",
+        "PyCallable",
+        "PySymbol",
         "signature",
         {
             "signature": "string",
@@ -116,21 +116,21 @@ class RelType:
         },
     ),
     NodeLabel(
-        "External",
-        "Symbol",
+        "PyExternal",
+        "PySymbol",
         "signature",
         {"signature": "string", "name": "string"},
     ),
-    NodeLabel("Package", "Package", "name", {"name": "string"}),
+    NodeLabel("PyPackage", "PyPackage", "name", {"name": "string"}),
     NodeLabel(
-        "Decorator",
-        "Decorator",
+        "PyDecorator",
+        "PyDecorator",
         "name",
         {"name": "string"},
     ),
     NodeLabel(
-        "CallSite",
-        "CallSite",
+        "PyCallSite",
+        "PyCallSite",
         "id",
         {
             "id": "string",
@@ -149,8 +149,8 @@ class RelType:
         },
     ),
     NodeLabel(
-        "Attribute",
-        "Attribute",
+        "PyAttribute",
+        "PyAttribute",
         "id",
         {
             "id": "string",
@@ -162,8 +162,8 @@ class RelType:
         },
     ),
     NodeLabel(
-        "Variable",
-        "Variable",
+        "PyVariable",
+        "PyVariable",
         "id",
         {
             "id": "string",
@@ -177,31 +177,31 @@ class RelType:
     ),
 ]
 
-_DECL_TARGETS = ["Class", "Callable"]
+_DECL_TARGETS = ["PyClass", "PyCallable"]
 
 
 REL_TYPES: List[RelType] = [
-    RelType("HAS_MODULE", ["Application"], ["Module"]),
-    RelType("DECLARES", ["Module", "Class", "Callable"], _DECL_TARGETS),
-    RelType("HAS_METHOD", ["Class"], ["Callable"]),
-    RelType("HAS_ATTRIBUTE", ["Class"], ["Attribute"]),
-    RelType("DECLARES_VAR", ["Module", "Callable"], ["Variable"]),
-    RelType("HAS_CALLSITE", ["Callable"], ["CallSite"]),
-    RelType("RESOLVES_TO", ["CallSite"], ["Callable", "External"]),
+    RelType("PY_HAS_MODULE", ["PyApplication"], ["PyModule"]),
+    RelType("PY_DECLARES", ["PyModule", "PyClass", "PyCallable"], _DECL_TARGETS),
+    RelType("PY_HAS_METHOD", ["PyClass"], ["PyCallable"]),
+    RelType("PY_HAS_ATTRIBUTE", ["PyClass"], ["PyAttribute"]),
+    RelType("PY_DECLARES_VAR", ["PyModule", "PyCallable"], ["PyVariable"]),
+    RelType("PY_HAS_CALLSITE", ["PyCallable"], ["PyCallSite"]),
+    RelType("PY_RESOLVES_TO", ["PyCallSite"], ["PyCallable", "PyExternal"]),
     RelType(
-        "CALLS",
-        ["Callable", "External"],
-        ["Callable", "External"],
+        "PY_CALLS",
+        ["PyCallable", "PyExternal"],
+        ["PyCallable", "PyExternal"],
         {"weight": "integer", "provenance": "string[]"},
     ),
-    RelType("EXTENDS", ["Class"], ["Class"]),
+    RelType("PY_EXTENDS", ["PyClass"], ["PyClass"]),
     RelType(
-        "IMPORTS",
-        ["Module"],
-        ["Package"],
+        "PY_IMPORTS",
+        ["PyModule"],
+        ["PyPackage"],
         {"imported_names": "string[]", "aliases": "string[]"},
     ),
-    RelType("DECORATED_BY", ["Callable"], ["Decorator"]),
+    RelType("PY_DECORATED_BY", ["PyCallable"], ["PyDecorator"]),
 ]
 
 

codeanalyzer/neo4j/cypher.py

@@ -69,9 +69,9 @@ def _wipe(app_name: str) -> str:
     name = cypher_value(app_name)
     return "\n".join(
         [
-            f"MATCH (a:Application {{name: {name}}})",
-            "OPTIONAL MATCH (a)-[:HAS_MODULE]->(m:Module)",
-            "OPTIONAL MATCH (m)-[:DECLARES|HAS_METHOD|HAS_ATTRIBUTE|DECLARES_VAR|HAS_CALLSITE*1..]->(x)",
+            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;",
         ]
     )