@archznn/xavva 2.5.0 → 2.7.0

package/src/services/FileWatcher.ts

@@ -0,0 +1,243 @@
+/**
+ * FileWatcher genérico
+ * Responsabilidade única: observar mudanças em arquivos
+ * Sem acoplamento com lógica de deploy
+ */
+
+import { watch, type FSWatcher } from "fs";
+import { Logger } from "../utils/ui";
+
+export interface FileWatcherOptions {
+    recursive?: boolean;
+    debounceMs?: number;
+    coolingMs?: number;
+    ignoredPatterns?: RegExp[];
+}
+
+export interface FileChangeEvent {
+    eventType: "rename" | "change";
+    filename: string | null;
+    fullPath: string;
+}
+
+export type FileChangeHandler = (event: FileChangeEvent) => void | Promise<void>;
+
+export class FileWatcher {
+    private watcher: FSWatcher | null = null;
+    private options: Required<FileWatcherOptions>;
+    private handlers: Map<string, FileChangeHandler> = new Map();
+    private debounceTimers: Map<string, Timer> = new Map();
+    private coolingFiles: Set<string> = new Set();
+    private isWatching = false;
+
+    private static readonly DEFAULT_OPTIONS: Required<FileWatcherOptions> = {
+        recursive: true,
+        debounceMs: 300,
+        coolingMs: 1000,
+        ignoredPatterns: [
+            /node_modules/,
+            /\.git/,
+            /target/,
+            /build/,
+            /\.xavva/,
+            /\.idea/,
+            /\.vscode/,
+            /dist/,
+            /out/,
+        ],
+    };
+
+    constructor(options: FileWatcherOptions = {}) {
+        this.options = { ...FileWatcher.DEFAULT_OPTIONS, ...options };
+    }
+
+    /**
+     * Registra um handler para um padrão específico
+     */
+    on(pattern: string | RegExp, handler: FileChangeHandler): () => void {
+        const key = pattern.toString();
+        this.handlers.set(key, handler);
+        
+        // Retorna função para remover handler
+        return () => this.handlers.delete(key);
+    }
+
+    /**
+     * Registra handler para qualquer mudança
+     */
+    onAny(handler: FileChangeHandler): () => void {
+        return this.on("*", handler);
+    }
+
+    /**
+     * Inicia o watching
+     */
+    start(rootPath: string = process.cwd()): void {
+        if (this.isWatching) {
+            Logger.debug("FileWatcher já está rodando");
+            return;
+        }
+
+        this.watcher = watch(
+            rootPath,
+            { recursive: this.options.recursive },
+            (eventType, filename) => this.handleWatchEvent(eventType, filename)
+        );
+
+        this.isWatching = true;
+        Logger.debug(`FileWatcher iniciado em ${rootPath}`);
+    }
+
+    /**
+     * Para o watching
+     */
+    stop(): void {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        
+        // Limpa timers pendentes
+        this.debounceTimers.forEach(timer => clearTimeout(timer));
+        this.debounceTimers.clear();
+        
+        this.isWatching = false;
+        Logger.debug("FileWatcher parado");
+    }
+
+    /**
+     * Verifica se está observando
+     */
+    isActive(): boolean {
+        return this.isWatching;
+    }
+
+    /**
+     * Processa evento do fs.watch
+     */
+    private handleWatchEvent(
+        eventType: "rename" | "change",
+        filename: string | null
+    ): void {
+        if (!filename) return;
+
+        // Ignora arquivos em cooling
+        if (this.coolingFiles.has(filename)) return;
+        this.addToCooling(filename);
+
+        // Ignora patterns definidos
+        if (this.isIgnored(filename)) return;
+
+        const fullPath = this.resolvePath(filename);
+        const event: FileChangeEvent = { eventType, filename, fullPath };
+
+        // Aplica debounce
+        this.debounce(filename, () => {
+            this.notifyHandlers(event);
+        });
+    }
+
+    /**
+     * Adiciona arquivo ao período de cooling
+     */
+    private addToCooling(filename: string): void {
+        this.coolingFiles.add(filename);
+        setTimeout(() => {
+            this.coolingFiles.delete(filename);
+        }, this.options.coolingMs);
+    }
+
+    /**
+     * Verifica se arquivo deve ser ignorado
+     */
+    private isIgnored(filename: string): boolean {
+        return this.options.ignoredPatterns.some(pattern => pattern.test(filename));
+    }
+
+    /**
+     * Resolve caminho completo
+     */
+    private resolvePath(filename: string): string {
+        // Normaliza separadores de path
+        return filename.replace(/\\/g, "/");
+    }
+
+    /**
+     * Aplica debounce no handler
+     */
+    private debounce(key: string, fn: () => void): void {
+        const existing = this.debounceTimers.get(key);
+        if (existing) {
+            clearTimeout(existing);
+        }
+
+        const timer = setTimeout(() => {
+            this.debounceTimers.delete(key);
+            fn();
+        }, this.options.debounceMs);
+
+        this.debounceTimers.set(key, timer);
+    }
+
+    /**
+     * Notifica todos os handlers relevantes
+     */
+    private notifyHandlers(event: FileChangeEvent): void {
+        // Notifica handlers específicos
+        for (const [pattern, handler] of this.handlers) {
+            if (this.matchesPattern(event.filename, pattern)) {
+                try {
+                    const result = handler(event);
+                    if (result instanceof Promise) {
+                        result.catch(err => {
+                            Logger.debug(`Erro em handler de watch: ${err.message}`);
+                        });
+                    }
+                } catch (err) {
+                    Logger.debug(`Erro em handler de watch: ${(err as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Verifica se filename match com pattern
+     */
+    private matchesPattern(filename: string | null, pattern: string): boolean {
+        if (!filename) return false;
+        if (pattern === "*") return true;
+        
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(filename);
+        } catch {
+            // Se não for regex válido, trata como string simples
+            return filename.includes(pattern);
+        }
+    }
+}
+
+/**
+ * Helper para criar watcher com configuração padrão de projetos Java
+ */
+export function createJavaFileWatcher(): FileWatcher {
+    return new FileWatcher({
+        recursive: true,
+        debounceMs: 300,
+        coolingMs: 1000,
+        ignoredPatterns: [
+            /node_modules/,
+            /\.git/,
+            /target/,
+            /build/,
+            /\.xavva/,
+            /\.idea/,
+            /\.vscode/,
+            /dist/,
+            /out/,
+            /\.class$/,
+            /\.jar$/,
+            /\.war$/,
+        ],
+    });
+}

package/src/services/LogAnalyzer.ts

@@ -77,7 +77,7 @@ export class LogAnalyzer {
         const isProject = this.projectPrefixes.some(p => trimmed.includes(p));
         
         if (isProject) {
-            return `    ${Logger.C.bold}${Logger.C.yellow}${trimmed}${Logger.C.reset}`;
+            return `    ${Logger.C.bold}${Logger.C.warning}${trimmed}${Logger.C.reset}`;
         } else {
             return `    ${Logger.C.dim}${trimmed}${Logger.C.reset}`;
         }
@@ -100,7 +100,7 @@ export class LogAnalyzer {
 
         let color = Logger.C.primary;
         let symbol = "●";
-        if (level === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        if (level === "WARN") { color = Logger.C.warning; symbol = "▲"; }
         else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         return `${color}${symbol} ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg}`;
@@ -113,7 +113,7 @@ export class LogAnalyzer {
         
         let color = Logger.C.dim;
         let symbol = "ℹ";
-        if (label === "WARNING") { color = Logger.C.yellow; symbol = "▲"; }
+        if (label === "WARNING") { color = Logger.C.warning; symbol = "▲"; }
         else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?|org\.glassfish)\.[a-zA-Z0-9.]+\s/, "").trim();
@@ -129,7 +129,7 @@ export class LogAnalyzer {
         
         let color = Logger.C.dim;
         let symbol = "ℹ";
-        if (label === "WARNING" || label === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        if (label === "WARNING" || label === "WARN") { color = Logger.C.warning; symbol = "▲"; }
         else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?)\.[a-zA-Z0-9.]+\s/, "").trim();

package/src/services/TomcatService.ts

@@ -1,10 +1,20 @@
-import type { TomcatConfig, AppConfig } from "../types/config";
+import type { TomcatConfig, AppConfig } from "../types";
+import { getHotswapAgentUrl, VERSIONS } from "../config/versions";
+import { NetworkError } from "../errors/XavvaError";
 import { Logger } from "../utils/ui";
 import type { Subprocess } from "bun";
 import { ProjectService } from "./ProjectService";
 import { existsSync, mkdirSync, writeFileSync, statSync, promises as fs } from "fs";
 import path from "path";
 import os from "os";
+import {
+	getCatalinaPath,
+	getMemoryCommand,
+	getKillCommand,
+	getPortCheckCommand,
+	getJavaPath,
+	isWindows,
+} from "../utils/platform";
 
 export class TomcatService {
 	private activeConfig: TomcatConfig;
@@ -13,6 +23,7 @@ export class TomcatService {
 	public onReady?: () => void;
 	private pid: number | null = null;
 	private projectService: ProjectService | null = null;
+	private hasReadyBeenCalled: boolean = false;
 
 	constructor(customConfig: TomcatConfig) {
 		this.activeConfig = customConfig;
@@ -25,23 +36,55 @@ export class TomcatService {
 	async getMemoryUsage(): Promise<string> {
 		if (!this.pid) return "0 MB";
 		try {
-			const { stdout } = Bun.spawnSync(["powershell", "-command", `(Get-Process -Id ${this.pid}).WorkingSet64 / 1MB`]);
+			const cmd = getMemoryCommand(this.pid);
+			if (!cmd) return "N/A";
+			
+			const { stdout } = Bun.spawnSync(cmd);
 			const mem = await new Response(stdout).text();
-			return `${Math.round(parseFloat(mem))} MB`;
+			const memValue = parseFloat(mem.trim());
+			
+			if (isNaN(memValue)) return "N/A";
+			
+			// No Linux/macOS, ps retorna em KB, convertemos para MB
+			if (!isWindows()) {
+				return `${Math.round(memValue / 1024)} MB`;
+			}
+			
+			return `${Math.round(memValue)} MB`;
 		} catch (e) {
 			return "N/A";
 		}
 	}
 
 	async killConflict() {
-		const { stdout } = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${this.activeConfig.port}`]);
+		const cmd = getPortCheckCommand(this.activeConfig.port);
+		const { stdout } = Bun.spawnSync(cmd);
 		const output = await new Response(stdout).text();
 
 		if (output) {
-			const lines = output.trim().split('\n');
-			const pid = lines[0].trim().split(/\s+/).pop();
-			Logger.step(`Freeing port ${this.activeConfig.port}`);
-			Bun.spawnSync(["taskkill", "/F", "/PID", pid]);
+			// Extrai PID do output
+			let pid: string | undefined;
+			
+			if (isWindows()) {
+				// Windows: netstat output, última coluna é o PID
+				const lines = output.trim().split('\n');
+				pid = lines[0].trim().split(/\s+/).pop();
+			} else {
+				// Linux/Mac: tenta extrair PID de lsof, ss ou netstat
+				// lsof -i :port: formato tem PID na coluna 2
+				// ss -tlnp: tem pid=XXXX
+				// netstat -tlnp: tem /XXXX no final
+				const match = output.match(/\b(\d+)\b/) || // número isolado (lsof)
+							  output.match(/pid=(\d+)/) ||     // ss format
+							  output.match(/\/(\d+)/);         // netstat format
+				if (match) pid = match[1];
+			}
+			
+			if (pid) {
+				Logger.step(`Freeing port ${this.activeConfig.port}`);
+				const killCmd = getKillCommand(pid);
+				Bun.spawnSync(killCmd);
+			}
 		}
 	}
 
@@ -96,7 +139,7 @@ export class TomcatService {
 
 	private async ensureHotswapAgent(): Promise<string | null> {
 		const agentDir = path.join(os.homedir(), ".xavva", "agents");
-		const agentPath = path.join(agentDir, "hotswap-agent-2.0.3.jar");
+		const agentPath = path.join(agentDir, `hotswap-agent-${VERSIONS.HOTSWAP_AGENT.VERSION}.jar`);
 
 		if (existsSync(agentPath) && statSync(agentPath).size > 1000) return agentPath;
 
@@ -105,21 +148,54 @@ export class TomcatService {
 			
 			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}`);
+			
+			Logger.debug(`URL: ${url}`);
+			Logger.debug(`Destino: ${agentPath}`);
+			
+			const response = await fetch(url, {
+				redirect: "follow",
+			});
+			
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			}
+			
+			const contentLength = response.headers.get("content-length");
+			Logger.debug(`Content-Length: ${contentLength || "unknown"}`);
 			
 			const buffer = await response.arrayBuffer();
+			Logger.debug(`Downloaded: ${buffer.byteLength} bytes`);
+			
+			if (buffer.byteLength < 1000) {
+				throw new Error(`Arquivo muito pequeno (${buffer.byteLength} bytes)`);
+			}
+			
 			writeFileSync(agentPath, Buffer.from(buffer));
-			Logger.success("HotswapAgent v2.0.3 installed globally!");
+			
+			// Verifica se foi escrito corretamente
+			const stats = statSync(agentPath);
+			Logger.debug(`Escrito: ${stats.size} bytes`);
+			
+			Logger.success(`HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION} installed globally!`);
 			return agentPath;
-		} catch (e) {
-			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
+		} catch (e: any) {
+			throw new NetworkError(url, e);
+			Logger.warn("Usando hot swap padrão da JVM.");
+			
+			// Limpa arquivo parcial se existir
+			if (existsSync(agentPath)) {
+				try {
+					await fs.unlink(agentPath);
+					Logger.debug("Arquivo parcial removido");
+				} catch {}
+			}
+			
 			return null;
 		}
 	}
 
 	async start(config: AppConfig, isWatching: boolean = false) {
-		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
+		const binPath = getCatalinaPath(this.activeConfig.path);
 		const args = (config.project.debug || isWatching) ? ["jpda", "run"] : ["run"];
 		
 		const catalinaOpts = [process.env.CATALINA_OPTS || ""];
@@ -134,7 +210,7 @@ export class TomcatService {
 					javaBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
 				}
 
-				const javaVer = Bun.spawnSync([javaBin, "-version"]);
+				const javaVer = Bun.spawnSync([getJavaPath(), "-version"]);
 				const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
 				
 				if (output.includes("dcevm") || output.includes("jbr") || output.includes("trava")) {
@@ -258,7 +334,8 @@ export class TomcatService {
 						this.stopStartupSpinner(isSuccess);
 						this.stopStartupSpinner = undefined;
 					}
-					if (isSuccess && this.onReady) {
+					if (isSuccess && this.onReady && !this.hasReadyBeenCalled) {
+						this.hasReadyBeenCalled = true;
 						this.onReady();
 					}
 				}

package/src/types/args.ts

@@ -0,0 +1,136 @@
+/**
+ * Argumentos de linha de comando tipados por contexto
+ * Substitui CLIArguments monolítico
+ */
+
+// ===== Args Base (comuns a todos os comandos) =====
+export interface BaseArgs {
+    help?: boolean;
+    version?: boolean;
+    verbose?: boolean;
+    quiet?: boolean;
+}
+
+// ===== Args de Configuração de Projeto =====
+export interface ProjectArgs {
+    tool?: string;
+    name?: string;
+    profile?: string;
+    encoding?: string;
+    "no-build"?: boolean;
+    clean?: boolean;
+    war?: boolean;
+    cache?: boolean;
+}
+
+// ===== Args de Configuração do Tomcat =====
+export interface TomcatArgs {
+    path?: string;
+    port?: string;
+    "tomcat-version"?: string;
+    yes?: boolean;
+}
+
+// ===== Args de Debug/Desenvolvimento =====
+export interface DebugArgs {
+    debug?: boolean;
+    watch?: boolean;
+    tui?: boolean;
+    dp?: string;
+}
+
+// ===== Args de Análise =====
+export interface AnalysisArgs {
+    grep?: string;
+    scan?: boolean;
+    fix?: boolean;
+    output?: string;
+    strict?: boolean;
+    "update-safe"?: boolean;
+}
+
+// ===== Args de Encoding =====
+export interface EncodingArgs {
+    from?: string;
+    to?: string;
+    backup?: boolean;
+    "dry-run"?: boolean;
+    force?: boolean;
+    src?: string;
+}
+
+// ===== Args Específicas de Comandos =====
+export interface DeployArgs extends BaseArgs, ProjectArgs, TomcatArgs, DebugArgs {
+    incremental?: boolean;
+    changedFiles?: string[];
+}
+
+export interface BuildArgs extends BaseArgs, ProjectArgs {
+    // Herda de ProjectArgs
+}
+
+export interface StartArgs extends BaseArgs, TomcatArgs, DebugArgs {
+    // Herda de TomcatArgs e DebugArgs
+}
+
+export interface RunArgs extends BaseArgs, DebugArgs {
+    // Positional: className
+}
+
+export interface LogsArgs extends BaseArgs {
+    grep?: string;
+}
+
+export interface AuditArgs extends BaseArgs, AnalysisArgs {
+    // Herda de AnalysisArgs
+}
+
+export interface DepsArgs extends BaseArgs, AnalysisArgs {
+    // Herda de AnalysisArgs
+}
+
+export interface DocsArgs extends BaseArgs {
+    output?: string;
+}
+
+export interface ProfilesArgs extends BaseArgs {
+    // Sem args específicas
+}
+
+export interface DoctorArgs extends BaseArgs {
+    fix?: boolean;
+}
+
+export interface TomcatCommandArgs extends BaseArgs, TomcatArgs {
+    "tomcat-action"?: string;
+}
+
+export interface EncodingCommandArgs extends BaseArgs, EncodingArgs {
+    // Herda de EncodingArgs
+}
+
+// ===== CLIArguments Legado (para compatibilidade) =====
+// Será gradualmente removido
+export interface CLIArguments extends 
+    BaseArgs, 
+    ProjectArgs, 
+    TomcatArgs, 
+    DebugArgs, 
+    AnalysisArgs, 
+    EncodingArgs {
+    // Campos adicionais para compatibilidade
+    [key: string]: unknown;
+}
+
+// ===== Type Guards =====
+export function isDeployArgs(args: CLIArguments): args is DeployArgs {
+    return "incremental" in args || "watch" in args;
+}
+
+export function isBuildArgs(args: CLIArguments): args is BuildArgs {
+    return "tool" in args || "clean" in args;
+}
+
+export function isEncodingArgs(args: CLIArguments): args is EncodingCommandArgs {
+    return "from" in args || "to" in args;
+}

package/src/types/config.ts

@@ -62,6 +62,12 @@ export interface CLIArguments {
     war?: boolean;
     cache?: boolean;
     changedFiles?: string[];
+    from?: string;
+    to?: string;
+    backup?: boolean;
+    "dry-run"?: boolean;
+    force?: boolean;
+    src?: string;
 }
 
 export interface CommandContext {

package/src/types/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel export para todos os tipos
+ */
+
+export * from "./config";
+export * from "./endpoint";
+export * from "./args";