Merge pull request #105 from codellm-devkit/fix/issue-104-neo4j-code-property

fix(neo4j): derive the code property from module source spans

Author: rahlk

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- **Neo4j `code` property was silently null** (#104): schema v2 removed the per-node `code`
+  field (source lives once on `PyModule.source`, sliced by spans), but the Neo4j projection
+  still read the old field — every `:PyClass`/`:PyCallable` node was written without `code`,
+  deadening the `py_code_fts` fulltext index and the SDK's `RETURN c.code` queries. The
+  projection now derives `code` at projection time by slicing the owning module's source
+  with the node's utf-8 byte span. Regression gate:
+  `test_projected_code_property_is_the_module_source_span_slice`.
+
 ## [1.0.1] - 2026-07-15
 
 ### Fixed

codeanalyzer/neo4j/project.py

@@ -290,9 +290,11 @@ def _project_module_body(
     externals: dict, sig_to_id: dict, module_id_by_key: dict,
 ) -> None:
     for fn in (mod.functions or {}).values():
-        _project_callable(b, file_key, mod_ref, "PY_DECLARES", fn, externals, sig_to_id)
+        _project_callable(b, file_key, mod_ref, "PY_DECLARES", fn, externals, sig_to_id,
+                          mod.source)
     for cl in (mod.types or {}).values():
-        _project_class(b, file_key, mod_ref, "PY_DECLARES", cl, externals, sig_to_id)
+        _project_class(b, file_key, mod_ref, "PY_DECLARES", cl, externals, sig_to_id,
+                       mod.source)
     for v in mod.variables or []:
         _project_variable(b, file_key, mod_ref, file_key, v)
     _project_imports(b, mod_ref, mod, module_id_by_key)
@@ -360,10 +362,10 @@ 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,
+    externals: dict, sig_to_id: dict, source: str,
 ) -> None:
     ref = b.node(
-        ["PySymbol", "PyClass"], "id", cl.id, _class_props(cl, file_key)
+        ["PySymbol", "PyClass"], "id", cl.id, _class_props(cl, file_key, source)
     )
     b.edge(parent_rel, parent, ref)
 
@@ -372,22 +374,23 @@ def _project_class(
             b.edge_to_symbol("PY_EXTENDS", ref, _symbol_ref(base, externals, sig_to_id))
 
     for m in (cl.callables or {}).values():
-        _project_callable(b, file_key, ref, "PY_HAS_METHOD", m, externals, sig_to_id)
+        _project_callable(b, file_key, ref, "PY_HAS_METHOD", m, externals, sig_to_id,
+                          source)
     for a in (cl.attributes or {}).values():
         _project_attribute(b, file_key, ref, cl.signature, a)
     for ic in (cl.types or {}).values():
-        _project_class(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id)
+        _project_class(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id, source)
 
 
 def _project_callable(
     b: RowBuilder, file_key: str, owner: NodeRef, owner_rel: str, c: PyCallable,
-    externals: dict, sig_to_id: dict,
+    externals: dict, sig_to_id: dict, source: str,
 ) -> None:
     ref = b.node(
         ["PySymbol", "PyCallable"],
         "id",
         c.id,
-        _callable_props(c, file_key),
+        _callable_props(c, file_key, source),
     )
     b.edge(owner_rel, owner, ref)
 
@@ -410,9 +413,10 @@ def _project_callable(
     for v in c.local_variables or []:
         _project_variable(b, file_key, ref, c.signature, v)
     for ic in (c.callables or {}).values():
-        _project_callable(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id)
+        _project_callable(b, file_key, ref, "PY_DECLARES", ic, externals, sig_to_id,
+                          source)
     for cl in (c.types or {}).values():
-        _project_class(b, file_key, ref, "PY_DECLARES", cl, externals, sig_to_id)
+        _project_class(b, file_key, ref, "PY_DECLARES", cl, externals, sig_to_id, source)
 
 
 def _project_attribute(
@@ -459,13 +463,24 @@ def _module_props(mod: PyModule, file_key: str) -> Props:
     )
 
 
-def _class_props(cl: PyClass, file_key: str) -> Props:
+def _span_code(source: str, span) -> str | None:
+    """A declaration's text: the owning module's ``source`` sliced by the node's
+    utf-8 byte span. Schema v2 stores source once per module, so the graph's
+    ``code`` property (declared on :PyClass/:PyCallable and indexed by
+    ``py_code_fts``) is derived here at projection time (#104)."""
+    if span is None or not source:
+        return None
+    lo, hi = span.bytes
+    return source.encode("utf-8")[lo:hi].decode("utf-8")
+
+
+def _class_props(cl: PyClass, file_key: str, source: str) -> Props:
     return prune(
         {
             "id": cl.id,
             "signature": cl.signature,
             "name": cl.name,
-            "code": getattr(cl, "code", None),
+            "code": _span_code(source, cl.span),
             "base_classes": list(cl.base_classes or []),
             "docstring": _docstring_of(cl.comments),
             "start_line": cl.start_line,
@@ -475,7 +490,7 @@ def _class_props(cl: PyClass, file_key: str) -> Props:
     )
 
 
-def _callable_props(c: PyCallable, file_key: str) -> Props:
+def _callable_props(c: PyCallable, file_key: str, source: str) -> Props:
     return prune(
         {
             "id": c.id,
@@ -484,7 +499,7 @@ def _callable_props(c: PyCallable, file_key: str) -> Props:
             "path": c.path,
             "return_type": c.return_type,
             "cyclomatic_complexity": c.cyclomatic_complexity,
-            "code": getattr(c, "code", None),
+            "code": _span_code(source, c.span),
             "code_start_line": c.code_start_line,
             "start_line": c.start_line,
             "end_line": c.end_line,

test/test_v2_two_projection_agreement.py

@@ -207,3 +207,41 @@ def test_l4_param_summary_overlay_projects_onto_pycfgnode(tmp_path):
     assert any(
         e.type == "PY_DDG" and "prov" in e.props for e in rows.edges
     ), "expected a PY_DDG edge carrying a prov prop at -a 4"
+
+
+# ----------------------------------------------------------------------------------------------
+# Regression for #104: schema v2 dropped the per-node `code` field (source lives once on
+# PyModule.source, sliced by spans), but the graph schema still declares `code` on
+# :PyClass / :PyCallable and indexes it (py_code_fts). The projection must therefore
+# derive `code` at projection time — module source sliced by the node's byte span —
+# or code search in the graph and the SDK's `RETURN c.code` go silently null.
+# ----------------------------------------------------------------------------------------------
+
+
+def test_projected_code_property_is_the_module_source_span_slice():
+    from sample_graph_app import make_sample_app
+
+    app, sig_to_id = make_sample_app()
+    rows = project(app, "sample-app", sig_to_id)
+    by_id = {n.value: n for n in rows.nodes}
+
+    checked = 0
+    for mod in app.symbol_table.values():
+        src = mod.source.encode("utf-8")
+        stack = list((mod.functions or {}).values()) + list((mod.types or {}).values())
+        while stack:
+            decl = stack.pop()
+            stack += list((decl.callables or {}).values())
+            stack += list((decl.types or {}).values())
+            assert decl.span is not None, f"{decl.signature}: span missing at L1+"
+            lo, hi = decl.span.bytes
+            expected = src[lo:hi].decode("utf-8")
+            got = by_id[decl.id].props.get("code")
+            assert got == expected, (
+                f"{decl.signature}: projected code must be the span slice of "
+                f"module.source, got {got!r}"
+            )
+            checked += 1
+    # the sample app has functions, methods, an inner class and a subclass —
+    # if we checked fewer than that, the walk itself is broken.
+    assert checked >= 6