feat(neo4j): namespace labels, lossless projection, and a driver-free Bolt seam (#154)

Brings the Java Neo4j backend to parity with the Python/TypeScript siblings and
makes it a lossless projection of the IR.

Namespacing (so a Java graph can share a Neo4j DB with Py*/TS* graphs):
- all node labels J-prefixed, all relationship types J_-prefixed, constraint/index
  names j_-prefixed.
- provenance property renamed _unit -> _module (matches the siblings).
- --emit schema now writes schema.neo4j.json (matches the checked-in contract);
  release asset + README updated.
- NEO4J_URI/USERNAME/PASSWORD/DATABASE env-var fallback (flag > env > default).

Lossless projection (every Lombok entity field is represented):
- new first-class nodes :JInitializationBlock, :JCrudOperation, :JCrudQuery,
  :JComment, with J_HAS_INIT_BLOCK / J_HAS_CRUD_OPERATION / J_HAS_CRUD_QUERY /
  J_HAS_COMMENT and J_HAS_CALLSITE/J_DECLARES_VAR extended to init blocks.
- added scalar props: is_modified, file_path (callable), variable_initializers_json,
  default_value, argument_expr, is_unspecified, start/end_column on params & vars,
  docstrings, and source_kind/destination_kind on J_CALLS.
- CypherWriter.DESCENDANTS extended so the scoped wipe / orphan prune reach the new
  containment edges.

Packaging seam (lets the GraalVM native image prune the driver):
- BoltConfig + BoltSink extracted as driver-free core types; BoltWriter is the only
  class importing org.neo4j.driver.* and is loaded reflectively by Neo4jEmitter, so
  the fat jar bundles the driver (live Bolt push works) while native-image, which
  never statically references it, falls back to writing graph.cypher.

Schema contract regenerated (16 node labels, 20 relationship types, 15 constraints);
conformance test updated; neo4j-schema.drawio refreshed to the J-prefixed schema
with the call graph (J_CALLS / J_RESOLVES_TO) drawn explicitly.

Author: rahlk

.github/workflows/release.yml

@@ -52,7 +52,7 @@ jobs:
           mkdir -p release-assets
           cp build/libs/codeanalyzer-${{ steps.ver.outputs.version }}.jar release-assets/codeanalyzer.jar
           cp build/libs/codeanalyzer-${{ steps.ver.outputs.version }}.jar "release-assets/codeanalyzer-${{ steps.ver.outputs.version }}.jar"
-          java -jar build/libs/codeanalyzer-${{ steps.ver.outputs.version }}.jar --emit schema > release-assets/schema.json
+          java -jar build/libs/codeanalyzer-${{ steps.ver.outputs.version }}.jar --emit schema > release-assets/schema.neo4j.json
           cp packaging/install/codeanalyzer-installer.sh release-assets/codeanalyzer-installer.sh
           ls -lh release-assets
 
@@ -88,7 +88,7 @@ jobs:
             echo "| --- | --- |"
             echo "| \`codeanalyzer.jar\` | Self-contained analyzer (run with \`java -jar\`) |"
             echo "| \`codeanalyzer-installer.sh\` | Installer that fetches the jar and adds a \`codeanalyzer\` launcher |"
-            echo "| \`schema.json\` | Neo4j graph schema contract (node labels, relationships, DDL) |"
+            echo "| \`schema.neo4j.json\` | Neo4j graph schema contract (node labels, relationships, DDL) |"
             echo
             echo "---"
             echo
@@ -101,7 +101,7 @@ jobs:
           files: |
             release-assets/codeanalyzer.jar
             release-assets/codeanalyzer-${{ steps.ver.outputs.version }}.jar
-            release-assets/schema.json
+            release-assets/schema.neo4j.json
             release-assets/codeanalyzer-installer.sh
           body_path: release-notes.md
         env:

README.md

@@ -105,18 +105,20 @@ Analyze java application.
   -b, --build-cmd=<build>    Custom build command. Defaults to auto build.
       --no-build             Do not build your application (use if already built).
   -a, --analysis-level=<n>   Level of analysis: 1 (symbol table) or 2 (call graph).
-                               Default: 1. Level 2 adds CALLS edges to the graph.
+                               Default: 1. Level 2 adds J_CALLS edges to the graph.
   -t, --target-files=<f>...  Restrict analysis to specific files (incremental).
       --emit=<emit>          Output target: json (analysis.json, default) |
                                neo4j (graph.cypher or live Bolt push) |
-                               schema (the Neo4j schema.json contract).
-      --app-name=<name>      Logical application name for the graph :Application
+                               schema (the Neo4j schema.neo4j.json contract).
+      --app-name=<name>      Logical application name for the graph :JApplication
                                anchor (default: input dir name).
       --neo4j-uri=<uri>      Push the graph to a live Neo4j over Bolt (incremental);
-                               omit to write graph.cypher.
-      --neo4j-user=<user>    Neo4j username (default: neo4j).
-      --neo4j-password=<pw>  Neo4j password (default: neo4j).
-      --neo4j-database=<db>  Neo4j database name (default: server default).
+                               omit to write graph.cypher. Falls back to the
+                               NEO4J_URI environment variable.
+      --neo4j-user=<user>    Neo4j username (env: NEO4J_USERNAME, default: neo4j).
+      --neo4j-password=<pw>  Neo4j password (env: NEO4J_PASSWORD, default: neo4j).
+      --neo4j-database=<db>  Neo4j database name (env: NEO4J_DATABASE, default:
+                               server default).
   -v, --verbose              Print logs to console.
   -h, --help                 Show this help message and exit.
   -V, --version              Print version information and exit.
@@ -188,14 +190,20 @@ This will produce print the SDG on the console. Explore other flags to save the
 ## 4. Neo4j graph output
 
 `codeanalyzer` can project the analysis IR into a [Neo4j](https://neo4j.com/) property graph instead
-of `analysis.json`. The graph models the same information — compilation units, types, callables,
-fields, parameters, call sites, variables, enum constants, record components, annotations, packages —
-as first-class nodes and relationships, and (at `-a 2`) adds `CALLS` edges from the call graph.
+of `analysis.json`. The graph is a **lossless** projection of the IR: compilation units, types,
+callables, fields, parameters, call sites, variables, enum constants, record components,
+initialization blocks, CRUD operations/queries, comments, annotations and packages are all
+first-class nodes and relationships, and (at `-a 2`) it adds `J_CALLS` edges from the call graph.
+Every field of the Lombok entity model is represented (scalars as node properties — maps such as a
+field's per-variable initializers are kept as a `*_json` property since Neo4j has no map type;
+comments are `:JComment` nodes in addition to the convenience `docstring` property).
 
 The full contract (node labels, their keys and typed properties, relationship types and endpoints,
 plus the constraint/index DDL) lives in [`schema.neo4j.json`](./schema.neo4j.json) and is visualized
-in [`neo4j-schema.drawio`](./neo4j-schema.drawio). `SCHEMA_VERSION` is stamped onto the
-`:Application` node of every emitted graph.
+in [`neo4j-schema.drawio`](./neo4j-schema.drawio). All node labels are `J`-prefixed and relationship
+types `J_`-prefixed (e.g. `:JType`, `:JCallable`, `J_CALLS`) so a Java graph can share a Neo4j
+database with the Python (`Py*`/`PY_*`) and TypeScript (`TS*`/`TS_*`) backends without colliding.
+`SCHEMA_VERSION` is stamped onto the `:JApplication` node of every emitted graph.
 
 ### 4.1. Cypher snapshot (no database required)
 
@@ -223,7 +231,7 @@ compilation unit's `content_hash`, replaces just the changed units' subgraphs (i
 ### 4.3. Schema contract
 
 ```sh
-codeanalyzer --emit schema -o ./out   # → ./out/schema.json (no project analysis needed)
+codeanalyzer --emit schema -o ./out   # → ./out/schema.neo4j.json (no project analysis needed)
 codeanalyzer --emit schema            # → prints the contract to stdout
 ```
 

build.gradle

@@ -125,7 +125,10 @@ dependencies {
     implementation('com.github.javaparser:javaparser-core:3.26.3')
 
     // Neo4j Bolt driver for `--emit neo4j --neo4j-uri ...` (live incremental graph push).
-    // 4.4.x retains Java 8/11 compatibility for the GraalVM native-image build.
+    // Bundled into the fat jar so `java -jar` supports live push out of the box. It is reached ONLY
+    // reflectively, via the BoltSink seam (see Neo4jEmitter#loadBoltSink), so the GraalVM native image
+    // prunes BoltWriter and never compiles the driver + Netty into the binary — the native build stays
+    // small and Netty-metadata-free, and `--neo4j-uri` there falls back to a graph.cypher snapshot.
     implementation('org.neo4j.driver:neo4j-java-driver:4.4.12')
 
     // TestContainers