deepdebug-local-agent 0.3.8 → 0.3.10

package/analyzers/controller-analyzer.js

@@ -0,0 +1,429 @@
+import path from "path";
+import { readFile } from "../fs-utils.js";
+
+/**
+ * ControllerAnalyzer - ENHANCED VERSION
+ *
+ * Analyzes Java Spring Boot controllers to extract:
+ * - REST endpoints (@GetMapping, @PostMapping, etc.)
+ * - Request/Response DTOs
+ * - Path variables and query parameters
+ * - HTTP methods and paths
+ * - Handles constants and complex path expressions
+ */
+export class ControllerAnalyzer {
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+        this.pathConstants = new Map(); // Store resolved path constants
+    }
+
+    /**
+     * Find all controller files in the workspace
+     */
+    async findControllers(files) {
+        const controllerFiles = files.filter(file => {
+            const fileName = path.basename(file.path || file);
+            return fileName.endsWith("Controller.java") ||
+                   fileName.endsWith("Resource.java") ||
+                   fileName.endsWith("Api.java");
+        });
+
+        return controllerFiles.map(f => f.path || f);
+    }
+
+    /**
+     * Try to resolve path constants from PathAPI or similar classes
+     */
+    async resolvePathConstants(files) {
+        // Look for PathAPI, ApiPaths, Routes, etc.
+        const pathFiles = files.filter(file => {
+            const filePath = file.path || file;
+            const fileName = path.basename(filePath);
+            return fileName.includes("Path") ||
+                   fileName.includes("Route") ||
+                   fileName.includes("Api") && fileName.endsWith(".java") &&
+                   !fileName.includes("Controller");
+        });
+
+        for (const file of pathFiles) {
+            try {
+                const filePath = file.path || file;
+                const fullPath = path.join(this.workspaceRoot, filePath);
+                const content = await readFile(fullPath, "utf8");
+
+                // Extract constants like: public static final String CORE = "/v1";
+                const constantRegex = /(?:public\s+)?static\s+final\s+String\s+(\w+)\s*=\s*"([^"]+)"/g;
+                let match;
+                while ((match = constantRegex.exec(content)) !== null) {
+                    this.pathConstants.set(match[1], match[2]);
+                }
+            } catch (err) {
+                // Ignore errors reading path files
+            }
+        }
+
+        // Common defaults
+        if (!this.pathConstants.has("ID")) {
+            this.pathConstants.set("ID", "/{id}");
+        }
+    }
+
+    /**
+     * Resolve a path expression that may contain constants
+     */
+    resolvePath(pathExpr) {
+        if (!pathExpr) return "";
+
+        // Handle string literals
+        if (pathExpr.startsWith('"') && pathExpr.endsWith('"')) {
+            return pathExpr.slice(1, -1);
+        }
+
+        // Handle constant references like PathAPI.CORE + PathAPI.AGREEMENT
+        let resolved = pathExpr;
+
+        // Replace constant references
+        for (const [name, value] of this.pathConstants) {
+            // Match patterns like PathAPI.NAME or ClassName.NAME
+            const pattern = new RegExp(`\\w+\\.${name}\\b`, 'g');
+            resolved = resolved.replace(pattern, `"${value}"`);
+
+            // Also match just the constant name
+            const simplePattern = new RegExp(`\\b${name}\\b`, 'g');
+            resolved = resolved.replace(simplePattern, `"${value}"`);
+        }
+
+        // Now concatenate string parts
+        // "a" + "b" + "c" -> "abc"
+        const stringParts = resolved.match(/"([^"]*)"/g);
+        if (stringParts) {
+            return stringParts.map(s => s.slice(1, -1)).join('');
+        }
+
+        // If we couldn't resolve, return as-is or empty
+        return pathExpr.includes('.') ? "" : pathExpr;
+    }
+
+    /**
+     * Analyze a single controller file
+     */
+    async analyzeController(filePath) {
+        try {
+            const fullPath = path.join(this.workspaceRoot, filePath);
+            const content = await readFile(fullPath, "utf8");
+
+            const controller = {
+                file: filePath,
+                className: this.extractClassName(content),
+                basePath: this.extractBasePath(content),
+                endpoints: this.extractEndpoints(content),
+                imports: this.extractImports(content)
+            };
+
+            return controller;
+        } catch (err) {
+            console.error(`Failed to analyze controller ${filePath}:`, err.message);
+            return null;
+        }
+    }
+
+    /**
+     * Extract class name from Java file
+     */
+    extractClassName(content) {
+        const match = content.match(/public\s+class\s+(\w+)/);
+        return match ? match[1] : "Unknown";
+    }
+
+    /**
+     * Extract base path from @RequestMapping annotation on class
+     */
+    extractBasePath(content) {
+        // Find @RequestMapping on class level (before the class declaration)
+        const classMatch = content.match(/(@RequestMapping[^)]*\))\s*(?:@\w+[^)]*\)\s*)*public\s+class/s);
+
+        if (classMatch) {
+            const annotation = classMatch[1];
+
+            // @RequestMapping("/api/v1/users")
+            let match = annotation.match(/@RequestMapping\s*\(\s*"([^"]+)"\s*\)/);
+            if (match) return match[1];
+
+            // @RequestMapping(value = "/api/v1/users")
+            match = annotation.match(/@RequestMapping\s*\([^)]*value\s*=\s*"([^"]+)"/);
+            if (match) return match[1];
+
+            // @RequestMapping(path = "/api/v1/users")
+            match = annotation.match(/@RequestMapping\s*\([^)]*path\s*=\s*"([^"]+)"/);
+            if (match) return match[1];
+
+            // @RequestMapping(PathAPI.CORE + PathAPI.USERS)
+            match = annotation.match(/@RequestMapping\s*\(([^)]+)\)/);
+            if (match) {
+                const pathExpr = match[1].trim();
+                if (!pathExpr.includes("=") || pathExpr.includes("value")) {
+                    // Extract the value part if present
+                    const valueMatch = pathExpr.match(/value\s*=\s*([^,)]+)/);
+                    const resolved = this.resolvePath(valueMatch ? valueMatch[1].trim() : pathExpr);
+                    if (resolved) return resolved;
+                }
+            }
+        }
+
+        return "";
+    }
+
+    /**
+     * Extract all endpoint mappings from controller
+     */
+    extractEndpoints(content) {
+        const endpoints = [];
+
+        // Find all methods with mapping annotations
+        const methodPatterns = [
+            { regex: /@GetMapping(?:\s*\(\s*([^)]*)\s*\)|\s+)/g, method: "GET" },
+            { regex: /@PostMapping(?:\s*\(\s*([^)]*)\s*\)|\s+)/g, method: "POST" },
+            { regex: /@PutMapping(?:\s*\(\s*([^)]*)\s*\)|\s+)/g, method: "PUT" },
+            { regex: /@DeleteMapping(?:\s*\(\s*([^)]*)\s*\)|\s+)/g, method: "DELETE" },
+            { regex: /@PatchMapping(?:\s*\(\s*([^)]*)\s*\)|\s+)/g, method: "PATCH" }
+        ];
+
+        for (const { regex, method } of methodPatterns) {
+            let match;
+            const regexCopy = new RegExp(regex.source, 'g');
+
+            while ((match = regexCopy.exec(content)) !== null) {
+                const annotationEnd = match.index + match[0].length;
+
+                // Get the method block that follows this annotation
+                const methodBlock = content.substring(match.index, Math.min(annotationEnd + 500, content.length));
+
+                // Extract path from annotation
+                let endpointPath = "";
+                const annotationContent = match[1] || "";
+
+                if (annotationContent) {
+                    // Handle: @GetMapping("/{id}")
+                    const stringMatch = annotationContent.match(/^"([^"]*)"$/);
+                    if (stringMatch) {
+                        endpointPath = stringMatch[1];
+                    } else {
+                        // Handle: @GetMapping(value = "/{id}")
+                        const valueMatch = annotationContent.match(/value\s*=\s*"([^"]+)"/);
+                        if (valueMatch) {
+                            endpointPath = valueMatch[1];
+                        } else {
+                            // Handle: @GetMapping(PathAPI.ID)
+                            endpointPath = this.resolvePath(annotationContent.trim());
+                        }
+                    }
+                }
+
+                const endpoint = this.parseMethodBlock(methodBlock, method, endpointPath);
+                if (endpoint) {
+                    endpoints.push(endpoint);
+                }
+            }
+        }
+
+        // Also check for @RequestMapping with method attribute
+        const requestMappingRegex = /@RequestMapping\s*\([^)]*method\s*=\s*(?:RequestMethod\.)?(\w+)[^)]*\)/g;
+        let match;
+        while ((match = requestMappingRegex.exec(content)) !== null) {
+            const httpMethod = match[1];
+            const annotationEnd = match.index + match[0].length;
+            const methodBlock = content.substring(match.index, Math.min(annotationEnd + 500, content.length));
+
+            // Extract path
+            const pathMatch = match[0].match(/value\s*=\s*"([^"]+)"|path\s*=\s*"([^"]+)"/);
+            const endpointPath = pathMatch ? (pathMatch[1] || pathMatch[2]) : "";
+
+            const endpoint = this.parseMethodBlock(methodBlock, httpMethod, endpointPath);
+            if (endpoint) {
+                endpoints.push(endpoint);
+            }
+        }
+
+        return endpoints;
+    }
+
+    /**
+     * Parse a method block to extract endpoint information
+     */
+    parseMethodBlock(methodBlock, httpMethod, endpointPath) {
+        // Find the method signature
+        // Pattern: returnType methodName(params)
+        const methodMatch = methodBlock.match(/(?:public|private|protected)\s+([\w<>,\s?]+?)\s+(\w+)\s*\(([^)]*)\)/);
+
+        if (!methodMatch) return null;
+
+        const returnType = methodMatch[1].trim();
+        const methodName = methodMatch[2];
+        const paramsString = methodMatch[3];
+
+        // Parse parameters
+        const requestBody = this.extractRequestBody(paramsString);
+        const pathVariables = this.extractPathVariables(paramsString);
+        const queryParams = this.extractQueryParams(paramsString);
+
+        return {
+            method: httpMethod,
+            path: endpointPath,
+            methodName: methodName,
+            returnType: this.cleanReturnType(returnType),
+            requestBody: requestBody,
+            pathVariables: pathVariables,
+            queryParams: queryParams
+        };
+    }
+
+    /**
+     * Clean up return type (remove Mono/Flux wrappers, etc.)
+     */
+    cleanReturnType(returnType) {
+        let clean = returnType
+            .replace(/Mono<(.+)>/, "$1")
+            .replace(/Flux<(.+)>/, "List<$1>")
+            .replace(/ResponseEntity<(.+)>/, "$1")
+            .replace(/CompletableFuture<(.+)>/, "$1")
+            .trim();
+        return clean;
+    }
+
+    /**
+     * Extract @RequestBody parameter
+     */
+    extractRequestBody(paramsString) {
+        // Match @RequestBody Type name or @RequestBody @Valid Type name
+        const match = paramsString.match(/@RequestBody\s+(?:@\w+\s+)*(\w+)\s+(\w+)/);
+        if (match) {
+            return {
+                type: match[1],
+                name: match[2]
+            };
+        }
+        return null;
+    }
+
+    /**
+     * Extract @PathVariable parameters
+     */
+    extractPathVariables(paramsString) {
+        const pathVars = [];
+
+        // @PathVariable("id") Long id
+        // @PathVariable Long id
+        // @PathVariable(value = "id") Long id
+        const regex = /@PathVariable(?:\s*\(\s*(?:value\s*=\s*)?["']?(\w+)["']?\s*\))?\s+(\w+)\s+(\w+)/g;
+        let match;
+        while ((match = regex.exec(paramsString)) !== null) {
+            pathVars.push({
+                name: match[1] || match[3],
+                type: match[2],
+                paramName: match[3]
+            });
+        }
+        return pathVars;
+    }
+
+    /**
+     * Extract @RequestParam parameters
+     */
+    extractQueryParams(paramsString) {
+        const queryParams = [];
+
+        const regex = /@RequestParam(?:\s*\([^)]*\))?\s+(\w+)\s+(\w+)/g;
+        let match;
+        while ((match = regex.exec(paramsString)) !== null) {
+            queryParams.push({
+                name: match[2],
+                type: match[1],
+                paramName: match[2],
+                required: !paramsString.includes("required = false")
+            });
+        }
+        return queryParams;
+    }
+
+    /**
+     * Extract imports to understand DTOs
+     */
+    extractImports(content) {
+        const imports = [];
+        const regex = /import\s+([\w.]+);/g;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            imports.push(match[1]);
+        }
+        return imports;
+    }
+
+    /**
+     * Analyze all controllers in workspace
+     */
+    async analyzeAll(files) {
+        // First, try to resolve path constants
+        await this.resolvePathConstants(files);
+
+        const controllerPaths = await this.findControllers(files);
+        const controllers = [];
+
+        for (const controllerPath of controllerPaths) {
+            const controller = await this.analyzeController(controllerPath);
+            if (controller) {
+                controllers.push(controller);
+            }
+        }
+
+        return controllers;
+    }
+
+    /**
+     * Generate full API documentation
+     */
+    async generateApiDocs(files) {
+        const controllers = await this.analyzeAll(files);
+
+        const endpoints = [];
+        for (const controller of controllers) {
+            const basePath = controller.basePath;
+
+            for (const endpoint of controller.endpoints) {
+                const fullPath = this.combinePaths(basePath, endpoint.path);
+                endpoints.push({
+                    controller: controller.className,
+                    file: controller.file,
+                    method: endpoint.method,
+                    path: fullPath,
+                    methodName: endpoint.methodName,
+                    returnType: endpoint.returnType,
+                    requestBody: endpoint.requestBody,
+                    pathVariables: endpoint.pathVariables,
+                    queryParams: endpoint.queryParams
+                });
+            }
+        }
+
+        return {
+            totalControllers: controllers.length,
+            totalEndpoints: endpoints.length,
+            controllers: controllers,
+            endpoints: endpoints
+        };
+    }
+
+    /**
+     * Combine base path and endpoint path
+     */
+    combinePaths(basePath, endpointPath) {
+        if (!basePath && !endpointPath) return "/";
+        if (!basePath) return endpointPath.startsWith("/") ? endpointPath : "/" + endpointPath;
+        if (!endpointPath) return basePath.startsWith("/") ? basePath : "/" + basePath;
+
+        const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+        const endpoint = endpointPath.startsWith("/") ? endpointPath : "/" + endpointPath;
+        return base + endpoint;
+    }
+}
+
+export default ControllerAnalyzer;