feat: auto-enrich Neo4j on serve startup

When serve starts and Neo4j is empty, automatically runs the full analysis
pipeline (analyze → persist to Neo4j → evict caches) so API/MCP endpoints
return data immediately without requiring manual POST /api/analyze.

Flow:
1. Check if Neo4j has data → if yes, report stats and skip
2. If empty → run full analyzer.run() with progress output
3. bulkSave() results to Neo4j with UNWIND batches
4. Evict Spring caches
5. Report final node/edge counts

This fixes the disconnect where H2 cache stats were shown on startup
but Neo4j was empty, causing all API queries to return 0.

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

Author: aksOps

src/main/java/io/github/randomcodespace/iq/cli/ServeCommand.java

@@ -1,16 +1,23 @@
 package io.github.randomcodespace.iq.cli;
 
+import io.github.randomcodespace.iq.analyzer.AnalysisResult;
+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 org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.CacheManager;
 import org.springframework.stereotype.Component;
 import picocli.CommandLine.Command;
 import picocli.CommandLine.Option;
 import picocli.CommandLine.Parameters;
 
 import java.nio.file.Path;
+import java.text.NumberFormat;
+import java.util.Locale;
+import java.util.Optional;
 import java.util.concurrent.Callable;
 
 /**
@@ -49,33 +56,24 @@ public class ServeCommand implements Callable<Integer> {
     @Autowired
     private CodeIqConfig config;
 
+    @Autowired
+    private Analyzer analyzer;
+
+    @Autowired(required = false)
+    private GraphStore graphStore;
+
+    @Autowired(required = false)
+    private CacheManager cacheManager;
+
     @Override
     public Integer call() {
         Path root = path.toAbsolutePath().normalize();
 
         // Update config with the root path so controllers can find it
         config.setRootPath(root.toString());
 
-        // Check that H2 cache exists and report status
-        Path cacheDir;
-        if (graphPath != null) {
-            cacheDir = graphPath.toAbsolutePath().normalize();
-        } else {
-            cacheDir = root.resolve(config.getCacheDir());
-        }
-        Path h2File = cacheDir.resolve("analysis-cache.mv.db");
-        if (java.nio.file.Files.exists(h2File)) {
-            try (AnalysisCache cache = new AnalysisCache(cacheDir.resolve("analysis-cache.db"))) {
-                long nodeCount = cache.getNodeCount();
-                long edgeCount = cache.getEdgeCount();
-                CliOutput.success("Loaded analysis cache: " + nodeCount + " nodes, " + edgeCount + " edges");
-            } catch (Exception e) {
-                log.warn("Could not read H2 cache stats", e);
-            }
-        } else {
-            CliOutput.info("No analysis cache found at " + cacheDir);
-            CliOutput.info("  Run 'code-iq analyze " + root + "' to populate data.");
-        }
+        // Auto-enrich: if Neo4j is empty, run full analysis to populate it
+        autoEnrich(root);
 
         CliOutput.step("\uD83D\uDE80", "@|bold,green Server started|@");
         System.out.println();
@@ -101,6 +99,66 @@ public Integer call() {
         return 0;
     }
 
+    /**
+     * Auto-enrich Neo4j on startup: if the graph is empty, run the full analysis
+     * pipeline to populate Neo4j from the codebase. This ensures the API/MCP
+     * endpoints return data immediately without requiring a manual POST /api/analyze.
+     */
+    private void autoEnrich(Path root) {
+        // Check if Neo4j already has data
+        boolean neo4jEmpty = true;
+        if (graphStore != null) {
+            try {
+                neo4jEmpty = graphStore.count() == 0;
+            } catch (Exception e) {
+                log.debug("Could not check Neo4j state", e);
+            }
+        }
+
+        if (!neo4jEmpty) {
+            long nodeCount = graphStore.count();
+            long edgeCount = graphStore.countEdges();
+            CliOutput.success("Neo4j graph loaded: " + nodeCount + " nodes, " + edgeCount + " edges");
+            return;
+        }
+
+        // Neo4j is empty — run analysis to populate it
+        NumberFormat nf = NumberFormat.getIntegerInstance(Locale.US);
+        CliOutput.step("\u26A1", "Auto-enriching Neo4j graph...");
+
+        try {
+            AnalysisResult result = analyzer.run(root, null, true, msg -> {
+                if (msg.startsWith("Discovering") || msg.startsWith("Found") || msg.startsWith("Analyzing")
+                        || msg.startsWith("Building") || msg.startsWith("Linking") || msg.startsWith("Classifying")
+                        || msg.startsWith("Analysis complete")) {
+                    CliOutput.info("  " + msg);
+                }
+            });
+
+            // Persist to Neo4j
+            if (graphStore != null && result.nodes() != null && !result.nodes().isEmpty()) {
+                CliOutput.step("\uD83D\uDCBE", "Persisting " + nf.format(result.nodes().size()) + " nodes to Neo4j...");
+                graphStore.bulkSave(result.nodes());
+            }
+
+            // Evict Spring caches
+            if (cacheManager != null) {
+                cacheManager.getCacheNames().forEach(name -> {
+                    var cache = cacheManager.getCache(name);
+                    if (cache != null) cache.clear();
+                });
+            }
+
+            CliOutput.success("Graph ready: " + nf.format(result.nodeCount()) + " nodes, "
+                    + nf.format(result.edgeCount()) + " edges from "
+                    + nf.format(result.filesAnalyzed()) + " files");
+        } catch (Exception e) {
+            log.error("Auto-enrich failed", e);
+            CliOutput.error("Auto-enrich failed: " + e.getMessage());
+            CliOutput.info("  You can manually trigger analysis via POST /api/analyze");
+        }
+    }
+
     public Path getPath() {
         return path;
     }