@archznn/xavva 1.6.5 → 1.7.0

package/README.md

@@ -1,25 +1,21 @@
-# XAVVA 🚀 (Windows Only) `v1.6.5`
+# XAVVA 🚀 (Windows Only) `v1.7.0`
 
 Xavva é uma CLI de alto desempenho construída com **Bun** para automatizar o ciclo de desenvolvimento de aplicações Java (Maven/Gradle) rodando no Apache Tomcat. Ela foi desenhada especificamente para desenvolvedores que buscam a velocidade de ambientes modernos (como Node.js/Vite) dentro do ecossistema Java Enterprise.
 
-> [!IMPORTANT]
-> **Compatibilidade:** Atualmente, o Xavva é exclusivo para **Windows**, utilizando integrações nativas com PowerShell e CMD para automação de browser e gerenciamento de processos.
-
 ## 🛠️ Funcionalidades de Elite
 
 - **⚡ Ultra-Fast Hot Swap**: Compilação incremental e injeção direta de arquivos `.class` e recursos (JSP, HTML, CSS, JS) no Tomcat em execução sem necessidade de restart.
+- **📦 Multi-Module Support**: Detecção recursiva de diretórios de classes em projetos complexos, garantindo que o Hot-Reload funcione entre diferentes módulos.
 - **🛠️ Modo Dev Inteligente**: O comando `xavva dev` ativa hot-reload, logs limpos, debugger (JPDA) e monitoramento de memória em um único fluxo.
 - **🌐 Live Reload Automático**: Atualiza automaticamente as abas do Chrome ou Edge após o deploy ou sincronização de arquivos, mantendo o foco no código.
-- **🔍 API Documentation (Swagger-like)**: O comando `xavva docs` mapeia estaticamente sua API, exibindo endpoints, métodos HTTP e parâmetros (Query, Path, Body) diretamente no terminal.
-- **📊 Real-time Log Filtering**: Filtra ruídos excessivos do Tomcat/Jersey/SLF4J, destacando erros Java com dicas de solução e tempo de startup.
-- **📈 JVM & Memory Monitor**: Exibe o consumo de RAM (Working Set) do processo do Tomcat em tempo real.
-- **🩺 Doctor Mode**: Diagnostica o ambiente (Java, Tomcat, Maven, Gradle) e corrige automaticamente problemas de **Encoding (UTF-8 BOM)** que podem causar falhas silenciosas no Java.
-- **🛡️ JAR Audit**: O comando `xavva audit` analisa todas as dependências (`.jar`) da sua aplicação e verifica vulnerabilidades conhecidas (CVEs) usando o banco de dados **OSV.dev**.
+- **🔍 API Documentation (Swagger-like)**: O comando `xavva docs` mapeia estaticamente sua API, exibindo endpoints, métodos HTTP e parâmetros diretamente no terminal.
+- **📊 Real-time Log Filtering**: Filtra ruídos excessivos do Tomcat/Jersey/SLF4J, destacando erros Java com dicas de solução.
+- **📈 JVM & Memory Monitor**: Exibe o consumo de RAM do processo do Tomcat em tempo real.
+- **🩺 Doctor Mode**: Diagnostica o ambiente e corrige automaticamente problemas de **Encoding (UTF-8 BOM)**.
+- **🛡️ JAR Audit**: Analisa todas as dependências (`.jar`) da sua aplicação em busca de vulnerabilidades (CVEs).
 
 ## 🚀 Instalação e Uso
 
-Você pode instalar o Xavva globalmente usando o NPM (requer [Bun](https://bun.sh/) instalado no sistema):
-
 ```bash
 # Instalação global
 npm install -g @archznn/xavva
@@ -30,46 +26,16 @@ npx @archznn/xavva dev
 
 ## ⚙️ Zero Config & Auto-Detection
 
-O Xavva foi evoluído para um modelo **Zero Config**. Você não precisa mais de arquivos de configuração para começar.
-
-- **Auto-Detecção:** O Xavva identifica automaticamente se seu projeto usa **Maven** (`pom.xml`) ou **Gradle** (`build.gradle`) ao ser executado na raiz.
-- **Ambiente Inteligente:** Ele utiliza as variáveis de ambiente `TOMCAT_HOME` ou `CATALINA_HOME` para localizar o servidor.
-- **Prioridade CLI:** Qualquer parâmetro passado via linha de comando (como `--path` ou `--port`) tem precedência total sobre o ambiente.
+O Xavva identifica automaticamente se seu projeto usa **Maven** (`pom.xml`) ou **Gradle** (`build.gradle`) e localiza o Tomcat através das variáveis `TOMCAT_HOME` ou `CATALINA_HOME`.
 
 ### Comandos Principais
 
 ```bash
-# Inicia o modo de desenvolvimento completo (Auto-detecta Maven/Gradle)
-xavva dev
-
-# Define o Tomcat e o Profile manualmente via CLI
-xavva dev -p C:\tomcat-9 -P production
-
-# Exibe a documentação da API
-xavva docs
-
-# Audita vulnerabilidades nas dependências JAR do app
-xavva audit
-
-# Diagnostica o ambiente e limpa arquivos com BOM (UTF-8 signature)
-xavva doctor --fix
+xavva dev          # Modo desenvolvimento completo com Hot-Reload
+xavva docs         # Documentação estática de endpoints
+xavva audit        # Auditoria de segurança de dependências
+xavva doctor --fix # Diagnóstico e reparo de ambiente
 ```
 
-### Opções Úteis
-
-- `-p, --path <path>`: Caminho customizado do Tomcat (Sobrescreve TOMCAT_HOME).
-- `-P, --profile <nome>`: Define o profile do Maven/Gradle (ex: dev, prod).
-- `-t, --tool <maven|gradle>`: Força o uso de uma ferramenta específica.
-- `-n, --name <nome>`: Define o nome do contexto da aplicação.
-- `-w, --watch`: Ativa o monitoramento de arquivos para hot-reload.
-- `-d, --debug`: Habilita o Java Debugger na porta 5005.
-
-## 📦 Stack Tecnológica
-
-- **Runtime:** [Bun](https://bun.sh/) (Engine de alta performance)
-- **Linguagem:** [TypeScript](https://www.typescriptlang.org/)
-- **Automação:** PowerShell & CMD (Integração nativa Windows)
-- **CI/CD:** GitHub Actions para geração de binários multi-plataforma (via Bun Compile)
-
 ---
 *Desenvolvido para transformar a experiência de desenvolvimento Java Legacy em algo ágil e produtivo.*

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "1.6.5",
+	"version": "1.7.0",
 	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
 	"module": "src/index.ts",
 	"type": "module",

package/src/commands/AuditCommand.ts

@@ -11,12 +11,10 @@ export class AuditCommand implements Command {
 
         let appName = config.project.appName;
         
-        // 1. Tentar inferir do diretório atual se não foi passado via config
         if (!appName) {
             appName = this.inferFromArtifacts();
         }
 
-        // 2. Se ainda não tem nome, tenta inferir do Tomcat
         if (!appName) {
             const webappsPath = path.join(config.tomcat.path, "webapps");
             if (fs.existsSync(webappsPath)) {
@@ -68,14 +66,12 @@ export class AuditCommand implements Command {
     }
 
     private inferFromArtifacts(): string | undefined {
-        // Busca .war no target (Maven) ou build/libs (Gradle)
         const paths = ["target", "build/libs"];
         for (const p of paths) {
             const fullPath = path.join(process.cwd(), p);
             if (fs.existsSync(fullPath)) {
                 const wars = fs.readdirSync(fullPath).filter(f => f.endsWith(".war"));
                 if (wars.length > 0) {
-                    // Retorna o nome do .war mais recente sem a extensão
                     const latest = wars.map(name => ({
                         name,
                         time: fs.statSync(path.join(fullPath, name)).mtimeMs

package/src/commands/DeployCommand.ts

@@ -32,16 +32,27 @@ export class DeployCommand implements Command {
         const builder = this.builder || new BuildService(config.project, config.tomcat);
 
         if (!incremental) {
-            Logger.section("Deploy Configuration");
-            if (config.project.quiet) {
-                Logger.info("App", `${config.project.appName} (${config.project.buildTool.toUpperCase()}${config.project.profile ? ` - ${config.project.profile}` : ""})`);
-                Logger.info("Status", `Watch: ${isWatching ? "ON" : "OFF"} | Debug: ${config.project.debug ? "ON" : "OFF"}`);
-            } else {
-                Logger.info("Tool", config.project.buildTool.toUpperCase());
-                Logger.info("App Name", config.project.appName);
-                if (config.project.profile) Logger.info("Profile", config.project.profile);
-                Logger.info("Watch Mode", isWatching ? "Active" : "Inactive");
-                Logger.info("Debug Mode", config.project.debug ? "Active" : "Inactive");
+            Logger.config("Runtime", config.project.buildTool.toUpperCase());
+            Logger.config("Watch Mode", isWatching ? "ON" : "OFF");
+            Logger.config("Debug", config.project.debug ? "ON (Port 5005)" : "OFF");
+
+            let javaBin = "java";
+            if (process.env.JAVA_HOME) {
+                const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
+                if (fs.existsSync(homeBin)) javaBin = homeBin;
+            }
+            
+            const javaVer = Bun.spawnSync([javaBin, "-version"]);
+            const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
+            const hasDcevm = output.includes("dcevm") || 
+                             output.includes("jetbrains") || 
+                             output.includes("trava") || 
+                             output.includes("jbr");
+            
+            if (!hasDcevm && isWatching) {
+                Logger.config("Hot Reload", "Standard (No structural changes)");
+            } else if (hasDcevm) {
+                Logger.config("Hot Reload", "Advanced (DCEVM Active)");
             }
 
             const srcPath = path.join(process.cwd(), "src");
@@ -49,12 +60,11 @@ export class DeployCommand implements Command {
                 const contextPath = (config.project.appName || "").replace(".war", "");
                 const endpoints = EndpointService.scan(srcPath, contextPath);
                 if (endpoints.length > 0) {
-                    Logger.info("Endpoints", endpoints.length);
+                    Logger.config("Endpoints", endpoints.length);
                 }
             }
         } else {
-            console.log("");
-            Logger.warn("Re-deploying detected changes...");
+            Logger.watcher("Change detected", "change");
         }
         
         try {
@@ -65,45 +75,64 @@ export class DeployCommand implements Command {
             }
 
             if (!config.project.skipBuild) {
+                if (incremental) Logger.watcher("Incremental compilation", "start");
                 await builder.runBuild(incremental);
+                if (!incremental) Logger.build("Full project build");
             }
 
             if (incremental) {
-                const appFolder = await builder.syncClasses();
-                const actualContextPath = contextPath || appFolder || "";
-                if (actualContextPath) {
-                    const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
-                    await this.reloadBrowser(actualAppUrl);
-                }
+                const actualAppFolder = await builder.syncClasses(true); 
+                const actualContextPath = contextPath || actualAppFolder || "";
+                const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
+                await this.reloadBrowser(actualAppUrl);
+                Logger.watcher("Redeploy completed", "success");
                 return;
             }
 
-            Logger.step("Cleaning webapps and cache");
-            tomcat.clearWebapps();
+            Logger.build("Webapps cleaned");
+            const artifactInfo = await builder.deployToWebapps();
+            Logger.build("Artifacts generated");
+            
+            const finalContextPath = contextPath || artifactInfo.finalName.replace(".war", "");
+            const appWebappPath = path.join(config.tomcat.path, "webapps", finalContextPath);
+
+            if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
+
+            try {
+                Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
+                Logger.build("Artifacts deployed");
+            } catch (e: any) {
+                const extractCmd = `powershell -command "Expand-Archive -Path '${artifactInfo.path}' -DestinationPath '${appWebappPath}' -Force"`;
+                Bun.spawnSync(["powershell", "-command", extractCmd]);
+                Logger.build("Artifacts deployed (legacy mode)");
+            }
 
-            Logger.step("Moving artifacts to webapps");
-            const artifact = await builder.deployToWebapps();
+            const webInfClassesDir = path.join(appWebappPath, "WEB-INF", "classes");
+            if (!fs.existsSync(webInfClassesDir)) fs.mkdirSync(webInfClassesDir, { recursive: true });
             
-            const finalContextPath = contextPath || artifact.replace(".war", "");
+            const xavvaProps = path.join(process.cwd(), ".xavva", "hotswap-agent.properties");
+            if (fs.existsSync(xavvaProps)) {
+                fs.copyFileSync(xavvaProps, path.join(webInfClassesDir, "hotswap-agent.properties"));
+            }
+
             const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
             
             tomcat.onReady = async () => {
-                Logger.step(`Checking health at ${finalAppUrl}`);
-                
                 try {
                     await new Promise(r => setTimeout(r, 1500));
-                    
                     const response = await fetch(finalAppUrl);
                     if (response.status < 500) {
                         const memory = await tomcat.getMemoryUsage();
-                        Logger.success(`App is UP! (Status: ${response.status} | RAM: ${memory})`);
+                        Logger.health(finalAppUrl, "success");
+                        Logger.health(`Status ${response.status}`, "success");
+                        Logger.health(`Memory ${memory}`, "success");
 
                         if (!config.project.quiet) {
                             const endpoints = EndpointService.scan(path.join(process.cwd(), "src"), finalContextPath);
                             if (endpoints.length > 0) {
-                                console.log(`\n  ${"\x1b[36m"}◈ ENDPOINT MAP:${"\x1b[0m"}`);
-                                endpoints.forEach(e => console.log(`    ${"\x1b[90m"}➜${"\x1b[0m"} http://localhost:${config.tomcat.port}${e.fullPath}`));
-                                console.log("");
+                                Logger.newline();
+                                Logger.log(`${Logger.C.cyan}◈ ENDPOINT MAP:${Logger.C.reset}`);
+                                endpoints.forEach(e => Logger.log(`${Logger.C.dim}➜ ${Logger.C.reset}http://localhost:${config.tomcat.port}${e.fullPath}`));
                             }
                         }
                         
@@ -118,14 +147,14 @@ export class DeployCommand implements Command {
                             }
                         }
                     } else {
-                        Logger.warn(`App is starting, but returned status ${response.status}. Check your logs.`);
+                        Logger.health(`App returned status ${response.status}`, "warn");
                     }
                 } catch (e) {
-                    Logger.error(`Health check failed: Could not connect to ${finalAppUrl}`);
+                    Logger.health(`Could not connect to ${finalAppUrl}`, "error");
                 }
             };
 
-            tomcat.start(config.project.cleanLogs, config.project.debug, config.project.skipScan, config.project.quiet);
+            tomcat.start(config, isWatching);
         } catch (error: any) {
             Logger.error(error.message);
             throw error;
@@ -133,26 +162,40 @@ export class DeployCommand implements Command {
     }
 
     async syncResource(config: AppConfig, filename: string): Promise<void> {
-        const appName = config.project.appName || "";
-        const explodedPath = path.join(config.tomcat.path, "webapps", appName);
+        const contextPath = (config.project.appName || "").replace(".war", "");
+        
+        const webappsPath = path.join(config.tomcat.path, "webapps");
+        let appFolder = contextPath;
         
-        if (!fs.existsSync(explodedPath)) {
+        if (!appFolder && fs.existsSync(webappsPath)) {
+            const folders = fs.readdirSync(webappsPath, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs"].includes(dirent.name));
+            if (folders.length === 1) appFolder = folders[0].name;
+        }
+
+        const explodedPath = path.join(webappsPath, appFolder);
+        
+        if (!appFolder || !fs.existsSync(explodedPath)) {
             return;
         }
 
         const parts = filename.split(/[/\\]/);
         const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
         
-        if (webappIndex !== -1) {
-            const relPath = parts.slice(webappIndex + 1).join(path.sep);
+        if (rootIndex !== -1) {
+            const relPath = parts.slice(rootIndex + 1).join(path.sep);
             const targetPath = path.join(explodedPath, relPath);
             
             try {
+                const targetDir = path.dirname(targetPath);
+                if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+
                 fs.copyFileSync(filename, targetPath);
                 if (!config.project.quiet) Logger.success(`Synced ${path.basename(filename)} directly to Tomcat!`);
                 
-                const contextPath = config.project.appName || "";
-                const appUrl = `http://localhost:${config.tomcat.port}/${contextPath}`;
+                const appUrl = `http://localhost:${config.tomcat.port}/${appFolder}`;
                 await this.reloadBrowser(appUrl);
             } catch (e) {
                 Logger.error(`Failed to sync resource: ${filename}`);

package/src/commands/DocsCommand.ts

@@ -49,12 +49,12 @@ export class DocsCommand implements Command {
 
     private renderEndpoint(ep: ApiEndpoint, port: number) {
         const methodColors: Record<string, string> = {
-            GET: "\x1b[32m",    // Green
-            POST: "\x1b[33m",   // Yellow
-            PUT: "\x1b[34m",    // Blue
-            DELETE: "\x1b[31m", // Red
-            PATCH: "\x1b[35m",  // Magenta
-            ALL: "\x1b[37m"     // White
+            GET: "\x1b[32m",
+            POST: "\x1b[33m",
+            PUT: "\x1b[34m",
+            DELETE: "\x1b[31m",
+            PATCH: "\x1b[35m",
+            ALL: "\x1b[37m"
         };
 
         const color = methodColors[ep.method] || "\x1b[37m";
@@ -75,11 +75,11 @@ export class DocsCommand implements Command {
 
     private renderParameter(param: ApiParam) {
         const sourceColors: Record<string, string> = {
-            PATH: "\x1b[35m",   // Magenta
-            QUERY: "\x1b[36m",  // Cyan
-            BODY: "\x1b[33m",   // Yellow
-            HEADER: "\x1b[32m", // Green
-            FORM: "\x1b[34m"    // Blue
+            PATH: "\x1b[35m",
+            QUERY: "\x1b[36m",
+            BODY: "\x1b[33m",
+            HEADER: "\x1b[32m",
+            FORM: "\x1b[34m"
         };
 
         const color = sourceColors[param.source] || "\x1b[37m";