deepdebug-local-agent 0.3.8 → 0.3.9

package/analyzers/dto-analyzer.js

@@ -0,0 +1,455 @@
+import path from "path";
+import { readFile } from "../fs-utils.js";
+
+/**
+ * DTOAnalyzer
+ *
+ * Analyzes Java DTO/Model classes to extract:
+ * - Fields and types
+ * - Validation annotations
+ * - Example payloads
+ */
+export class DTOAnalyzer {
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+        this.analyzedDtos = new Map();
+    }
+
+    /**
+     * Find all DTO/Model files in the workspace
+     */
+    async findDtoFiles(files) {
+        const dtoPatterns = [
+            /Dto\.java$/,
+            /DTO\.java$/,
+            /Request\.java$/,
+            /Response\.java$/,
+            /Model\.java$/,
+            /Entity\.java$/
+        ];
+
+        // Also look in model/dto/request/response directories
+        const dtoDirectories = ["/model/", "/dto/", "/request/", "/response/", "/entity/"];
+
+        return files.filter(file => {
+            const filePath = file.path || file;
+            const fileName = path.basename(filePath);
+
+            // Check by name pattern
+            for (const pattern of dtoPatterns) {
+                if (pattern.test(fileName)) return true;
+            }
+
+            // Check by directory
+            for (const dir of dtoDirectories) {
+                if (filePath.includes(dir)) return true;
+            }
+
+            return false;
+        }).map(f => f.path || f);
+    }
+
+    /**
+     * Analyze a single DTO file
+     */
+    async analyzeDto(filePath) {
+        // Check cache
+        if (this.analyzedDtos.has(filePath)) {
+            return this.analyzedDtos.get(filePath);
+        }
+
+        try {
+            const fullPath = path.join(this.workspaceRoot, filePath);
+            const content = await readFile(fullPath, "utf8");
+
+            const dto = {
+                file: filePath,
+                className: this.extractClassName(content),
+                packageName: this.extractPackageName(content),
+                fields: this.extractFields(content),
+                annotations: this.extractClassAnnotations(content),
+                isRecord: content.includes("public record"),
+                extends: this.extractExtends(content),
+                implements: this.extractImplements(content)
+            };
+
+            // Generate example payload
+            dto.examplePayload = this.generateExamplePayload(dto);
+
+            this.analyzedDtos.set(filePath, dto);
+            return dto;
+        } catch (err) {
+            console.error(`Failed to analyze DTO ${filePath}:`, err.message);
+            return null;
+        }
+    }
+
+    /**
+     * Extract package name
+     */
+    extractPackageName(content) {
+        const match = content.match(/package\s+([\w.]+);/);
+        return match ? match[1] : "";
+    }
+
+    /**
+     * Extract class name
+     */
+    extractClassName(content) {
+        // Handle records
+        const recordMatch = content.match(/public\s+record\s+(\w+)/);
+        if (recordMatch) return recordMatch[1];
+
+        const classMatch = content.match(/public\s+class\s+(\w+)/);
+        return classMatch ? classMatch[1] : "Unknown";
+    }
+
+    /**
+     * Extract class-level annotations
+     */
+    extractClassAnnotations(content) {
+        const annotations = [];
+        const beforeClass = content.split(/public\s+(?:class|record)/)[0];
+        const regex = /@(\w+)(?:\([^)]*\))?/g;
+        let match;
+        while ((match = regex.exec(beforeClass)) !== null) {
+            annotations.push(match[1]);
+        }
+        return annotations;
+    }
+
+    /**
+     * Extract all fields from class
+     */
+    extractFields(content) {
+        const fields = [];
+
+        // Check if it's a record
+        const recordMatch = content.match(/public\s+record\s+\w+\s*\(([^)]+)\)/);
+        if (recordMatch) {
+            return this.extractRecordFields(recordMatch[1]);
+        }
+
+        // Regular class fields
+        const fieldRegex = /(?:@[\w.]+(?:\([^)]*\))?\s+)*(?:private|protected|public)\s+([\w<>,\s?]+)\s+(\w+)\s*(?:=|;)/g;
+        let match;
+        while ((match = fieldRegex.exec(content)) !== null) {
+            const fieldBlock = content.substring(match.index - 200, match.index + match[0].length);
+            const annotations = this.extractFieldAnnotations(fieldBlock);
+
+            fields.push({
+                type: match[1].trim(),
+                name: match[2],
+                annotations: annotations,
+                required: this.isFieldRequired(annotations),
+                validation: this.extractValidationRules(annotations)
+            });
+        }
+
+        return fields;
+    }
+
+    /**
+     * Extract fields from record definition
+     */
+    extractRecordFields(recordParams) {
+        const fields = [];
+        const params = this.splitParameters(recordParams);
+
+        for (const param of params) {
+            const parts = param.trim().split(/\s+/);
+            if (parts.length >= 2) {
+                const type = parts[0];
+                const name = parts[parts.length - 1];
+                fields.push({
+                    type: type,
+                    name: name,
+                    annotations: [],
+                    required: true,
+                    validation: {}
+                });
+            }
+        }
+
+        return fields;
+    }
+
+    /**
+     * Split parameters handling generics
+     */
+    splitParameters(paramsString) {
+        const params = [];
+        let current = "";
+        let depth = 0;
+
+        for (const char of paramsString) {
+            if (char === "<") depth++;
+            else if (char === ">") depth--;
+            else if (char === "," && depth === 0) {
+                params.push(current);
+                current = "";
+                continue;
+            }
+            current += char;
+        }
+        if (current.trim()) params.push(current);
+        return params;
+    }
+
+    /**
+     * Extract annotations for a field
+     */
+    extractFieldAnnotations(fieldBlock) {
+        const annotations = [];
+        const regex = /@(\w+)(?:\(([^)]*)\))?/g;
+        let match;
+        while ((match = regex.exec(fieldBlock)) !== null) {
+            annotations.push({
+                name: match[1],
+                value: match[2] || null
+            });
+        }
+        return annotations;
+    }
+
+    /**
+     * Check if field is required based on annotations
+     */
+    isFieldRequired(annotations) {
+        const requiredAnnotations = ["NotNull", "NotBlank", "NotEmpty", "NonNull"];
+        return annotations.some(a => requiredAnnotations.includes(a.name));
+    }
+
+    /**
+     * Extract validation rules from annotations
+     */
+    extractValidationRules(annotations) {
+        const rules = {};
+
+        for (const annotation of annotations) {
+            switch (annotation.name) {
+                case "Size":
+                    const sizeMatch = annotation.value?.match(/min\s*=\s*(\d+).*max\s*=\s*(\d+)/);
+                    if (sizeMatch) {
+                        rules.minLength = parseInt(sizeMatch[1]);
+                        rules.maxLength = parseInt(sizeMatch[2]);
+                    }
+                    break;
+                case "Min":
+                    rules.min = parseInt(annotation.value);
+                    break;
+                case "Max":
+                    rules.max = parseInt(annotation.value);
+                    break;
+                case "Email":
+                    rules.format = "email";
+                    break;
+                case "Pattern":
+                    const patternMatch = annotation.value?.match(/regexp\s*=\s*"([^"]+)"/);
+                    if (patternMatch) rules.pattern = patternMatch[1];
+                    break;
+            }
+        }
+
+        return rules;
+    }
+
+    /**
+     * Extract extends clause
+     */
+    extractExtends(content) {
+        const match = content.match(/class\s+\w+\s+extends\s+([\w<>]+)/);
+        return match ? match[1] : null;
+    }
+
+    /**
+     * Extract implements clause
+     */
+    extractImplements(content) {
+        const match = content.match(/class\s+\w+(?:\s+extends\s+[\w<>]+)?\s+implements\s+([\w<>,\s]+)/);
+        if (match) {
+            return match[1].split(",").map(s => s.trim());
+        }
+        return [];
+    }
+
+    /**
+     * Generate example payload JSON
+     */
+    generateExamplePayload(dto) {
+        const payload = {};
+
+        for (const field of dto.fields) {
+            payload[field.name] = this.generateExampleValue(field);
+        }
+
+        return payload;
+    }
+
+    /**
+     * Generate example value for a field based on type
+     */
+    generateExampleValue(field) {
+        const type = field.type.replace(/<.*>/, ""); // Remove generics
+
+        // Check validation rules first
+        if (field.validation?.format === "email") {
+            return "user@example.com";
+        }
+
+        switch (type) {
+            case "String":
+                if (field.name.toLowerCase().includes("email")) return "user@example.com";
+                if (field.name.toLowerCase().includes("name")) return "John Doe";
+                if (field.name.toLowerCase().includes("phone")) return "+1234567890";
+                if (field.name.toLowerCase().includes("password")) return "********";
+                if (field.name.toLowerCase().includes("id")) return "abc123";
+                if (field.name.toLowerCase().includes("url")) return "https://example.com";
+                return "example_" + field.name;
+
+            case "Integer":
+            case "int":
+            case "Long":
+            case "long":
+                if (field.name.toLowerCase().includes("id")) return 1;
+                if (field.name.toLowerCase().includes("age")) return 25;
+                if (field.name.toLowerCase().includes("count")) return 10;
+                return field.validation?.min || 1;
+
+            case "Double":
+            case "double":
+            case "Float":
+            case "float":
+            case "BigDecimal":
+                if (field.name.toLowerCase().includes("price")) return 99.99;
+                if (field.name.toLowerCase().includes("amount")) return 100.00;
+                return 0.0;
+
+            case "Boolean":
+            case "boolean":
+                return true;
+
+            case "List":
+            case "Set":
+            case "Collection":
+                return [];
+
+            case "Map":
+                return {};
+
+            case "Date":
+            case "LocalDate":
+                return "2024-01-15";
+
+            case "LocalDateTime":
+            case "Instant":
+            case "ZonedDateTime":
+                return "2024-01-15T10:30:00Z";
+
+            case "UUID":
+                return "550e8400-e29b-41d4-a716-446655440000";
+
+            default:
+                // Complex type - return empty object
+                return {};
+        }
+    }
+
+    /**
+     * Find DTO by class name
+     */
+    async findDtoByClassName(className, files) {
+        // Clean class name (remove generics)
+        const cleanName = className.replace(/<.*>/, "").replace("ResponseEntity", "").trim();
+
+        if (!cleanName || cleanName === "void" || cleanName === "Object") {
+            return null;
+        }
+
+        // Look for file with this class name
+        for (const file of files) {
+            const filePath = file.path || file;
+            const fileName = path.basename(filePath, ".java");
+
+            if (fileName === cleanName) {
+                return this.analyzeDto(filePath);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Analyze all DTOs in workspace
+     */
+    async analyzeAll(files) {
+        const dtoPaths = await this.findDtoFiles(files);
+        const dtos = [];
+
+        for (const dtoPath of dtoPaths) {
+            const dto = await this.analyzeDto(dtoPath);
+            if (dto) {
+                dtos.push(dto);
+            }
+        }
+
+        return dtos;
+    }
+
+    /**
+     * Generate complete API payload documentation
+     */
+    async generatePayloadDocs(files, endpoints) {
+        const dtos = await this.analyzeAll(files);
+        const dtoMap = new Map(dtos.map(d => [d.className, d]));
+
+        // Enrich endpoints with payload info
+        const enrichedEndpoints = [];
+
+        for (const endpoint of endpoints) {
+            const enriched = { ...endpoint };
+
+            // Find request body DTO
+            if (endpoint.requestBody) {
+                const requestDto = dtoMap.get(endpoint.requestBody.type);
+                if (requestDto) {
+                    enriched.requestPayload = {
+                        dto: requestDto.className,
+                        fields: requestDto.fields,
+                        example: requestDto.examplePayload
+                    };
+                }
+            }
+
+            // Find response DTO
+            if (endpoint.returnType) {
+                const returnTypeName = endpoint.returnType
+                    .replace(/ResponseEntity</, "")
+                    .replace(/Mono</, "")
+                    .replace(/Flux</, "")
+                    .replace(/<.*>/, "")
+                    .replace(/>/, "")
+                    .trim();
+
+                const responseDto = dtoMap.get(returnTypeName);
+                if (responseDto) {
+                    enriched.responsePayload = {
+                        dto: responseDto.className,
+                        fields: responseDto.fields,
+                        example: responseDto.examplePayload
+                    };
+                }
+            }
+
+            enrichedEndpoints.push(enriched);
+        }
+
+        return {
+            totalDtos: dtos.length,
+            dtos: dtos,
+            endpoints: enrichedEndpoints
+        };
+    }
+}
+
+export default DTOAnalyzer;

package/detectors/framework-detector.js

@@ -0,0 +1,91 @@
+export class FrameworkDetector {
+    constructor(language, files, fileReader) {
+        this.language = language;
+        this.files = files;
+        this.fileReader = fileReader;
+    }
+
+    async detect() {
+        switch (this.language) {
+            case 'java':
+                return this.detectJavaFramework();
+            case 'node':
+                return this.detectNodeFramework();
+            case 'python':
+                return this.detectPythonFramework();
+            case 'dotnet':
+                return { framework: 'dotnet', version: null, buildTool: 'dotnet' };
+            case 'go':
+                return { framework: 'go', version: null, buildTool: 'go' };
+            default:
+                return { framework: 'unknown', version: null, buildTool: null };
+        }
+    }
+
+    async detectJavaFramework() {
+        const pomFile = this.files.find(f => f.name === 'pom.xml');
+        if (pomFile) {
+            const content = await this.fileReader.read(pomFile.path);
+            if (content.content.includes('spring-boot')) {
+                const version = this.extractVersion(content.content, 'spring-boot-starter-parent');
+                return { framework: 'spring-boot', version, buildTool: 'maven' };
+            }
+            if (content.content.includes('quarkus')) {
+                return { framework: 'quarkus', version: null, buildTool: 'maven' };
+            }
+            return { framework: 'java-maven', version: null, buildTool: 'maven' };
+        }
+
+        const gradleFile = this.files.find(f => f.name === 'build.gradle' || f.name === 'build.gradle.kts');
+        if (gradleFile) {
+            const content = await this.fileReader.read(gradleFile.path);
+            if (content.content.includes('spring-boot') || content.content.includes('org.springframework.boot')) {
+                return { framework: 'spring-boot', version: null, buildTool: 'gradle' };
+            }
+            return { framework: 'java-gradle', version: null, buildTool: 'gradle' };
+        }
+
+        return { framework: 'java-plain', version: null, buildTool: null };
+    }
+
+    async detectNodeFramework() {
+        const pkgFile = this.files.find(f => f.name === 'package.json');
+        if (!pkgFile) return { framework: 'unknown', version: null, buildTool: 'npm' };
+
+        const content = await this.fileReader.read(pkgFile.path);
+        const pkg = JSON.parse(content.content);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+        if (deps['next']) return { framework: 'next', version: deps['next'], buildTool: 'npm' };
+        if (deps['express']) return { framework: 'express', version: deps['express'], buildTool: 'npm' };
+        if (deps['react']) return { framework: 'react', version: deps['react'], buildTool: 'npm' };
+        if (deps['vue']) return { framework: 'vue', version: deps['vue'], buildTool: 'npm' };
+        if (deps['@nestjs/core']) return { framework: 'nestjs', version: deps['@nestjs/core'], buildTool: 'npm' };
+        if (deps['@angular/core']) return { framework: 'angular', version: deps['@angular/core'], buildTool: 'npm' };
+
+        return { framework: 'node-plain', version: null, buildTool: 'npm' };
+    }
+
+    async detectPythonFramework() {
+        const reqFile = this.files.find(f => f.name === 'requirements.txt');
+        if (reqFile) {
+            const content = await this.fileReader.read(reqFile.path);
+            if (content.content.includes('django')) return { framework: 'django', version: null, buildTool: 'pip' };
+            if (content.content.includes('flask')) return { framework: 'flask', version: null, buildTool: 'pip' };
+            if (content.content.includes('fastapi')) return { framework: 'fastapi', version: null, buildTool: 'pip' };
+        }
+
+        const pyprojectFile = this.files.find(f => f.name === 'pyproject.toml');
+        if (pyprojectFile) {
+            return { framework: 'python-poetry', version: null, buildTool: 'poetry' };
+        }
+
+        return { framework: 'python-plain', version: null, buildTool: 'pip' };
+    }
+
+    extractVersion(xml, dependency) {
+        const regex = new RegExp(`<${dependency}>.*?<version>(.*?)</version>`, 's');
+        const match = xml.match(regex);
+        return match ? match[1] : null;
+    }
+}

package/detectors/language-detector.js

@@ -0,0 +1,89 @@
+export class LanguageDetector {
+    constructor(files) {
+        this.files = files;
+    }
+
+    detect() {
+        const markers = this.findMarkers();
+        const extensions = this.analyzeExtensions();
+
+        return {
+            primary: this.determinePrimaryLanguage(markers, extensions),
+            secondary: this.findSecondaryLanguages(extensions),
+            confidence: this.calculateConfidence(markers)
+        };
+    }
+
+    findMarkers() {
+        const markers = {
+            java: this.files.some(f => f.name === 'pom.xml' || f.name === 'build.gradle'),
+            node: this.files.some(f => f.name === 'package.json'),
+            python: this.files.some(f => f.name === 'requirements.txt' || f.name === 'pyproject.toml'),
+            dotnet: this.files.some(f => f.name.endsWith('.csproj') || f.name.endsWith('.sln')),
+            go: this.files.some(f => f.name === 'go.mod'),
+            php: this.files.some(f => f.name === 'composer.json'),
+            ruby: this.files.some(f => f.name === 'Gemfile')
+        };
+        return markers;
+    }
+
+    analyzeExtensions() {
+        const extCount = {};
+        this.files.forEach(f => {
+            const ext = f.extension?.toLowerCase();
+            if (ext) extCount[ext] = (extCount[ext] || 0) + 1;
+        });
+        return extCount;
+    }
+
+    determinePrimaryLanguage(markers, extensions) {
+        // Prioridade: markers > extensões
+        const detected = Object.entries(markers)
+            .filter(([_, exists]) => exists)
+            .map(([lang]) => lang);
+
+        if (detected.length === 1) return detected[0];
+        if (detected.length > 1) {
+            // Múltiplas linguagens, escolhe por extensões
+            const sortedExts = Object.entries(extensions)
+                .sort((a, b) => b[1] - a[1]);
+            return this.mapExtToLang(sortedExts[0]?.[0]);
+        }
+
+        // Fallback: extensão mais comum
+        const sortedExts = Object.entries(extensions)
+            .sort((a, b) => b[1] - a[1]);
+        return this.mapExtToLang(sortedExts[0]?.[0]) || 'unknown';
+    }
+
+    mapExtToLang(ext) {
+        const map = {
+            '.java': 'java',
+            '.js': 'node',
+            '.ts': 'node',
+            '.jsx': 'node',
+            '.tsx': 'node',
+            '.py': 'python',
+            '.cs': 'dotnet',
+            '.go': 'go',
+            '.php': 'php',
+            '.rb': 'ruby'
+        };
+        return map[ext] || null;
+    }
+
+    findSecondaryLanguages(extensions) {
+        const primary = this.determinePrimaryLanguage(this.findMarkers(), extensions);
+        return Object.keys(extensions)
+            .map(ext => this.mapExtToLang(ext))
+            .filter(lang => lang && lang !== primary)
+            .filter((v, i, a) => a.indexOf(v) === i); // unique
+    }
+
+    calculateConfidence(markers) {
+        const markerCount = Object.values(markers).filter(Boolean).length;
+        if (markerCount === 0) return 0.3;
+        if (markerCount === 1) return 0.9;
+        return 0.7; // Múltiplos markers = projeto polyglot
+    }
+}