@archznn/xavva 1.6.5 → 1.8.0

package/src/services/WatcherService.ts

@@ -0,0 +1,78 @@
+import { watch } from "fs";
+import { Logger } from "../utils/ui";
+import { DeployCommand } from "../commands/DeployCommand";
+import type { AppConfig } from "../types/config";
+
+export class WatcherService {
+    private isDeploying = false;
+    private pendingFullBuild = false;
+    private coolingFiles = new Set<string>();
+    private debounceTimer?: Timer;
+
+    constructor(private config: AppConfig, private deployCmd: DeployCommand) {}
+
+    public async start() {
+        await this.run(false);
+
+        watch(process.cwd(), { recursive: true }, async (event, filename) => {
+            if (!filename) return;
+
+            if (this.coolingFiles.has(filename)) return;
+            this.coolingFiles.add(filename);
+            setTimeout(() => this.coolingFiles.delete(filename), 500);
+
+            if (this.isIgnored(filename)) return;
+
+            const isBuildConfig = filename === "pom.xml" || filename === "build.gradle" || filename === "build.gradle.kts";
+            const isJava = filename.endsWith(".java") || isBuildConfig;
+            const isResource = this.isResourceFile(filename);
+
+            if (isBuildConfig) {
+                Logger.watcher(`Build configuration changed: ${filename}`, 'warn');
+                const { BuildCacheService } = await import("./BuildCacheService");
+                new BuildCacheService().clearCache();
+                this.pendingFullBuild = true;
+            }
+
+            if (isResource && !isJava) {
+                await this.deployCmd.syncResource(this.config, filename);
+                return;
+            }
+
+            if (!isJava) return;
+
+            Logger.watcher(filename, 'watch');
+            clearTimeout(this.debounceTimer);
+            
+            this.debounceTimer = setTimeout(() => {
+                this.run(this.pendingFullBuild ? false : true);
+                this.pendingFullBuild = false;
+            }, 1000);
+        });
+    }
+
+    private async run(incremental = false) {
+        if (this.isDeploying) return;
+        this.isDeploying = true;
+        try {
+            await this.deployCmd.execute(this.config, { watch: true, incremental });
+        } catch (e) {
+            // Error handled by command
+        } finally {
+            this.isDeploying = false;
+        }
+    }
+
+    private isIgnored(filename: string): boolean {
+        return filename.includes("target") || 
+               filename.includes("build") || 
+               filename.includes("node_modules") || 
+               filename.split(/[/\\]/).some(part => part.startsWith("."));
+    }
+
+    private isResourceFile(filename: string): boolean {
+        return filename.endsWith(".jsp") || filename.endsWith(".html") || 
+               filename.endsWith(".css") || filename.endsWith(".js") || 
+               filename.endsWith(".xml") || filename.endsWith(".properties");
+    }
+}

package/src/types/config.ts

@@ -11,10 +11,12 @@ export interface ProjectConfig {
     profile: string;
     skipBuild: boolean;
     skipScan: boolean;
-    cleanLogs: boolean;
+    clean: boolean;
     quiet: boolean;
     verbose: boolean;
     debug: boolean;
+    debugPort: number;
+    cleanLogs: boolean;
     grep?: string;
 }
 
@@ -22,3 +24,30 @@ export interface AppConfig {
     tomcat: TomcatConfig;
     project: ProjectConfig;
 }
+
+export interface CLIArguments {
+    path?: string;
+    tool?: string;
+    name?: string;
+    port?: string;
+    "no-build"?: boolean;
+    scan?: boolean;
+    clean?: boolean;
+    quiet?: boolean;
+    help?: boolean;
+    version?: boolean;
+    debug?: boolean;
+    watch?: boolean;
+    profile?: string;
+    grep?: string;
+    verbose?: boolean;
+    dp?: string;
+    fix?: boolean;
+    incremental?: boolean;
+}
+
+export interface CommandContext {
+    config: AppConfig;
+    positionals: string[];
+    values: CLIArguments;
+}

package/src/utils/config.ts

@@ -1,10 +1,10 @@
 import { parseArgs } from "util";
 import path from "path";
 import fs from "fs";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments, CommandContext } from "../types/config";
 
 export class ConfigManager {
-    static async load(): Promise<{ config: AppConfig, positionals: string[], values: any }> {
+    static async load(): Promise<CommandContext> {
         const args = Bun.argv.slice(Bun.argv[0].endsWith("bun.exe") || Bun.argv[0].endsWith("bun") ? 2 : 1);
         
         const { values, positionals } = parseArgs({
@@ -25,12 +25,14 @@ export class ConfigManager {
                 profile: { type: "string", short: "P" },
                 grep: { type: "string", short: "G" },
                 verbose: { type: "boolean", short: "V" },
+                dp: { type: "string" },
                 fix: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
         });
 
+        const cliValues = values as CLIArguments;
         const isDev = positionals.includes("dev");
         const isRun = positionals.includes("run") || positionals.includes("debug");
         
@@ -47,30 +49,32 @@ export class ConfigManager {
 
         const config: AppConfig = {
             tomcat: {
-                path: String(values.path || envTomcatPath),
-                port: parseInt(String(values.port || "8080")),
+                path: String(cliValues.path || envTomcatPath),
+                port: parseInt(String(cliValues.port || "8080")),
                 webapps: "webapps",
-                grep: values.grep ? String(values.grep) : "",
+                grep: cliValues.grep ? String(cliValues.grep) : "",
             },
             project: {
-                appName: values.name ? String(values.name) : "",
-                buildTool: (values.tool as "maven" | "gradle") || detectedTool,
-                profile: String(values.profile || ""),
-                skipBuild: !!values["no-build"],
-                skipScan: values.scan !== undefined ? !values.scan : true,
-                cleanLogs: !!(values.clean || isDev),
-                quiet: !!(values.quiet || isDev),
-                verbose: !!values.verbose,
-                debug: !!(values.debug || isDev || isRun),
-                grep: runClass || (values.grep ? String(values.grep) : ""),
+                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) : ""),
             }
         };
 
-        if (isDev) values.watch = true;
+        if (isDev) cliValues.watch = true;
 
         this.ensureGitIgnore();
 
-        return { config, positionals, values };
+        return { config, positionals, values: cliValues };
     }
 
     private static detectBuildTool(): "maven" | "gradle" {
@@ -80,7 +84,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() || "PROJECT").toUpperCase();
+        const version = `v${pkg.version}`;
+        
+        const mode = command?.toUpperCase() || "DEPLOY";
+        const modeColor = mode === "DEV" ? this.C.green : this.C.blue;
+        const modeIcon = mode === "DEV" ? "⚡" : "🚀";
+
+        console.log("");
+        console.log(`  ${this.C.bold}${this.C.cyan}X A V V A${this.C.reset} ${this.C.dim}─${this.C.reset} ${this.C.bold}${this.C.white}${name}${this.C.reset}`);
+        
+        const gitInfo = git.branch ? `${this.C.magenta}🌿 ${git.branch}${this.C.reset} ${this.C.dim}•${this.C.reset} ${this.C.yellow}${git.hash}${this.C.reset}` : "";
+        console.log(`  ${this.C.dim}📦 ${version}${gitInfo ? `  ${this.C.dim}•${this.C.reset}  ${gitInfo}` : ""}${this.C.reset}`);
+        
+        console.log(`  ${modeColor}${this.C.bold}⬢ ${modeIcon} ${mode} MODE${this.C.reset}`);
+        console.log(`  ${this.C.dim}─────────────────────────────────────────────────${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,153 @@ 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", "initialized in ClassLoader", "Discovered plugins:",
+            "enhanced with plugin initialization", "registerJerseyContainer", "JasperLoader@",
+            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false"
         ];
         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 "";