feat(entrypoints): end-to-end detection and Neo4j projection (#27)

Adds the local-decorator fixture and e2e test proving detection through
the real CLI, including the --entrypoint-rules path. The fixture ships
a requirements.txt naming its detect package so Stage 0 exercises the
manifest-detection path (no other test covers it).

Projects is_entrypoint/entrypoint_frameworks onto :PyCallable and
:PyClass in the Neo4j schema and row builder, and regenerates the
schema snapshot.

Author: rahlk

codeanalyzer/neo4j/project.py

@@ -517,6 +517,8 @@ def _class_props(cl: PyClass, file_key: str, source: str) -> Props:
             "start_line": cl.start_line,
             "end_line": cl.end_line,
             "_module": file_key,
+            "is_entrypoint": bool(cl.entrypoints),
+            "entrypoint_frameworks": sorted({e.framework for e in (cl.entrypoints or [])}),
         }
     )
 
@@ -539,6 +541,8 @@ def _callable_props(c: PyCallable, file_key: str, source: str) -> Props:
             "parameters_json": _stringify_if(c.parameters),
             "accessed_symbols_json": _stringify_if(c.accessed_symbols),
             "_module": file_key,
+            "is_entrypoint": bool(c.entrypoints),
+            "entrypoint_frameworks": sorted({e.framework for e in (c.entrypoints or [])}),
         }
     )
 

codeanalyzer/neo4j/schema.py

@@ -105,6 +105,8 @@ class RelType:
             "docstring": "string",
             **_SPAN,
             "_module": "string",
+            "is_entrypoint": "boolean",
+            "entrypoint_frameworks": "string[]",
         },
     ),
     NodeLabel(
@@ -126,6 +128,8 @@ class RelType:
             "parameters_json": "string",
             "accessed_symbols_json": "string",
             "_module": "string",
+            "is_entrypoint": "boolean",
+            "entrypoint_frameworks": "string[]",
         },
     ),
     NodeLabel(

schema.neo4j.json

@@ -45,7 +45,9 @@
         "docstring": "string",
         "start_line": "integer",
         "end_line": "integer",
-        "_module": "string"
+        "_module": "string",
+        "is_entrypoint": "boolean",
+        "entrypoint_frameworks": "string[]"
       }
     },
     {
@@ -67,7 +69,9 @@
         "decorators": "string[]",
         "parameters_json": "string",
         "accessed_symbols_json": "string",
-        "_module": "string"
+        "_module": "string",
+        "is_entrypoint": "boolean",
+        "entrypoint_frameworks": "string[]"
       }
     },
     {

test/fixtures/single_functionalities/entrypoints_local/app.py

@@ -0,0 +1,15 @@
+def route(path, methods=None):
+    """Stands in for a framework's routing decorator."""
+    def deco(fn):
+        return fn
+    return deco
+
+
+@route("/products", methods=["POST"])
+def create_product():
+    return helper()
+
+
+def helper():
+    """Called only internally - must NOT be flagged."""
+    return {}

test/fixtures/single_functionalities/entrypoints_local/requirements.txt

@@ -0,0 +1 @@
+app

test/fixtures/single_functionalities/entrypoints_local/rules.yml

@@ -0,0 +1,9 @@
+version: 1
+frameworks:
+  inhouse:
+    detect: [app]
+    decorators:
+      - id: inhouse.route
+        match: "app.route"
+        route: {from: positional, index: 0}
+        methods: {from: keyword, name: methods, default: [GET]}

test/test_entrypoints_e2e.py

@@ -0,0 +1,49 @@
+"""End-to-end coverage: entrypoint detection driven through the real CLI,
+including the ``--entrypoint-rules`` user-rules path (#27).
+
+A local decorator (not Flask) so matching resolves deterministically via
+Jedi without a venv/network dependency -- see the fixture's ``rules.yml``
+for why. The fixture also carries a ``requirements.txt`` naming ``app`` so
+Stage 0 detection has a real manifest signal to key off of (the fixture
+module is not imported by anything, so an import scan alone would never
+see it).
+"""
+import json
+import subprocess
+from pathlib import Path
+
+FIXTURE = Path(__file__).parent / "fixtures" / "single_functionalities" / "entrypoints_local"
+
+
+def test_decorated_function_flagged_and_helper_not(tmp_path):
+    subprocess.run(
+        [
+            "uv", "run", "canpy",
+            "-i", str(FIXTURE),
+            "-a", "1",
+            "-o", str(tmp_path),
+            "--no-venv",
+            # Cache defaults to the input dir; keep it in tmp_path so the
+            # checked-in fixture directory is never mutated by a test run
+            # and each run starts from a clean (entrypoint-free) cache.
+            "--cache-dir", str(tmp_path / "cache"),
+            "--entrypoint-rules", str(FIXTURE / "rules.yml"),
+        ],
+        check=True,
+    )
+    data = json.loads((tmp_path / "analysis.json").read_text())
+    fns = data["application"]["symbol_table"]["app.py"]["functions"]
+
+    create = fns["create_product"]
+    assert create["is_entrypoint"] is True
+    (ep,) = create["entrypoints"]
+    assert ep["framework"] == "inhouse" and ep["rule"] == "inhouse.route"
+    assert ep["route"] == "/products" and ep["http_methods"] == ["POST"]
+    assert ep["ruleset"].startswith("user:")
+
+    assert fns["helper"]["is_entrypoint"] is False
+    assert fns["helper"]["entrypoints"] == []
+
+    report = data["application"]["entrypoint_report"]
+    assert "inhouse" in report["frameworks_detected"]
+    assert report["errors"] == []