checkpoint: pre-yolo 20260330-220034

Author: aksOps

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

@@ -56,11 +56,7 @@ public Map<String, Object> getStats() {
     public Map<String, Object> getDetailedStats(
             @RequestParam(defaultValue = "all") String category) {
         requireQueryService();
-        if ("all".equalsIgnoreCase(category) || "graph".equalsIgnoreCase(category)) {
-            return queryService.getStats();
-        }
-        throw new ResponseStatusException(HttpStatus.NOT_IMPLEMENTED,
-                "Detailed stats by category not yet supported via Neo4j. Use /api/stats instead.");
+        return queryService.getDetailedStats(category);
     }
 
     @GetMapping("/kinds")

src/main/java/io/github/randomcodespace/iq/mcp/McpTools.java

@@ -94,7 +94,7 @@ public String getStats() {
     public String getDetailedStats(
             @ToolParam(description = "Category filter (default: all)", required = false) String category) {
         try {
-            return toJson(queryService.getStats());
+            return toJson(queryService.getDetailedStats(category != null ? category : "all"));
         } catch (Exception e) {
             return toJson(Map.of("error", e.getMessage()));
         }
@@ -335,13 +335,7 @@ public String traceImpact(
     public String findRelatedEndpoints(
             @ToolParam(description = "File, class, or entity identifier") String identifier) {
         try {
-            // Search for the identifier, then find endpoints connected to the results
-            List<Map<String, Object>> results = queryService.searchGraph(identifier, 50);
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("identifier", identifier);
-            response.put("related_nodes", results);
-            response.put("count", results.size());
-            return toJson(response);
+            return toJson(queryService.findRelatedEndpoints(identifier));
         } catch (Exception e) {
             return toJson(Map.of("error", e.getMessage()));
         }
@@ -368,7 +362,7 @@ public String readFile(
             Path resolved = root.resolve(filePath).normalize();
             // Path traversal protection
             if (!resolved.startsWith(root)) {
-                return "Error: Path traversal detected";
+                return toJson(Map.of("error", "Path traversal detected"));
             }
             String content = java.nio.file.Files.readString(resolved, java.nio.charset.StandardCharsets.UTF_8);
             if (startLine != null || endLine != null) {
@@ -387,7 +381,7 @@ public String readFile(
             }
             return content;
         } catch (Exception e) {
-            return "Error: " + e.getMessage();
+            return toJson(Map.of("error", "Failed to read file: " + e.getMessage()));
         }
     }
 
@@ -523,7 +517,9 @@ private Object toSerializable(Object val) {
         if (val instanceof org.neo4j.graphdb.Node node) {
             Map<String, Object> map = new LinkedHashMap<>();
             map.put("_id", node.getElementId());
-            map.put("_labels", node.getLabels().spliterator().estimateSize());
+            List<String> labels = new ArrayList<>();
+            node.getLabels().forEach(l -> labels.add(l.name()));
+            map.put("_labels", labels);
             for (String key : node.getPropertyKeys()) {
                 map.put(key, node.getProperty(key));
             }

src/main/java/io/github/randomcodespace/iq/query/QueryService.java

@@ -13,6 +13,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * High-level query service wrapping GraphStore with caching.
@@ -24,90 +25,65 @@ public class QueryService {
 
     private final GraphStore graphStore;
     private final CodeIqConfig config;
+    private final StatsService statsService;
 
-    public QueryService(GraphStore graphStore, CodeIqConfig config) {
+    public QueryService(GraphStore graphStore, CodeIqConfig config, StatsService statsService) {
         this.graphStore = graphStore;
         this.config = config;
+        this.statsService = statsService;
     }
 
     @Cacheable("graph-stats")
     public Map<String, Object> getStats() {
-        long nodeCount = graphStore.count();
-        long edgeCount = graphStore.countEdges();
-        long fileCount = graphStore.countDistinctFiles();
+        // Load full graph data and compute rich categorized stats
+        List<CodeNode> nodes = graphStore.findAll();
+        List<CodeEdge> edges = nodes.stream()
+                .flatMap(n -> n.getEdges().stream())
+                .toList();
+
+        Map<String, Object> result = statsService.computeStats(nodes, edges);
 
+        // Also include raw counts and breakdowns for backward compat
         Map<String, Long> nodesByKind = new LinkedHashMap<>();
         for (Map<String, Object> row : graphStore.countNodesByKind()) {
             nodesByKind.put((String) row.get("kind"), ((Number) row.get("cnt")).longValue());
         }
-
         Map<String, Long> nodesByLayer = new LinkedHashMap<>();
         for (Map<String, Object> row : graphStore.countNodesByLayer()) {
             nodesByLayer.put((String) row.get("layer"), ((Number) row.get("cnt")).longValue());
         }
 
-        // Language breakdown from file extensions
-        Map<String, Long> languages = new LinkedHashMap<>();
-        for (Map<String, Object> row : graphStore.countByFileExtension()) {
-            String ext = (String) row.get("ext");
-            long cnt = ((Number) row.get("cnt")).longValue();
-            String lang = extToLanguage(ext);
-            languages.merge(lang, cnt, Long::sum);
-        }
-
-        // Return in ComputedStatsResponse format for frontend compatibility
-        Map<String, Object> graph = new LinkedHashMap<>();
-        graph.put("nodes", nodeCount);
-        graph.put("edges", edgeCount);
-        graph.put("files", fileCount);
-
-        Map<String, Object> result = new LinkedHashMap<>();
-        result.put("graph", graph);
-        result.put("languages", languages);
-        result.put("frameworks", Map.of());
-        result.put("infra", Map.of("databases", Map.of(), "messaging", Map.of(), "cloud", Map.of()));
-        result.put("connections", Map.of("rest", Map.of("total", 0, "by_method", Map.of()),
-                "grpc", 0, "websocket", 0, "producers", 0, "consumers", 0));
-        result.put("auth", Map.of());
-        result.put("architecture", Map.of());
-        // Also include raw counts for backward compat
-        result.put("node_count", nodeCount);
-        result.put("edge_count", edgeCount);
+        result.put("node_count", nodes.size());
+        result.put("edge_count", edges.size());
         result.put("nodes_by_kind", nodesByKind);
         result.put("nodes_by_layer", nodesByLayer);
         return result;
     }
 
-    private static String extToLanguage(String ext) {
-        if (ext == null) return "unknown";
-        return switch (ext.toLowerCase()) {
-            case "java" -> "java";
-            case "kt", "kts" -> "kotlin";
-            case "py" -> "python";
-            case "js", "mjs", "cjs" -> "javascript";
-            case "ts", "tsx" -> "typescript";
-            case "go" -> "go";
-            case "rs" -> "rust";
-            case "cs" -> "csharp";
-            case "scala" -> "scala";
-            case "cpp", "cc", "cxx", "h", "hpp" -> "cpp";
-            case "c" -> "c";
-            case "rb" -> "ruby";
-            case "proto" -> "protobuf";
-            case "yml", "yaml" -> "yaml";
-            case "json" -> "json";
-            case "xml" -> "xml";
-            case "tf" -> "terraform";
-            case "sql" -> "sql";
-            case "md" -> "markdown";
-            case "html", "htm" -> "html";
-            case "css", "scss", "sass" -> "css";
-            case "vue" -> "vue";
-            case "svelte" -> "svelte";
-            case "jsx" -> "jsx";
-            case "sh", "bash" -> "shell";
-            default -> ext;
-        };
+    /**
+     * Get detailed stats for a specific category, or all categories.
+     * Categories: all, graph, languages, frameworks, infra, connections, auth, architecture
+     */
+    @Cacheable(value = "detailed-stats", key = "#category")
+    public Map<String, Object> getDetailedStats(String category) {
+        List<CodeNode> nodes = graphStore.findAll();
+        List<CodeEdge> edges = nodes.stream()
+                .flatMap(n -> n.getEdges().stream())
+                .toList();
+
+        if (category == null || "all".equalsIgnoreCase(category)) {
+            return statsService.computeStats(nodes, edges);
+        }
+        Map<String, Object> catResult = statsService.computeCategory(nodes, edges, category);
+        if (catResult == null) {
+            Map<String, Object> error = new LinkedHashMap<>();
+            error.put("error", "Unknown category: " + category
+                    + ". Valid: all, graph, languages, frameworks, infra, connections, auth, architecture");
+            return error;
+        }
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put(category.toLowerCase(), catResult);
+        return result;
     }
 
     @Cacheable("kinds-list")
@@ -352,6 +328,44 @@ public List<Map<String, Object>> searchGraph(String query, int limit) {
         return results.stream().map(this::nodeToMap).toList();
     }
 
+    /**
+     * Find API endpoints related to an identifier (file, class, entity).
+     * Searches for matching nodes, then traverses the graph to find connected endpoints.
+     */
+    public Map<String, Object> findRelatedEndpoints(String identifier) {
+        // Find nodes matching the identifier
+        List<CodeNode> matches = graphStore.search(identifier, 50);
+
+        // Collect endpoints: any match that IS an endpoint, plus neighbors of matches that are endpoints
+        Set<String> seenIds = new java.util.LinkedHashSet<>();
+        List<Map<String, Object>> endpoints = new ArrayList<>();
+
+        for (CodeNode match : matches) {
+            if (match.getKind() == NodeKind.ENDPOINT || match.getKind() == NodeKind.WEBSOCKET_ENDPOINT) {
+                if (seenIds.add(match.getId())) {
+                    endpoints.add(nodeToMap(match));
+                }
+            }
+            // Check neighbors for connected endpoints
+            List<CodeNode> neighbors = graphStore.findNeighbors(match.getId());
+            for (CodeNode neighbor : neighbors) {
+                if ((neighbor.getKind() == NodeKind.ENDPOINT || neighbor.getKind() == NodeKind.WEBSOCKET_ENDPOINT)
+                        && seenIds.add(neighbor.getId())) {
+                    Map<String, Object> epMap = nodeToMap(neighbor);
+                    epMap.put("connected_via", match.getId());
+                    endpoints.add(epMap);
+                }
+            }
+        }
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("identifier", identifier);
+        result.put("endpoints", endpoints);
+        result.put("count", endpoints.size());
+        result.put("searched_nodes", matches.size());
+        return result;
+    }
+
     // --- Topology ---
 
     @Cacheable("topology")

src/test/java/io/github/randomcodespace/iq/api/TopologyEndpointTest.java

@@ -184,7 +184,7 @@ void getTopologyReturnsEmptyListsWhenNoData() throws Exception {
     @Test
     void queryServiceGetTopologyDelegatesToGraphStore() {
         CodeIqConfig cfg = new CodeIqConfig();
-        QueryService service = new QueryService(graphStore, cfg);
+        QueryService service = new QueryService(graphStore, cfg, new io.github.randomcodespace.iq.query.StatsService());
         when(graphStore.getTopology()).thenReturn(buildTopologyResponse());
 
         Map<String, Object> result = service.getTopology();
@@ -199,7 +199,7 @@ void queryServiceGetTopologyDelegatesToGraphStore() {
     @Test
     void queryServiceGetTopologyReturnsServicesInfraConnections() {
         CodeIqConfig cfg = new CodeIqConfig();
-        QueryService service = new QueryService(graphStore, cfg);
+        QueryService service = new QueryService(graphStore, cfg, new io.github.randomcodespace.iq.query.StatsService());
         Map<String, Object> topology = buildTopologyResponse();
         when(graphStore.getTopology()).thenReturn(topology);
 

src/test/java/io/github/randomcodespace/iq/mcp/McpToolsTest.java

@@ -450,10 +450,12 @@ void traceImpactShouldUseCustomDepth() throws IOException {
 
     @Test
     void findRelatedEndpointsShouldSearchAndReturn() throws IOException {
-        List<Map<String, Object>> searchResults = List.of(
-                Map.of("id", "n1", "kind", "endpoint")
-        );
-        when(queryService.searchGraph("UserService", 50)).thenReturn(searchResults);
+        Map<String, Object> endpointResult = new java.util.LinkedHashMap<>();
+        endpointResult.put("identifier", "UserService");
+        endpointResult.put("endpoints", List.of(Map.of("id", "ep1", "kind", "endpoint")));
+        endpointResult.put("count", 1);
+        endpointResult.put("searched_nodes", 3);
+        when(queryService.findRelatedEndpoints("UserService")).thenReturn(endpointResult);
 
         String result = mcpTools.findRelatedEndpoints("UserService");
         Map<String, Object> parsed = parseJson(result);
@@ -496,21 +498,24 @@ void readFileShouldReadContent(@TempDir Path tempDir) throws IOException {
     }
 
     @Test
-    void readFileShouldRejectPathTraversal(@TempDir Path tempDir) {
+    void readFileShouldRejectPathTraversal(@TempDir Path tempDir) throws IOException {
         config.setRootPath(tempDir.toString());
 
         String result = mcpTools.readFile("../../etc/passwd", null, null);
+        Map<String, Object> parsed = parseJson(result);
 
-        assertEquals("Error: Path traversal detected", result);
+        assertEquals("Path traversal detected", parsed.get("error"));
     }
 
     @Test
-    void readFileShouldHandleMissingFile(@TempDir Path tempDir) {
+    void readFileShouldHandleMissingFile(@TempDir Path tempDir) throws IOException {
         config.setRootPath(tempDir.toString());
 
         String result = mcpTools.readFile("nonexistent.txt", null, null);
+        Map<String, Object> parsed = parseJson(result);
 
-        assertTrue(result.startsWith("Error:"));
+        assertNotNull(parsed.get("error"));
+        assertTrue(parsed.get("error").toString().contains("Failed to read file"));
     }
 
     @Test

src/test/java/io/github/randomcodespace/iq/query/QueryServiceTest.java

@@ -28,14 +28,16 @@ class QueryServiceTest {
     private GraphStore graphStore;
 
     private CodeIqConfig config;
+    private StatsService statsService;
     private QueryService service;
 
     @BeforeEach
     void setUp() {
         config = new CodeIqConfig();
         config.setMaxDepth(10);
         config.setMaxRadius(10);
-        service = new QueryService(graphStore, config);
+        statsService = new StatsService();
+        service = new QueryService(graphStore, config, statsService);
     }
 
     private CodeNode makeNode(String id, NodeKind kind, String label) {
@@ -59,30 +61,43 @@ private CodeNode makeNodeWithEdge(String id, NodeKind kind, String label,
 
     @Test
     void getStatsShouldReturnNodeAndEdgeCounts() {
-        when(graphStore.count()).thenReturn(2L);
-        when(graphStore.countEdges()).thenReturn(1L);
-        when(graphStore.countDistinctFiles()).thenReturn(5L);
+        var endpoint = makeNodeWithEdge("ep:1", NodeKind.ENDPOINT, "GET /users",
+                "svc:1", EdgeKind.CALLS);
+        endpoint.getProperties().put("http_method", "GET");
+        endpoint.setFilePath("src/Main.java");
+        var cls = makeNode("cls:1", NodeKind.CLASS, "UserService");
+        cls.setFilePath("src/UserService.java");
+        cls.setEdges(new ArrayList<>());
+        when(graphStore.findAll()).thenReturn(List.of(endpoint, cls));
         when(graphStore.countNodesByKind()).thenReturn(List.of(
                 Map.of("kind", "endpoint", "cnt", 1L),
                 Map.of("kind", "class", "cnt", 1L)));
         when(graphStore.countNodesByLayer()).thenReturn(List.of(
                 Map.of("layer", "backend", "cnt", 2L)));
-        when(graphStore.countByFileExtension()).thenReturn(List.of(
-                Map.of("ext", "java", "cnt", 3L),
-                Map.of("ext", "py", "cnt", 2L)));
 
         Map<String, Object> stats = service.getStats();
 
-        // ComputedStatsResponse format
+        // ComputedStatsResponse format — graph section from StatsService
         @SuppressWarnings("unchecked")
         Map<String, Object> graph = (Map<String, Object>) stats.get("graph");
-        assertEquals(2L, graph.get("nodes"));
-        assertEquals(1L, graph.get("edges"));
-        assertEquals(5L, graph.get("files"));
+        assertEquals(2, graph.get("nodes"));
+        assertEquals(1, graph.get("edges"));
+        assertEquals(2L, graph.get("files"));
         assertNotNull(stats.get("languages"));
+        assertNotNull(stats.get("frameworks"));
+        assertNotNull(stats.get("infra"));
+        assertNotNull(stats.get("connections"));
+        assertNotNull(stats.get("auth"));
+        assertNotNull(stats.get("architecture"));
+        // REST endpoint detection
+        @SuppressWarnings("unchecked")
+        Map<String, Object> connections = (Map<String, Object>) stats.get("connections");
+        @SuppressWarnings("unchecked")
+        Map<String, Object> rest = (Map<String, Object>) connections.get("rest");
+        assertEquals(1L, rest.get("total"));
         // Backward compat
-        assertEquals(2L, stats.get("node_count"));
-        assertEquals(1L, stats.get("edge_count"));
+        assertEquals(2, stats.get("node_count"));
+        assertEquals(1, stats.get("edge_count"));
         assertNotNull(stats.get("nodes_by_kind"));
         assertNotNull(stats.get("nodes_by_layer"));
     }