@archznn/xavva 1.8.0 → 2.0.0

package/README.md

@@ -1,4 +1,4 @@
-# XAVVA 🚀 (Windows Only) `v1.8.0`
+# XAVVA 🚀 (Windows Only) `v2.0.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.
 
@@ -10,102 +10,69 @@ Desenvolver para Java/Tomcat tradicionalmente envolve ciclos lentos de `clean in
 
 ### ⚡ 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`).
-- **DCEVM Integration**: O Xavva pode baixar e configurar automaticamente uma JDK com DCEVM (JetBrains Runtime), permitindo mudanças estruturais em classes (novos métodos/campos) em tempo real.
-- **API Documentation (Swagger-like)**: Mapeamento estático de endpoints, métodos HTTP e parâmetros diretamente no terminal via `xavva docs`.
-- **Live Reload Automático**: Sincronização inteligente que atualiza o browser (Chrome/Edge) após mudanças em JSPs ou recursos estáticos.
 - **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 através de geração dinâmica de Manifestos compatíveis com a especificação Java.
-- **Auto-Healing**: Diagnóstico e reparo automático de problemas comuns de ambiente, como encoding UTF-8 com BOM.
+- **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
 
-### Pré-requisitos
-- **Windows** (Otimizado para PowerShell Core e Windows PowerShell)
-- **Bun** instalado (`powershell -c "irm bun.sh/install.ps1 | iex"`)
-- **Tomcat** configurado via variável de ambiente `TOMCAT_HOME` ou `CATALINA_HOME`.
-
 ### Instalação
 ```powershell
 # Instalação global via NPM
 npm install -g @archznn/xavva
 
-# Ou use diretamente via npx
-npx @archznn/xavva dev
+# Iniciar em modo Dashboard (TUI)
+xavva dev --tui
 ```
 
 ---
 
 ## 📖 Referência de Comandos
 
-O Xavva utiliza uma arquitetura modular de comandos e serviços, garantindo alta performance e extensibilidade.
+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.
-  - **O que faz**: Compila Java, sincroniza recursos, limpa logs, inicia o Tomcat e monitora mudanças.
 - **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.
-  - `--dp 9000`: Altera a porta do Debugger (JPDA) (padrão 5005).
-
-### 2. Execução de Classes (`xavva run` / `xavva debug`)
-Executa classes Java standalone (`public static void main`) com resolução automática de dependências Maven ou Gradle.
-- **Inteligência de Classpath**: Gera automaticamente um `classpath.jar` temporário (Pathing JAR) para evitar o erro de "Command line too long" no Windows.
-- **Busca por Grep**: Se você fornecer apenas parte do nome da classe, o Xavva a encontrará recursivamente no projeto.
-
-### 3. Documentação de API (`xavva docs`)
-Gera uma documentação instantânea dos seus controladores Jersey/Spring no terminal.
-- Mostra a URL completa, método HTTP e parâmetros (Path, Query, Body).
-
-### 4. Diagnóstico e Reparo (`xavva doctor`)
-Verifica se o seu ambiente está saudável.
-- **`xavva doctor --fix`**:
-  - Instala o **JetBrains Runtime (DCEVM)** se necessário.
-  - Remove automaticamente o **BOM (Byte Order Mark)** de arquivos Java que causam erros de compilação.
-  - Configura o `JAVA_HOME` do sistema.
 
-### 5. Auditoria de Segurança (`xavva audit`)
-Analisa a pasta `WEB-INF/lib` em busca de JARs vulneráveis via integração com **OSV.dev**. Essencial para manter a integridade do projeto antes de deploys em produção.
+### 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
+  }
+}
+```
 
-### 6. Logs em Tempo Real (`xavva logs`)
-Exibe os logs do Tomcat filtrando ruídos excessivos e destacando StackTraces importantes. Use `--grep "NomeDaClasse"` para focar em logs específicos.
+### 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 do Sistema
+## 🏗️ Arquitetura Xavva 2.0
 
 O Xavva foi refatorado para uma arquitetura de **Injeção de Dependências** e **Serviços Centralizados**:
 
-- **CommandRegistry**: Gerenciamento modular de comandos via Command Pattern.
-- **ProjectService**: Inteligência centralizada para descoberta de diretórios de build, artefatos e classpaths Java.
-- **AuditService**: Segurança aprimorada com execução isolada e protegida no PowerShell.
-- **TomcatService**: Gerenciamento do ciclo de vida do servidor com suporte a hotswap dinâmico.
-
----
-
-## ⚙️ Configuração (Zero Config)
-
-O Xavva funciona sem arquivos de configuração externos, baseando-se no ambiente:
-
-| Variável | Descrição |
-|----------|-----------|
-| `TOMCAT_HOME` | Caminho raiz do seu Apache Tomcat. |
-| `JAVA_HOME` | JDK utilizada para compilação e execução. |
-
-**Dica**: O Xavva cria automaticamente uma pasta `.xavva` no seu projeto para cache e artefatos temporários, e a adiciona ao seu `.gitignore`.
-
----
-
-## 🧩 Sincronização de Recursos
-
-Ao editar um arquivo, o Xavva decide a melhor estratégia:
-- **`.java`**: Compila apenas a classe e injeta o bytecode via `fastSync`.
-- **`.jsp` / `.html` / `.css`**: Sincroniza o arquivo diretamente na pasta de deploy do Tomcat.
-- **`pom.xml` / `build.gradle`**: Identifica mudanças estruturais e sugere um rebuild completo com invalidação de cache inteligente.
+- **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. 🚀*

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "1.8.0",
+	"version": "2.0.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/DeployCommand.ts

@@ -27,16 +27,13 @@ export class DeployCommand implements Command {
             const contextPath = (config.project.appName || "").replace(".war", "");
 
             if (!incremental) {
-                tomcat.clearWebapps(contextPath);
+                await tomcat.killConflict();
+                await tomcat.clearWebapps();
 
-                const buildTask = config.project.skipBuild ? Promise.resolve() : builder.runBuild(incremental);
-                const killTask = tomcat.killConflict();
-                
                 if (!config.project.skipBuild) {
-                    Logger.watcher("Preparing environment and building in parallel", "start");
+                    Logger.watcher("Building project", "start");
+                    await builder.runBuild(incremental);
                 }
-
-                await Promise.all([buildTask, killTask]);
                 
                 if (!config.project.skipBuild) {
                     Logger.build("Full project build and environment ready");

package/src/commands/LogsCommand.ts

@@ -1,34 +1,36 @@
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { DashboardService } from "../services/DashboardService";
+import { LogAnalyzer } from "../services/LogAnalyzer";
 import { Logger } from "../utils/ui";
 import path from "path";
 import fs from "fs";
 
 export class LogsCommand implements Command {
-    async execute(config: AppConfig): Promise<void> {
+    constructor(private dashboard?: DashboardService, private logAnalyzer?: LogAnalyzer) {}
+
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
         const logPath = path.join(config.tomcat.path, "logs", "catalina.out");
 
         if (!fs.existsSync(logPath)) {
-            Logger.error(`Arquivo de log não encontrado: ${logPath}`);
+            const errorMsg = `Arquivo de log não encontrado: ${logPath}`;
+            if (this.dashboard) this.dashboard.log(Logger.C.red + errorMsg);
+            else Logger.error(errorMsg);
             return;
         }
 
-        Logger.section(`Monitoring Logs: ${logPath}`);
-        if (config.tomcat.grep) {
-            Logger.info("Filter", config.tomcat.grep);
+        const analyzer = this.logAnalyzer || new LogAnalyzer(config.project);
+        const dashboard = this.dashboard || new DashboardService(config);
+
+        dashboard.setStatus("LOGGING", Logger.C.green);
+        
+        if (args?.grep) {
+            dashboard.log(`${Logger.C.dim}Filter:${Logger.C.reset} ${Logger.C.bold}${args.grep}${Logger.C.reset}`);
         }
 
         const stats = fs.statSync(logPath);
         let currentSize = stats.size;
 
-        const colorize = (line: string): string => {
-            if (line.match(/SEVERE|ERROR|Exception|Error/i)) return `\x1b[31m${line}\x1b[0m`;
-            if (line.match(/WARNING|WARN/i)) return `\x1b[33m${line}\x1b[0m`;
-            if (line.match(/INFO/i)) return `\x1b[36m${line}\x1b[0m`;
-            if (line.match(/DEBUG/i)) return `\x1b[90m${line}\x1b[0m`;
-            return line;
-        };
-
         fs.watch(logPath, (event) => {
             if (event === "change") {
                 const newStats = fs.statSync(logPath);
@@ -43,18 +45,22 @@ export class LogsCommand implements Command {
                         lines.forEach(line => {
                             if (!line.trim()) return;
                             
-                            if (config.tomcat.grep && !line.toLowerCase().includes(config.tomcat.grep.toLowerCase())) {
+                            const grep = args?.grep || config.project.grep;
+                            if (grep && !line.toLowerCase().includes(grep.toLowerCase())) {
                                 return;
                             }
 
-                            process.stdout.write(colorize(line) + "\n");
+                            const formatted = analyzer.summarize(line);
+                            if (formatted) {
+                                dashboard.log(formatted);
+                            }
                         });
                     });
 
                     currentSize = newStats.size;
                 } else if (newStats.size < currentSize) {
                     currentSize = newStats.size;
-                    Logger.warn("Arquivo de log foi resetado/rotacionado.");
+                    dashboard.log(Logger.C.yellow + "Arquivo de log foi resetado/rotacionado.");
                 }
             }
         });

package/src/commands/RunCommand.ts

@@ -1,7 +1,6 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { Logger } from "../utils/ui";
-import { spawn } from "child_process";
 import path from "path";
 
 export class RunCommand implements Command {
@@ -54,19 +53,20 @@ export class RunCommand implements Command {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java") : "java";
+        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java.exe") : "java";
         
-        return new Promise((resolve) => {
-            const child = spawn(bin, javaArgs, {
-                stdio: "inherit",
-                shell: false
-            });
-
-            child.on("exit", () => {
-                Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
-                resolve();
-            });
+        const proc = Bun.spawn([bin, ...javaArgs], {
+            stdout: "inherit",
+            stderr: "inherit",
+            stdin: "inherit",
+            env: {
+                ...process.env,
+                JAVA_OPTS: "-Xms256m -Xmx1024m"
+            } as any
         });
+
+        await proc.exited;
+        Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
     }
 
     private async discoverClass(simpleName: string): Promise<string | null> {

package/src/index.ts

@@ -17,6 +17,8 @@ import { BuildService } from "./services/BuildService";
 import { AuditService } from "./services/AuditService";
 import { WatcherService } from "./services/WatcherService";
 import { BuildCacheService } from "./services/BuildCacheService";
+import { DashboardService } from "./services/DashboardService";
+import { LogAnalyzer } from "./services/LogAnalyzer";
 
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
@@ -33,7 +35,7 @@ async function main() {
 	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit"];
 	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
-	if (!values.help) {
+	if (!values.help && !values.tui) {
 		Logger.banner(commandName);
 	}
 
@@ -49,18 +51,23 @@ async function main() {
 	const tomcatService = new TomcatService(config.tomcat);
 	tomcatService.setProjectService(projectService);
 	const auditService = new AuditService(config.tomcat);
+	
+	// Xavva 2.0: Dashboard & LogAnalyzer
+	const logAnalyzer = new LogAnalyzer(config.project);
+	const dashboard = new DashboardService(config);
 
 	// 2. Registrar Comandos
 	const registry = new CommandRegistry();
 	
 	const deployCmd = new DeployCommand(tomcatService, buildService);
+	const logsCmd = new LogsCommand(dashboard, logAnalyzer);
 	
 	registry.register("build", new BuildCommand(buildService));
 	registry.register("start", new StartCommand(tomcatService));
 	registry.register("doctor", new DoctorCommand());
 	registry.register("run", new RunCommand());
 	registry.register("debug", new RunCommand());
-	registry.register("logs", new LogsCommand());
+	registry.register("logs", logsCmd);
 	registry.register("docs", new DocsCommand());
 	registry.register("audit", new AuditCommand(auditService));
 	registry.register("deploy", deployCmd);
@@ -72,7 +79,6 @@ async function main() {
 		await watcher.start();
 	} else {
 		// 3. Executar do Registro
-		// Ajusta flags baseadas no nome do comando para comandos compartilhados
 		if (commandName === "debug") values.debug = true;
 		if (commandName === "run") values.debug = false;
 		

package/src/services/BuildCacheService.ts

@@ -41,7 +41,7 @@ export class BuildCacheService {
         return crypto.createHash("md5").update(hash).digest("hex");
     }
 
-    shouldRebuild(tool: "maven" | "gradle"): boolean {
+    shouldRebuild(tool: "maven" | "gradle", projectService?: any): boolean {
         if (!fs.existsSync(this.cacheFile)) return true;
 
         try {
@@ -51,8 +51,16 @@ export class BuildCacheService {
             // Se o pom/gradle mudou, precisa de rebuild completo
             if (currentHash !== cache.lastConfigHash) return true;
 
-            // Verificar se o artefato (.war) ainda existe
-            // (Esta parte será integrada ao BuildService)
+            // Verificar se o artefato (.war) ainda existe fisicamente
+            if (projectService) {
+                try {
+                    const artifact = projectService.getArtifact();
+                    if (!fs.existsSync(artifact.path)) return true;
+                } catch (e) {
+                    return true;
+                }
+            }
+
             return false;
         } catch (e) {
             return true;

package/src/services/BuildService.ts

@@ -19,16 +19,22 @@ export class BuildService {
 		}
 
 		if (!incremental && !this.projectConfig.skipBuild) {
-			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool)) {
+			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool, this.projectService)) {
 				Logger.success("Build cache hit! Skipping full build.");
 				return;
 			}
 		}
 
 		const command = [];
+		const env = { ...process.env };
 		
 		if (this.projectConfig.buildTool === 'maven') {
 			command.push("mvn");
+
+			if (!this.cache.shouldRebuild('maven', this.projectService)) {
+				command.push("-o");
+			}
+
 			if (incremental) {
 				command.push("compile");
 			} else {
@@ -38,6 +44,8 @@ export class BuildService {
 			}
 			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");
 			if (this.projectConfig.profile) command.push(`-P${this.projectConfig.profile}`);
+
+			env.MAVEN_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
 		} else {
 			command.push("gradle");
 			if (incremental) {
@@ -49,13 +57,16 @@ export class BuildService {
 			}
 			command.push("-x", "test", "-x", "javadoc");
 			if (this.projectConfig.profile) command.push(`-Pprofile=${this.projectConfig.profile}`);
+
+			env.GRADLE_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
 		}
 
 		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
 
 		const proc = Bun.spawn(command, { 
 			stdout: "pipe",
-			stderr: "pipe"
+			stderr: "pipe",
+			env: env as any
 		});
 
 		if (this.projectConfig.verbose) {

package/src/services/DashboardService.ts

@@ -0,0 +1,117 @@
+import { Logger } from "../utils/ui";
+import type { AppConfig } from "../types/config";
+import os from "os";
+
+export class DashboardService {
+    private isTui: boolean;
+    private logLines: string[] = [];
+    private maxLogLines: number = 0;
+    private status: string = "IDLE";
+    private statusColor: string = Logger.C.dim;
+
+    constructor(private config: AppConfig) {
+        this.isTui = config.project.tui;
+        if (this.isTui) {
+            this.maxLogLines = process.stdout.rows - 10;
+            this.setupTui();
+        }
+    }
+
+    private setupTui() {
+        process.stdout.write("\x1B[?1049h"); // Switch to alternate buffer
+        process.stdout.write("\x1B[?25l"); // Hide cursor
+        
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+
+        process.stdin.on("data", (key: string) => {
+            // Ctrl+C ou Q para sair
+            if (key === "\u0003" || key.toLowerCase() === "q") {
+                this.exit();
+            }
+            if (key.toLowerCase() === "l") {
+                this.logLines = [];
+                this.render();
+            }
+        });
+
+        process.on("SIGINT", () => this.exit());
+        process.on("exit", () => this.exit());
+
+        // Atualiza o dashboard periodicamente para memória/status
+        setInterval(() => this.render(), 1000);
+    }
+
+    public onKey(key: string, callback: () => void) {
+        process.stdin.on("data", (input: string) => {
+            if (input.toLowerCase() === key.toLowerCase()) {
+                callback();
+            }
+        });
+    }
+
+    public setStatus(status: string, color: string = Logger.C.cyan) {
+        this.status = status;
+        this.statusColor = color;
+        this.render();
+    }
+
+    public log(message: string) {
+        if (!message) return;
+        
+        if (this.isTui) {
+            const lines = message.split("\n");
+            this.logLines.push(...lines);
+            if (this.logLines.length > 1000) { // Limite de scrollbuffer
+                this.logLines = this.logLines.slice(-1000);
+            }
+            this.render();
+        } else {
+            console.log(message);
+        }
+    }
+
+    private render() {
+        if (!this.isTui) return;
+
+        this.maxLogLines = process.stdout.rows - 8;
+        
+        let output = "\x1B[H"; // Move to 0,0
+        
+        // Header
+        const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
+        const git = Logger.getGitContext();
+        const mem = Math.round((os.totalmem() - os.freemem()) / 1024 / 1024 / 1024 * 10) / 10;
+        const totalMem = Math.round(os.totalmem() / 1024 / 1024 / 1024);
+
+        output += `${Logger.C.bold}${Logger.C.cyan} X A V V A  2.0 ${Logger.C.reset} ${Logger.C.dim}│${Logger.C.reset} ${Logger.C.white}${Logger.C.bold}${name}${Logger.C.reset}\n`;
+        output += `${Logger.C.dim} STATUS: ${this.statusColor}${this.status.padEnd(10)}${Logger.C.reset} ${Logger.C.dim}│ MEM: ${Logger.C.yellow}${mem}G/${totalMem}G${Logger.C.reset} ${Logger.C.dim}│ BRANCH: ${Logger.C.magenta}${git.branch || "unknown"}${Logger.C.reset}\n`;
+        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\n`;
+
+        // Logs
+        const visibleLogs = this.logLines.slice(-this.maxLogLines);
+        for (let i = 0; i < this.maxLogLines; i++) {
+            const line = visibleLogs[i] || "";
+            // Limpa a linha antes de escrever (ANSI escape EL)
+            output += line.substring(0, process.stdout.columns) + "\x1B[K\n";
+        }
+
+        // Footer
+        output += `\x1B[${process.stdout.rows - 1};1H`; // Move to last rows
+        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\n`;
+        output += ` ${Logger.C.bold}${Logger.C.white}R${Logger.C.reset} Restart  ${Logger.C.bold}${Logger.C.white}L${Logger.C.reset} Clear  ${Logger.C.bold}${Logger.C.white}Q${Logger.C.reset} Quit    ${Logger.C.dim} (Xavva 2.0 TUI Mode)${Logger.C.reset}`;
+
+        process.stdout.write(output);
+    }
+
+    private exit() {
+        if (this.isTui) {
+            process.stdout.write("\x1B[?1049l"); // Restore buffer
+            process.stdout.write("\x1B[?25h"); // Show cursor
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+        process.exit(0);
+    }
+}

package/src/services/LogAnalyzer.ts

@@ -0,0 +1,140 @@
+import { Logger } from "../utils/ui";
+import type { ProjectConfig } from "../types/config";
+
+export class LogAnalyzer {
+    private projectPrefixes: string[] = [];
+
+    constructor(private config: ProjectConfig) {
+        // Tentamos inferir prefixos comuns do projeto. 
+        // Em Java/Maven/Gradle geralmente começam com com.empresa, br.com.etc
+        // Podemos extrair isso do ProjectService se necessário, ou usar o appName como base.
+        if (config.appName) {
+            this.projectPrefixes.push(config.appName.split('-')[0].toLowerCase());
+        }
+        // Prefixos padrões que queremos destacar se encontrarmos
+        this.projectPrefixes.push("com.xavva"); 
+    }
+
+    setProjectPrefixes(prefixes: string[]) {
+        this.projectPrefixes = [...new Set([...this.projectPrefixes, ...prefixes])];
+    }
+
+    public summarize(line: string): string {
+        if (Logger.isSystemNoise(line)) return "";
+
+        // Reuso da lógica existente no Logger.summarize, mas aprimorada
+        const startupMatch = line.match(/Server startup in (\[?)(.*?)(\]?)\s*ms/);
+        if (startupMatch) {
+            const time = (parseInt(startupMatch[2]) / 1000).toFixed(1);
+            return `${Logger.C.green}✔ ${Logger.C.bold}Server started in ${time}s`;
+        }
+
+        const deployMatch = line.match(/Deployment of web application archive \[(.*?)\] has finished in \[(.*?)\] ms/);
+        if (deployMatch) {
+            return `${Logger.C.green}✔ Artifacts deployed`;
+        }
+
+        // Smart Folding para Stack Traces
+        if (line.trim().startsWith("at ")) {
+            return this.formatStackTraceLine(line);
+        }
+
+        if (line.includes("Caused by:")) {
+            return `${Logger.C.bgRed}${Logger.C.white}${Logger.C.bold} ROOT CAUSE ${Logger.C.reset} ${Logger.C.red}${line.trim()}${Logger.C.reset}`;
+        }
+
+        // Hotswap
+        const hotswapPattern = /HOTSWAP AGENT:.*? (INFO|WARN|ERROR|RELOAD) (.*?) - (.*)/;
+        const hotswapMatch = line.match(hotswapPattern);
+        if (hotswapMatch) {
+            return this.formatHotswapLine(hotswapMatch);
+        }
+
+        // Tomcat standard logs
+        const tomcatPattern = /^(\d{2}-\w{3}-\d{4} \d{2}:\d{2}:\d{2}\.\d{3})\s+(INFO|WARNING|SEVERE|ERROR)\s+\[(.*?)\]\s+(.*)$/;
+        const tMatch = line.match(tomcatPattern);
+        if (tMatch) {
+            return this.formatTomcatLine(tMatch);
+        }
+
+        // Generic [LEVEL] logs
+        const logPattern = /^\[(INFO|WARNING|WARN|SEVERE|ERROR)\]\s+(.*)$/;
+        const match = line.match(logPattern);
+        if (match) {
+            return this.formatGenericLog(match);
+        }
+
+        // Se a linha contém Exception mas não é o 'at ', destaca
+        if (line.includes("Exception:")) {
+            return `${Logger.C.red}${Logger.C.bold}${line.trim()}${Logger.C.reset}`;
+        }
+
+        return "";
+    }
+
+    private formatStackTraceLine(line: string): string {
+        const trimmed = line.trim();
+        const isProject = this.projectPrefixes.some(p => trimmed.includes(p));
+        
+        if (isProject) {
+            return `    ${Logger.C.bold}${Logger.C.yellow}${trimmed}${Logger.C.reset}`;
+        } else {
+            return `    ${Logger.C.dim}${trimmed}${Logger.C.reset}`;
+        }
+    }
+
+    private formatHotswapLine(match: RegExpMatchArray): string {
+        const level = match[1];
+        let msg = match[3];
+
+        if (msg.includes("plugin initialized")) return "";
+        
+        if (msg.includes("redefinition") || msg.includes("reloaded") || level === 'RELOAD') {
+            if (msg.includes("Reloading classes [")) {
+                const classes = msg.match(/\[(.*?)\]/)?.[1] || "";
+                const classCount = classes.split(",").length;
+                if (classCount > 3) msg = `Reloading ${classCount} classes...`;
+            }
+            return `${Logger.C.magenta}👀 ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg.replace(/Class '.*?'/, (m) => Logger.C.bold + m + Logger.C.reset)}`;
+        }
+
+        let color = Logger.C.cyan;
+        let symbol = "●";
+        if (level === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }
+        
+        return `${color}${symbol} ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg}`;
+    }
+
+    private formatTomcatLine(match: RegExpMatchArray): string {
+        const label = match[2];
+        let msg = match[4].trim();
+        if (Logger.isSystemNoise(msg)) return "";
+        
+        let color = Logger.C.dim;
+        let symbol = "ℹ";
+        if (label === "WARNING") { color = Logger.C.yellow; symbol = "▲"; }
+        else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
+        
+        msg = msg.replace(/^(org\.apache|com\.sun|java\..*?|org\.glassfish)\.[a-zA-Z0-9.]+\s/, "").trim();
+        if (!msg) return "";
+        
+        return `${color}${symbol} ${msg}`;
+    }
+
+    private formatGenericLog(match: RegExpMatchArray): string {
+        const label = match[1];
+        let msg = match[2].trim();
+        if (msg.includes("Total time:") || msg.includes("Finished at:") || msg.includes("Final Memory:") || msg.includes("-----------------------")) return "";
+        
+        let color = Logger.C.dim;
+        let symbol = "ℹ";
+        if (label === "WARNING" || label === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
+        
+        msg = msg.replace(/^(org\.apache|com\.sun|java\..*?)\.[a-zA-Z0-9.]+\s/, "").trim();
+        if (!msg || msg === "]" || msg.includes("Compilation failure")) return "";
+        
+        return `${color}${symbol} ${msg}`;
+    }
+}

package/src/services/TomcatService.ts

@@ -42,28 +42,45 @@ export class TomcatService {
 		}
 	}
 
-	clearWebapps() {
-		const fs = require("fs");
+	async clearWebapps() {
+		const fs = require("fs").promises;
+		const { existsSync } = require("fs");
 		const path = require("path");
 		const webappsPath = path.join(this.activeConfig.path, "webapps");
 		const workPath = path.join(this.activeConfig.path, "work");
 		const tempPath = path.join(this.activeConfig.path, "temp");
 
 		try {
-			[workPath, tempPath].forEach(p => {
-				if (fs.existsSync(p)) {
-					fs.rmSync(p, { recursive: true, force: true });
-					fs.mkdirSync(p);
+			const cleanDir = async (p: string) => {
+				if (existsSync(p)) {
+					await fs.rm(p, { recursive: true, force: true });
+					
+					// Resiliência para Windows: garante que o diretório foi liberado antes do mkdir
+					let retries = 10;
+					while (retries > 0 && existsSync(p)) {
+						await new Promise(r => setTimeout(r, 50));
+						retries--;
+					}
+					
+					await fs.mkdir(p, { recursive: true });
+				}
+			};
+
+			const tasks: Promise<any>[] = [
+				cleanDir(workPath),
+				cleanDir(tempPath)
+			];
+
+			if (existsSync(webappsPath)) {
+				const files = await fs.readdir(webappsPath);
+				for (const file of files) {
+					if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
+					const fullPath = path.join(webappsPath, file);
+					tasks.push(fs.rm(fullPath, { recursive: true, force: true }));
 				}
-			});
-
-			const files = fs.readdirSync(webappsPath);
-			for (const file of files) {
-				const fullPath = path.join(webappsPath, file);
-				if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
-				
-				fs.rmSync(fullPath, { recursive: true, force: true });
 			}
+
+			await Promise.all(tasks);
 		} catch (e) {
 			Logger.warn("Não foi possível limpar totalmente a pasta webapps ou cache.");
 		}

package/src/types/config.ts

@@ -18,6 +18,7 @@ export interface ProjectConfig {
     debugPort: number;
     cleanLogs: boolean;
     grep?: string;
+    tui: boolean;
 }
 
 export interface AppConfig {
@@ -44,6 +45,7 @@ export interface CLIArguments {
     dp?: string;
     fix?: boolean;
     incremental?: boolean;
+    tui?: boolean;
 }
 
 export interface CommandContext {

package/src/utils/config.ts

@@ -27,12 +27,25 @@ export class ConfigManager {
                 verbose: { type: "boolean", short: "V" },
                 dp: { type: "string" },
                 fix: { type: "boolean" },
+                tui: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
         });
 
         const cliValues = values as CLIArguments;
+
+        // Load xavva.json
+        const xavvaJsonPath = path.join(process.cwd(), "xavva.json");
+        let xavvaJson: Partial<CLIArguments> = {};
+        if (fs.existsSync(xavvaJsonPath)) {
+            try {
+                xavvaJson = JSON.parse(fs.readFileSync(xavvaJsonPath, "utf8"));
+            } catch (e) {
+                console.error("Error reading xavva.json:", (e as Error).message);
+            }
+        }
+
         const isDev = positionals.includes("dev");
         const isRun = positionals.includes("run") || positionals.includes("debug");
         
@@ -49,24 +62,25 @@ export class ConfigManager {
 
         const config: AppConfig = {
             tomcat: {
-                path: String(cliValues.path || envTomcatPath),
-                port: parseInt(String(cliValues.port || "8080")),
+                path: String(cliValues.path || xavvaJson.path || envTomcatPath),
+                port: parseInt(String(cliValues.port || xavvaJson.port || "8080")),
                 webapps: "webapps",
-                grep: cliValues.grep ? String(cliValues.grep) : "",
+                grep: cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : "",
             },
             project: {
-                appName: cliValues.name ? String(cliValues.name) : "",
-                buildTool: (cliValues.tool as "maven" | "gradle") || detectedTool,
-                profile: String(cliValues.profile || ""),
-                skipBuild: !!cliValues["no-build"],
-                skipScan: cliValues.scan !== undefined ? !cliValues.scan : true,
-                clean: !!cliValues.clean,
-                cleanLogs: cliValues.verbose ? false : true,
-                quiet: cliValues.verbose ? false : true,
-                verbose: !!cliValues.verbose,
-                debug: !!(cliValues.debug || isDev || isRun),
-                debugPort: parseInt(String(cliValues.dp || "5005")),
-                grep: runClass || (cliValues.grep ? String(cliValues.grep) : ""),
+                appName: cliValues.name || xavvaJson.name ? String(cliValues.name || xavvaJson.name) : "",
+                buildTool: (cliValues.tool as any) || (xavvaJson.tool as any) || detectedTool,
+                profile: String(cliValues.profile || xavvaJson.profile || ""),
+                skipBuild: !!(cliValues["no-build"] ?? xavvaJson["no-build"]),
+                skipScan: cliValues.scan !== undefined ? !cliValues.scan : (xavvaJson.scan !== undefined ? !xavvaJson.scan : true),
+                clean: !!(cliValues.clean ?? xavvaJson.clean),
+                cleanLogs: (cliValues.verbose ?? xavvaJson.verbose) ? false : true,
+                quiet: (cliValues.verbose ?? xavvaJson.verbose) ? false : true,
+                verbose: !!(cliValues.verbose ?? xavvaJson.verbose),
+                debug: !!(cliValues.debug ?? xavvaJson.debug ?? isDev ?? isRun),
+                debugPort: parseInt(String(cliValues.dp || xavvaJson.dp || "5005")),
+                grep: runClass || (cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : ""),
+                tui: !!(cliValues.tui ?? xavvaJson.tui),
             }
         };