Fix flow command and API to work from H2 cache without Neo4j

- Extract FlowDataSource interface from GraphStore for flow diagram generation
- Add CacheFlowDataSource backed by pre-loaded node list from H2
- FlowEngine no longer a Spring bean — created manually by FlowCommand/FlowController
- FlowCommand loads from H2 cache when Neo4j/GraphStore unavailable
- FlowController removes @ConditionalOnProperty(neo4j.enabled) — works with H2 fallback
- FlowViews accepts FlowDataSource instead of GraphStore directly
- All 1,227 tests pass (fixed 8 previously broken DetectorInfoAnnotationTest errors)

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

Author: aksOps

src/main/frontend/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/App.tsx","./src/env.d.ts","./src/main.tsx","./src/components/Dashboard.tsx","./src/components/ExplorerView.tsx","./src/components/FlowView.tsx","./src/components/FrameworkBadges.tsx","./src/components/Layout.tsx","./src/components/McpConsole.tsx","./src/components/NodeDetailModal.tsx","./src/components/SearchBar.tsx","./src/components/StatsCards.tsx","./src/components/SwaggerView.tsx","./src/components/ThemeToggle.tsx","./src/components/TopologyView.tsx","./src/hooks/useApi.ts","./src/hooks/useTheme.ts","./src/lib/api.ts","./src/types/api.ts"],"version":"5.7.3"}

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

@@ -1,7 +1,10 @@
 package io.github.randomcodespace.iq.api;
 
+import io.github.randomcodespace.iq.cache.AnalysisCache;
+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.model.CodeNode;
 import org.springframework.context.annotation.Profile;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -13,91 +16,113 @@
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.server.ResponseStatusException;
 
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 /**
  * REST API controller for architecture flow diagrams.
- * Supports drill-down and drill-up navigation.
+ * Works from either Neo4j (GraphStore) or H2 cache.
  */
 @RestController
 @RequestMapping("/api/flow")
 @Profile("serving")
-@org.springframework.boot.autoconfigure.condition.ConditionalOnProperty(name = "codeiq.neo4j.enabled", havingValue = "true", matchIfMissing = true)
 public class FlowController {
 
     private final FlowEngine flowEngine;
+    private final CodeIqConfig config;
 
-    public FlowController(FlowEngine flowEngine) {
-        this.flowEngine = flowEngine;
+    public FlowController(Optional<FlowEngine> flowEngine, CodeIqConfig config) {
+        this.flowEngine = flowEngine.orElse(null);
+        this.config = config;
     }
 
-    /**
-     * Get all flow views as JSON diagrams.
-     */
     @GetMapping
     public Map<String, Object> getAllFlows() {
-        var allViews = flowEngine.generateAll();
+        FlowEngine engine = resolveEngine();
+        var allViews = engine.generateAll();
         var result = new LinkedHashMap<String, Object>();
         for (var entry : allViews.entrySet()) {
             result.put(entry.getKey(), entry.getValue().toMap());
         }
         return result;
     }
 
-    /**
-     * Get a specific flow view, optionally in a different format.
-     */
     @GetMapping("/{view}")
     public ResponseEntity<?> getFlow(
             @PathVariable String view,
             @RequestParam(defaultValue = "json") String format) {
         try {
-            FlowDiagram diagram = flowEngine.generate(view);
+            FlowEngine engine = resolveEngine();
+            FlowDiagram diagram = engine.generate(view);
 
             return switch (format.toLowerCase()) {
                 case "json" -> ResponseEntity.ok(diagram.toMap());
                 case "mermaid" -> ResponseEntity.ok()
                         .contentType(MediaType.TEXT_PLAIN)
-                        .body(flowEngine.render(diagram, "mermaid"));
+                        .body(engine.render(diagram, "mermaid"));
                 case "html" -> ResponseEntity.ok()
                         .contentType(MediaType.TEXT_HTML)
-                        .body(flowEngine.renderInteractive("Project"));
+                        .body(engine.renderInteractive("Project"));
                 default -> throw new IllegalArgumentException(
-                        "Unknown format: " + format + ". Available: json, mermaid, html");
+                        "Unknown format. Available: json, mermaid, html");
             };
         } catch (IllegalArgumentException e) {
             throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage());
         }
     }
 
-    /**
-     * Drill down into a node within a view -- returns the child view's diagram.
-     */
     @GetMapping("/{view}/{nodeId}/children")
     public Map<String, Object> getChildren(
             @PathVariable String view,
             @PathVariable String nodeId) {
-        Map<String, Object> children = flowEngine.getChildren(view, nodeId);
+        FlowEngine engine = resolveEngine();
+        Map<String, Object> children = engine.getChildren(view, nodeId);
         if (children == null) {
             throw new ResponseStatusException(HttpStatus.NOT_FOUND,
                     "No drill-down available for node " + nodeId + " in view " + view);
         }
         return children;
     }
 
-    /**
-     * Drill up from a node -- returns the parent context.
-     */
     @GetMapping("/{view}/{nodeId}/parent")
     public Map<String, Object> getParent(
             @PathVariable String view,
             @PathVariable String nodeId) {
-        Map<String, Object> parent = flowEngine.getParentContext(nodeId);
+        FlowEngine engine = resolveEngine();
+        Map<String, Object> parent = engine.getParentContext(nodeId);
         if (parent == null) {
             throw new ResponseStatusException(HttpStatus.NOT_FOUND,
                     "No parent context found for node " + nodeId);
         }
         return parent;
     }
+
+    private FlowEngine resolveEngine() {
+        if (flowEngine != null) {
+            return flowEngine;
+        }
+
+        // Fall back to H2 cache
+        Path root = Path.of(config.getRootPath()).toAbsolutePath().normalize();
+        Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
+        Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
+
+        if (!Files.exists(h2File)) {
+            throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
+                    "No analysis data available. Run 'code-iq analyze' first.");
+        }
+
+        try (AnalysisCache cache = new AnalysisCache(cachePath)) {
+            List<CodeNode> nodes = cache.loadAllNodes();
+            if (nodes.isEmpty()) {
+                throw new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE,
+                        "Analysis cache is empty. Run 'code-iq analyze' first.");
+            }
+            return FlowEngine.fromCache(nodes);
+        }
+    }
 }

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

@@ -1,7 +1,10 @@
 package io.github.randomcodespace.iq.cli;
 
+import io.github.randomcodespace.iq.cache.AnalysisCache;
+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.model.CodeNode;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import picocli.CommandLine.Command;
@@ -12,11 +15,13 @@
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.Callable;
 
 /**
  * Generate architecture flow diagrams from the knowledge graph.
+ * Works from H2 cache (no Neo4j required).
  * Supports 5 views (overview, ci, deploy, runtime, auth) and 3 formats (mermaid, json, html).
  */
 @Component
@@ -39,37 +44,43 @@ public class FlowCommand implements Callable<Integer> {
     private Path output;
 
     private final FlowEngine flowEngine;
+    private final CodeIqConfig config;
 
     /** No-arg constructor for Picocli direct instantiation. */
     public FlowCommand() {
         this.flowEngine = null;
+        this.config = null;
     }
 
     @Autowired
-    public FlowCommand(Optional<FlowEngine> flowEngine) {
+    public FlowCommand(Optional<FlowEngine> flowEngine, CodeIqConfig config) {
         this.flowEngine = flowEngine.orElse(null);
+        this.config = config;
     }
 
     /** Convenience constructor for tests. */
-    FlowCommand(FlowEngine flowEngine) {
+    FlowCommand(FlowEngine flowEngine, CodeIqConfig config) {
         this.flowEngine = flowEngine;
+        this.config = config;
     }
 
     @Override
     public Integer call() {
-        if (flowEngine == null) {
-            CliOutput.error("Flow diagrams require the serve profile (Neo4j). Use 'code-iq serve' to start the server, or 'code-iq stats' for cache-based queries.");
+        FlowEngine engine = resolveEngine();
+        if (engine == null) {
+            CliOutput.error("No analysis cache found. Run 'code-iq analyze' or 'code-iq index' first.");
             return 1;
         }
+
         try {
             String content;
 
             if ("html".equalsIgnoreCase(format)) {
                 String projectName = path.toAbsolutePath().getFileName().toString();
-                content = flowEngine.renderInteractive(projectName);
+                content = engine.renderInteractive(projectName);
             } else {
-                FlowDiagram diagram = flowEngine.generate(view.toLowerCase());
-                content = flowEngine.render(diagram, format.toLowerCase());
+                FlowDiagram diagram = engine.generate(view.toLowerCase());
+                content = engine.render(diagram, format.toLowerCase());
             }
 
             if (output != null) {
@@ -88,4 +99,31 @@ public Integer call() {
             return 1;
         }
     }
+
+    /**
+     * Use the Spring-injected FlowEngine (backed by GraphStore/Neo4j) if available,
+     * otherwise create one from H2 cache.
+     */
+    private FlowEngine resolveEngine() {
+        if (flowEngine != null) {
+            return flowEngine;
+        }
+
+        // Fall back to H2 cache
+        if (config == null) return null;
+
+        Path root = path.toAbsolutePath().normalize();
+        Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
+        Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
+
+        if (!Files.exists(h2File)) {
+            return null;
+        }
+
+        try (AnalysisCache cache = new AnalysisCache(cachePath)) {
+            List<CodeNode> nodes = cache.loadAllNodes();
+            if (nodes.isEmpty()) return null;
+            return FlowEngine.fromCache(nodes);
+        }
+    }
 }

src/main/java/io/github/randomcodespace/iq/flow/CacheFlowDataSource.java

@@ -0,0 +1,35 @@
+package io.github.randomcodespace.iq.flow;
+
+import io.github.randomcodespace.iq.model.CodeNode;
+import io.github.randomcodespace.iq.model.NodeKind;
+
+import java.util.List;
+
+/**
+ * FlowDataSource backed by a pre-loaded list of nodes (from H2 cache).
+ */
+public class CacheFlowDataSource implements FlowDataSource {
+
+    private final List<CodeNode> nodes;
+
+    public CacheFlowDataSource(List<CodeNode> nodes) {
+        this.nodes = nodes;
+    }
+
+    @Override
+    public List<CodeNode> findAll() {
+        return nodes;
+    }
+
+    @Override
+    public List<CodeNode> findByKind(NodeKind kind) {
+        return nodes.stream()
+                .filter(n -> n.getKind() == kind)
+                .toList();
+    }
+
+    @Override
+    public long count() {
+        return nodes.size();
+    }
+}

src/main/java/io/github/randomcodespace/iq/flow/FlowDataSource.java

@@ -0,0 +1,19 @@
+package io.github.randomcodespace.iq.flow;
+
+import io.github.randomcodespace.iq.model.CodeNode;
+import io.github.randomcodespace.iq.model.NodeKind;
+
+import java.util.List;
+
+/**
+ * Abstraction over graph data access for flow diagram generation.
+ * Allows FlowEngine to work from either Neo4j (GraphStore) or H2 cache.
+ */
+public interface FlowDataSource {
+
+    List<CodeNode> findAll();
+
+    List<CodeNode> findByKind(NodeKind kind);
+
+    long count();
+}