@archznn/xavva 1.6.5 → 1.7.0

package/src/services/TomcatService.ts

@@ -70,13 +70,129 @@ export class TomcatService {
 		}
 	}
 
-	start(cleanLogs: boolean = false, debug: boolean = false, skipScan: boolean = false, quiet: boolean = false) {
+	private async ensureHotswapAgent(): Promise<string | null> {
+		const fs = require("fs");
+		const path = require("path");
+		const os = require("os");
+		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;
+
+		try {
+			if (!fs.existsSync(agentDir)) fs.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";
+			const response = await fetch(url);
+			if (!response.ok) throw new Error(`Status: ${response.status}`);
+			
+			const buffer = await response.arrayBuffer();
+			fs.writeFileSync(agentPath, Buffer.from(buffer));
+			Logger.success("HotswapAgent v2.0.3 installed globally!");
+			return agentPath;
+		} catch (e) {
+			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
+			return null;
+		}
+	}
+
+	private findAllClassPaths(buildTool: 'maven' | 'gradle'): string[] {
+		const fs = require("fs");
+		const path = require("path");
+		const results: string[] = [];
+		const root = process.cwd();
+
+		const scan = (dir: string) => {
+			try {
+				const files = fs.readdirSync(dir, { withFileTypes: true });
+				for (const file of files) {
+					if (!file.isDirectory()) continue;
+					
+					const name = file.name;
+					if (name.startsWith('.') || ['node_modules', 'out', 'bin', 'src', 'webapps', '.xavva'].includes(name)) continue;
+
+					const fullPath = path.join(dir, name);
+					
+					const isMavenClasses = buildTool === 'maven' && name === 'classes' && dir.endsWith('target');
+					const isGradleClasses = buildTool === 'gradle' && name === 'main' && dir.endsWith(path.join('classes', 'java'));
+					
+					if (isMavenClasses || isGradleClasses) {
+						results.push(fullPath.replace(/\\/g, "/"));
+					} else {
+						scan(fullPath);
+					}
+				}
+			} catch (e) {}
+		};
+
+		scan(root);
+		
+		if (results.length === 0) {
+			const defaultPath = buildTool === 'maven' 
+				? path.join(root, "target", "classes")
+				: path.join(root, "build", "classes", "java", "main");
+			results.push(defaultPath.replace(/\\/g, "/"));
+		}
+
+		return results;
+	}
+
+	async start(config: any, isWatching: boolean = false) {
 		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
-		const args = debug ? ["jpda", "run"] : ["run"];
+		const args = (config.project.debug || isWatching) ? ["jpda", "run"] : ["run"];
 		
 		const catalinaOpts = [process.env.CATALINA_OPTS || ""];
 		
-		if (skipScan) {
+		if (config.project.debug || isWatching) {
+			const agentPath = await this.ensureHotswapAgent();
+			if (agentPath) {
+				catalinaOpts.push(`-javaagent:${agentPath}`);
+				
+				let javaBin = "java";
+				if (process.env.JAVA_HOME) {
+					javaBin = require("path").join(process.env.JAVA_HOME, "bin", "java.exe");
+				}
+
+				const javaVer = Bun.spawnSync([javaBin, "-version"]);
+				const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
+				
+				if (output.includes("dcevm") || output.includes("jbr") || output.includes("trava")) {
+					catalinaOpts.push("-XX:+AllowEnhancedClassRedefinition");
+				}
+
+				catalinaOpts.push(
+					"--add-opens=java.base/jdk.internal.loader=ALL-UNNAMED",
+					"--add-opens=java.base/java.lang=ALL-UNNAMED",
+					"--add-opens=java.base/java.io=ALL-UNNAMED",
+					"--add-opens=java.base/java.net=ALL-UNNAMED",
+					"--add-opens=java.base/java.util=ALL-UNNAMED",
+					"--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
+					"--add-opens=java.base/java.security=ALL-UNNAMED",
+					"--add-opens=java.base/jdk.internal.reflect=ALL-UNNAMED",
+					"--add-opens=java.base/java.lang.reflect=ALL-UNNAMED",
+					"--add-opens=java.base/sun.nio.ch=ALL-UNNAMED",
+					"--add-opens=java.base/java.util.jar=ALL-UNNAMED",
+					"--add-opens=java.desktop/java.beans=ALL-UNNAMED"
+				);
+				
+				const fs = require("fs");
+				const path = require("path");
+				const xavvaDir = path.join(process.cwd(), ".xavva");
+				if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir, { recursive: true });
+				
+				const classPaths = this.findAllClassPaths(config.project.buildTool);
+				const extraClasspath = classPaths.join(",");
+
+				const propsPath = path.join(xavvaDir, "hotswap-agent.properties");
+				const propsContent = `autoHotswap=true\nautoHotswap.delay=3000\nwatchResources=false\nextraClasspath=${extraClasspath}\nLOGGER=info`;
+				fs.writeFileSync(propsPath, propsContent);
+				
+				catalinaOpts.push(`-Dhotswap-agent.properties.path=${propsPath}`);
+			}
+		}
+
+		if (config.project.skipScan) {
 			catalinaOpts.push(
 				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToSkip=*.jar",
 				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToScan=",
@@ -93,13 +209,18 @@ export class TomcatService {
 			CATALINA_OPTS: catalinaOpts.join(" ").trim()
 		};
 
-		if (debug) {
-			Logger.warn("🐞 Java Debugger habilitado na porta 5005");
+		if (process.env.JAVA_HOME) {
+			env.JAVA_HOME = process.env.JAVA_HOME;
+			env.JRE_HOME = process.env.JAVA_HOME;
+		}
+
+		if (config.project.debug) {
+			Logger.debug("Java Debugger habilitado na porta 5005");
 			env.JPDA_ADDRESS = "5005";
 			env.JPDA_TRANSPORT = "dt_socket";
 		}
 
-		if (cleanLogs || quiet) {
+		if ((config.project.cleanLogs || config.project.quiet) && !config.project.verbose) {
 			this.stopStartupSpinner = Logger.spinner("Starting Tomcat server");
 		}
 
@@ -111,11 +232,11 @@ export class TomcatService {
 
 		this.pid = this.currentProcess.pid;
 
-		this.processLogStream(this.currentProcess.stdout, cleanLogs, quiet);
-		this.processLogStream(this.currentProcess.stderr, cleanLogs, quiet);
+		this.processLogStream(this.currentProcess.stdout, config.project.cleanLogs, config.project.quiet, config.project.verbose, config.tomcat.grep);
+		this.processLogStream(this.currentProcess.stderr, config.project.cleanLogs, config.project.quiet, config.project.verbose, config.tomcat.grep);
 	}
 
-	private async processLogStream(stream: ReadableStream, clean: boolean, quiet: boolean) {
+	private async processLogStream(stream: ReadableStream, clean: boolean, quiet: boolean, verbose: boolean, grep: string) {
 		const reader = stream.getReader();
 		const decoder = new TextDecoder();
 
@@ -141,6 +262,11 @@ export class TomcatService {
 					}
 				}
 
+				if (verbose) {
+					Logger.log(cleanLine);
+					continue;
+				}
+
 				if (clean) {
 					if (quiet && !Logger.isEssential(cleanLine)) {
 						if (Logger.isSystemNoise(cleanLine)) continue;
@@ -149,14 +275,14 @@ export class TomcatService {
 						continue;
 					}
 
-					if (this.activeConfig.grep && !cleanLine.toLowerCase().includes(this.activeConfig.grep.toLowerCase())) {
+					if (grep && !cleanLine.toLowerCase().includes(grep.toLowerCase())) {
 						if (!Logger.isEssential(cleanLine)) continue;
 					}
 					
 					const summarized = Logger.summarize(cleanLine);
-					console.log(summarized);
+					if (summarized) Logger.log(summarized);
 				} else {
-					console.log(cleanLine);
+					Logger.log(cleanLine);
 				}
 			}
 		}

package/src/utils/config.ts

@@ -80,7 +80,7 @@ export class ConfigManager {
         if (fs.existsSync(path.join(process.cwd(), "build.gradle")) || fs.existsSync(path.join(process.cwd(), "build.gradle.kts"))) {
             return "gradle";
         }
-        return "maven"; // Default to maven if not found
+        return "maven";
     }
 
     private static ensureGitIgnore() {

package/src/utils/ui.ts

@@ -1,7 +1,7 @@
 import pkg from "../../package.json";
 
 export class Logger {
-    private static readonly C = {
+    public static readonly C = {
         reset: "\x1b[0m",
         cyan: "\x1b[36m",
         green: "\x1b[32m",
@@ -9,60 +9,124 @@ export class Logger {
         red: "\x1b[31m",
         dim: "\x1b[90m",
         bold: "\x1b[1m",
-        blue: "\x1b[34m"
+        blue: "\x1b[34m",
+        magenta: "\x1b[35m",
+        bgRed: "\x1b[41m",
+        white: "\x1b[37m",
+        gray: "\x1b[38;5;240m",
+        lightGray: "\x1b[38;5;248m",
+        darkGray: "\x1b[38;5;238m"
     };
 
-    static getGitContext(): string {
+    private static hotswapPluginsCount = 0;
+    private static lastDomain = "";
+    private static lastHotswapMsg = "";
+    private static activeSpinnerMsg = "";
+
+    private static write(message: string, isError: boolean = false) {
+        if (this.activeSpinnerMsg) {
+            process.stdout.write("\r\x1B[K"); // Limpa a linha do spinner
+        }
+        
+        if (isError) {
+            console.error(message + this.C.reset);
+        } else {
+            console.log(message + this.C.reset);
+        }
+
+        if (this.activeSpinnerMsg) {
+            // Re-imprime o início da linha do spinner para o próximo frame
+            process.stdout.write(`  ${this.C.cyan}⠋${this.C.reset} ${this.activeSpinnerMsg}...`);
+        }
+    }
+
+    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();
-            return branch ? `${this.C.blue} ${branch}${this.C.reset} ${this.C.dim}(${author})${this.C.reset}` : "";
+            const hash = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"]).stdout.toString().trim();
+            return { branch, author, hash };
         } catch (e) {
-            return "";
+            return { branch: "", author: "", hash: "" };
         }
     }
 
     static banner(command?: string) {
         console.clear();
         const git = this.getGitContext();
-        console.log(`${this.C.cyan}
-  ${this.C.bold}XAVVA ${this.C.reset}${this.C.dim}v${pkg.version}${this.C.reset} ${git}
-  ${this.C.dim}──────────────────────────${this.C.reset}`);
-        if (command) {
-            console.log(`  ${this.C.yellow}${this.C.bold}MODO: ${command.toUpperCase()}${this.C.reset}\n`);
-        }
+        const name = (process.cwd().split(/[/\\]/).pop() || "JAVA").toUpperCase();
+        
+        const width = 62;
+        const line = "─".repeat(width);
+        
+        this.write(`${this.C.gray}╭${line}╮`);
+        this.write(`${this.C.gray}│  ${this.C.bold}${this.C.blue}${name} CLI${this.C.reset}${" ".repeat(width - name.length - 6)} ${this.C.gray}│`);
+        
+        const info = `Version: ${pkg.version}  |  Branch: ${git.branch}  |  ${git.hash}`;
+        this.write(`${this.C.gray}│  ${this.C.dim}${info}${" ".repeat(width - info.length - 2)}${this.C.gray}│`);
+        
+        const modeLine = `Mode: ${command?.toUpperCase() || "DEPLOY"}`;
+        const status = command === 'dev' ? `${this.C.green}🟢` : `${this.C.blue}🔵`;
+        this.write(`${this.C.gray}│  ${this.C.yellow}${this.C.bold}${modeLine}${" ".repeat(width - modeLine.length - 5)}${status}   ${this.C.gray}│`);
+        this.write(`${this.C.gray}╰${line}╯${this.C.reset}`);
     }
 
     static section(title: string) {
-        console.log(`\n  ${this.C.bold}${this.C.blue}◈ ${title.toUpperCase()} ${this.C.reset}`);
-        console.log(`  ${this.C.dim}──────────────────────────${this.C.reset}`);
+        this.write(`\n${this.C.bold}${this.C.blue}[${title.toUpperCase()}]${this.C.reset}`);
     }
 
-    static info(label: string, value: string | number | boolean) {
-        console.log(`  ${this.C.cyan}${label.padEnd(12)}${this.C.reset} ${this.C.bold}${value}${this.C.reset}`);
+    private static domain(name: string) {
+        if (this.lastDomain !== name) {
+            this.write(`\n${this.C.bold}${this.C.blue}[${name.toUpperCase()}]${this.C.reset}`);
+            this.lastDomain = name;
+        }
     }
 
-    static success(msg: string) {
-        console.log(`\n  ${this.C.green}✔ ${msg}${this.C.reset}`);
+    static config(label: string, value: string | number | boolean) {
+        this.domain("config");
+        this.info(label, value);
     }
 
-    static error(msg: string) {
-        console.error(`\n  ${this.C.red}✘ ${msg}${this.C.reset}`);
+    static info(label: string, value: string | number | boolean) {
+        this.write(`  ${this.C.lightGray}${label.padEnd(12)}${this.C.reset} : ${this.C.bold}${value}${this.C.reset}`);
     }
 
-    static warn(msg: string) {
-        console.log(`  ${this.C.yellow}⚠ ${msg}${this.C.reset}`);
+    static build(msg: string, status: 'start' | 'success' | 'error' | 'info' = 'success') {
+        this.domain("build");
+        const symbol = status === 'start' ? `${this.C.blue}▶` : status === 'success' ? `${this.C.green}✔` : status === 'error' ? `${this.C.red}✖` : `${this.C.dim}ℹ`;
+        this.write(`  ${symbol} ${this.C.reset}${msg}`);
     }
 
-    static log(msg: string) {
-        console.log(`  ${msg}`);
+    static server(msg: string, status: 'start' | 'success' | 'error' | 'info' = 'info') {
+        this.domain("server");
+        const symbol = status === 'start' ? `${this.C.blue}▶` : status === 'success' ? `${this.C.green}✔` : status === 'error' ? `${this.C.red}✖` : `${this.C.dim}ℹ`;
+        this.write(`  ${symbol} ${this.C.reset}${msg}`);
     }
 
-    static step(msg: string) {
-        console.log(`  ${this.C.dim}➜ ${msg}${this.C.reset}`);
+    static health(msg: string, status: 'success' | 'error' | 'warn' = 'success') {
+        this.domain("health");
+        const symbol = status === 'success' ? `${this.C.green}✔` : status === 'error' ? `${this.C.red}✖` : `${this.C.yellow}⚠`;
+        this.write(`  ${symbol} ${this.C.reset}${msg}`);
     }
 
+    static watcher(msg: string, status: 'watch' | 'change' | 'start' | 'success' = 'success') {
+        this.domain("watcher");
+        const symbol = status === 'watch' ? `${this.C.magenta}👀` : status === 'change' ? `${this.C.yellow}▲` : status === 'start' ? `${this.C.blue}▶` : `${this.C.green}✔`;
+        this.write(`  ${symbol} ${this.C.reset}${msg}`);
+    }
+
+    static success(msg: string) { this.write(`  ${this.C.green}✔ ${msg}`); }
+    static error(msg: string) { this.write(`  ${this.C.red}✖ ${msg}`, true); }
+    static warn(msg: string) { this.write(`  ${this.C.yellow}⚠ ${msg}`); }
+    static log(msg: string) { this.write(`  ${msg}`); }
+    static step(msg: string) { this.write(`  ${this.C.dim}» ${msg}`); }
+    static debug(msg: string) { this.write(`  ${this.C.magenta}🐛 ${msg}`); }
+    static process(msg: string) { this.write(`  ${this.C.blue}▶ ${msg}`); }
+    static newline() { this.write(""); }
+    static dim(msg: string) { this.write(`  ${this.C.dim}${msg}${this.C.reset}`); }
+
     static spinner(msg: string) {
+        this.activeSpinnerMsg = msg;
         const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         let i = 0;
         process.stdout.write("\x1B[?25l");
@@ -74,121 +138,151 @@ export class Logger {
 
         return (success = true) => {
             clearInterval(timer);
+            this.activeSpinnerMsg = "";
             process.stdout.write("\r\x1B[K");
             process.stdout.write("\x1B[?25h");
             if (success) {
-                console.log(`  ${this.C.green}✔${this.C.reset} ${msg}`);
+                this.write(`  ${this.C.green}✔${this.C.reset} ${msg}`);
+            } else {
+                this.error(`Falha em ${msg}`);
             }
         };
     }
 
     static isSystemNoise(line: string): boolean {
         const noise = [
-            "Using CATALINA_",
-            "Using JRE_HOME",
-            "Using CLASSPATH",
-            "NOTE: Picked up JDK_JAVA_OPTIONS",
-            "Command line argument",
-            "VersionLoggerListener",
-            "Scanning for projects...",
-            "Building ",
-            "--- ",
-            "+++ ",
-            "DEBUG: ",
-            "org.apache.catalina.startup.VersionLoggerListener",
-            "org.apache.catalina.core.AprLifecycleListener",
-            "org.apache.coyote.AbstractProtocol.init",
-            "org.apache.catalina.startup.Catalina.load",
-            "Arquivos processados em",
-            "org.apache.jasper.servlet.TldScanner.scanJars",
-            "Listening for transport dt_socket",
-            "org.apache.catalina.startup.ExpandWar.expand",
-            "org.apache.catalina.startup.ContextConfig.configureStart",
-            "SLF4J: ",
-            "org.glassfish.jersey.internal.Errors.logErrors",
-            "contains empty path annotation",
-            "org.apache.catalina.core.StandardContext.setPath",
-            "milliseconds"
+            "Using CATALINA_", "Using JRE_HOME", "Using CLASSPATH", "NOTE: Picked up JDK_JAVA_OPTIONS",
+            "Command line argument", "VersionLoggerListener", "Scanning for projects...",
+            "Building ", "--- ", "+++ ", "DEBUG: ", "org.apache.catalina.startup.VersionLoggerListener",
+            "org.apache.catalina.core.AprLifecycleListener", "org.apache.coyote.AbstractProtocol.init",
+            "org.apache.catalina.startup.Catalina.load", "Arquivos processados em",
+            "org.apache.jasper.servlet.TldScanner.scanJars", "Listening for transport dt_socket",
+            "org.apache.catalina.startup.ExpandWar.expand", "org.apache.catalina.startup.ContextConfig.configureStart",
+            "SLF4J: ", "org.glassfish.jersey.internal.Errors.logErrors", "contains empty path annotation",
+            "org.apache.catalina.core.StandardContext.setPath", "milliseconds",
+            "org.apache.catalina.startup.HostConfig.deployWAR", "org.apache.catalina.startup.HostConfig.deployDirectory",
+            "Deployment of web application", "Deploying web application archive", "at org.apache",
+            "Registering directory"
         ];
         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");
+        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:");
     }
 
     static summarize(line: string): string {
+        if (this.isSystemNoise(line)) return "";
+
         const startupMatch = line.match(/Server startup in (\[?)(.*?)(\]?)\s*ms/);
         if (startupMatch) {
-            const time = startupMatch[2] || "???";
-            return `\n  ${this.C.green}${this.C.bold}🚀 TOMCAT PRONTO EM ${time}ms${this.C.reset}\n`;
+            const time = (parseInt(startupMatch[2]) / 1000).toFixed(1);
+            this.domain("server");
+            return `${this.C.green}✔ ${this.C.bold}Server started in ${time}s`;
+        }
+
+        const deployMatch = line.match(/Deployment of web application archive \[(.*?)\] has finished in \[(.*?)\] ms/);
+        if (deployMatch) {
+            this.domain("build");
+            return `${this.C.green}✔ Artifacts deployed`;
+        }
+
+        const hotswapPattern = /HOTSWAP AGENT:.*? (INFO|WARN|ERROR|RELOAD) (.*?) - (.*)/;
+        const hotswapMatch = line.match(hotswapPattern);
+        if (hotswapMatch) {
+            const level = hotswapMatch[1];
+            let msg = hotswapMatch[3];
+
+            if (msg.includes("plugin initialized")) {
+                this.hotswapPluginsCount++;
+                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...`;
+                }
+                
+                if (msg === this.lastHotswapMsg) return "";
+                this.lastHotswapMsg = msg;
+
+                this.watcher(`Hotswap: ${msg.replace(/Class '.*?'/, (m) => this.C.bold + m + this.C.reset)}`, 'success');
+                return "";
+            }
+
+            if (msg.includes("Loading Hotswap agent")) {
+                this.domain("server");
+                return `${this.C.blue}▶ ${this.C.reset}Initializing Hotswap Agent ${msg.match(/\d+\.\d+\.\d+/)?.[0] || ""}`;
+            }
+
+            if (this.hotswapPluginsCount > 0) {
+                const count = this.hotswapPluginsCount;
+                this.hotswapPluginsCount = 0;
+                this.domain("server");
+                this.write(`  ${this.C.green}✔ ${this.C.reset}Hotswap ready (Plugins: ${count} loaded)`);
+            }
+
+            let color = this.C.cyan;
+            let symbol = "●";
+            if (level === "WARN") { color = this.C.yellow; symbol = "▲"; }
+            else if (level === "ERROR") { color = this.C.red; symbol = "✖"; }
+            
+            this.domain("server");
+            return `${color}${symbol} ${this.C.bold}Hotswap:${this.C.reset} ${msg}`;
+        }
+
+        if (line.includes("java.lang.UnsupportedOperationException") && (line.includes("add a method") || line.includes("change the schema"))) {
+            this.domain("watcher");
+            this.write(`  ${this.C.red}✖ ${this.C.bold}Hotswap Falhou:${this.C.reset} Mudança estrutural detectada (novo método/campo).`);
+            this.write(`    ${this.C.yellow}💡 Dica: Sua JVM atual não suporta mudar a estrutura da classe. Reinicie o servidor para aplicar.`);
+            return "";
         }
 
-        if (line.match(/^\[(INFO|WARN|ERROR)\]\s*$/) || line.includes("--- maven-") || line.includes("--- bpo-")) return "";
-        if (line.includes("Scanning for projects...") || line.includes("Building bpo-consig") || line.includes("--- ")) return "";
+        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) {
+            const label = tMatch[2];
+            let msg = tMatch[4].trim();
+            if (this.isSystemNoise(msg)) return "";
+            let color = this.C.dim;
+            let symbol = "ℹ";
+            if (label === "WARNING") { color = this.C.yellow; symbol = "▲"; }
+            else if (label === "SEVERE" || label === "ERROR") { color = this.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}`;
+        }
 
         const compilationErrorMatch = line.match(/^\[ERROR\]\s+(.*\.java):\[(\d+),(\d+)\]\s+(.*)$/);
         if (compilationErrorMatch) {
             const [_, filePath, row, col, msg] = compilationErrorMatch;
             const fileName = filePath.split(/[/\\]/).pop();
-            
-            let contextTip = "";
-            if (msg.includes("unmappable character") || msg.includes("encoding")) {
-                contextTip = `\n      ${this.C.yellow}💡 Dica: Erro de encoding detectado. O arquivo parece usar um charset (como UTF-8) diferente do configurado no Maven.${this.C.reset}`;
-            } else if (msg.includes("illegal character")) {
-                if (msg.includes("\\u00bb") || msg.includes("\\u00bf") || msg.includes("\\u00ef")) {
-                    contextTip = `\n      ${this.C.yellow}💡 Dica: UTF-8 BOM detectado! O arquivo tem caracteres invisíveis no início que o Java não aceita. Use 'xavva doctor' para corrigir.${this.C.reset}`;
-                } else {
-                    contextTip = `\n      ${this.C.yellow}💡 Dica: Caractere invisível ou inválido. Tente remover espaços ou quebras de linha estranhas no topo do arquivo.${this.C.reset}`;
-                }
-            } else if (msg.includes("cannot find symbol")) {
-                contextTip = `\n      ${this.C.yellow}💡 Dica: Símbolo não encontrado. Verifique se o import está correto ou se a dependência existe.${this.C.reset}`;
-            }
-
-            return `  ${this.C.red}${this.C.bold}✖ ERROR ${this.C.reset}${this.C.dim}em ${this.C.reset}${this.C.bold}${fileName}${this.C.reset}${this.C.dim}:${row}${this.C.reset}\n    ${this.C.red}➜ ${this.C.reset}${msg}${contextTip}\n`;
+            return `${this.C.red}✖ ERROR ${this.C.reset}${this.C.dim}em ${this.C.reset}${this.C.bold}${fileName}${this.C.reset}${this.C.dim}:${row}${this.C.reset} ${this.C.red}➜ ${this.C.reset}${msg}`;
         }
 
         const logPattern = /^\[(INFO|WARNING|WARN|SEVERE|ERROR)\]\s+(.*)$/;
         const match = line.match(logPattern);
-
         if (match) {
             const label = match[1];
-            let msg = match[2];
-
+            let msg = match[2].trim();
             if (msg.includes("Total time:") || msg.includes("Finished at:") || msg.includes("Final Memory:") || msg.includes("-----------------------")) return "";
-
-            let color = "";
-            let prefix = "";
-
-            if (label === "INFO") { 
-                color = this.C.dim; 
-                prefix = "ℹ"; 
-            } else if (label === "WARNING" || label === "WARN") { 
-                color = this.C.yellow; 
-                prefix = "⚠"; 
-            } else if (label === "SEVERE" || label === "ERROR") { 
-                color = this.C.red; 
-                prefix = "✘"; 
-            }
-
+            let color = this.C.dim;
+            let symbol = "ℹ";
+            if (label === "WARNING") { color = this.C.yellow; symbol = "▲"; }
+            else if (label === "SEVERE" || label === "ERROR") { color = this.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}${prefix} ${msg}${this.C.reset}`;
+            return `${color}${symbol} ${msg}`;
         }
 
-        if (line.includes("Exception") || line.includes("at ") || line.includes("Caused by")) {
+        if (line.includes("Exception") || line.includes("Caused by") || line.includes("at ")) {
             const trimmed = line.trim();
-            if (trimmed.includes("org.apache") || trimmed.includes("java.base") || trimmed.includes("sun.reflect")) {
-                return `     ${this.C.dim}${trimmed}${this.C.reset}`;
-            }
-            return `     ${this.C.yellow}${trimmed}${this.C.reset}`;
+            const color = (trimmed.includes("org.apache") || trimmed.includes("java.base") || trimmed.includes("sun.reflect")) ? this.C.dim : this.C.yellow;
+            return `   ${color}${trimmed}`;
         }
 
         return "";