@archznn/xavva 2.0.3 → 2.2.0

package/README.md

@@ -1,78 +1 @@
-# XAVVA 🚀 (Windows Only) `v2.0.3`
-
-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.
-
----
-
-## 🛠️ Por que Xavva?
-
-Desenvolver para Java/Tomcat tradicionalmente envolve ciclos lentos de `clean install`, `war deploy` e restarts de servidor. O Xavva quebra esse paradigma ao introduzir um fluxo de **Hot-Reload incremental**, onde apenas o que mudou é enviado ao servidor.
-
-### ⚡ Funcionalidades de Elite
-
-- **Interactive Dashboard (TUI)**: Um painel em tempo real (`--tui`) com métricas de sistema, status do servidor e atalhos rápidos (Restart, Clear, Quit).
-- **Smart Log Analyzer**: Logs inteligentes que escondem ruídos do framework (Stack Folding) e destacam a causa raiz de erros Java.
-- **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 restart.
-- **Gradle & Maven Native**: Suporte robusto para ambos os ecossistemas, incluindo extração automática de classpath para execução de classes standalone (`run`/`debug`).
-- **Segurança & Robustez**: Auditoria de dependências (`.jar`) e execução protegida contra *Command Injection* no PowerShell.
-- **Pathing JAR (Windows)**: Contorna limites de caracteres do Windows em classpaths gigantes.
-- **Auto-Healing**: Diagnóstico e reparo automático de problemas comuns de ambiente.
-
----
-
-## 🚀 Começo Rápido
-
-### Instalação
-```powershell
-# Instalação global via NPM
-npm install -g @archznn/xavva
-
-# Iniciar em modo Dashboard (TUI)
-xavva dev --tui
-```
-
----
-
-## 📖 Referência de Comandos
-
-O Xavva 2.0 utiliza uma arquitetura modular de comandos e serviços.
-
-### 1. Modo Desenvolvimento (`xavva dev`)
-O comando principal para o dia a dia. Ativa o monitoramento de arquivos e o Hot-Reload.
-- **Flags úteis**: 
-  - `--tui`: Ativa o Dashboard interativo no terminal.
-  - `--no-build`: Pula o build inicial.
-  - `--watch`: Ativa o modo de observação de arquivos (padrão em `dev`).
-  - `--port 8081`: Define uma porta específica para o Tomcat.
-
-### 2. Configuração de Projeto (`xavva.json`)
-Crie um arquivo `xavva.json` na raiz do seu projeto para salvar suas configurações:
-```json
-{
-  "project": {
-    "appName": "meu-app",
-    "buildTool": "maven",
-    "tui": true
-  },
-  "tomcat": {
-    "port": 8080
-  }
-}
-```
-
-### 3. Execução de Classes (`xavva run` / `xavva debug`)
-Executa classes Java standalone (`public static void main`) com resolução automática de dependências.
-
----
-
-## 🏗️ Arquitetura Xavva 2.0
-
-O Xavva foi refatorado para uma arquitetura de **Injeção de Dependências** e **Serviços Centralizados**:
-
-- **DashboardService**: Gerenciamento de interface TUI e interatividade.
-- **LogAnalyzer**: Processamento inteligente de logs e stack traces.
-- **ProjectService**: Inteligência centralizada para descoberta de diretórios e artefatos.
-- **CommandRegistry**: Despacho modular de comandos.
-
----
-*Desenvolvido para transformar o legado em produtivo. 🚀*
+# XAVVA CLI 🚀> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows[![Version](https://img.shields.io/badge/version-2.2.0-blue.svg)](https://github.com/leorsousa05/Xavva)[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.---## ✨ Features- ⚡ **Hot Reload** — Incremental compilation and class injection without server restart- 📊 **Interactive Dashboard** — Real-time TUI with system metrics and shortcuts- 🧠 **Smart Log Analyzer** — Stack trace folding and root cause highlighting- 🔒 **Security Audit** — Automated vulnerability scanning via OSV.dev- 📦 **Dependency Analysis** — Detect conflicts and outdated dependencies- 🎯 **Maven & Gradle** — Native support for both build tools- 🔧 **Auto-Healing** — Automatic diagnosis and repair of common issues---## 📦 Installation```powershell# Via NPMnpm install -g @archznn/xavva# Or run directly with Bunbunx @archznn/xavva dev```---## 🚀 Quick Start```bash# Start development mode with dashboardxavva dev --tui# Deploy to Tomcatxavva deploy# Analyze dependencies for issuesxavva deps# Check for security vulnerabilitiesxavva audit```---## 📖 Commands### Core Development| Command | Description ||---------|-------------|| `xavva dev` | Full development mode (build + deploy + watch + debug) || `xavva deploy` | Build and deploy application to Tomcat || `xavva build` | Compile project only || `xavva start` | Start Tomcat server only |### Code Execution| Command | Description ||---------|-------------|| `xavva run <class>` | Execute a Java class with automatic classpath || `xavva debug <class>` | Debug a Java class (port 5005) |### Analysis & Monitoring| Command | Description ||---------|-------------|| `xavva logs` | Stream and analyze Tomcat logs in real-time || `xavva deps` | **Analyze dependencies** — detect conflicts, find updates || `xavva audit` | Security audit of JAR files via OSV.dev || `xavva doctor` | Diagnose environment issues (JAVA_HOME, DCEVM) || `xavva profiles` | List available Maven/Gradle profiles || `xavva docs` | Generate endpoint documentation |---## 🔍 Dependency AnalysisThe `xavva deps` command provides comprehensive dependency analysis:```bash# Basic analysisxavva deps# With verbose output for debuggingxavva deps --verbose# Show fix suggestions for conflictsxavva deps --fix# Export report as JSONxavva deps --output report.json# Fail on critical conflicts (useful in CI/CD)xavva deps --strict```### What it detects:- ⚠️ **Version Conflicts** — Same dependency with different versions- ⬆️ **Available Updates** — Newer versions in Maven Central- 🔴 **Major Updates** — Breaking changes that need attention- 📊 **Statistics** — Direct vs transitive dependencies### Sample output:```══════════════════════════════════════════════════════════📊 DEPENDENCY ANALYSIS══════════════════════════════════════════════════════════Statistics:  Total: 183 dependencies  Direct: 45 | Transitive: 138⚠️  VERSION CONFLICTS (2)  ✖ com.fasterxml.jackson.core:jackson-databind     Versions: 2.13.0, 2.12.6⬆️  UPDATES AVAILABLE (5)  ↑ org.postgresql:postgresql     42.2.5 → 42.7.1⚠️  MAJOR UPDATES (1)  ! org.springframework.boot:spring-boot-starter     2.5.0 → 3.1.0```---## ⚙️ ConfigurationCreate `xavva.json` in your project root:```json{  "project": {    "appName": "my-application",    "buildTool": "maven",    "profile": "dev",    "tui": false  },  "tomcat": {    "path": "C:/apache-tomcat",    "port": 8080  }}```### CLI Options| Option | Description ||--------|-------------|| `-p, --path <path>` | Tomcat installation path || `-t, --tool <tool>` | Build tool: `maven` or `gradle` || `-n, --name <name>` | Application name (WAR context) || `--port <port>` | Tomcat port (default: 8080) || `-P, --profile <prof>` | Maven/Gradle profile || `-e, --encoding <enc>` | Source encoding (utf8, cp1252) || `-w, --watch` | Enable file watching || `--tui` | Interactive dashboard mode || `-d, --debug` | Enable JPDA debugger || `-c, --clean` | Clean logs before start || `-s, --no-build` | Skip initial build || `-V, --verbose` | Detailed output |---## 🏗️ ArchitectureXavva uses a modular service-oriented architecture:- **DashboardService** — TUI management and interactivity- **LogAnalyzer** — Intelligent log processing- **DependencyAnalyzerService** — Dependency conflict detection- **ProjectService** — Project structure discovery- **BuildService** — Maven/Gradle integration- **TomcatService** — Server lifecycle management---## 🤝 ContributingContributions are welcome! Please feel free to submit a Pull Request.---## 📄 LicenseMIT License — see [LICENSE](LICENSE) for details.---<p align="center">  <sub>Built with ❤️ for Java developers who miss modern tooling</sub></p>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.0.3",
+	"version": "2.2.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

@@ -60,8 +60,9 @@ export class AuditCommand implements Command {
             Logger.info("Total de Falhas", totalVulns);
             Logger.info("Relatório gerado via", "OSV.dev (Open Source Vulnerability Database)");
 
-        } catch (e: any) {
-            Logger.error(e.message);
+        } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            Logger.error(message);
         }
     }
 

package/src/commands/BuildCommand.ts

@@ -2,6 +2,7 @@ import type { Command } from "./Command";
 import type { AppConfig } from "../types/config";
 import { BuildService } from "../services/BuildService";
 import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
 
 export class BuildCommand implements Command {
     constructor(private buildService: BuildService) {}
@@ -14,9 +15,10 @@ export class BuildCommand implements Command {
         try {
             await this.buildService.runBuild();
             Logger.success("Build completed successfully!");
-        } catch (error: any) {
-            Logger.error(error.message);
-            process.exit(1);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.error(message);
+            await ProcessManager.getInstance().shutdown(1);
         }
     }
 }

package/src/commands/CommandRegistry.ts

@@ -2,6 +2,7 @@ import type { AppConfig, CLIArguments } from "../types/config";
 import type { Command } from "./Command";
 import { Logger } from "../utils/ui";
 import { HelpCommand } from "./HelpCommand";
+import { ProcessManager } from "../utils/processManager";
 
 export class CommandRegistry {
     private commands = new Map<string, Command>();
@@ -18,19 +19,22 @@ export class CommandRegistry {
         return this.commands.get(name);
     }
 
-    async execute(name: string, config: AppConfig, args: CLIArguments) {
+    async execute(name: string, config: AppConfig, args: CLIArguments): Promise<void> {
         const command = this.commands.get(name);
+        const processManager = ProcessManager.getInstance();
+        
         if (!command) {
             Logger.error(`Comando desconhecido: ${name}`);
             await new HelpCommand().execute(config);
-            process.exit(1);
+            await processManager.shutdown(2);
         }
 
         try {
             await command.execute(config, args);
-        } catch (error: any) {
-            Logger.error(`Erro ao executar comando '${name}': ${error.message}`);
-            process.exit(1);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.error(`Erro ao executar comando '${name}': ${message}`);
+            await processManager.shutdown(1);
         }
     }
 }

package/src/commands/DeployCommand.ts

@@ -20,7 +20,7 @@ export class DeployCommand implements Command {
         if (!incremental) {
             this.logConfiguration(config, isWatching);
         } else {
-            Logger.watcher("Change detected", "change");
+            Logger.watch("Change detected");
         }
         
         try {
@@ -31,16 +31,16 @@ export class DeployCommand implements Command {
                 await tomcat.clearWebapps();
 
                 if (!config.project.skipBuild) {
-                    Logger.watcher("Building project", "start");
+                    Logger.build("compiling...");
                     await builder.runBuild(incremental);
                 }
                 
                 if (!config.project.skipBuild) {
-                    Logger.build("Full project build and environment ready");
+                    Logger.build("completed");
                 }
             } else {
                 if (!config.project.skipBuild) {
-                    Logger.watcher("Incremental compilation", "start");
+                    Logger.build("incremental compile...");
                     await builder.runBuild(incremental);
                 }
             }
@@ -50,13 +50,13 @@ export class DeployCommand implements Command {
                 const actualContextPath = contextPath || actualAppFolder || "";
                 const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
                 await BrowserService.reload(actualAppUrl);
-                Logger.watcher("Redeploy completed", "success");
+                Logger.success("redeploy completed");
                 return;
             }
 
-            Logger.build("Webapps cleaned");
+            Logger.server("cleaning webapps...");
             const artifactInfo = await builder.deployToWebapps();
-            Logger.build("Artifacts generated");
+            Logger.server("artifacts ready");
             
             const finalContextPath = contextPath || artifactInfo.finalName.replace(".war", "");
             const appWebappPath = path.join(config.tomcat.path, "webapps", finalContextPath);
@@ -65,7 +65,7 @@ export class DeployCommand implements Command {
                 // Se é um diretório (exploded), sincronizamos o conteúdo total para a pasta do webapps
                 if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
                 await builder.syncExploded(artifactInfo.path, appWebappPath);
-                Logger.build("Exploded directory synced to webapps");
+                Logger.server("synced exploded directory");
             } else {
                 if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
 
@@ -75,7 +75,7 @@ export class DeployCommand implements Command {
                 if (!webappStat || artifactStat.mtimeMs > webappStat.mtimeMs) {
                     try {
                         Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
-                        Logger.build("Artifacts deployed");
+                        Logger.server("extracted WAR");
                     } catch (e) {
                         const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
                         Bun.spawnSync(["powershell", "-command", extractCmd], {
@@ -85,10 +85,10 @@ export class DeployCommand implements Command {
                                 DEST_PATH: appWebappPath
                             }
                         });
-                        Logger.build("Artifacts deployed (legacy mode)");
+                        Logger.server("extracted WAR (legacy)");
                     }
                 } else {
-                    Logger.build("Webapp already up to date, skipping extraction");
+                    Logger.server("webapp up to date");
                 }
             }
 
@@ -102,17 +102,19 @@ export class DeployCommand implements Command {
             };
 
             tomcat.start(config, isWatching);
-        } catch (error: any) {
-            Logger.error(error.message);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.error(message);
             throw error;
         }
     }
 
     private logConfiguration(config: AppConfig, isWatching: boolean) {
-        Logger.config("Runtime", config.project.buildTool.toUpperCase());
-        if (config.project.profile) Logger.config("Profile", config.project.profile.toUpperCase());
-        Logger.config("Watch Mode", isWatching ? "ON" : "OFF");
-        Logger.config("Debug", config.project.debug ? `ON (Port ${config.project.debugPort})` : "OFF");
+        Logger.section("Configuration");
+        Logger.config("runtime", config.project.buildTool.toLowerCase());
+        if (config.project.profile) Logger.config("profile", config.project.profile);
+        Logger.config("watch", isWatching);
+        Logger.config("debug", config.project.debug ? `port ${config.project.debugPort}` : false);
 
         let javaBin = "java";
         if (process.env.JAVA_HOME) {
@@ -125,9 +127,9 @@ export class DeployCommand implements Command {
         const hasDcevm = ["dcevm", "jetbrains", "trava", "jbr"].some(v => output.includes(v));
         
         if (!hasDcevm && isWatching) {
-            Logger.config("Hot Reload", "Standard (No structural changes)");
+            Logger.config("hotswap", "standard");
         } else if (hasDcevm) {
-            Logger.config("Hot Reload", "Advanced (DCEVM Active)");
+            Logger.config("hotswap", "dcevm");
         }
 
         const srcPath = path.join(process.cwd(), "src");
@@ -135,9 +137,10 @@ export class DeployCommand implements Command {
             const contextPath = (config.project.appName || "").replace(".war", "");
             const endpoints = EndpointService.scan(srcPath, contextPath);
             if (endpoints.length > 0) {
-                Logger.config("Endpoints", endpoints.length);
+                Logger.config("endpoints", endpoints.length);
             }
         }
+        Logger.endSection();
     }
 
     private injectContextConfiguration(appPath: string) {
@@ -170,9 +173,12 @@ export class DeployCommand implements Command {
             const response = await fetch(url);
             if (response.status < 500) {
                 const memory = await tomcat.getMemoryUsage();
-                Logger.health(url, "success");
-                Logger.health(`Status ${response.status}`, "success");
-                Logger.health(`Memory ${memory}`, "success");
+                Logger.divider();
+                Logger.ready("Server ready");
+                Logger.url("Local", url);
+                Logger.info("Status", `${response.status}`);
+                Logger.info("Memory", memory);
+                Logger.done();
 
                 if (!config.project.quiet) {
                     this.showEndpointMap(config.tomcat.port, context);
@@ -184,32 +190,32 @@ export class DeployCommand implements Command {
                     BrowserService.open(url);
                 }
             } else {
-                Logger.health(`App returned status ${response.status}`, "warn");
+                Logger.warn(`App returned status ${response.status}`);
             }
         } catch (e) {
-            Logger.health(`Could not connect to ${url}`, "error");
+            Logger.error(`Could not connect to ${url}`);
         }
     }
 
     private showEndpointMap(port: number, context: string) {
         const endpoints = EndpointService.scan(path.join(process.cwd(), "src"), context);
         if (endpoints.length > 0) {
-            Logger.newline();
-            Logger.log(`${Logger.C.cyan}◈ ENDPOINT MAP:${Logger.C.reset}`);
+            Logger.section("Endpoints");
             
             const apis = endpoints.filter(e => e.className !== "JSP");
             const jsps = endpoints.filter(e => e.className === "JSP");
 
             if (apis.length > 0) {
                 const uniqueApiUrls = [...new Set(apis.map(e => `http://localhost:${port}${e.fullPath}`))];
-                uniqueApiUrls.forEach(url => Logger.log(`${Logger.C.dim}➜ ${Logger.C.reset}${url}`));
+                uniqueApiUrls.forEach(url => Logger.info("", url));
             }
 
             if (jsps.length > 0) {
-                Logger.log(`${Logger.C.dim}--- JSPs ---${Logger.C.reset}`);
+                Logger.info("JSPs", "");
                 const uniqueJspUrls = [...new Set(jsps.map(e => `http://localhost:${port}${e.fullPath}`))];
-                uniqueJspUrls.forEach(url => Logger.log(`${Logger.C.dim}📄 ${Logger.C.reset}${url}`));
+                uniqueJspUrls.forEach(url => Logger.info("", `  ${url}`));
             }
+            Logger.endSection();
         }
     }
 

package/src/commands/DepsCommand.ts

@@ -0,0 +1,123 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import type { DependencyAnalysisResult } from "../services/DependencyAnalyzerService";
+import { DependencyAnalyzerService } from "../services/DependencyAnalyzerService";
+import { AuditService } from "../services/AuditService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+import fs from "fs";
+
+export class DepsCommand implements Command {
+	private config!: AppConfig;
+
+	async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+		this.config = config;
+		const analyzer = new DependencyAnalyzerService(config.project);
+		analyzer.setVerbose(!!args?.verbose);
+
+		Logger.section("Análise de Dependências");
+		Logger.info("Ferramenta", config.project.buildTool.toUpperCase());
+		Logger.info("Diretório", process.cwd());
+		
+		const spinner = Logger.spinner("Analisando dependências...");
+		
+		try {
+			const result = await analyzer.analyze();
+			spinner();
+
+			// Se não encontrou dependências, mostrar ajuda
+			if (result.dependencies.length === 0) {
+				Logger.warn("Nenhuma dependência encontrada!");
+				Logger.info("Possíveis causas:", "");
+				Logger.log("  • Projeto não foi compilado ainda (execute: mvn compile)");
+				Logger.log("  • Maven não está no PATH");
+				Logger.log("  • Arquivo pom.xml/build.gradle não encontrado");
+				Logger.log("  • Erro de parsing no arquivo de configuração");
+				Logger.newline();
+				Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} Execute com --verbose para mais detalhes`);
+				return;
+			}
+
+			// Verificar vulnerabilidades se solicitado
+			if (args?.["scan"] !== false) {
+				Logger.step("Verificando vulnerabilidades");
+				// Integração com AuditService para check de vulnerabilidades
+				// nas dependências do projeto
+			}
+
+			// Exibir relatório
+			const report = analyzer.generateReport(result);
+			console.log(report);
+
+			// Ações adicionais baseadas em flags
+			if (args?.["fix"]) {
+				await this.suggestFixes(result, config.project.buildTool);
+			}
+
+			// Exportar resultado se solicitado
+			if (args?.["output"]) {
+				this.exportReport(result, args["output"] as string);
+			}
+
+			// Sair com erro se houver conflitos críticos
+			const hasErrors = result.conflicts.some(c => c.severity === "error");
+			if (hasErrors && args?.["strict"]) {
+				await ProcessManager.getInstance().shutdown(1);
+			}
+
+		} catch (error) {
+			spinner(false);
+			const message = error instanceof Error ? error.message : String(error);
+			Logger.error(`Falha na análise: ${message}`);
+			throw error;
+		}
+	}
+
+	private async suggestFixes(result: DependencyAnalysisResult, buildTool: string): Promise<void> {
+		if (result.conflicts.length === 0) {
+			Logger.success("Nenhum conflito para resolver!");
+			return;
+		}
+
+		Logger.newline();
+		Logger.section("Sugestões de Correção");
+
+		for (const conflict of result.conflicts) {
+			Logger.log(`\n${Logger.C.cyan}${conflict.groupId}:${conflict.artifactId}${Logger.C.reset}`);
+			
+			if (buildTool === "maven") {
+				Logger.log("  Adicione ao pom.xml:");
+				Logger.log(`  ${Logger.C.dim}<dependencyManagement>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}  <dependencies>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}    <dependency>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}      <groupId>${conflict.groupId}</groupId>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}      <artifactId>${conflict.artifactId}</artifactId>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}      <version>${conflict.versions[conflict.versions.length - 1]}</version>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}    </dependency>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}  </dependencies>${Logger.C.reset}`);
+				Logger.log(`  ${Logger.C.dim}</dependencyManagement>${Logger.C.reset}`);
+			} else {
+				Logger.log("  Adicione ao build.gradle:");
+				Logger.log(`  ${Logger.C.dim}implementation("${conflict.groupId}:${conflict.artifactId}:${conflict.versions[conflict.versions.length - 1]}")${Logger.C.reset}`);
+			}
+		}
+	}
+
+	private exportReport(
+		result: DependencyAnalysisResult,
+		outputPath: string
+	): void {
+		const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), "utf-8"));
+		const data = {
+			timestamp: new Date().toISOString(),
+			tool: "xavva",
+			version: pkg.version,
+			result
+		};
+		
+		fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+		Logger.success(`Relatório exportado para: ${outputPath}`);
+	}
+}
+
+import path from "path";

package/src/commands/DoctorCommand.ts

@@ -1,11 +1,12 @@
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import { Logger } from "../utils/ui";
 import fs from "fs";
 import path from "path";
+import os from "os";
 
 export class DoctorCommand implements Command {
-	async execute(config: AppConfig, values: any = {}): Promise<void> {
+	async execute(config: AppConfig, values: CLIArguments = {}): Promise<void> {
 		Logger.section("Xavva Doctor - Ambiente");
 
 		this.check(
@@ -252,7 +253,7 @@ export class DoctorCommand implements Command {
         
         // URL para o JetBrains Runtime 21 SDK Windows x64
         const url = "https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-21.0.6-windows-x64-b895.97.tar.gz";
-        const installDir = path.join(require("os").homedir(), ".xavva", "jdk-dcevm");
+        const installDir = path.join(os.homedir(), ".xavva", "jdk-dcevm");
         
         // Limpar instalação anterior se existir
         if (fs.existsSync(installDir)) {
@@ -344,7 +345,7 @@ export class DoctorCommand implements Command {
 			                        
 			                                    Logger.newline();
 			                                    Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
-			                                } catch (e: any) {
+			                                } catch (e) {
 			                        
 			            			Logger.error(`Falha na instalação: ${e.message}`);
 		}

package/src/commands/HelpCommand.ts

@@ -4,46 +4,100 @@ import pkg from "../../package.json";
 
 export class HelpCommand implements Command {
     async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
+        const version = pkg.version;
+        
         console.log(`
-🛠️  XAVVA CLI v${pkg.version} 🚀
----------------------------------------
-Automatização de alta performance para Java Enterprise (Tomcat) no Windows.
-Detecta automaticamente Maven/Gradle e otimiza o ciclo de desenvolvimento.
-
-Comandos principais:
-  dev           🚀 MODO COMPLETO: Build + Deploy + Watch + Debug.
-  deploy        (Padrão) Compila, sincroniza e inicia o servidor.
-  logs          📋 Tail inteligente (catalina.out) com Smart Folding.
-  run / debug   🚀 Executa classes standalone com Pathing JAR (Windows).
-  doctor        🩺 Diagnóstico e reparo de ambiente (DCEVM, JAVA_HOME).
-  audit         🛡️ Auditoria de segurança em JARs via OSV.dev.
-  profiles      🏷️ Lista perfis de build disponíveis (Maven Profiles).
-  docs          📖 Mapeamento estático de Endpoints e JSPs.
-  build / start Comandos granulares de compilação ou startup.
-
-Opções de Interface:
-  --tui         🖥️  Ativa o Dashboard Interativo (Interface TUI).
-                No modo TUI use: [R] Restart, [L] Clear, [Q] Quit.
-  -w, --watch   👀 Hot Reload: Redeploy incremental de classes e recursos.
-  -c, --clean   🧹 Logs coloridos e simplificados (Recomendado).
-  -V, --verbose 📣 Exibe logs completos do Maven/Gradle.
-
-Opções de Runtime:
-  -d, --debug   🐞 Habilita JPDA Debugging (Porta 5005).
-  -P, --profile Define o profile de build (ex: -P prod).
-  -s, --no-build Pula o build inicial.
-  --fix         🔧 Corrige problemas automaticamente (Doctor).
-
-Configuração:
-  O Xavva prioriza o arquivo 'xavva.json' na raiz do projeto.
-  Flags de linha de comando: -p (Tomcat Path), -t (Build Tool), -n (WAR Name).
-
-Exemplos:
-  xavva dev --tui      Experiência completa com Dashboard.
-  xavva run MyClass    Execução standalone com classpath automático.
-  xavva audit          Verifica vulnerabilidades conhecidas.
-
-*Transformando o legado em produtivo.*
-        `);
+  ${this.c("cyan", "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓")}
+  ${this.c("cyan", "▓")}                                              ${this.c("cyan", "▓")}
+  ${this.c("cyan", "▓")}   ${this.c("bold", "XAVVA")} ${this.c("dim", `v${version}`)} ${this.c("gray", "— Java/Tomcat Dev CLI")}           ${this.c("cyan", "▓")}
+  ${this.c("cyan", "▓")}                                              ${this.c("cyan", "▓")}
+  ${this.c("cyan", "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓")}
+
+  ${this.c("yellow", "USAGE")}
+    xavva <command> [options]
+
+  ${this.c("yellow", "COMMANDS")}
+    ${this.c("green", "dev")}              Start development mode (build + deploy + watch)
+    ${this.c("green", "deploy")}           Build and deploy to Tomcat (default)
+    ${this.c("green", "build")}            Compile project only
+    ${this.c("green", "start")}            Start Tomcat server only
+    ${this.c("green", "run")} <class>      Run a Java class with automatic classpath
+    ${this.c("green", "debug")} <class>    Debug a Java class (port 5005)
+    ${this.c("green", "logs")}             Stream and analyze Tomcat logs
+    ${this.c("green", "deps")}             Analyze dependencies (conflicts, updates)
+    ${this.c("green", "audit")}            Security audit of JAR files
+    ${this.c("green", "doctor")}           Diagnose and fix environment issues
+    ${this.c("green", "profiles")}         List available Maven/Gradle profiles
+    ${this.c("green", "docs")}             Generate endpoint documentation
+
+  ${this.c("yellow", "OPTIONS")}
+    ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
+    ${this.c("cyan", "-t, --tool")} <tool>     Build tool: maven | gradle
+    ${this.c("cyan", "-n, --name")} <name>     Application name (WAR context)
+    ${this.c("cyan", "--port")} <port>        Tomcat port (default: 8080)
+    ${this.c("cyan", "-P, --profile")} <prof>  Maven/Gradle profile
+    ${this.c("cyan", "-e, --encoding")} <enc>  Source encoding (utf8, cp1252)
+    
+    ${this.c("cyan", "-w, --watch")}          Enable file watching (hot reload)
+    ${this.c("cyan", "--tui")}                Interactive dashboard mode
+    ${this.c("cyan", "-d, --debug")}          Enable JPDA debugger
+    ${this.c("cyan", "--dp")} <port>          Debugger port (default: 5005)
+    
+    ${this.c("cyan", "-c, --clean")}          Clean logs before start
+    ${this.c("cyan", "-s, --no-build")}       Skip initial build
+    ${this.c("cyan", "-q, --quiet")}          Minimal output
+    ${this.c("cyan", "-V, --verbose")}        Detailed output
+    ${this.c("cyan", "-h, --help")}           Show this help
+    ${this.c("cyan", "-v, --version")}        Show version
+
+  ${this.c("yellow", "EXAMPLES")}
+    ${this.c("dim", "# Development with hot reload and dashboard")}
+    xavva dev --tui --watch
+
+    ${this.c("dim", "# Quick deploy to specific Tomcat")}
+    xavva deploy -p /opt/tomcat --port 8081
+
+    ${this.c("dim", "# Run a class with debugging")}
+    xavva debug com.example.MyClass
+
+    ${this.c("dim", "# Analyze dependencies for conflicts")}
+    xavva deps --verbose
+
+    ${this.c("dim", "# Security audit with auto-fix suggestions")}
+    xavva audit --fix
+
+  ${this.c("yellow", "CONFIGURATION")}
+    Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
+    
+    ${this.c("dim", `{
+      "project": {
+        "appName": "my-app",
+        "buildTool": "maven",
+        "tui": true
+      },
+      "tomcat": {
+        "path": "C:/apache-tomcat",
+        "port": 8080
+      }
+    }`)}
+
+  ${this.c("gray", "────────────────────────────────────────────────────────────")}
+  ${this.c("gray", "Docs: github.com/leorsousa05/Xavva  |  License: MIT")}
+`);
+    }
+
+    private c(color: string, text: string): string {
+        const colors: Record<string, string> = {
+            reset: "\x1b[0m",
+            bold: "\x1b[1m",
+            dim: "\x1b[2m",
+            gray: "\x1b[90m",
+            red: "\x1b[31m",
+            green: "\x1b[32m",
+            yellow: "\x1b[33m",
+            blue: "\x1b[34m",
+            cyan: "\x1b[36m",
+        };
+        return `${colors[color] || ""}${text}\x1b[0m`;
     }
 }