@archznn/xavva 1.8.1 → 2.0.1

package/README.md

@@ -1,4 +1,4 @@
-# XAVVA 🚀 (Windows Only) `v1.8.1`
+# XAVVA 🚀 (Windows Only) `v2.0.1`
 
 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.1",
+	"version": "2.0.1",
 	"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/HelpCommand.ts

@@ -1,50 +1,48 @@
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import pkg from "../../package.json";
 
 export class HelpCommand implements Command {
-    async execute(_config: AppConfig): Promise<void> {
+    async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
         console.log(`
-🛠️  Xavva CLI v${pkg.version}
--------------------------------
-A Xavva automatiza o ciclo de vida de aplicações Java (Tomcat).
-Se nenhum comando for fornecido, 'deploy' será executado por padrão.
+🛠️  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: Deploy + Watch + Debug + Clean.
-  deploy        (Padrão) Builda o projeto, move para webapps e inicia o Tomcat.
-  start         Apenas inicia o servidor (útil quando o .war já foi gerado).
-  build         Executa apenas a compilação (mvn package ou gradle build).
-  doctor        🩺 Verifica o ambiente (Java, Tomcat, Maven, etc).
-  docs          📖 Swagger-like: Exibe endpoints e URLs de JSPs.
-  audit         🛡️ JAR Audit: Busca vulnerabilidades (CVEs) nas dependências.
-  run           🚀 Executa uma classe main (Uso: xavva run NomeDaClasse).
-  debug         🐞 Debuga uma classe main (Uso: xavva debug NomeDaClasse).
-  logs          📋 Monitora o catalina.out do Tomcat em tempo real.
+  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:
-  -w, --watch   👀 Hot Reload: monitora arquivos e redeploya automaticamente.
-  -d, --debug   🐞 Habilita debug Java (JPDA).
-  --dp [porta]  🔌 Porta do Debugger (padrão: 5005).
-  -c, --clean   🧹 Logs coloridos e simplificados (recomendado).
-  -q, --quiet   🤫 Mostra apenas mensagens essenciais nos logs.
-  -V, --verbose 📣 Mostra logs completos do Maven/Gradle.
-  -s, --no-build Pula o build (usa o que já estiver na pasta target/build).
-  -P, --profile Define o profile (ex: -P prod).
-  --fix         🔧 Corrige problemas automaticamente no 'doctor'.
+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.
 
-Exemplos de uso:
-  xavva dev           A melhor experiência de dev local.
-  xavva -w -c         Inicia com auto-reload e logs limpos.
-  xavva deploy -d     Builda e inicia com debugger habilitado.
-  xavva start -c      Apenas sobe o servidor com logs limpos.
-  xavva build -P dev  Apenas compila usando o profile 'dev'.
+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).
 
-Opções de Configuração:
-  -p, --path    Caminho do Tomcat (padrão via config.ts)
-  -t, --tool    Ferramenta (maven/gradle)
-  -n, --name    Nome do .war (ex: -n ROOT)
-  --port        Porta HTTP (padrão: 8080)
+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.*
         `);
     }
 }

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/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,24 @@ 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);
+	Logger.setDashboard(dashboard);
 
 	// 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);
@@ -68,11 +76,18 @@ async function main() {
 
 	// Caso especial: Watch Mode para Deploy/Dev
 	if ((commandName === "deploy" || commandName === "dev") && values.watch) {
+		// Registrar ação de restart manual na TUI
+		if (dashboard.isTuiActive()) {
+			dashboard.onAction("r", () => {
+				dashboard.log(Logger.C.yellow + "Restart manual solicitado via TUI...");
+				deployCmd.execute(config, false, true); // Executa deploy completo mas mantém o watch
+			});
+		}
+
 		const watcher = new WatcherService(config, deployCmd);
 		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/DashboardService.ts

@@ -0,0 +1,123 @@
+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;
+    private gitContext: any = null;
+    private actions: Map<string, () => void> = new Map();
+
+    constructor(private config: AppConfig) {
+        this.isTui = config.project.tui;
+        if (this.isTui) {
+            this.gitContext = Logger.getGitContext();
+            this.maxLogLines = process.stdout.rows - 6;
+            this.setupTui();
+        }
+    }
+
+    public isTuiActive(): boolean {
+        return this.isTui;
+    }
+
+    public onAction(key: string, callback: () => void) {
+        this.actions.set(key.toLowerCase(), callback);
+    }
+
+    private setupTui() {
+        process.stdout.write("\x1B[?1049h"); // Switch to alternate buffer
+        process.stdout.write("\x1B[2J"); // Clear screen
+        process.stdout.write("\x1B[?25l"); // Hide cursor
+        
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+
+        process.stdin.on("data", (key: string) => {
+            const input = key.toLowerCase();
+            // Ctrl+C ou Q para sair
+            if (key === "\u0003" || input === "q") {
+                this.exit();
+            }
+            if (input === "l") {
+                this.logLines = [];
+                this.render();
+                return;
+            }
+            
+            const action = this.actions.get(input);
+            if (action) action();
+        });
+
+        process.on("SIGINT", () => this.exit());
+        process.on("exit", () => this.exit());
+
+        // Atualiza o dashboard periodicamente para memória/status
+        setInterval(() => this.render(), 1000);
+    }
+
+    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 - 6;
+        
+        let output = "\x1B[H"; // Move to 0,0
+        
+        // Header
+        const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
+        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}\x1B[K\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}${this.gitContext?.branch || "unknown"}${Logger.C.reset}\x1B[K\n`;
+        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\x1B[K\n`;
+
+        // Logs
+        const visibleLogs = this.logLines.slice(-this.maxLogLines);
+        for (let i = 0; i < this.maxLogLines; i++) {
+            const line = visibleLogs[i] || "";
+            output += line.substring(0, process.stdout.columns) + "\x1B[K\n";
+        }
+
+        // Footer
+        output += `\x1B[${process.stdout.rows};1H`; // Move to last row
+        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}\x1B[K`;
+
+        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/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),
             }
         };
 

package/src/utils/ui.ts

@@ -22,8 +22,18 @@ export class Logger {
     private static lastDomain = "";
     private static lastHotswapMsg = "";
     private static activeSpinnerMsg = "";
+    private static dashboard: any = null;
+
+    static setDashboard(dashboard: any) {
+        this.dashboard = dashboard;
+    }
 
     private static write(message: string, isError: boolean = false) {
+        if (this.dashboard && this.dashboard.isTuiActive()) {
+            this.dashboard.log(message);
+            return;
+        }
+
         if (this.activeSpinnerMsg) {
             process.stdout.write("\r\x1B[K"); // Limpa a linha do spinner
         }
@@ -126,6 +136,17 @@ export class Logger {
     static dim(msg: string) { this.write(`  ${this.C.dim}${msg}${this.C.reset}`); }
 
     static spinner(msg: string) {
+        if (this.dashboard && this.dashboard.isTuiActive()) {
+            this.dashboard.log(`${this.C.cyan}⠋${this.C.reset} ${msg}...`);
+            return (success = true) => {
+                if (success) {
+                    this.dashboard.log(`${this.C.green}✔${this.C.reset} ${msg}`);
+                } else {
+                    this.dashboard.log(`${this.C.red}✖${this.C.reset} Falha em ${msg}`);
+                }
+            };
+        }
+
         this.activeSpinnerMsg = msg;
         const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         let i = 0;