Fix serve to use Neo4j as primary query engine after enrich

Architecture fix:
- serve now queries Neo4j (enriched graph) as primary data source
- H2 fallback only when Neo4j is unavailable
- GraphBootstrapper auto-loads H2 into Neo4j on serve startup if graph empty
- CodeIqApplication sets graph.db path from codebase root for serve command

Controllers:
- GraphController: Neo4j-first for all 13 data endpoints, H2 fallback
- TopologyController: loads from Neo4j (has SERVICE nodes from enrich)
- FlowController: creates FlowEngine from GraphStore when Neo4j available

Startup:
- Suppress MCP scanner warnings (logging.level config)
- Suppress BeanPostProcessor warnings
- Reduce startup log verbosity in serving profile

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/CodeIqApplication.java

@@ -66,6 +66,32 @@ public static void main(String[] args) {
             if (portStr != null) {
                 System.setProperty("server.port", portStr);
             }
+
+            // Resolve codebase root so Neo4j points to the correct graph.db
+            String codebasePath = extractPositionalArg(args, "serve");
+            java.nio.file.Path root = java.nio.file.Path.of(
+                    codebasePath != null ? codebasePath : "."
+            ).toAbsolutePath().normalize();
+            System.setProperty("codeiq.root-path", root.toString());
+
+            // Check if enrich has been run (graph.db exists), otherwise
+            // check for the --graph flag override
+            String graphOverride = extractFlag(args, "--graph");
+            java.nio.file.Path graphDbPath;
+            if (graphOverride != null) {
+                graphDbPath = java.nio.file.Path.of(graphOverride).toAbsolutePath().normalize();
+            } else {
+                graphDbPath = root.resolve(".osscodeiq/graph.db");
+            }
+
+            if (java.nio.file.Files.isDirectory(graphDbPath)) {
+                // Enriched Neo4j graph exists -- point Neo4j config to it
+                System.setProperty("codeiq.graph.path", graphDbPath.toString());
+            } else {
+                // No enriched graph -- Neo4j will start with an empty db,
+                // GraphBootstrapper will auto-load from H2 cache if available
+                System.setProperty("codeiq.graph.path", graphDbPath.toString());
+            }
         } else if (isIndex) {
             app.setAdditionalProfiles("indexing");
             // Index command: no web server, no Neo4j

src/main/java/io/github/randomcodespace/iq/api/FlowController.java

@@ -4,7 +4,9 @@
 import io.github.randomcodespace.iq.config.CodeIqConfig;
 import io.github.randomcodespace.iq.flow.FlowEngine;
 import io.github.randomcodespace.iq.flow.FlowModels.FlowDiagram;
+import io.github.randomcodespace.iq.graph.GraphStore;
 import io.github.randomcodespace.iq.model.CodeNode;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Profile;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -33,10 +35,14 @@
 public class FlowController {
 
     private final FlowEngine flowEngine;
+    private final GraphStore graphStore;
     private final CodeIqConfig config;
 
-    public FlowController(Optional<FlowEngine> flowEngine, CodeIqConfig config) {
+    public FlowController(Optional<FlowEngine> flowEngine,
+                          @Autowired(required = false) GraphStore graphStore,
+                          CodeIqConfig config) {
         this.flowEngine = flowEngine.orElse(null);
+        this.graphStore = graphStore;
         this.config = config;
     }
 
@@ -106,6 +112,11 @@ private FlowEngine resolveEngine() {
             return flowEngine;
         }
 
+        // Prefer GraphStore (Neo4j) when available and populated
+        if (graphStore != null && graphStore.count() > 0) {
+            return new FlowEngine(graphStore);
+        }
+
         // Fall back to H2 cache
         Path root = Path.of(config.getRootPath()).toAbsolutePath().normalize();
         Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");

src/main/java/io/github/randomcodespace/iq/api/GraphController.java

@@ -4,6 +4,7 @@
 import io.github.randomcodespace.iq.analyzer.Analyzer;
 import io.github.randomcodespace.iq.cache.AnalysisCache;
 import io.github.randomcodespace.iq.config.CodeIqConfig;
+import io.github.randomcodespace.iq.graph.GraphStore;
 import io.github.randomcodespace.iq.model.CodeEdge;
 import io.github.randomcodespace.iq.model.CodeNode;
 import io.github.randomcodespace.iq.model.NodeKind;
@@ -42,6 +43,7 @@
 public class GraphController {
 
     private final QueryService queryService;
+    private final GraphStore graphStore;
     private final Analyzer analyzer;
     private final CodeIqConfig config;
     private final StatsService statsService;
@@ -51,10 +53,12 @@ public class GraphController {
     private volatile List<CodeEdge> cachedEdges;
 
     public GraphController(@org.springframework.beans.factory.annotation.Autowired(required = false) QueryService queryService,
+                           @org.springframework.beans.factory.annotation.Autowired(required = false) GraphStore graphStore,
                            Analyzer analyzer,
                            CodeIqConfig config, StatsService statsService,
                            TopologyService topologyService) {
         this.queryService = queryService;
+        this.graphStore = graphStore;
         this.analyzer = analyzer;
         this.config = config;
         this.statsService = statsService;
@@ -87,32 +91,61 @@ private void invalidateCache() {
         cachedEdges = null;
     }
 
+    /**
+     * Get nodes from the best available source: Neo4j first, H2 fallback.
+     * Returns null if neither source has data.
+     */
+    private List<CodeNode> getEffectiveNodes() {
+        if (graphStore != null && useNeo4j()) {
+            return graphStore.findAll();
+        }
+        ensureCacheLoaded();
+        return cachedNodes;
+    }
+
+    /**
+     * Get edges from the best available source: Neo4j first, H2 fallback.
+     * Returns null if neither source has data.
+     */
+    private List<CodeEdge> getEffectiveEdges() {
+        if (graphStore != null && useNeo4j()) {
+            // Collect all edges from Neo4j nodes
+            return graphStore.findAll().stream()
+                    .flatMap(n -> n.getEdges().stream())
+                    .toList();
+        }
+        ensureCacheLoaded();
+        return cachedEdges;
+    }
+
     @GetMapping("/stats")
     public Map<String, Object> getStats() {
+        if (useNeo4j()) {
+            return queryService.getStats();
+        }
         ensureCacheLoaded();
         if (cachedNodes != null) {
             return statsService.computeStats(cachedNodes, cachedEdges);
         }
-        if (queryService != null) {
-            return queryService.getStats();
-        }
         throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
                 "No analysis data available. Run analyze first.");
     }
 
     @GetMapping("/stats/detailed")
     public Map<String, Object> getDetailedStats(
             @RequestParam(defaultValue = "all") String category) {
-        ensureCacheLoaded();
-        if (cachedNodes == null) {
+        // Use Neo4j-backed stats if available, fall back to H2
+        List<CodeNode> nodes = getEffectiveNodes();
+        List<CodeEdge> edges = getEffectiveEdges();
+        if (nodes == null) {
             throw new ResponseStatusException(HttpStatus.NOT_FOUND,
-                    "No analysis cache found. Run analyze first.");
+                    "No analysis data found. Run analyze first.");
         }
 
         if ("all".equalsIgnoreCase(category)) {
-            return statsService.computeStats(cachedNodes, cachedEdges);
+            return statsService.computeStats(nodes, edges);
         }
-        Map<String, Object> catStats = statsService.computeCategory(cachedNodes, cachedEdges, category);
+        Map<String, Object> catStats = statsService.computeCategory(nodes, edges, category);
         if (catStats == null) {
             throw new ResponseStatusException(HttpStatus.BAD_REQUEST,
                     "Unknown category: " + category);
@@ -124,6 +157,9 @@ public Map<String, Object> getDetailedStats(
 
     @GetMapping("/kinds")
     public Map<String, Object> listKinds() {
+        if (useNeo4j()) {
+            return queryService.listKinds();
+        }
         ensureCacheLoaded();
         if (cachedNodes != null) {
             Map<String, Long> kindCounts = cachedNodes.stream()
@@ -144,7 +180,6 @@ public Map<String, Object> listKinds() {
             result.put("total", cachedNodes.size());
             return result;
         }
-        if (queryService != null) return queryService.listKinds();
         throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
                 "No data available. Run analyze first.");
     }
@@ -155,6 +190,9 @@ public Map<String, Object> nodesByKind(
             @RequestParam(defaultValue = "50") int limit,
             @RequestParam(defaultValue = "0") int offset) {
         int safeLimit = Math.min(limit, 1000);
+        if (useNeo4j()) {
+            return queryService.nodesByKind(kind, safeLimit, offset);
+        }
         ensureCacheLoaded();
         if (cachedNodes != null) {
             List<CodeNode> filtered = cachedNodes.stream()
@@ -170,7 +208,6 @@ public Map<String, Object> nodesByKind(
             result.put("nodes", filtered.subList(start, end).stream().map(this::nodeToMap).toList());
             return result;
         }
-        if (queryService != null) return queryService.nodesByKind(kind, safeLimit, offset);
         throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
                 "No data available. Run analyze first.");
     }
@@ -181,6 +218,9 @@ public Map<String, Object> listNodes(
             @RequestParam(defaultValue = "100") int limit,
             @RequestParam(defaultValue = "0") int offset) {
         int safeLimit = Math.min(limit, 1000);
+        if (useNeo4j()) {
+            return queryService.listNodes(kind, safeLimit, offset);
+        }
         ensureCacheLoaded();
         if (cachedNodes != null) {
             List<CodeNode> filtered = cachedNodes;
@@ -198,13 +238,15 @@ public Map<String, Object> listNodes(
             result.put("limit", safeLimit);
             return result;
         }
-        if (queryService != null) return queryService.listNodes(kind, safeLimit, offset);
         throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
                 "No data available. Run analyze first.");
     }
 
     @GetMapping("/nodes/find")
     public List<Map<String, Object>> findNode(@RequestParam String q) {
+        if (graphStore != null && useNeo4j()) {
+            return topologyService.findNode(q, graphStore.findAll());
+        }
         ensureCacheLoaded();
         if (cachedNodes == null) {
             return List.of();
@@ -214,7 +256,12 @@ public List<Map<String, Object>> findNode(@RequestParam String q) {
 
     @GetMapping("/nodes/{nodeId}/detail")
     public Map<String, Object> nodeDetail(@PathVariable String nodeId) {
-        // Try H2 cache first
+        // Try Neo4j first for rich detail with edges
+        if (useNeo4j()) {
+            Map<String, Object> result = queryService.nodeDetailWithEdges(nodeId);
+            if (result != null) return result;
+        }
+        // Fall back to H2 cache
         ensureCacheLoaded();
         if (cachedNodes != null) {
             return cachedNodes.stream()
@@ -223,12 +270,7 @@ public Map<String, Object> nodeDetail(@PathVariable String nodeId) {
                     .map(this::nodeToMap)
                     .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Node not found: " + nodeId));
         }
-        if (queryService == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Node not found: " + nodeId);
-        Map<String, Object> result = queryService.nodeDetailWithEdges(nodeId);
-        if (result == null) {
-            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Node not found: " + nodeId);
-        }
-        return result;
+        throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Node not found: " + nodeId);
     }
 
     @GetMapping("/nodes/{nodeId}/neighbors")
@@ -245,6 +287,9 @@ public Map<String, Object> listEdges(
             @RequestParam(defaultValue = "100") int limit,
             @RequestParam(defaultValue = "0") int offset) {
         int safeLimit = Math.min(limit, 1000);
+        if (useNeo4j()) {
+            return queryService.listEdges(kind, safeLimit, offset);
+        }
         ensureCacheLoaded();
         if (cachedEdges != null) {
             List<CodeEdge> filtered = cachedEdges;
@@ -261,8 +306,8 @@ public Map<String, Object> listEdges(
             result.put("total", filtered.size());
             return result;
         }
-        requireQueryService();
-        return queryService.listEdges(kind, safeLimit, offset);
+        throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
+                "No data available. Run analyze first.");
     }
 
     @GetMapping("/ego/{center}")
@@ -329,7 +374,12 @@ public ResponseEntity<?> findDeadCode(
             @RequestParam(defaultValue = "100") int limit) {
         int safeLimit = Math.min(limit, 1000);
 
-        // Try H2 cache first for dead code analysis
+        // Try Neo4j first
+        if (useNeo4j()) {
+            return ResponseEntity.ok(queryService.findDeadCode(kind, safeLimit));
+        }
+
+        // Fall back to H2 cache
         ensureCacheLoaded();
         if (cachedNodes != null && cachedEdges != null) {
             List<CodeNode> candidates = cachedNodes;
@@ -368,10 +418,6 @@ public ResponseEntity<?> findDeadCode(
             return ResponseEntity.ok(result);
         }
 
-        // Fall back to QueryService (Neo4j)
-        if (queryService != null) {
-            return ResponseEntity.ok(queryService.findDeadCode(kind, safeLimit));
-        }
         throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
                 "No data available. Run analyze first.");
     }
@@ -396,16 +442,29 @@ public List<Map<String, Object>> searchGraph(
             @RequestParam String q,
             @RequestParam(defaultValue = "50") int limit) {
         int safeLimit = Math.min(limit, 1000);
-        // Search from H2 cache
+        // Search via Neo4j first
+        if (useNeo4j()) {
+            return queryService.searchGraph(q, safeLimit);
+        }
+        // Fall back to H2 cache
         ensureCacheLoaded();
         if (cachedNodes != null) {
             return topologyService.findNode(q, cachedNodes);
         }
-        if (queryService != null) return queryService.searchGraph(q, safeLimit);
         throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
                 "No data available. Run analyze first.");
     }
 
+    /**
+     * Check whether Neo4j (via QueryService/GraphStore) is available for queries.
+     * When true, Neo4j is the primary data source (enriched graph with SERVICE
+     * nodes, layer classifications, linker edges).
+     * When false, falls back to H2 cache (basic indexed data only).
+     */
+    private boolean useNeo4j() {
+        return queryService != null;
+    }
+
     private void requireQueryService() {
         if (queryService == null) {
             throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,