@archznn/xavva 2.0.2 → 2.1.0

package/README.md

@@ -1,78 +1,204 @@
-# XAVVA 🚀 (Windows Only) `v2.0.2`
+# XAVVA CLI 🚀
 
-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.
+> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
 
----
+[![Version](https://img.shields.io/badge/version-2.0.3-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
-## 🛠️ Por que Xavva?
+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.
 
-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
+## ✨ Features
 
-- **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.
+- ⚡ **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
 
 ---
 
-## 🚀 Começo Rápido
+## 📦 Installation
 
-### Instalação
 ```powershell
-# Instalação global via NPM
+# Via NPM
 npm install -g @archznn/xavva
 
-# Iniciar em modo Dashboard (TUI)
+# Or run directly with Bun
+bunx @archznn/xavva dev
+```
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# Start development mode with dashboard
 xavva dev --tui
+
+# Deploy to Tomcat
+xavva deploy
+
+# Analyze dependencies for issues
+xavva deps
+
+# Check for security vulnerabilities
+xavva audit
 ```
 
 ---
 
-## 📖 Referência de Comandos
+## 📖 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 Analysis
+
+The `xavva deps` command provides comprehensive dependency analysis:
+
+```bash
+# Basic analysis
+xavva deps
 
-O Xavva 2.0 utiliza uma arquitetura modular de comandos e serviços.
+# With verbose output for debugging
+xavva deps --verbose
 
-### 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.
+# Show fix suggestions for conflicts
+xavva deps --fix
+
+# Export report as JSON
+xavva 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
+```
+
+---
+
+## ⚙️ Configuration
+
+Create `xavva.json` in your project root:
 
-### 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",
+    "appName": "my-application",
     "buildTool": "maven",
-    "tui": true
+    "profile": "dev",
+    "tui": false
   },
   "tomcat": {
+    "path": "C:/apache-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.
+### 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 |
 
 ---
 
-## 🏗️ Arquitetura Xavva 2.0
+## 🏗️ Architecture
+
+Xavva 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
+
+---
 
-O Xavva foi refatorado para uma arquitetura de **Injeção de Dependências** e **Serviços Centralizados**:
+## 🤝 Contributing
 
-- **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.
+Contributions are welcome! Please feel free to submit a Pull Request.
 
 ---
-*Desenvolvido para transformar o legado em produtivo. 🚀*
+
+## 📄 License
+
+MIT 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.2",
+	"version": "2.1.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

@@ -102,14 +102,16 @@ 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");
 

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,45 +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.
-  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`;
     }
 }