@archznn/xavva 2.2.0 → 2.2.1

package/README.md

@@ -1 +1,3 @@
-# XAVVA CLI 🚀> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows[![Version](https://img.shields.io/badge/version-2.2.0-blue.svg)](https://github.com/leorsousa05/Xavva)[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.---## ✨ Features- ⚡ **Hot Reload** — Incremental compilation and class injection without server restart- 📊 **Interactive Dashboard** — Real-time TUI with system metrics and shortcuts- 🧠 **Smart Log Analyzer** — Stack trace folding and root cause highlighting- 🔒 **Security Audit** — Automated vulnerability scanning via OSV.dev- 📦 **Dependency Analysis** — Detect conflicts and outdated dependencies- 🎯 **Maven & Gradle** — Native support for both build tools- 🔧 **Auto-Healing** — Automatic diagnosis and repair of common issues---## 📦 Installation```powershell# Via NPMnpm install -g @archznn/xavva# Or run directly with Bunbunx @archznn/xavva dev```---## 🚀 Quick Start```bash# Start development mode with dashboardxavva dev --tui# Deploy to Tomcatxavva deploy# Analyze dependencies for issuesxavva deps# Check for security vulnerabilitiesxavva audit```---## 📖 Commands### Core Development| Command | Description ||---------|-------------|| `xavva dev` | Full development mode (build + deploy + watch + debug) || `xavva deploy` | Build and deploy application to Tomcat || `xavva build` | Compile project only || `xavva start` | Start Tomcat server only |### Code Execution| Command | Description ||---------|-------------|| `xavva run <class>` | Execute a Java class with automatic classpath || `xavva debug <class>` | Debug a Java class (port 5005) |### Analysis & Monitoring| Command | Description ||---------|-------------|| `xavva logs` | Stream and analyze Tomcat logs in real-time || `xavva deps` | **Analyze dependencies** — detect conflicts, find updates || `xavva audit` | Security audit of JAR files via OSV.dev || `xavva doctor` | Diagnose environment issues (JAVA_HOME, DCEVM) || `xavva profiles` | List available Maven/Gradle profiles || `xavva docs` | Generate endpoint documentation |---## 🔍 Dependency AnalysisThe `xavva deps` command provides comprehensive dependency analysis:```bash# Basic analysisxavva deps# With verbose output for debuggingxavva deps --verbose# Show fix suggestions for conflictsxavva deps --fix# Export report as JSONxavva deps --output report.json# Fail on critical conflicts (useful in CI/CD)xavva deps --strict```### What it detects:- ⚠️ **Version Conflicts** — Same dependency with different versions- ⬆️ **Available Updates** — Newer versions in Maven Central- 🔴 **Major Updates** — Breaking changes that need attention- 📊 **Statistics** — Direct vs transitive dependencies### Sample output:```══════════════════════════════════════════════════════════📊 DEPENDENCY ANALYSIS══════════════════════════════════════════════════════════Statistics:  Total: 183 dependencies  Direct: 45 | Transitive: 138⚠️  VERSION CONFLICTS (2)  ✖ com.fasterxml.jackson.core:jackson-databind     Versions: 2.13.0, 2.12.6⬆️  UPDATES AVAILABLE (5)  ↑ org.postgresql:postgresql     42.2.5 → 42.7.1⚠️  MAJOR UPDATES (1)  ! org.springframework.boot:spring-boot-starter     2.5.0 → 3.1.0```---## ⚙️ ConfigurationCreate `xavva.json` in your project root:```json{  "project": {    "appName": "my-application",    "buildTool": "maven",    "profile": "dev",    "tui": false  },  "tomcat": {    "path": "C:/apache-tomcat",    "port": 8080  }}```### CLI Options| Option | Description ||--------|-------------|| `-p, --path <path>` | Tomcat installation path || `-t, --tool <tool>` | Build tool: `maven` or `gradle` || `-n, --name <name>` | Application name (WAR context) || `--port <port>` | Tomcat port (default: 8080) || `-P, --profile <prof>` | Maven/Gradle profile || `-e, --encoding <enc>` | Source encoding (utf8, cp1252) || `-w, --watch` | Enable file watching || `--tui` | Interactive dashboard mode || `-d, --debug` | Enable JPDA debugger || `-c, --clean` | Clean logs before start || `-s, --no-build` | Skip initial build || `-V, --verbose` | Detailed output |---## 🏗️ ArchitectureXavva uses a modular service-oriented architecture:- **DashboardService** — TUI management and interactivity- **LogAnalyzer** — Intelligent log processing- **DependencyAnalyzerService** — Dependency conflict detection- **ProjectService** — Project structure discovery- **BuildService** — Maven/Gradle integration- **TomcatService** — Server lifecycle management---## 🤝 ContributingContributions are welcome! Please feel free to submit a Pull Request.---## 📄 LicenseMIT License — see [LICENSE](LICENSE) for details.---<p align="center">  <sub>Built with ❤️ for Java developers who miss modern tooling</sub></p>
+# XAVVA CLI 🚀> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows[![Version](https://img.shields.io/badge/version-2.2.1-blue.svg)](https://github.com/leorsousa05/Xavva)[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.---## ✨ Features- ⚡ **Hot Reload** — Incremental compilation and class injection without server restart- 📊 **Interactive Dashboard** — Real-time TUI with system metrics and shortcuts- 🧠 **Smart Log Analyzer** — Stack trace folding and root cause highlighting- 🔒 **Security Audit** — Automated vulnerability scanning via OSV.dev- 📦 **Dependency Analysis** — Detect conflicts and outdated dependencies- 🎯 **Maven & Gradle** — Native support for both build tools- 🔧 **Auto-Healing** — Automatic diagnosis and repair of common issues---## 📦 Installation```powershell# Via NPMnpm install -g @archznn/xavva# Or run directly with Bunbunx @archznn/xavva dev```---## 🚀 Quick Start```bash# Start development mode with dashboardxavva dev --tui# Deploy to Tomcatxavva deploy# Analyze dependencies for issuesxavva deps
+# Update safe dependencies (non-breaking)
+xavva deps --update-safe# Check for security vulnerabilitiesxavva audit```---## 📖 Commands### Core Development| Command | Description ||---------|-------------|| `xavva dev` | Full development mode (build + deploy + watch + debug) || `xavva deploy` | Build and deploy application to Tomcat || `xavva build` | Compile project only || `xavva start` | Start Tomcat server only |### Code Execution| Command | Description ||---------|-------------|| `xavva run <class>` | Execute a Java class with automatic classpath || `xavva debug <class>` | Debug a Java class (port 5005) |### Analysis & Monitoring| Command | Description ||---------|-------------|| `xavva logs` | Stream and analyze Tomcat logs in real-time || `xavva deps` | **Analyze dependencies** — detect conflicts, find updates || `xavva audit` | Security audit of JAR files via OSV.dev || `xavva doctor` | Diagnose environment issues (JAVA_HOME, DCEVM) || `xavva profiles` | List available Maven/Gradle profiles || `xavva docs` | Generate endpoint documentation |---## 🔍 Dependency AnalysisThe `xavva deps` command provides comprehensive dependency analysis:```bash# Basic analysisxavva deps# With verbose output for debuggingxavva deps --verbose# Show fix suggestions for conflictsxavva deps --fix# Export report as JSONxavva deps --output report.json# Fail on critical conflicts (useful in CI/CD)xavva deps --strict```### What it detects:- ⚠️ **Version Conflicts** — Same dependency with different versions- ⬆️ **Available Updates** — Newer versions in Maven Central- 🔴 **Major Updates** — Breaking changes that need attention- 📊 **Statistics** — Direct vs transitive dependencies### Sample output:```══════════════════════════════════════════════════════════📊 DEPENDENCY ANALYSIS══════════════════════════════════════════════════════════Statistics:  Total: 183 dependencies  Direct: 45 | Transitive: 138⚠️  VERSION CONFLICTS (2)  ✖ com.fasterxml.jackson.core:jackson-databind     Versions: 2.13.0, 2.12.6⬆️  UPDATES AVAILABLE (5)  ↑ org.postgresql:postgresql     42.2.5 → 42.7.1⚠️  MAJOR UPDATES (1)  ! org.springframework.boot:spring-boot-starter     2.5.0 → 3.1.0```---## ⚙️ ConfigurationCreate `xavva.json` in your project root:```json{  "project": {    "appName": "my-application",    "buildTool": "maven",    "profile": "dev",    "tui": false  },  "tomcat": {    "path": "C:/apache-tomcat",    "port": 8080  }}```### CLI Options| Option | Description ||--------|-------------|| `-p, --path <path>` | Tomcat installation path || `-t, --tool <tool>` | Build tool: `maven` or `gradle` || `-n, --name <name>` | Application name (WAR context) || `--port <port>` | Tomcat port (default: 8080) || `-P, --profile <prof>` | Maven/Gradle profile || `-e, --encoding <enc>` | Source encoding (utf8, cp1252) || `-w, --watch` | Enable file watching || `--tui` | Interactive dashboard mode || `-d, --debug` | Enable JPDA debugger || `-c, --clean` | Clean logs before start || `-s, --no-build` | Skip initial build || `-V, --verbose` | Detailed output |---## 🏗️ ArchitectureXavva uses a modular service-oriented architecture:- **DashboardService** — TUI management and interactivity- **LogAnalyzer** — Intelligent log processing- **DependencyAnalyzerService** — Dependency conflict detection- **ProjectService** — Project structure discovery- **BuildService** — Maven/Gradle integration- **TomcatService** — Server lifecycle management---## 🤝 ContributingContributions are welcome! Please feel free to submit a Pull Request.---## 📄 LicenseMIT License — see [LICENSE](LICENSE) for details.---<p align="center">  <sub>Built with ❤️ for Java developers who miss modern tooling</sub></p>

package/package.json

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

@@ -50,6 +50,10 @@ export class DepsCommand implements Command {
 			console.log(report);
 
 			// Ações adicionais baseadas em flags
+			if (args?.["update-safe"] || args?.["updateSafe"]) {
+				await this.performUpdateSafe(analyzer, result, config.project.buildTool);
+			}
+
 			if (args?.["fix"]) {
 				await this.suggestFixes(result, config.project.buildTool);
 			}
@@ -103,6 +107,62 @@ export class DepsCommand implements Command {
 		}
 	}
 
+	private async performUpdateSafe(
+		analyzer: DependencyAnalyzerService,
+		result: DependencyAnalysisResult,
+		buildTool: string
+	): Promise<void> {
+		const safeUpdates = result.updates.filter(u => !u.isMajor);
+		
+		if (safeUpdates.length === 0) {
+			Logger.info("", "Nenhuma atualização segura disponível");
+			return;
+		}
+
+		Logger.newline();
+		Logger.section("Atualizando Dependências (Safe Mode)");
+		Logger.info("Atualizações a aplicar", String(safeUpdates.length));
+
+		const spinner = Logger.spinner("Atualizando arquivos de configuração...");
+		
+		try {
+			const updateResult = await analyzer.updateSafe(safeUpdates);
+			spinner();
+
+			if (updateResult.updated > 0) {
+				Logger.success(`${updateResult.updated} dependências atualizadas`);
+				Logger.info("", `Backup criado: ${buildTool === "maven" ? "pom.xml.backup" : "build.gradle.backup"}`);
+				
+				// Listar o que foi atualizado
+				for (const update of safeUpdates.slice(0, 5)) {
+					Logger.log(`  ${Logger.C.success}↑${Logger.C.reset} ${update.groupId}:${update.artifactId} ${update.currentVersion} → ${Logger.C.success}${update.latestVersion}${Logger.C.reset}`);
+				}
+				if (safeUpdates.length > 5) {
+					Logger.log(`  ${Logger.C.dim}... e mais ${safeUpdates.length - 5}${Logger.C.reset}`);
+				}
+
+				Logger.newline();
+				Logger.log(`${Logger.C.warning}⚠️  Execute 'mvn compile' ou 'gradle build' para aplicar as mudanças${Logger.C.reset}`);
+			} else {
+				Logger.warn("Nenhuma dependência foi atualizada");
+			}
+
+			if (updateResult.skipped > 0) {
+				Logger.info("Dependências ignoradas", `${updateResult.skipped} (definidas via propriedades)`);
+			}
+
+			if (updateResult.errors.length > 0) {
+				for (const error of updateResult.errors) {
+					Logger.warn(error);
+				}
+			}
+		} catch (error) {
+			spinner(false);
+			const message = error instanceof Error ? error.message : String(error);
+			Logger.error(`Falha na atualização: ${message}`);
+		}
+	}
+
 	private exportReport(
 		result: DependencyAnalysisResult,
 		outputPath: string

package/src/commands/HelpCommand.ts

@@ -63,6 +63,9 @@ export class HelpCommand implements Command {
     ${this.c("dim", "# Analyze dependencies for conflicts")}
     xavva deps --verbose
 
+    ${this.c("dim", "# Update safe dependencies (non-breaking only)")}
+    xavva deps --update-safe
+
     ${this.c("dim", "# Security audit with auto-fix suggestions")}
     xavva audit --fix
 

package/src/services/BuildService.ts

@@ -162,6 +162,7 @@ export class BuildService {
 		const decoder = new TextDecoder();
 		let errorCount = 0;
 		const maxErrors = 15;
+		const buildTool = this.projectConfig.buildTool as 'maven' | 'gradle';
 
 		while (true) {
 			const { done, value } = await reader.read();
@@ -174,20 +175,27 @@ export class BuildService {
 				const cleanLine = line.trim();
 				if (!cleanLine) continue;
 
-				if (cleanLine.includes("[ERROR]")) {
+				if (cleanLine.includes("[ERROR]") || cleanLine.includes("error:")) {
 					errorCount++;
 					if (errorCount > maxErrors && !this.projectConfig.verbose) {
 						if (errorCount === maxErrors + 1) {
-							Logger.warn("... e mais erros ocultos. Use -V para ver todos.");
+							Logger.warn("... and more errors hidden. Use -V to see all.");
 						}
 						continue;
 					}
 				}
 
 				if (!this.projectConfig.verbose) {
-					// Lógica de sumarização omitida para brevidade
+					// Modo não-verbose: usa sumarização existente
+					const formatted = Logger.formatBuildLog(cleanLine, buildTool);
+					if (formatted) console.log(formatted);
 				} else {
-					process.stdout.write(line + "\n");
+					// Modo verbose: formata mas mantém estrutura
+					const formatted = Logger.formatBuildLog(cleanLine, buildTool);
+					if (formatted) {
+						console.log(formatted);
+					}
+					// Silencia linhas que são noise puro
 				}
 			}
 		}

package/src/services/DependencyAnalyzerService.ts

@@ -471,12 +471,120 @@ export class DependencyAnalyzerService {
 		return 0;
 	}
 
+	async updateSafe(updates: DependencyUpdate[]): Promise<{ updated: number; skipped: number; errors: string[] }> {
+		const safeUpdates = updates.filter(u => !u.isMajor);
+		const result = { updated: 0, skipped: 0, errors: [] as string[] };
+		
+		if (safeUpdates.length === 0) {
+			return result;
+		}
+
+		if (this.projectConfig.buildTool === "maven") {
+			return this.updateMavenSafe(safeUpdates);
+		} else {
+			return this.updateGradleSafe(safeUpdates);
+		}
+	}
+
+	private async updateMavenSafe(updates: DependencyUpdate[]): Promise<{ updated: number; skipped: number; errors: string[] }> {
+		const result = { updated: 0, skipped: 0, errors: [] as string[] };
+		const pomPath = path.join(process.cwd(), "pom.xml");
+		
+		if (!fs.existsSync(pomPath)) {
+			result.errors.push("pom.xml não encontrado");
+			return result;
+		}
+
+		let content = fs.readFileSync(pomPath, "utf-8");
+		let modified = false;
+
+		for (const update of updates) {
+			// Pattern para encontrar a versão específica desta dependência
+			const groupId = update.groupId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const artifactId = update.artifactId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const currentVersion = update.currentVersion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			
+			// Regex para encontrar <version> dentro do bloco da dependência
+			const depPattern = new RegExp(
+				`(<dependency>\\s*<groupId>${groupId}</groupId>\\s*<artifactId>${artifactId}</artifactId>(?:\\s*<version>)${currentVersion}(</version>))`,
+				'g'
+			);
+			
+			if (depPattern.test(content)) {
+				content = content.replace(depPattern, `$1${update.latestVersion}$2`);
+				result.updated++;
+				modified = true;
+			} else {
+				// Pode ser definida via property
+				result.skipped++;
+			}
+		}
+
+		if (modified) {
+			// Backup do pom.xml
+			fs.writeFileSync(`${pomPath}.backup`, fs.readFileSync(pomPath));
+			fs.writeFileSync(pomPath, content);
+		}
+
+		return result;
+	}
+
+	private async updateGradleSafe(updates: DependencyUpdate[]): Promise<{ updated: number; skipped: number; errors: string[] }> {
+		const result = { updated: 0, skipped: 0, errors: [] as string[] };
+		const gradlePath = path.join(process.cwd(), "build.gradle");
+		
+		if (!fs.existsSync(gradlePath)) {
+			result.errors.push("build.gradle não encontrado");
+			return result;
+		}
+
+		let content = fs.readFileSync(gradlePath, "utf-8");
+		let modified = false;
+
+		for (const update of updates) {
+			const groupId = update.groupId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const artifactId = update.artifactId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			const currentVersion = update.currentVersion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			
+			// Pattern: implementation("group:artifact:version") ou implementation 'group:artifact:version'
+			const patterns = [
+				new RegExp(`(implementation\\s*\\(\\s*["']${groupId}:${artifactId}:)${currentVersion}(["']\\s*\\))`, 'g'),
+				new RegExp(`(implementation\\s+["']${groupId}:${artifactId}:)${currentVersion}(["'])`, 'g'),
+				new RegExp(`(compile\\s*\\(\\s*["']${groupId}:${artifactId}:)${currentVersion}(["']\\s*\\))`, 'g'),
+				new RegExp(`(compile\\s+["']${groupId}:${artifactId}:)${currentVersion}(["'])`, 'g'),
+			];
+			
+			let updated = false;
+			for (const pattern of patterns) {
+				if (pattern.test(content)) {
+					content = content.replace(pattern, `$1${update.latestVersion}$2`);
+					updated = true;
+					break;
+				}
+			}
+			
+			if (updated) {
+				result.updated++;
+				modified = true;
+			} else {
+				result.skipped++;
+			}
+		}
+
+		if (modified) {
+			fs.writeFileSync(`${gradlePath}.backup`, fs.readFileSync(gradlePath));
+			fs.writeFileSync(gradlePath, content);
+		}
+
+		return result;
+	}
+
 	generateReport(result: DependencyAnalysisResult): string {
 		const lines: string[] = [];
 		lines.push("");
-		lines.push(`${Logger.C.cyan}══════════════════════════════════════════════════════════${Logger.C.reset}`);
+		lines.push(`${Logger.C.primary}══════════════════════════════════════════════════════════${Logger.C.reset}`);
 		lines.push(`${Logger.C.bold}📊 ANÁLISE DE DEPENDÊNCIAS${Logger.C.reset}`);
-		lines.push(`${Logger.C.cyan}══════════════════════════════════════════════════════════${Logger.C.reset}`);
+		lines.push(`${Logger.C.primary}══════════════════════════════════════════════════════════${Logger.C.reset}`);
 		lines.push("");
 		
 		// Estatísticas
@@ -487,10 +595,10 @@ export class DependencyAnalyzerService {
 
 		// Conflitos
 		if (result.conflicts.length > 0) {
-			lines.push(`${Logger.C.yellow}⚠️  CONFLITOS DE VERSÃO (${result.conflicts.length})${Logger.C.reset}`);
+			lines.push(`${Logger.C.warning}⚠️  CONFLITOS DE VERSÃO (${result.conflicts.length})${Logger.C.reset}`);
 			for (const conflict of result.conflicts) {
 				const icon = conflict.severity === "error" ? "✖" : "▲";
-				const color = conflict.severity === "error" ? Logger.C.red : Logger.C.yellow;
+				const color = conflict.severity === "error" ? Logger.C.error : Logger.C.warning;
 				lines.push(`  ${color}${icon}${Logger.C.reset} ${conflict.groupId}:${conflict.artifactId}`);
 				lines.push(`     Versões: ${conflict.versions.join(", ")}`);
 			}
@@ -503,10 +611,10 @@ export class DependencyAnalyzerService {
 			const minorUpdates = result.updates.filter(u => !u.isMajor);
 
 			if (minorUpdates.length > 0) {
-				lines.push(`${Logger.C.green}⬆️  ATUALIZAÇÕES DISPONÍVEIS (${minorUpdates.length})${Logger.C.reset}`);
+				lines.push(`${Logger.C.success}⬆️  ATUALIZAÇÕES DISPONÍVEIS (${minorUpdates.length})${Logger.C.reset}`);
 				for (const update of minorUpdates.slice(0, 5)) {
-					lines.push(`  ${Logger.C.green}↑${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
-					lines.push(`     ${update.currentVersion} → ${Logger.C.green}${update.latestVersion}${Logger.C.reset}`);
+					lines.push(`  ${Logger.C.success}↑${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
+					lines.push(`     ${update.currentVersion} → ${Logger.C.success}${update.latestVersion}${Logger.C.reset}`);
 				}
 				if (minorUpdates.length > 5) {
 					lines.push(`  ${Logger.C.dim}... e mais ${minorUpdates.length - 5}${Logger.C.reset}`);
@@ -515,11 +623,11 @@ export class DependencyAnalyzerService {
 			}
 
 			if (majorUpdates.length > 0) {
-				lines.push(`${Logger.C.yellow}⚠️  ATUALIZAÇÕES MAJOR (${majorUpdates.length})${Logger.C.reset}`);
+				lines.push(`${Logger.C.warning}⚠️  ATUALIZAÇÕES MAJOR (${majorUpdates.length})${Logger.C.reset}`);
 				lines.push(`  ${Logger.C.dim}Podem conter breaking changes${Logger.C.reset}`);
 				for (const update of majorUpdates.slice(0, 3)) {
-					lines.push(`  ${Logger.C.yellow}!${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
-					lines.push(`     ${update.currentVersion} → ${Logger.C.yellow}${update.latestVersion}${Logger.C.reset}`);
+					lines.push(`  ${Logger.C.warning}!${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
+					lines.push(`     ${update.currentVersion} → ${Logger.C.warning}${update.latestVersion}${Logger.C.reset}`);
 				}
 				lines.push("");
 			}
@@ -527,7 +635,7 @@ export class DependencyAnalyzerService {
 
 		// Resumo
 		if (result.conflicts.length === 0 && result.updates.length === 0) {
-			lines.push(`${Logger.C.green}✔ Todas as dependências estão atualizadas!${Logger.C.reset}`);
+			lines.push(`${Logger.C.success}✔ Todas as dependências estão atualizadas!${Logger.C.reset}`);
 		}
 
 		lines.push("");

package/src/services/TomcatService.ts

@@ -2,7 +2,7 @@ import type { TomcatConfig, AppConfig } from "../types/config";
 import { Logger } from "../utils/ui";
 import type { Subprocess } from "bun";
 import { ProjectService } from "./ProjectService";
-import { existsSync, mkdirSync, writeFileSync, promises as fs } from "fs";
+import { existsSync, mkdirSync, writeFileSync, statSync, promises as fs } from "fs";
 import path from "path";
 import os from "os";
 
@@ -98,10 +98,10 @@ export class TomcatService {
 		const agentDir = path.join(os.homedir(), ".xavva", "agents");
 		const agentPath = path.join(agentDir, "hotswap-agent-2.0.3.jar");
 
-		if (fs.existsSync(agentPath) && fs.statSync(agentPath).size > 1000) return agentPath;
+		if (existsSync(agentPath) && statSync(agentPath).size > 1000) return agentPath;
 
 		try {
-			if (!fs.existsSync(agentDir)) fs.mkdirSync(agentDir, { recursive: true });
+			if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
 			
 			Logger.step("Downloading HotswapAgent v2.0.3 (Global)...");
 			const url = "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-2.0.3/hotswap-agent-2.0.3.jar";
@@ -109,7 +109,7 @@ export class TomcatService {
 			if (!response.ok) throw new Error(`Status: ${response.status}`);
 			
 			const buffer = await response.arrayBuffer();
-			fs.writeFileSync(agentPath, Buffer.from(buffer));
+			writeFileSync(agentPath, Buffer.from(buffer));
 			Logger.success("HotswapAgent v2.0.3 installed globally!");
 			return agentPath;
 		} catch (e) {
@@ -237,18 +237,21 @@ export class TomcatService {
 	private async processLogStream(stream: ReadableStream, clean: boolean, quiet: boolean, verbose: boolean, grep: string) {
 		const reader = stream.getReader();
 		const decoder = new TextDecoder();
+		let buffer = "";
 
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
 
-			const chunk = decoder.decode(value);
-			const lines = chunk.split(/[\r\n]+/);
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split(/\r?\n/);
+			buffer = lines.pop() || ""; // Keep incomplete line in buffer
 
 			for (const line of lines) {
 				const cleanLine = line.trim();
 				if (!cleanLine || cleanLine.startsWith("Listening for transport")) continue;
 
+				// Detect startup completion
 				if (cleanLine.includes("Server startup in") || cleanLine.includes("SEVERE") || cleanLine.includes("Exception")) {
 					const isSuccess = cleanLine.includes("Server startup in");
 					if (this.stopStartupSpinner) {
@@ -260,26 +263,44 @@ export class TomcatService {
 					}
 				}
 
+				// Verbose: formata logs do Tomcat
 				if (verbose) {
-					Logger.log(cleanLine);
+					if (Logger.isTomcatNoise(cleanLine)) {
+						continue; // Silencia noise completamente
+					}
+					const formatted = Logger.formatTomcatLog(cleanLine);
+					if (formatted) {
+						console.log(formatted);
+					}
 					continue;
 				}
 
+				// Clean mode: filtra noise
 				if (clean) {
+					// Sempre filtra noise do sistema
+					if (Logger.isSystemNoise(cleanLine)) continue;
+
+					// Quiet mode: só mostra essencial
 					if (quiet && !Logger.isEssential(cleanLine)) {
-						if (Logger.isSystemNoise(cleanLine)) continue;
-						if (cleanLine.includes("INFO")) continue;
-					} else if (Logger.isSystemNoise(cleanLine)) {
-						continue;
+						if (cleanLine.includes("INFO") && !cleanLine.includes("ERROR")) continue;
 					}
 
+					// Grep filter
 					if (grep && !cleanLine.toLowerCase().includes(grep.toLowerCase())) {
 						if (!Logger.isEssential(cleanLine)) continue;
 					}
 					
 					const summarized = Logger.summarize(cleanLine);
-					if (summarized) Logger.log(summarized);
+					if (summarized) {
+						// Só mostra se não for vazio (rate limiting)
+						if (summarized.trim()) Logger.log(summarized);
+					}
 				} else {
+					// Non-clean: mostra tudo mas formata
+					if (Logger.isSystemNoise(cleanLine)) {
+						// Silencia completamente noise em non-clean também
+						continue;
+					}
 					Logger.log(cleanLine);
 				}
 			}

package/src/utils/ui.ts

@@ -39,34 +39,110 @@ export class Logger {
 		this.dashboard = dashboard;
 	}
 
-	// Banner moderno e clean
+	// Banner completo com informações do ambiente
 	static banner(command?: string, profile?: string, encoding?: string) {
 		console.clear();
 		const git = this.getGitContext();
 		const name = process.cwd().split(/[/\\]/).pop() || "project";
+		const now = new Date().toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' });
+		const W = 52; // Largura interna do box (espaço entre os ║)
 		
-		// Linha superior decorativa
-		console.log(`${C.gray}┌────────────────────────────────────────────────────────┐${C.reset}`);
+		// Remove ANSI codes para calcular tamanho
+		const plain = (s: string) => s.replace(/\x1b\[\d+m/g, '');
 		
-		// Logo e projeto
-		console.log(`${C.gray}│${C.reset}  ${C.primary}${C.bold}XAVVA${C.reset}${C.gray}.${C.reset}${C.dim}v${pkg.version}${C.reset}  ${C.gray}│${C.reset}  ${C.white}${C.bold}${name}${C.reset}`);
+		// Cria uma linha com conteúdo alinhado à esquerda
+		const row = (content: string) => {
+			const pad = W - plain(content).length;
+			return `${C.gray}║${C.reset} ${content}${' '.repeat(Math.max(0, pad))}${C.gray}║${C.reset}`;
+		};
+		
+		// Linha superior
+		console.log(`${C.gray}╔══════════════════════════════════════════════════════╗${C.reset}`);
+		
+		// Linha 1: XAVVA v2.2.0 + hora alinhada à direita
+		const verPlain = `XAVVA v${pkg.version}`; // "XAVVA v2.2.0" = 12 chars
+		const timePlain = now; // 5 chars
+		const gap1 = W - verPlain.length - timePlain.length - 1; // -1 para deixar 1 espaço antes do ║
+		const line1Content = `${C.primary}${C.bold}XAVVA${C.reset}${C.gray} v${pkg.version}${C.reset}${' '.repeat(Math.max(1, gap1))}${C.dim}${now}${C.reset}`;
+		console.log(row(line1Content));
 		
-		// Info adicional em uma linha
-		const parts: string[] = [];
-		if (command) parts.push(`${C.primary}${command}${C.reset}`);
-		if (profile) parts.push(`${C.warning}profile:${profile}${C.reset}`);
-		if (encoding) parts.push(`${C.info}${encoding}${C.reset}`);
-		if (git.branch) parts.push(`${C.secondary}git:${git.branch}${C.reset}`);
+		// Linha 2: Nome do projeto
+		console.log(row(`${C.white}${C.bold}${name}${C.reset}`));
 		
-		if (parts.length > 0) {
-			console.log(`${C.gray}│${C.reset}  ${C.dim}mode${C.reset}  ${C.gray}│${C.reset}  ${parts.join(` ${C.gray}•${C.reset} `)}`);
+		// Linha 3: Git info
+		if (git.branch) {
+			const gitStatus = this.getGitStatus();
+			const dirty = gitStatus.dirty ? '*' : '';
+			const author = git.author ? git.author.split(' ')[0].slice(0, 10) : '';
+			const hash = git.hash ? git.hash.slice(0, 7) : '';
+			const branchDisplay = git.branch.slice(0, 20); // Limita branch
+			const gitLine = `${C.gray}git:${C.reset}${C.secondary}${branchDisplay}${dirty}${C.reset} ${C.dim}${hash}${C.reset} ${C.gray}by${C.reset} ${C.dim}${author}${C.reset}`;
+			console.log(row(gitLine));
 		}
 		
-		// Linha inferior
-		console.log(`${C.gray}└────────────────────────────────────────────────────────┘${C.reset}`);
+		// Divisor
+		console.log(`${C.gray}╠══════════════════════════════════════════════════════╣${C.reset}`);
+		
+		// Config: mode, profile, java, encoding
+		const cfg: string[] = [];
+		if (command) cfg.push(`${C.primary}${command}${C.reset}`);
+		if (profile) cfg.push(`${C.warning}${profile}${C.reset}`);
+		const jv = this.getJavaVersion();
+		if (jv) cfg.push(`${C.info}java:${jv}${C.reset}`);
+		if (encoding) cfg.push(`${C.gray}${encoding}${C.reset}`);
+		
+		if (cfg.length) {
+			const sep = `${C.gray} │ ${C.reset}`;
+			const cfgLine = `${C.dim}mode${C.reset} : ${cfg.join(sep)}`;
+			console.log(row(cfgLine));
+		}
+		
+		// Memory
+		const mem = process.memoryUsage();
+		const mb = Math.round((mem.heapUsed || mem.rss || 0) / 1024 / 1024);
+		console.log(row(`${C.dim}mem${C.reset}  : ${mb}MB ${C.gray}heap${C.reset}`));
+		
+		// OS
+		const plat = process.platform === 'win32' ? 'windows' : process.platform;
+		console.log(row(`${C.dim}os${C.reset}   : ${plat} ${C.gray}|${C.reset} ${process.arch}`));
+		
+		// Rodapé
+		console.log(`${C.gray}╚══════════════════════════════════════════════════════╝${C.reset}`);
 		console.log();
 	}
 
+	private static getGitStatus(): { dirty: boolean; modified: number } {
+		try {
+			const result = Bun.spawnSync(["git", "status", "--porcelain"]);
+			const lines = result.stdout.toString().trim().split('\n').filter(l => l.trim());
+			return { dirty: lines.length > 0, modified: lines.length };
+		} catch {
+			return { dirty: false, modified: 0 };
+		}
+	}
+
+	private static getJavaVersion(): string | null {
+		try {
+			const javaBin = process.env.JAVA_HOME 
+				? `${process.env.JAVA_HOME}/bin/java`
+				: 'java';
+			const result = Bun.spawnSync([javaBin, "-version"]);
+			const output = (result.stderr?.toString() || result.stdout?.toString() || '');
+			const match = output.match(/version "?(\d+(?:\.\d+)?)/);
+			if (match) {
+				const v = match[1];
+				// Check for DCEVM
+				if (output.toLowerCase().includes('dcevm') || output.toLowerCase().includes('jbr')) {
+					return `${v}+dcevm`;
+				}
+				return v;
+			}
+			return null;
+		} catch {
+			return null;
+		}
+	}
+
 	// Seções com divisórias clean
 	static section(title: string) {
 		console.log(`${C.gray}┌─ ${C.white}${C.bold}${title}${C.reset}`);
@@ -112,18 +188,46 @@ export class Logger {
 		console.log(`${C.gray}│${C.reset}  ${C.warning}⚠${C.reset} ${msg}`);
 	}
 
-	static build(msg: string) {
-		console.log(`${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}build${C.reset} ${C.gray}:${C.reset} ${msg}`);
+	static debug(msg: string) {
+		console.log(`${C.gray}│${C.reset}  ${C.gray}🐛 ${msg}${C.reset}`);
 	}
 
-	static server(msg: string) {
-		console.log(`${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}server${C.reset} ${C.gray}:${C.reset} ${msg}`);
+	static step(msg: string) {
+		console.log(`${C.gray}│${C.reset}  ${C.gray}▸ ${msg}${C.reset}`);
+	}
+
+	static log(msg: string) {
+		console.log(msg);
+	}
+
+	static dim(msg: string) {
+		console.log(`${C.dim}${msg}${C.reset}`);
+	}
+
+	static newline() {
+		console.log();
+	}
+
+	static watcher(msg: string, _type?: string) {
+		console.log(`${C.gray}│${C.reset}  ${C.secondary}◉${C.reset} ${C.dim}watch${C.reset} ${C.gray}:${C.reset} ${msg}`);
 	}
 
 	static watch(msg: string) {
 		console.log(`${C.gray}│${C.reset}  ${C.secondary}◉${C.reset} ${C.dim}watch${C.reset} ${C.gray}:${C.reset} ${msg}`);
 	}
 
+	static process(msg: string) {
+		console.log(`${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}process${C.reset} ${C.gray}:${C.reset} ${msg}`);
+	}
+
+	static build(msg: string) {
+		console.log(`${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}build${C.reset} ${C.gray}:${C.reset} ${msg}`);
+	}
+
+	static server(msg: string) {
+		console.log(`${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}server${C.reset} ${C.gray}:${C.reset} ${msg}`);
+	}
+
 	static hotswap(msg: string) {
 		console.log(`${C.gray}│${C.reset}  ${C.secondary}↻${C.reset} ${C.dim}hotswap${C.reset} ${C.gray}:${C.reset} ${msg}`);
 	}
@@ -161,11 +265,6 @@ export class Logger {
 		};
 	}
 
-	// Linha em branco
-	static newline() {
-		console.log();
-	}
-
 	// Divisória simples
 	static divider() {
 		console.log(`${C.gray}├────────────────────────────────────────────────────────┤${C.reset}`);
@@ -180,8 +279,8 @@ export class Logger {
 	// Helper para contexto git
 	static getGitContext(): { branch: string; author: string; hash: string } {
 		try {
-			const branch = Bun.spawnSync(["git", "rev-parse", "abbrev-ref", "HEAD"]).stdout.toString().trim();
-			const author = Bun.spawnSync(["git", "log", "-1", "format=%an"]).stdout.toString().trim();
+			const branch = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"]).stdout.toString().trim();
+			const author = Bun.spawnSync(["git", "log", "-1", "--format=%an"]).stdout.toString().trim();
 			const hash = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"]).stdout.toString().trim();
 			return { branch, author, hash };
 		} catch {
@@ -190,6 +289,10 @@ export class Logger {
 	}
 
 	// Filtros de noise (mantidos)
+	// Controle de rate limiting para hotswap
+	private static lastHotswapTime = 0;
+	private static hotswapCount = 0;
+
 	static isSystemNoise(line: string): boolean {
 		const noise = [
 			"Using CATALINA_", "Using JRE_HOME", "Using CLASSPATH", 
@@ -198,10 +301,22 @@ export class Logger {
 			"SLF4J: ", "Discovered plugins:",
 			"enhanced with plugin initialization", "Hotswap ready",
 			"autoHotswap.delay", "watchResources=false",
+			// HotswapAgent noise
+			"TreeWatcherNIO", "HOTSWAP AGENT", "org.hotswap.agent",
+			// Jersey/JAX-RS noise
+			"org.glassfish.jersey", "The (sub)resource method",
+			// Tomcat noise
+			"org.apache.catalina", "org.apache.jasper",
 		];
 		return noise.some(n => line.includes(n));
 	}
 
+	static isEssential(line: string): boolean {
+		return line.includes("SEVERE") || line.includes("ERROR") || line.includes("Exception") ||
+			   line.includes("Caused by") || line.includes("at ") || line.includes("... ") ||
+			   line.includes("Server startup in") || line.includes("HOTSWAP AGENT:");
+	}
+
 	// Sumarização de logs do Tomcat (simplificada)
 	static summarize(line: string): string {
 		if (this.isSystemNoise(line)) return "";
@@ -214,9 +329,17 @@ export class Logger {
 			return `${C.success}ready ${C.gray}in ${C.white}${seconds}s${C.reset}`;
 		}
 
-		// Hotswap
+		// Hotswap com rate limiting (evita spam)
 		if (line.includes("HOTSWAP AGENT") && line.includes("RELOAD")) {
-			return `${C.secondary}↻ hotswap ${C.gray}detected${C.reset}`;
+			const now = Date.now();
+			if (now - this.lastHotswapTime < 2000) {
+				this.hotswapCount++;
+				return ""; // Silencia se dentro de 2s
+			}
+			this.lastHotswapTime = now;
+			const count = this.hotswapCount > 0 ? ` ${C.gray}(${this.hotswapCount} more)${C.reset}` : "";
+			this.hotswapCount = 0;
+			return `${C.secondary}↻ hotswap${C.reset}${count}`;
 		}
 
 		// Erros de compilação
@@ -231,11 +354,293 @@ export class Logger {
 			return `${C.error}✗ ${C.gray}${line.slice(0, 80)}${C.reset}`;
 		}
 
-		// Warnings
-		if (line.includes("WARNING")) {
+		// Warnings (filtra noise conhecido)
+		if (line.includes("WARNING") || line.includes("ADVERTÊNCIA")) {
+			if (this.isSystemNoise(line)) return "";
 			return `${C.warning}⚠ ${C.gray}${line.slice(0, 80)}${C.reset}`;
 		}
 
 		return "";
 	}
+
+	// ========== Tomcat Log Formatting ==========
+	
+	private static tomcatNoisePatterns = [
+		/^Using CATALINA_/,
+		/^Using JRE_HOME/,
+		/^Using CLASSPATH/,
+		/^Using CATALINA_OPTS/,
+		/^NOTE: Picked up JDK_JAVA_OPTIONS/,
+		/^HOTSWAP AGENT:.*Plugin.*initialized in ClassLoader/,
+		/^HOTSWAP AGENT:.*Registering directory/,
+		/^HOTSWAP AGENT:.*WARNING.*TreeWatcherNIO.*Unable to watch/,
+		/^HOTSWAP AGENT:.*INFO.*TreeWatcherNIO/,
+		/^HOTSWAP AGENT:.*INFO.*PluginRegistry.*Discovered plugins/,
+		/^HOTSWAP AGENT:.*INFO.*HotswapAgent.*Loading Hotswap agent/,
+		/^HOTSWAP AGENT:.*INFO.*TomcatPlugin.*Tomcat plugin initialized/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*VersionLoggerListener/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*AprLifecycleListener/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Command line argument/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*CATALINA_BASE/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*CATALINA_HOME/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Server version/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Server built/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*OS Name/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*OS Version/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Architecture/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Java Home/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*JVM Version/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*JVM Vendor/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Loaded Apache Tomcat Native/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*APR capabilities/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*APR\/OpenSSL configuration/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*OpenSSL successfully initialized/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Server initialization in/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Starting service/,
+		/^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*Starting Servlet engine/,
+		/^ParallelWebappClassLoader/,
+		/^context:/,
+		/^delegate:/,
+		/^-+> Parent Classloader/,
+		/^java\.net\.URLClassLoader/,
+	];
+
+	static isTomcatNoise(line: string): boolean {
+		return this.tomcatNoisePatterns.some(p => p.test(line));
+	}
+
+	static formatTomcatLog(line: string): string {
+		const cleanLine = line.trim();
+		if (!cleanLine) return "";
+
+		// Silencia noise completamente
+		if (this.isTomcatNoise(cleanLine)) return "";
+
+		// HOTSWAP AGENT: Loading Hotswap agent X.X.X
+		if (cleanLine.includes("HOTSWAP AGENT") && cleanLine.includes("Loading Hotswap agent")) {
+			const versionMatch = cleanLine.match(/Loading Hotswap agent ([\d.]+)/);
+			if (versionMatch) {
+				return `${C.gray}│${C.reset}  ${C.secondary}↻${C.reset} ${C.dim}HotswapAgent v${versionMatch[1]}${C.reset}`;
+			}
+		}
+
+		// HOTSWAP AGENT: Discovered plugins
+		if (cleanLine.includes("HOTSWAP AGENT") && cleanLine.includes("Discovered plugins")) {
+			return `${C.gray}│${C.reset}  ${C.secondary}↻${C.reset} ${C.dim}plugins loaded${C.reset}`;
+		}
+
+		// Server initialization
+		const initMatch = cleanLine.match(/Server initialization in \[(\d+)\] milliseconds/);
+		if (initMatch) {
+			return `${C.gray}│${C.reset}  ${C.success}●${C.reset} ${C.dim}initialized in ${initMatch[1]}ms${C.reset}`;
+		}
+
+		// Starting service [Catalina]
+		const serviceMatch = cleanLine.match(/Starting service \[(\w+)\]/);
+		if (serviceMatch) {
+			return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}starting ${serviceMatch[1].toLowerCase()}${C.reset}`;
+		}
+
+		// Starting Servlet engine
+		if (cleanLine.includes("Starting Servlet engine")) {
+			const versionMatch = cleanLine.match(/Apache Tomcat\/([\d.]+)/);
+			if (versionMatch) {
+				return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}Tomcat ${versionMatch[1]}${C.reset}`;
+			}
+		}
+
+		// Deploy directory
+		const deployMatch = cleanLine.match(/deployDirectory.*webapps[\\/]([^'"\]]+)/);
+		if (deployMatch) {
+			return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}deploying ${deployMatch[1]}${C.reset}`;
+		}
+
+		// Server startup in ( já temos no summarize mas reforça aqui )
+		const startupMatch = cleanLine.match(/Server startup in.*?([\d,]+)\s*ms/);
+		if (startupMatch) {
+			const time = startupMatch[1].replace(",", "");
+			const seconds = (parseInt(time) / 1000).toFixed(1);
+			return `${C.gray}│${C.reset}  ${C.success}●${C.reset} ${C.dim}ready in ${C.white}${seconds}s${C.reset}`;
+		}
+
+		// Tomcat versão info (sumarizado)
+		const tomcatVersionMatch = cleanLine.match(/Server version number:\s+([\d.]+)/);
+		if (tomcatVersionMatch) {
+			return `${C.gray}│${C.reset}  ${C.dim}Tomcat ${tomcatVersionMatch[1]}${C.reset}`;
+		}
+
+		// JVM info sumarizada
+		const jvmMatch = cleanLine.match(/JVM Version:\s+([\d._]+)/);
+		if (jvmMatch) {
+			return `${C.gray}│${C.reset}  ${C.dim}JVM ${jvmMatch[1]}${C.reset}`;
+		}
+
+		// Protocol handler init
+		const protocolMatch = cleanLine.match(/Initializing ProtocolHandler \["(.+?)"\]/);
+		if (protocolMatch) {
+			return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}${protocolMatch[1]}${C.reset}`;
+		}
+
+		// Erros e warnings que passaram pelo filtro
+		if (cleanLine.includes("SEVERE") || cleanLine.includes("ERROR")) {
+			return `${C.gray}│${C.reset}  ${C.error}✗${C.reset} ${C.gray}${cleanLine.slice(0, 80)}${C.reset}`;
+		}
+
+		if (cleanLine.includes("WARNING") || cleanLine.includes("ADVERTÊNCIA")) {
+			return `${C.gray}│${C.reset}  ${C.warning}⚠${C.reset} ${C.gray}${cleanLine.slice(0, 80)}${C.reset}`;
+		}
+
+		// Outros logs INFO - mostra resumido
+		const infoMatch = cleanLine.match(/(?:INFORMAÇÕES|INFO)\s+\[.*?\]\s+(.+)/);
+		if (infoMatch) {
+			const msg = infoMatch[1].trim();
+			if (msg.length > 0 && !this.isTomcatNoise(msg)) {
+				return `${C.gray}│${C.reset}  ${C.dim}${msg.slice(0, 70)}${C.reset}`;
+			}
+		}
+
+		return "";
+	}
+
+	// ========== Build Log Formatting (Maven/Gradle) ==========
+	
+	private static buildNoisePatterns = [
+		/^\[INFO\]\s+Scanning for projects/,
+		/^\[INFO\]\s+Using the MultiThreadedBuilder/,
+		/^\[INFO\]\s+---\s+.*\s+---$/,
+		/^\[INFO\]\s+T+E+\s*$/,
+		/^\[INFO\]\s+BUILD\s+SUCCESS/i,
+		/^\[INFO\]\s+BUILD\s+FAILURE/i,
+		/^\[INFO\]\s+Total time:/,
+		/^\[INFO\]\s+Finished at:/,
+		/^\[INFO\]\s+Final Memory:/,
+		/^\[INFO\]\s+http:\/\/cwiki\.apache\.org/,
+		/^\[INFO\]\s+-> \[Help 1\]/,
+		/^\[INFO\]\s+Re-run Maven using/,
+		/^\[INFO\]\s+To see the full stack trace/,
+		/^\[INFO\]\s+For more information about the errors/,
+		/^\[ERROR\]\s+To see the full stack trace/,
+		/^\[ERROR\]\s+Re-run Maven using/,
+		/^\[ERROR\]\s+For more information/,
+		/^\[ERROR\]\s+-> \[Help 1\]/,
+		/^\[WARNING\]\s+It is highly recommended/,
+		/^\[WARNING\]\s+For this reason, future Maven/,
+		/^\[WARNING\]\s+\[HELP, sysprop:version/,
+		/^\[WARNING\]\s+Some problems were encountered/,
+		/^\[WARNING\]\s+'dependencies\.dependency/,
+		/Building .*war/,
+		/from pom\.xml/,
+		/\[ war \]/,
+		/^\s*$/,
+	];
+
+	private static gradleNoisePatterns = [
+		/^> Task/,
+		/^Download/,
+		/^Expiring/,
+		/^BUILD/,
+		/^\d+ actionable task/,
+	];
+
+	static isBuildNoise(line: string): boolean {
+		return this.buildNoisePatterns.some(p => p.test(line)) ||
+		       this.gradleNoisePatterns.some(p => p.test(line));
+	}
+
+	// Acumulador de erro de compilação (para pegar mensagens multi-linha)
+	private static pendingError: { file: string; line: string; msg: string } | null = null;
+	
+	static formatBuildLog(line: string, buildTool: 'maven' | 'gradle' = 'maven'): string {
+		const cleanLine = line.trim();
+		if (!cleanLine) return "";
+
+		// Maven: [ERROR] /path/file.java:[123,45] error message
+		const mavenErrorMatch = cleanLine.match(/^\[ERROR\]\s+(.+\.java):\[(\d+),\d+\]\s*(.+)/);
+		if (mavenErrorMatch) {
+			const [, file, lineNum, msg] = mavenErrorMatch;
+			const shortFile = file.split(/[/\\]/).pop() || file;
+			return `${C.gray}│${C.reset}  ${C.error}✗${C.reset} ${C.white}${shortFile}${C.gray}:${lineNum}${C.reset} ${C.error}${msg.slice(0, 60)}${C.reset}`;
+		}
+
+		// Maven: [ERROR] COMPILATION ERROR / BUILD FAILURE (título)
+		if (cleanLine.match(/^\[(ERROR|INFO)\]\s+(COMPILATION ERROR|BUILD FAILURE)/)) {
+			return `${C.gray}│${C.reset}  ${C.error}✗ COMPILATION FAILED${C.reset}`;
+		}
+
+		// Maven: [WARNING] 'dependencies.dependency...' 
+		if (cleanLine.match(/^\[WARNING\]\s+'dependencies\.dependency/)) {
+			const match = cleanLine.match(/'dependencies\.dependency\.[\w:]+'\s+(.+)/);
+			if (match) {
+				return `${C.gray}│${C.reset}  ${C.warning}⚠${C.reset} ${C.gray}${match[1].slice(0, 60)}${C.reset}`;
+			}
+		}
+
+		// Maven: [WARNING] The POM for ... is invalid
+		const invalidPomMatch = cleanLine.match(/^\[WARNING\]\s+The POM for (.+?) is invalid/);
+		if (invalidPomMatch) {
+			return `${C.gray}│${C.reset}  ${C.warning}⚠${C.reset} ${C.gray}Invalid POM: ${invalidPomMatch[1].slice(0, 50)}${C.reset}`;
+		}
+
+		// Maven: [INFO] Compiling N source files
+		const compilingMatch = cleanLine.match(/^\[INFO\]\s+Compiling\s+(\d+)\s+source/);
+		if (compilingMatch) {
+			return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}compiling ${C.white}${compilingMatch[1]}${C.reset} ${C.dim}files${C.reset}`;
+		}
+
+		// Maven: [INFO] /path/file.java: Some input files use or override a deprecated API
+		const deprecatedMatch = cleanLine.match(/^\[INFO\]\s+(.+\.java):\s+Some input files use (.+)/);
+		if (deprecatedMatch) {
+			const shortFile = deprecatedMatch[1].split(/[/\\]/).pop() || deprecatedMatch[1];
+			const type = deprecatedMatch[2].includes('removal') ? 'deprecated (removal)' : 'deprecated';
+			return `${C.gray}│${C.reset}  ${C.warning}⚠${C.reset} ${C.gray}${shortFile} uses ${type}${C.reset}`;
+		}
+
+		// Maven: [INFO] Changes detected - recompiling
+		if (cleanLine.match(/^\[INFO\]\s+Changes detected/)) {
+			return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}changes detected, recompiling${C.reset}`;
+		}
+
+		// Maven: [INFO] Copying N resources
+		const resourcesMatch = cleanLine.match(/^\[INFO\]\s+Copying\s+(\d+)\s+resources?/);
+		if (resourcesMatch) {
+			return `${C.gray}│${C.reset}  ${C.dim}copying ${C.white}${resourcesMatch[1]}${C.reset} ${C.dim}resources${C.reset}`;
+		}
+
+		// Maven: [INFO] Deleting ...
+		const deletingMatch = cleanLine.match(/^\[INFO\]\s+Deleting\s+(.+)/);
+		if (deletingMatch) {
+			return `${C.gray}│${C.reset}  ${C.dim}cleaning target directory${C.reset}`;
+		}
+
+		// Maven: [INFO] skip non existing resourceDirectory
+		if (cleanLine.match(/^\[INFO\]\s+skip non existing/)) {
+			return ""; // Silencia
+		}
+
+		// Gradle: > Task :name
+		const gradleTaskMatch = cleanLine.match(/^> Task :(.+)/);
+		if (gradleTaskMatch) {
+			return `${C.gray}│${C.reset}  ${C.primary}▸${C.reset} ${C.dim}${gradleTaskMatch[1]}${C.reset}`;
+		}
+
+		// Gradle errors
+		const gradleErrorMatch = cleanLine.match(/^(.+\.java):(\d+):\s*(error|warning):\s*(.+)/);
+		if (gradleErrorMatch) {
+			const [, file, lineNum, level, msg] = gradleErrorMatch;
+			const shortFile = file.split(/[/\\]/).pop() || file;
+			const icon = level === 'error' ? C.error + '✗' + C.reset : C.warning + '⚠' + C.reset;
+			return `${C.gray}│${C.reset}  ${icon} ${C.white}${shortFile}${C.gray}:${lineNum}${C.reset} ${C.error}${msg.slice(0, 60)}${C.reset}`;
+		}
+
+		// Se não for nenhum padrão conhecido e não for noise, retorna formatado como info
+		if (!this.isBuildNoise(cleanLine)) {
+			// Remove prefixos [INFO], [WARNING], [ERROR] genéricos
+			const clean = cleanLine.replace(/^\[(INFO|WARNING|ERROR)\]\s*/, '');
+			if (clean.length > 0 && !this.isBuildNoise(clean)) {
+				return `${C.gray}│${C.reset}  ${C.dim}${clean.slice(0, 70)}${C.reset}`;
+			}
+		}
+
+		return "";
+	}
 }