@archznn/xavva 2.1.0 → 2.2.1

package/src/services/DashboardService.ts

@@ -1,142 +1,187 @@
 import { Logger } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 import { 
-    MAX_LOG_SCROLLBUFFER, 
-    DASHBOARD_REFRESH_INTERVAL_MS,
-    DASHBOARD_LOG_SLICE_LINES 
+	MAX_LOG_SCROLLBUFFER, 
+	DASHBOARD_REFRESH_INTERVAL_MS,
+	DASHBOARD_LOG_SLICE_LINES 
 } from "../utils/constants";
 import type { AppConfig } from "../types/config";
 import os from "os";
 
+const C = Logger.C;
+
 export class DashboardService {
-    private isTui: boolean;
-    private logLines: string[] = [];
-    private maxLogLines: number = 0;
-    private status: string = "IDLE";
-    private statusColor: string = Logger.C.dim;
-    private gitContext: { branch: string; commit: string } | null = null;
-    private actions: Map<string, () => void> = new Map();
-
-    constructor(private config: AppConfig) {
-        this.isTui = config.project.tui;
-        if (this.isTui) {
-            this.gitContext = Logger.getGitContext();
-            this.maxLogLines = process.stdout.rows - 6;
-            this.setupTui();
-            this.registerShutdownHandlers();
-        }
-    }
-
-    private registerShutdownHandlers() {
-        const processManager = ProcessManager.getInstance();
-        processManager.onShutdown(() => {
-            this.restoreTerminal();
-        });
-    }
-
-    private restoreTerminal() {
-        if (this.isTui) {
-            process.stdout.write("\x1B[?1049l"); // Restore buffer
-            process.stdout.write("\x1B[?25h"); // Show cursor
-            process.stdin.setRawMode(false);
-            process.stdin.pause();
-        }
-    }
-
-    public isTuiActive(): boolean {
-        return this.isTui;
-    }
-
-    public onAction(key: string, callback: () => void) {
-        this.actions.set(key.toLowerCase(), callback);
-    }
-
-    private setupTui() {
-        process.stdout.write("\x1B[?1049h"); // Switch to alternate buffer
-        process.stdout.write("\x1B[2J"); // Clear screen
-        process.stdout.write("\x1B[?25l"); // Hide cursor
-        
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-
-        process.stdin.on("data", (key: string) => {
-            const input = key.toLowerCase();
-            // Ctrl+C ou Q para sair
-            if (key === "\u0003" || input === "q") {
-                this.exit();
-            }
-            if (input === "l") {
-                this.logLines = [];
-                this.render();
-                return;
-            }
-            
-            const action = this.actions.get(input);
-            if (action) action();
-        });
-
-        process.on("SIGINT", () => this.exit());
-        process.on("exit", () => this.exit());
-
-        // Atualiza o dashboard periodicamente para memória/status
-        setInterval(() => this.render(), 1000);
-    }
-
-    public setStatus(status: string, color: string = Logger.C.cyan) {
-        this.status = status;
-        this.statusColor = color;
-        this.render();
-    }
-
-    public log(message: string) {
-        if (!message) return;
-        
-        if (this.isTui) {
-            const lines = message.split("\n");
-            this.logLines.push(...lines);
-            if (this.logLines.length > MAX_LOG_SCROLLBUFFER) {
-                this.logLines = this.logLines.slice(-DASHBOARD_LOG_SLICE_LINES);
-            }
-            this.render();
-        } else {
-            console.log(message);
-        }
-    }
-
-    private render() {
-        if (!this.isTui) return;
-
-        this.maxLogLines = process.stdout.rows - 6;
-        
-        let output = "\x1B[H"; // Move to 0,0
-        
-        // Header
-        const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
-        const mem = Math.round((os.totalmem() - os.freemem()) / 1024 / 1024 / 1024 * 10) / 10;
-        const totalMem = Math.round(os.totalmem() / 1024 / 1024 / 1024);
-        const profile = this.config.project.profile ? ` ${Logger.C.dim}•${Logger.C.reset} ${Logger.C.yellow}♦ ${this.config.project.profile.toUpperCase()}${Logger.C.reset}` : "";
-
-        output += `${Logger.C.bold}${Logger.C.cyan} X A V V A  2.0 ${Logger.C.reset} ${Logger.C.dim}│${Logger.C.reset} ${Logger.C.white}${Logger.C.bold}${name}${Logger.C.reset}${profile}\x1B[K\n`;
-        output += `${Logger.C.dim} STATUS: ${this.statusColor}${this.status.padEnd(10)}${Logger.C.reset} ${Logger.C.dim}│ MEM: ${Logger.C.yellow}${mem}G/${totalMem}G${Logger.C.reset} ${Logger.C.dim}│ BRANCH: ${Logger.C.magenta}${this.gitContext?.branch || "unknown"}${Logger.C.reset}\x1B[K\n`;
-        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\x1B[K\n`;
-
-        // Logs
-        const visibleLogs = this.logLines.slice(-this.maxLogLines);
-        for (let i = 0; i < this.maxLogLines; i++) {
-            const line = visibleLogs[i] || "";
-            output += line.substring(0, process.stdout.columns) + "\x1B[K\n";
-        }
-
-        // Footer
-        output += `\x1B[${process.stdout.rows};1H`; // Move to last row
-        output += ` ${Logger.C.bold}${Logger.C.white}R${Logger.C.reset} Restart  ${Logger.C.bold}${Logger.C.white}L${Logger.C.reset} Clear  ${Logger.C.bold}${Logger.C.white}Q${Logger.C.reset} Quit    ${Logger.C.dim} (Xavva 2.0 TUI Mode)${Logger.C.reset}\x1B[K`;
-
-        process.stdout.write(output);
-    }
-
-    private async exit() {
-        this.restoreTerminal();
-        await ProcessManager.getInstance().shutdown(0);
-    }
+	private isTui: boolean;
+	private logLines: string[] = [];
+	private maxLogLines: number = 0;
+	private status: string = "idle";
+	private statusColor: string = C.gray;
+	private gitContext: { branch: string; hash: string } | null = null;
+	private actions: Map<string, () => void> = new Map();
+	private startTime = Date.now();
+
+	constructor(private config: AppConfig) {
+		this.isTui = config.project.tui;
+		if (this.isTui) {
+			this.gitContext = Logger.getGitContext();
+			this.maxLogLines = process.stdout.rows - 8;
+			this.setupTui();
+			this.registerShutdownHandlers();
+		}
+	}
+
+	private registerShutdownHandlers() {
+		const processManager = ProcessManager.getInstance();
+		processManager.onShutdown(() => {
+			this.restoreTerminal();
+		});
+	}
+
+	private restoreTerminal() {
+		if (this.isTui) {
+			process.stdout.write("\x1B[?1049l");
+			process.stdout.write("\x1B[?25h");
+			process.stdin.setRawMode(false);
+			process.stdin.pause();
+		}
+	}
+
+	public isTuiActive(): boolean {
+		return this.isTui;
+	}
+
+	public onAction(key: string, callback: () => void) {
+		this.actions.set(key.toLowerCase(), callback);
+	}
+
+	private setupTui() {
+		process.stdout.write("\x1B[?1049h");
+		process.stdout.write("\x1B[2J");
+		process.stdout.write("\x1B[?25l");
+		
+		process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdin.setEncoding("utf8");
+
+		process.stdin.on("data", (key: string) => {
+			const input = key.toLowerCase();
+			if (key === "\u0003" || input === "q") {
+				this.exit();
+			}
+			if (input === "l") {
+				this.logLines = [];
+				this.render();
+			}
+			
+			const action = this.actions.get(input);
+			if (action) action();
+		});
+
+		process.on("SIGINT", () => this.exit());
+		process.on("exit", () => this.exit());
+
+		setInterval(() => this.render(), DASHBOARD_REFRESH_INTERVAL_MS);
+	}
+
+	public setStatus(status: string, type: 'idle' | 'building' | 'ready' | 'error' = 'idle') {
+		this.status = status;
+		switch (type) {
+			case 'building':
+				this.statusColor = C.primary;
+				break;
+			case 'ready':
+				this.statusColor = C.success;
+				break;
+			case 'error':
+				this.statusColor = C.error;
+				break;
+			default:
+				this.statusColor = C.gray;
+		}
+		this.render();
+	}
+
+	public spinner(msg: string) {
+		const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+		let i = 0;
+		
+		this.setStatus(msg, 'building');
+		
+		const timer = setInterval(() => {
+			this.status = `${frames[i]} ${msg}`;
+			i = (i + 1) % frames.length;
+			this.render();
+		}, 80);
+
+		return (success = true) => {
+			clearInterval(timer);
+			if (success) {
+				this.setStatus('ready', 'ready');
+			} else {
+				this.setStatus('error', 'error');
+			}
+		};
+	}
+
+	public log(message: string) {
+		if (!message) return;
+		
+		if (this.isTui) {
+			const lines = message.split("\n");
+			this.logLines.push(...lines);
+			if (this.logLines.length > MAX_LOG_SCROLLBUFFER) {
+				this.logLines = this.logLines.slice(-DASHBOARD_LOG_SLICE_LINES);
+			}
+			this.render();
+		} else {
+			console.log(message);
+		}
+	}
+
+	private render() {
+		if (!this.isTui) return;
+
+		this.maxLogLines = process.stdout.rows - 8;
+		
+		const projectName = (process.cwd().split(/[/\\]/).pop() || "project").toLowerCase();
+		const uptime = Math.floor((Date.now() - this.startTime) / 1000);
+		const uptimeStr = uptime < 60 ? `${uptime}s` : `${Math.floor(uptime / 60)}m ${uptime % 60}s`;
+		
+		const mem = Math.round((os.totalmem() - os.freemem()) / 1024 / 1024 / 1024 * 10) / 10;
+		const totalMem = Math.round(os.totalmem() / 1024 / 1024 / 1024);
+		
+		// Header minimalista
+		let output = "\x1B[H";
+		output += `${C.gray}┌─ ${C.primary}${C.bold}XAVVA${C.reset}${C.gray}.${C.reset}${projectName}${C.reset}`;
+		output += ` ${C.gray}│${C.reset} ${this.statusColor}${this.status}${C.reset}\x1B[K\n`;
+		
+		// Info bar
+		const infos: string[] = [];
+		if (this.config.project.profile) infos.push(`${C.warning}${this.config.project.profile}${C.reset}`);
+		if (this.gitContext?.branch) infos.push(`${C.secondary}git:${this.gitContext.branch}${C.reset}`);
+		infos.push(`${C.gray}mem:${mem}/${totalMem}GB${C.reset}`);
+		infos.push(`${C.gray}up:${uptimeStr}${C.reset}`);
+		
+		output += `${C.gray}│${C.reset}  ${infos.join(` ${C.gray}•${C.reset} `)}\x1B[K\n`;
+		output += `${C.gray}├────────────────────────────────────────────────────────┤${C.reset}\x1B[K\n`;
+
+		// Logs
+		const visibleLogs = this.logLines.slice(-this.maxLogLines);
+		for (let i = 0; i < this.maxLogLines; i++) {
+			const line = visibleLogs[i] || "";
+			output += `${C.gray}│${C.reset} ${line.substring(0, process.stdout.columns - 3)}\x1B[K\n`;
+		}
+
+		// Footer minimalista
+		output += `${C.gray}├────────────────────────────────────────────────────────┤${C.reset}\x1B[K\n`;
+		output += `${C.gray}│${C.reset}  ${C.white}[r]${C.reset}${C.gray}estart  ${C.white}[l]${C.reset}${C.gray}og clear  ${C.white}[q]${C.reset}${C.gray}uit${C.reset}\x1B[K\n`;
+		output += `${C.gray}└────────────────────────────────────────────────────────┘${C.reset}\x1B[K`;
+
+		process.stdout.write(output);
+	}
+
+	private async exit() {
+		this.restoreTerminal();
+		await ProcessManager.getInstance().shutdown(0);
+	}
 }

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);
 				}
 			}