@archznn/xavva 2.5.0 → 2.7.0

package/src/utils/PathUtils.ts

@@ -0,0 +1,221 @@
+/**
+ * Utilitários para manipulação de paths
+ * Centraliza lógica comum de normalização e resolução de caminhos
+ */
+
+import path from "path";
+
+export class PathUtils {
+    /**
+     * Normaliza separadores de path para forward slash
+     */
+    static normalizeSeparators(filePath: string): string {
+        return filePath.replace(/\\/g, "/");
+    }
+
+    /**
+     * Converte caminho relativo para absoluto a partir do cwd
+     */
+    static resolveFromCwd(relativePath: string): string {
+        return path.resolve(process.cwd(), relativePath);
+    }
+
+    /**
+     * Obtém caminho relativo a partir do diretório raiz do projeto
+     */
+    static relativeToProject(absolutePath: string): string {
+        return path.relative(process.cwd(), absolutePath);
+    }
+
+    /**
+     * Verifica se caminho está dentro do diretório src/main/java (Maven) ou equivalente
+     */
+    static isSourceFile(filePath: string): boolean {
+        const normalized = this.normalizeSeparators(filePath);
+        return /src\/(main|test)\/(java|resources)/.test(normalized);
+    }
+
+    /**
+     * Extrai package de um arquivo Java baseado no caminho
+     */
+    static extractPackageFromPath(javaFilePath: string): string | null {
+        const normalized = this.normalizeSeparators(javaFilePath);
+        
+        // Procura por src/main/java ou src/test/java
+        const match = normalized.match(/src\/(?:main|test)\/java\/(.*)\/[^/]+\.java$/);
+        if (match) {
+            return match[1].replace(/\//g, ".");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Converte caminho de .java para .class
+     */
+    static javaToClassPath(javaPath: string): string {
+        return javaPath.replace(/\.java$/i, ".class");
+    }
+
+    /**
+     * Converte caminho relativo do source para caminho no diretório de classes
+     */
+    static sourceToClassesPath(
+        sourcePath: string, 
+        classesDir: string,
+        sourceRoots: string[] = ["src/main/java", "src/test/java", "src"]
+    ): string {
+        const normalized = this.normalizeSeparators(sourcePath);
+        
+        for (const root of sourceRoots) {
+            const normalizedRoot = this.normalizeSeparators(root);
+            const index = normalized.indexOf(normalizedRoot);
+            if (index !== -1) {
+                const relativePart = normalized.slice(index + normalizedRoot.length + 1);
+                const classFile = this.javaToClassPath(relativePart);
+                return path.join(classesDir, classFile);
+            }
+        }
+        
+        // Fallback: assume que é relativo ao classesDir
+        return path.join(classesDir, path.basename(this.javaToClassPath(sourcePath)));
+    }
+
+    /**
+     * Encontra o webapp root a partir de um caminho de recurso
+     */
+    static findWebappRoot(resourcePath: string): string | null {
+        const normalized = this.normalizeSeparators(resourcePath);
+        const parts = normalized.split("/");
+        
+        const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+        
+        if (rootIndex !== -1) {
+            return parts.slice(0, rootIndex + 1).join("/");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Obtém caminho relativo dentro do webapp
+     */
+    static getWebappRelativePath(resourcePath: string): string | null {
+        const normalized = this.normalizeSeparators(resourcePath);
+        const parts = normalized.split("/");
+        
+        const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+        
+        if (rootIndex !== -1 && rootIndex < parts.length - 1) {
+            return parts.slice(rootIndex + 1).join("/");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Verifica se é arquivo de recurso web (JSP, HTML, etc)
+     */
+    static isWebResource(filePath: string): boolean {
+        return /\.(jsp|html|htm|css|js|xml|properties|json|png|jpg|jpeg|gif|svg|ico)$/i.test(filePath);
+    }
+
+    /**
+     * Verifica se é arquivo Java
+     */
+    static isJavaFile(filePath: string): boolean {
+        return /\.java$/i.test(filePath);
+    }
+
+    /**
+     * Verifica se é arquivo de build/configuração
+     */
+    static isBuildConfig(filePath: string): boolean {
+        return /(pom\.xml|build\.gradle|build\.gradle\.kts|settings\.gradle)$/i.test(filePath);
+    }
+
+    /**
+     * Combina múltiplos paths de forma segura
+     */
+    static combinePaths(...parts: string[]): string {
+        return path.join(...parts);
+    }
+
+    /**
+     * Obtém diretório do arquivo
+     */
+    static getDir(filePath: string): string {
+        return path.dirname(filePath);
+    }
+
+    /**
+     * Obtém nome do arquivo
+     */
+    static getFilename(filePath: string): string {
+        return path.basename(filePath);
+    }
+
+    /**
+     * Obtém extensão do arquivo
+     */
+    static getExtension(filePath: string): string {
+        return path.extname(filePath).toLowerCase();
+    }
+
+    /**
+     * Remove extensão do arquivo
+     */
+    static removeExtension(filePath: string): string {
+        const ext = path.extname(filePath);
+        return ext ? filePath.slice(0, -ext.length) : filePath;
+    }
+
+    /**
+     * Verifica se caminho está dentro de diretório ignorado
+     */
+    static isIgnoredPath(filePath: string, ignoredDirs: string[] = []): boolean {
+        const normalized = this.normalizeSeparators(filePath);
+        const defaultIgnored = ["target", "build", "node_modules", ".git", ".xavva"];
+        const allIgnored = [...defaultIgnored, ...ignoredDirs];
+        
+        return allIgnored.some(dir => {
+            // Match exato ou como diretório
+            const pattern = new RegExp(`(^|/)${dir}($|/)`);
+            return pattern.test(normalized);
+        });
+    }
+
+    /**
+     * Resolve caminho de contexto WAR
+     */
+    static resolveContextPath(appName: string): string {
+        return appName.replace(/\.war$/i, "");
+    }
+}
+
+// Exporta funções standalone para conveniência
+export const {
+    normalizeSeparators,
+    resolveFromCwd,
+    relativeToProject,
+    isSourceFile,
+    extractPackageFromPath,
+    javaToClassPath,
+    sourceToClassesPath,
+    findWebappRoot,
+    getWebappRelativePath,
+    isWebResource,
+    isJavaFile,
+    isBuildConfig,
+    combinePaths,
+    getDir,
+    getFilename,
+    getExtension,
+    removeExtension,
+    isIgnoredPath,
+    resolveContextPath,
+} = PathUtils;

package/src/utils/config.ts

@@ -38,6 +38,12 @@ export class ConfigManager {
                 yes: { type: "boolean", short: "y" },
                 war: { type: "boolean", short: "W" },
                 cache: { type: "boolean" },
+                from: { type: "string" },
+                to: { type: "string" },
+                backup: { type: "boolean" },
+                "dry-run": { type: "boolean" },
+                force: { type: "boolean" },
+                src: { type: "string" },
             },
             strict: false,
             allowPositionals: true,

package/src/utils/parsers/JavaParser.ts

@@ -0,0 +1,413 @@
+/**
+ * Parser de código Java
+ * Centraliza análise de anotações e estrutura de arquivos .java
+ */
+
+import type { ApiEndpoint, ApiParam } from "../../types/endpoint";
+
+export interface JavaClassInfo {
+    className: string;
+    package?: string;
+    annotations: AnnotationInfo[];
+    methods: JavaMethodInfo[];
+}
+
+export interface AnnotationInfo {
+    name: string;
+    value?: string;
+    attributes: Record<string, string>;
+}
+
+export interface JavaMethodInfo {
+    name: string;
+    annotations: AnnotationInfo[];
+    parameters: JavaParameterInfo[];
+    returnType?: string;
+}
+
+export interface JavaParameterInfo {
+    name: string;
+    type: string;
+    annotations: AnnotationInfo[];
+}
+
+export class JavaParser {
+    /**
+     * Extrai informações completas de uma classe Java
+     */
+    static parseClass(content: string, fileName: string): JavaClassInfo {
+        const className = fileName.replace(/\.java$/i, "");
+        
+        return {
+            className,
+            package: this.extractPackage(content),
+            annotations: this.extractClassAnnotations(content),
+            methods: this.extractMethods(content),
+        };
+    }
+
+    /**
+     * Extrai package declaration
+     */
+    static extractPackage(content: string): string | undefined {
+        const match = content.match(/package\s+([\w.]+)\s*;/);
+        return match?.[1];
+    }
+
+    /**
+     * Extrai imports
+     */
+    static extractImports(content: string): string[] {
+        const imports: string[] = [];
+        const regex = /import\s+([\w.*]+)\s*;/g;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            imports.push(match[1]);
+        }
+        return imports;
+    }
+
+    /**
+     * Extrai anotações de classe
+     */
+    static extractClassAnnotations(content: string): AnnotationInfo[] {
+        // Procura anotações antes da declaração da classe
+        const classMatch = content.match(/(@[\w\s(,="{}[\]]+)\s+(?:public\s+)?(?:abstract\s+)?class\s+\w+/);
+        if (!classMatch) return [];
+        
+        return this.parseAnnotations(classMatch[1]);
+    }
+
+    /**
+     * Extrai métodos da classe
+     */
+    static extractMethods(content: string): JavaMethodInfo[] {
+        const methods: JavaMethodInfo[] = [];
+        
+        // Regex melhorado para encontrar métodos
+        // Procura por padrões como: @Anotacao public Tipo metodo(params)
+        // Também captura métodos sem anotações
+        const methodPattern = /((?:@[\w]+(?:\s*\([^)]*\))?\s*)*)\s*(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?([\w<>[\],\s.?]+)\s+(\w+)\s*\(([^)]*)\)\s*(?:throws\s+[\w,\s]+)?\s*[{;]/g;
+        
+        let match;
+        while ((match = methodPattern.exec(content)) !== null) {
+            const annotationsStr = match[1] || "";
+            const returnType = match[2].trim();
+            const name = match[3];
+            const paramsStr = match[4];
+            
+            // Pula métodos que parecem ser construtores (tipo == nome da classe)
+            // ou que não têm tipo de retorno válido
+            if (!returnType || returnType === name) continue;
+            
+            methods.push({
+                name,
+                annotations: this.parseAnnotations(annotationsStr),
+                parameters: this.parseParameters(paramsStr),
+                returnType,
+            });
+        }
+        
+        return methods;
+    }
+
+    /**
+     * Parse de string de anotações
+     */
+    static parseAnnotations(annotationsStr: string): AnnotationInfo[] {
+        const annotations: AnnotationInfo[] = [];
+        
+        // Regex para anotações: @Nome ou @Nome(atributos)
+        const regex = /@(\w+)(?:\s*\(\s*([^)]*)\s*\))?/g;
+        
+        let match;
+        while ((match = regex.exec(annotationsStr)) !== null) {
+            const name = match[1];
+            const attrsStr = match[2] || "";
+            
+            const { value, attributes } = this.parseAnnotationAttributes(attrsStr);
+            
+            annotations.push({ name, value, attributes });
+        }
+        
+        return annotations;
+    }
+
+    /**
+     * Parse de atributos de anotação
+     */
+    private static parseAnnotationAttributes(attrsStr: string): { value?: string; attributes: Record<string, string> } {
+        const attributes: Record<string, string> = {};
+        let value: string | undefined;
+        
+        if (!attrsStr.trim()) {
+            return { value, attributes };
+        }
+        
+        // Verifica se é valor simples (string literal ou array)
+        const simpleValueMatch = attrsStr.match(/^\s*["']([^"']+)["']\s*$/);
+        if (simpleValueMatch) {
+            value = simpleValueMatch[1];
+            return { value, attributes };
+        }
+        
+        // Parse de atributos chave=valor
+        // Pega tudo entre aspas após um sinal de igual
+        const attrRegex = /(\w+)\s*=\s*["']([^"']*?)["']/g;
+        let attrMatch;
+        while ((attrMatch = attrRegex.exec(attrsStr)) !== null) {
+            const key = attrMatch[1];
+            const val = attrMatch[2];
+            
+            if (key === "value") {
+                value = val;
+            } else {
+                attributes[key] = val;
+            }
+        }
+        
+        // Se não encontrou atributos com regex, tenta extrair valor como string simples
+        if (Object.keys(attributes).length === 0 && !value) {
+            const simpleMatch = attrsStr.match(/["']([^"']+)["']/);
+            if (simpleMatch) {
+                value = simpleMatch[1];
+            }
+        }
+        
+        return { value, attributes };
+    }
+
+    /**
+     * Parse de parâmetros de método
+     */
+    static parseParameters(paramsStr: string): JavaParameterInfo[] {
+        const parameters: JavaParameterInfo[] = [];
+        
+        if (!paramsStr.trim()) {
+            return parameters;
+        }
+        
+        // Divide por vírgula, mas cuida com generics
+        const params = this.splitParams(paramsStr);
+        
+        for (const param of params) {
+            const trimmed = param.trim();
+            if (!trimmed) continue;
+            
+            // Extrai anotações do parâmetro
+            const annotations: AnnotationInfo[] = [];
+            let paramWithoutAnnotations = trimmed;
+            
+            const annoRegex = /@(\w+)\s*\(\s*["']([^"']+)["']\s*\)/g;
+            let annoMatch;
+            while ((annoMatch = annoRegex.exec(trimmed)) !== null) {
+                annotations.push({
+                    name: annoMatch[1],
+                    value: annoMatch[2],
+                    attributes: {},
+                });
+                paramWithoutAnnotations = paramWithoutAnnotations.replace(annoMatch[0], "").trim();
+            }
+            
+            // Tipo e nome
+            const parts = paramWithoutAnnotations.split(/\s+/);
+            if (parts.length >= 2) {
+                parameters.push({
+                    type: parts.slice(0, -1).join(" "),
+                    name: parts[parts.length - 1],
+                    annotations,
+                });
+            }
+        }
+        
+        return parameters;
+    }
+
+    /**
+     * Divide string de parâmetros respeitando generics
+     */
+    private static splitParams(paramsStr: string): string[] {
+        const result: string[] = [];
+        let current = "";
+        let depth = 0;
+        
+        for (const char of paramsStr) {
+            if (char === "<") {
+                depth++;
+                current += char;
+            } else if (char === ">") {
+                depth--;
+                current += char;
+            } else if (char === "," && depth === 0) {
+                result.push(current);
+                current = "";
+            } else {
+                current += char;
+            }
+        }
+        
+        if (current.trim()) {
+            result.push(current);
+        }
+        
+        return result;
+    }
+
+    /**
+     * Extrai endpoints REST de um arquivo Java
+     * Suporta Spring MVC, JAX-RS, Jersey
+     */
+    static extractEndpoints(content: string, fileName: string, contextPath: string = ""): ApiEndpoint[] {
+        const classInfo = this.parseClass(content, fileName);
+        const endpoints: ApiEndpoint[] = [];
+        
+        // Encontra path base da classe
+        const basePath = this.extractBasePath(classInfo.annotations);
+        
+        for (const method of classInfo.methods) {
+            const methodPath = this.extractMethodPath(method.annotations);
+            const httpMethod = this.inferHttpMethod(method.annotations);
+            
+            if (!methodPath && httpMethod === "ALL") continue;
+            
+            const fullPath = this.combinePaths(contextPath, basePath, methodPath);
+            
+            endpoints.push({
+                method: httpMethod,
+                path: methodPath || "/",
+                fullPath,
+                className: classInfo.className,
+                methodName: method.name,
+                parameters: this.convertParams(method.parameters),
+            });
+        }
+        
+        return endpoints;
+    }
+
+    /**
+     * Extrai path base de anotações de classe
+     */
+    private static extractBasePath(annotations: AnnotationInfo[]): string {
+        // Spring: @RequestMapping("/path") ou @Path("/path") (JAX-RS)
+        const mapping = annotations.find(a => 
+            a.name === "RequestMapping" || a.name === "Path"
+        );
+        return mapping?.value || "";
+    }
+
+    /**
+     * Extrai path de método de anotações
+     */
+    private static extractMethodPath(annotations: AnnotationInfo[]): string {
+        // Procura qualquer anotação que tenha valor de path
+        const pathAnnotations = [
+            "RequestMapping", "GetMapping", "PostMapping", 
+            "PutMapping", "DeleteMapping", "PatchMapping",
+            "Path"
+        ];
+        
+        const mapping = annotations.find(a => pathAnnotations.includes(a.name));
+        return mapping?.value || "";
+    }
+
+    /**
+     * Infere método HTTP de anotações
+     */
+    private static inferHttpMethod(annotations: AnnotationInfo[]): ApiEndpoint["method"] {
+        const annoNames = annotations.map(a => a.name);
+        
+        if (annoNames.includes("GetMapping")) return "GET";
+        if (annoNames.includes("PostMapping")) return "POST";
+        if (annoNames.includes("PutMapping")) return "PUT";
+        if (annoNames.includes("DeleteMapping")) return "DELETE";
+        if (annoNames.includes("PatchMapping")) return "PATCH";
+        
+        // JAX-RS
+        if (annoNames.includes("GET")) return "GET";
+        if (annoNames.includes("POST")) return "POST";
+        if (annoNames.includes("PUT")) return "PUT";
+        if (annoNames.includes("DELETE")) return "DELETE";
+        if (annoNames.includes("PATCH")) return "PATCH";
+        
+        // RequestMapping genérico
+        if (annoNames.includes("RequestMapping")) {
+            const mapping = annotations.find(a => a.name === "RequestMapping");
+            const methodAttr = mapping?.attributes?.method;
+            if (methodAttr) {
+                const method = methodAttr.replace(/RequestMethod\./g, "").toUpperCase();
+                if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(method)) {
+                    return method as ApiEndpoint["method"];
+                }
+            }
+            return "ALL";
+        }
+        
+        return "ALL";
+    }
+
+    /**
+     * Converte parâmetros Java para ApiParam
+     */
+    private static convertParams(params: JavaParameterInfo[]): ApiParam[] {
+        return params.map(p => {
+            const source = this.inferParamSource(p.annotations);
+            const required = !p.annotations.some(a => 
+                a.name === "RequestParam" && a.attributes?.required === "false"
+            );
+            
+            return {
+                name: p.name,
+                type: p.type,
+                source,
+                required,
+            };
+        });
+    }
+
+    /**
+     * Infere fonte do parâmetro (PATH, QUERY, BODY, HEADER)
+     */
+    private static inferParamSource(annotations: AnnotationInfo[]): ApiParam["source"] {
+        const annoNames = annotations.map(a => a.name);
+        
+        if (annoNames.includes("PathVariable") || annoNames.includes("PathParam")) {
+            return "PATH";
+        }
+        if (annoNames.includes("RequestParam") || annoNames.includes("QueryParam")) {
+            return "QUERY";
+        }
+        if (annoNames.includes("RequestBody")) {
+            return "BODY";
+        }
+        if (annoNames.includes("RequestHeader") || annoNames.includes("HeaderParam")) {
+            return "HEADER";
+        }
+        
+        return "QUERY"; // Default
+    }
+
+    /**
+     * Combina múltiplos paths
+     */
+    private static combinePaths(...parts: string[]): string {
+        return parts
+            .map(p => p.trim())
+            .map(p => (p.startsWith("/") ? p : "/" + p))
+            .map(p => (p.endsWith("/") && p.length > 1 ? p.slice(0, -1) : p))
+            .filter(p => p && p !== "/")
+            .join("") || "/";
+    }
+}
+
+// Exporta funções standalone
+export const {
+    parseClass,
+    extractPackage,
+    extractImports,
+    extractClassAnnotations,
+    extractMethods,
+    parseAnnotations,
+    parseParameters,
+    extractEndpoints,
+} = JavaParser;