@archznn/xavva 3.1.3 → 3.2.0

package/src/services/DeployWatcher.ts

@@ -1,13 +1,26 @@
 /**
  * DeployWatcher - Específico para watch de deploy
- * Usa FileWatcher genérico e adiciona lógica de deploy
+ * 
+ * Melhorias:
+ * - Debounce inteligente com batch processing
+ * - Priorização de tipos de arquivos
+ * - Rate limiting de builds
+ * - Métricas de performance
  */
 
 import { FileWatcher, type FileChangeEvent } from "./FileWatcher";
 import { DeployCommand } from "../commands/DeployCommand";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import type { AppConfig } from "../types/config";
-import { WATCHER_DEBOUNCE_MS, WATCHER_COOLING_MS } from "../utils/constants";
+import { TIMEOUTS } from "../config/versions";
+
+interface WatcherMetrics {
+    filesChanged: number;
+    buildsTriggered: number;
+    lastBuildTime: number;
+    avgBuildTime: number;
+    buildTimes: number[];
+}
 
 export class DeployWatcher {
     private fileWatcher: FileWatcher;
@@ -16,6 +29,29 @@ export class DeployWatcher {
     private modifiedFiles = new Set<string>();
     private pendingFiles = new Set<string>();
     private hasPendingChanges = false;
+    private logger = Logger.getInstance();
+    
+    // Debounce e batching
+    private debounceTimer: ReturnType<typeof setTimeout> | null = null;
+    private readonly DEBOUNCE_MS = TIMEOUTS.DEBOUNCE;
+    private readonly MAX_BATCH_SIZE = 50;
+    private readonly MIN_BUILD_INTERVAL_MS = 500;
+    
+    // Métricas
+    private metrics: WatcherMetrics = {
+        filesChanged: 0,
+        buildsTriggered: 0,
+        lastBuildTime: 0,
+        avgBuildTime: 0,
+        buildTimes: [],
+    };
+    
+    // Priorização de arquivos
+    private static readonly PRIORITY = {
+        BUILD_CONFIG: 1,  // pom.xml, build.gradle
+        JAVA: 2,          // .java
+        RESOURCE: 3,      // .jsp, .html, etc
+    };
 
     constructor(
         private config: AppConfig,
@@ -23,8 +59,8 @@ export class DeployWatcher {
     ) {
         this.fileWatcher = new FileWatcher({
             recursive: true,
-            debounceMs: WATCHER_DEBOUNCE_MS,
-            coolingMs: WATCHER_COOLING_MS,
+            debounceMs: TIMEOUTS.WATCHER_DEBOUNCE,
+            coolingMs: TIMEOUTS.COOLING,
         });
     }
 
@@ -41,7 +77,7 @@ export class DeployWatcher {
         // Inicia o watcher
         this.fileWatcher.start();
 
-        Logger.info("DeployWatcher", "Monitorando alterações...");
+        this.logger.status("watch", "running", "monitorando arquivos");
     }
 
     /**
@@ -77,7 +113,8 @@ export class DeployWatcher {
     private async handleBuildConfigChange(event: FileChangeEvent): Promise<void> {
         if (!event.filename) return;
 
-        Logger.watcher(`Build configuration changed: ${event.filename}`, 'warn');
+        this.logger.file(event.filename, 'changed');
+        this.logger.info("Configuração de build alterada - rebuild completo necessário");
         
         // Limpa cache quando config muda
         const { BuildCacheService } = await import("./BuildCacheService");
@@ -87,22 +124,57 @@ export class DeployWatcher {
     }
 
     /**
-     * Trata mudança em arquivo Java
+     * Trata mudança em arquivo Java com debounce inteligente
      */
     private handleJavaChange(event: FileChangeEvent): void {
-        if (!event.filename || this.isDeploying) {
-            if (event.filename) {
-                this.pendingFiles.add(event.filename);
-                this.hasPendingChanges = true;
-            }
+        if (!event.filename) return;
+
+        this.metrics.filesChanged++;
+        this.logger.file(event.filename, 'changed');
+        this.modifiedFiles.add(event.filename);
+
+        // Se muitos arquivos mudaram, faz full build
+        if (this.modifiedFiles.size >= this.MAX_BATCH_SIZE) {
+            this.logger.warn(`Muitos arquivos modificados (${this.modifiedFiles.size}) - forçando build completo`);
+            this.pendingFullBuild = true;
+            this.flush();
             return;
         }
 
-        Logger.watcher(event.filename, 'watch');
-        this.modifiedFiles.add(event.filename);
+        // Debounce normal
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+
+        this.debounceTimer = setTimeout(() => {
+            this.flush();
+        }, this.DEBOUNCE_MS);
+    }
+
+    /**
+     * Processa batch de arquivos modificados
+     */
+    private flush(): void {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+
+        const files = [...this.modifiedFiles];
+        this.modifiedFiles.clear();
 
-        // Debounce para acumular múltiplas mudanças
-        this.scheduleDeploy();
+        if (files.length === 0) return;
+
+        // Rate limiting
+        const timeSinceLastBuild = Date.now() - this.metrics.lastBuildTime;
+        if (timeSinceLastBuild < this.MIN_BUILD_INTERVAL_MS) {
+            const delay = this.MIN_BUILD_INTERVAL_MS - timeSinceLastBuild;
+            setTimeout(() => this.run(this.pendingFullBuild ? false : true, files), delay);
+        } else {
+            this.run(this.pendingFullBuild ? false : true, files);
+        }
+
+        this.pendingFullBuild = false;
     }
 
     /**
@@ -111,12 +183,12 @@ export class DeployWatcher {
     private async handleResourceChange(event: FileChangeEvent): Promise<void> {
         if (!event.filename) return;
 
-        Logger.watcher(event.filename, 'resource');
+        this.logger.file(event.filename, 'changed');
         
         try {
             await this.deployCmd.syncResource(this.config, event.filename);
         } catch (error) {
-            Logger.error(`Falha ao sincronizar recurso: ${event.filename}`);
+            this.logger.error(`Falha ao sincronizar: ${event.filename}`);
         }
     }
 
@@ -134,12 +206,21 @@ export class DeployWatcher {
     }
 
     /**
-     * Executa o deploy
+     * Executa o deploy com métricas
      */
     private async run(incremental = false, changedFiles?: string[]): Promise<void> {
-        if (this.isDeploying) return;
+        if (this.isDeploying) {
+            // Acumula para próximo ciclo
+            if (changedFiles) {
+                changedFiles.forEach(f => this.pendingFiles.add(f));
+                this.hasPendingChanges = true;
+            }
+            return;
+        }
         
         this.isDeploying = true;
+        const buildStart = performance.now();
+        this.metrics.buildsTriggered++;
         
         try {
             await this.deployCmd.execute(this.config, {
@@ -147,18 +228,34 @@ export class DeployWatcher {
                 incremental,
                 changedFiles,
             });
+            
+            // Atualiza métricas
+            const buildTime = performance.now() - buildStart;
+            this.metrics.lastBuildTime = Date.now();
+            this.metrics.buildTimes.push(buildTime);
+            
+            // Mantém apenas últimos 10 builds para média
+            if (this.metrics.buildTimes.length > 10) {
+                this.metrics.buildTimes.shift();
+            }
+            
+            this.metrics.avgBuildTime = 
+                this.metrics.buildTimes.reduce((a, b) => a + b, 0) / this.metrics.buildTimes.length;
+            
+            this.logger.debug(`Build em ${buildTime.toFixed(0)}ms (média: ${this.metrics.avgBuildTime.toFixed(0)}ms)`);
+            
         } catch (error) {
             // Erro já é tratado pelo comando
         } finally {
             this.isDeploying = false;
             
             // Processa mudanças pendentes
-            if (this.hasPendingChanges) {
+            if (this.hasPendingChanges || this.pendingFiles.size > 0) {
                 const pending = [...this.pendingFiles];
                 this.pendingFiles.clear();
                 this.hasPendingChanges = false;
                 
-                Logger.watcher(`Processing ${pending.length} pending change(s)...`, 'warn');
+                this.logger.info(`${pending.length} arquivo(s) pendente(s)`);
                 
                 setTimeout(() => {
                     this.run(true, pending);
@@ -167,6 +264,13 @@ export class DeployWatcher {
         }
     }
 
+    /**
+     * Obtém métricas do watcher
+     */
+    getMetrics(): WatcherMetrics {
+        return { ...this.metrics };
+    }
+
     /**
      * Verifica se é arquivo de recurso (não Java)
      */

package/src/services/DockerService.ts

@@ -3,7 +3,7 @@
  * Gera configs e gerencia containers
  */
 
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import { spawn } from "child_process";
 import fs from "fs";
 import path from "path";
@@ -291,8 +291,8 @@ services:
 
         Logger.divider();
         for (const c of containers) {
-            const statusColor = c.status.includes("Up") ? Logger.C.success : Logger.C.error;
-            Logger.info(c.name, `${statusColor}${c.status}${Logger.C.reset}`);
+            const statusColor = c.status.includes("Up") ? C.success : C.error;
+            Logger.info(c.name, `${statusColor}${c.status}${C.reset}`);
             if (c.ports) {
                 Logger.dim(`  ${c.ports}`);
             }

package/src/services/EmbeddedTomcatService.ts

@@ -1,4 +1,4 @@
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { ProgressBar, ThemedSpinner } from "../utils/ProgressBar";
 import { VERSIONS, getAvailableTomcatVersions, isSupportedTomcatVersion } from "../config/versions";
 import {
@@ -46,6 +46,7 @@ export class EmbeddedTomcatService {
 	private tomcatHome: string;
 	private downloadUrl: string;
 	private isInstalled: boolean = false;
+	private logger = Logger.getInstance();
 
 	// Versões agora centralizadas em src/config/versions.ts
 
@@ -110,13 +111,13 @@ export class EmbeddedTomcatService {
 	 */
 	async install(): Promise<boolean> {
 		if (this.checkInstallation()) {
-			Logger.info("Tomcat", `Versão ${this.version} já instalada`);
+			this.logger.info(`Tomcat: Versão ${this.version} já instalada`);
 			return true;
 		}
 
-		Logger.section("Instalando Tomcat Embutido");
-		Logger.info("Versão", this.version);
-		Logger.info("Destino", this.tomcatHome);
+		this.logger.section("Instalando Tomcat Embutido");
+		this.logger.info(`Versão: ${this.version}`);
+		this.logger.info(`Destino: ${this.tomcatHome}`);
 
 		// Cria diretório base
 		if (!existsSync(this.baseDir)) {
@@ -152,10 +153,10 @@ export class EmbeddedTomcatService {
 			await this.configureContextXml();
 
 			this.isInstalled = true;
-			Logger.success(`Tomcat ${this.version} instalado com sucesso!`);
+			this.logger.success(`Tomcat ${this.version} instalado com sucesso!`);
 			return true;
 		} catch (error) {
-			Logger.error(`Falha ao instalar Tomcat: ${error}`);
+			this.logger.error(`Falha ao instalar Tomcat: ${error}`);
 			// Limpa arquivos parciais
 			if (existsSync(this.tomcatHome)) {
 				await fsPromises.rm(this.tomcatHome, { recursive: true, force: true });
@@ -203,7 +204,7 @@ export class EmbeddedTomcatService {
 		);
 
 		await fsPromises.writeFile(serverXmlPath, content, "utf-8");
-		Logger.debug(`server.xml configurado na porta ${this.port}`);
+		this.logger.debug(`server.xml configurado na porta ${this.port}`);
 	}
 
 	/**
@@ -280,7 +281,7 @@ export class EmbeddedTomcatService {
 </Context>`;
 
 		writeFileSync(contextFile, content);
-		Logger.debug(`Context criado: ${contextFile}`);
+		this.logger.debug(`Context criado: ${contextFile}`);
 	}
 
 	/**
@@ -394,7 +395,7 @@ export class EmbeddedTomcatService {
 			await fsPromises.writeFile(destPath, allChunks);
 			
 			const sizeMB = (received / 1024 / 1024).toFixed(1);
-			Logger.info("Download", `${sizeMB} MB baixados`);
+			this.logger.info(`Download: ${sizeMB} MB baixados`);
 		} else {
 			// Sem content-length, usar spinner temático
 			const spinner = new ThemedSpinner();
@@ -406,7 +407,7 @@ export class EmbeddedTomcatService {
 				stop(true);
 				
 				const sizeMB = (buffer.byteLength / 1024 / 1024).toFixed(1);
-				Logger.info("Download", `${sizeMB} MB baixados`);
+				this.logger.info(`Download: ${sizeMB} MB baixados`);
 			} catch (error) {
 				stop(false);
 				throw error;
@@ -455,7 +456,7 @@ export class EmbeddedTomcatService {
 	async uninstall(): Promise<void> {
 		if (existsSync(this.tomcatHome)) {
 			await fsPromises.rm(this.tomcatHome, { recursive: true, force: true });
-			Logger.info("Tomcat", `Versão ${this.version} removida`);
+			this.logger.info(`Tomcat: Versão ${this.version} removida`);
 		}
 	}
 

package/src/services/FileWatcher.ts

@@ -5,7 +5,7 @@
  */
 
 import { watch, type FSWatcher } from "fs";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 
 export interface FileWatcherOptions {
     recursive?: boolean;
@@ -29,6 +29,7 @@ export class FileWatcher {
     private debounceTimers: Map<string, Timer> = new Map();
     private coolingFiles: Set<string> = new Set();
     private isWatching = false;
+    private logger = Logger.getInstance();
 
     private static readonly DEFAULT_OPTIONS: Required<FileWatcherOptions> = {
         recursive: true,
@@ -74,7 +75,7 @@ export class FileWatcher {
      */
     start(rootPath: string = process.cwd()): void {
         if (this.isWatching) {
-            Logger.debug("FileWatcher já está rodando");
+            // Silently ignore
             return;
         }
 
@@ -85,7 +86,7 @@ export class FileWatcher {
         );
 
         this.isWatching = true;
-        Logger.debug(`FileWatcher iniciado em ${rootPath}`);
+        // Started silently
     }
 
     /**
@@ -102,7 +103,7 @@ export class FileWatcher {
         this.debounceTimers.clear();
         
         this.isWatching = false;
-        Logger.debug("FileWatcher parado");
+        // Stopped silently
     }
 
     /**
@@ -190,11 +191,11 @@ export class FileWatcher {
                     const result = handler(event);
                     if (result instanceof Promise) {
                         result.catch(err => {
-                            Logger.debug(`Erro em handler de watch: ${err.message}`);
+                            this.logger.debug(`Erro em handler de watch: ${err.message}`);
                         });
                     }
                 } catch (err) {
-                    Logger.debug(`Erro em handler de watch: ${(err as Error).message}`);
+                    this.logger.debug(`Erro em handler de watch: ${(err as Error).message}`);
                 }
             }
         }
@@ -208,7 +209,14 @@ export class FileWatcher {
         if (pattern === "*") return true;
         
         try {
-            const regex = new RegExp(pattern);
+            // Quando um RegExp é convertido para string (ex: usado como chave de Map),
+            // ele vira algo como "/\\.java$/". Precisamos extrair o padrão real.
+            let patternStr = pattern;
+            if (pattern.length > 2 && pattern.startsWith("/") && pattern.lastIndexOf("/") > 0) {
+                const lastSlash = pattern.lastIndexOf("/");
+                patternStr = pattern.slice(1, lastSlash);
+            }
+            const regex = new RegExp(patternStr);
             return regex.test(filename);
         } catch {
             // Se não for regex válido, trata como string simples

package/src/services/HttpService.ts

@@ -3,7 +3,7 @@
  * Similar ao Postman/curl mas integrado com o projeto
  */
 
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import type { ApiEndpoint } from "../types/endpoint";
 
 export interface HttpRequest {
@@ -195,12 +195,12 @@ export class HttpService {
     }
 
     private printResponse(res: HttpResponse): void {
-        const statusColor = res.status < 300 ? Logger.C.success 
-            : res.status < 400 ? Logger.C.warning 
-            : Logger.C.error;
+        const statusColor = res.status < 300 ? C.success 
+            : res.status < 400 ? C.warning 
+            : C.error;
 
         Logger.divider();
-        Logger.info("Status", `${statusColor}${res.status} ${res.statusText}${Logger.C.reset}`);
+        Logger.info("Status", `${statusColor}${res.status} ${res.statusText}${C.reset}`);
         Logger.info("Duration", `${res.duration}ms`);
         Logger.info("Size", `${this.formatBytes(res.size)}`);
 

package/src/services/LogAnalyzer.ts

@@ -1,8 +1,9 @@
-import { Logger } from "../utils/ui";
+import { Logger, Colors } from "../logging";
 import type { ProjectConfig } from "../types/config";
 
 export class LogAnalyzer {
     private projectPrefixes: string[] = [];
+    private logger = Logger.getInstance();
 
     constructor(private config: ProjectConfig) {
         // Tentamos inferir prefixos comuns do projeto. 
@@ -20,18 +21,18 @@ export class LogAnalyzer {
     }
 
     public summarize(line: string): string {
-        if (Logger.isSystemNoise(line)) return "";
+        if (line.includes("CATALINA") || line.includes("Using JRE_HOME") || line.includes("Using CLASSPATH")) return "";
 
         // Reuso da lógica existente no Logger.summarize, mas aprimorada
         const startupMatch = line.match(/Server startup in (\[?)(.*?)(\]?)\s*ms/);
         if (startupMatch) {
             const time = (parseInt(startupMatch[2]) / 1000).toFixed(1);
-            return `${Logger.C.green}✔ ${Logger.C.bold}Server started in ${time}s`;
+            return `${Colors.success}✔ ${Colors.bold}Servidor iniciado em ${time}s`;
         }
 
         const deployMatch = line.match(/Deployment of web application archive \[(.*?)\] has finished in \[(.*?)\] ms/);
         if (deployMatch) {
-            return `${Logger.C.green}✔ Artifacts deployed`;
+            return `${Colors.success}✔ Artefatos implantados`;
         }
 
         // Smart Folding para Stack Traces
@@ -40,7 +41,7 @@ export class LogAnalyzer {
         }
 
         if (line.includes("Caused by:")) {
-            return `${Logger.C.bgRed}${Logger.C.white}${Logger.C.bold} ROOT CAUSE ${Logger.C.reset} ${Logger.C.red}${line.trim()}${Logger.C.reset}`;
+            return `${Colors.bgRed}${Colors.white}${Colors.bold} CAUSA RAIZ ${Colors.reset} ${Colors.error}${line.trim()}${Colors.reset}`;
         }
 
         // Hotswap
@@ -66,7 +67,7 @@ export class LogAnalyzer {
 
         // Se a linha contém Exception mas não é o 'at ', destaca
         if (line.includes("Exception:")) {
-            return `${Logger.C.red}${Logger.C.bold}${line.trim()}${Logger.C.reset}`;
+            return `${Colors.error}${Colors.bold}${line.trim()}${Colors.reset}`;
         }
 
         return "";
@@ -77,9 +78,9 @@ export class LogAnalyzer {
         const isProject = this.projectPrefixes.some(p => trimmed.includes(p));
         
         if (isProject) {
-            return `    ${Logger.C.bold}${Logger.C.warning}${trimmed}${Logger.C.reset}`;
+            return `    ${Colors.bold}${Colors.warning}${trimmed}${Colors.reset}`;
         } else {
-            return `    ${Logger.C.dim}${trimmed}${Logger.C.reset}`;
+            return `    ${Colors.dim}${trimmed}${Colors.reset}`;
         }
     }
 
@@ -87,7 +88,10 @@ export class LogAnalyzer {
         const level = match[1];
         let msg = match[3];
 
-        if (msg.includes("plugin initialized")) return "";
+        // Ignora mensagens de plugin inicializado (são muito verbosas)
+        if (msg.toLowerCase().includes("plugin") && msg.toLowerCase().includes("initialized")) {
+            return "";
+        }
         
         if (msg.includes("redefinition") || msg.includes("reloaded") || level === 'RELOAD') {
             if (msg.includes("Reloading classes [")) {
@@ -95,26 +99,26 @@ export class LogAnalyzer {
                 const classCount = classes.split(",").length;
                 if (classCount > 3) msg = `Reloading ${classCount} classes...`;
             }
-            return `${Logger.C.magenta}👀 ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg.replace(/Class '.*?'/, (m) => Logger.C.bold + m + Logger.C.reset)}`;
+            return `${Colors.magenta}👀 ${Colors.bold}Hotswap:${Colors.reset} ${msg.replace(/Class '.*?'/, (m) => Colors.bold + m + Colors.reset)}`;
         }
 
-        let color = Logger.C.primary;
+        let color = Colors.primary;
         let symbol = "●";
-        if (level === "WARN") { color = Logger.C.warning; symbol = "▲"; }
-        else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }
+        if (level === "WARN") { color = Colors.warning; symbol = "▲"; }
+        else if (level === "ERROR") { color = Colors.error; symbol = "✖"; }
         
-        return `${color}${symbol} ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg}`;
+        return `${color}${symbol} ${Colors.bold}Hotswap:${Colors.reset} ${msg}`;
     }
 
     private formatTomcatLine(match: RegExpMatchArray): string {
         const label = match[2];
         let msg = match[4].trim();
-        if (Logger.isSystemNoise(msg)) return "";
+        if (msg.includes("CATALINA") || msg.includes("Using JRE_HOME")) return "";
         
-        let color = Logger.C.dim;
+        let color = Colors.dim;
         let symbol = "ℹ";
-        if (label === "WARNING") { color = Logger.C.warning; symbol = "▲"; }
-        else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
+        if (label === "WARNING") { color = Colors.warning; symbol = "▲"; }
+        else if (label === "SEVERE" || label === "ERROR") { color = Colors.error; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?|org\.glassfish)\.[a-zA-Z0-9.]+\s/, "").trim();
         if (!msg) return "";
@@ -127,13 +131,13 @@ export class LogAnalyzer {
         let msg = match[2].trim();
         if (msg.includes("Total time:") || msg.includes("Finished at:") || msg.includes("Final Memory:") || msg.includes("-----------------------")) return "";
         
-        let color = Logger.C.dim;
+        let color = Colors.dim;
         let symbol = "ℹ";
-        if (label === "WARNING" || label === "WARN") { color = Logger.C.warning; symbol = "▲"; }
-        else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
+        if (label === "WARNING" || label === "WARN") { color = Colors.warning; symbol = "▲"; }
+        else if (label === "SEVERE" || label === "ERROR") { color = Colors.error; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?)\.[a-zA-Z0-9.]+\s/, "").trim();
-        if (!msg || msg === "]" || msg.includes("Compilation failure")) return "";
+        if (!msg || msg === "]") return "";
         
         return `${color}${symbol} ${msg}`;
     }