@archznn/xavva 2.6.0 → 2.8.0

package/src/index.ts

@@ -1,115 +1,155 @@
 #!/usr/bin/env bun
 import { ConfigManager } from "./utils/config";
 import { CommandRegistry } from "./commands/CommandRegistry";
-import { BuildCommand } from "./commands/BuildCommand";
-import { DeployCommand } from "./commands/DeployCommand";
-import { StartCommand } from "./commands/StartCommand";
-import { HelpCommand } from "./commands/HelpCommand";
-import { DoctorCommand } from "./commands/DoctorCommand";
-import { RunCommand } from "./commands/RunCommand";
-import { LogsCommand } from "./commands/LogsCommand";
-import { DocsCommand } from "./commands/DocsCommand";
-import { AuditCommand } from "./commands/AuditCommand";
-import { ProfilesCommand } from "./commands/ProfilesCommand";
-import { DepsCommand } from "./commands/DepsCommand";
-import { TomcatCommand } from "./commands/TomcatCommand";
-
-import { ProjectService } from "./services/ProjectService";
-import { TomcatService } from "./services/TomcatService";
-import { BuildService } from "./services/BuildService";
-import { AuditService } from "./services/AuditService";
-import { WatcherService } from "./services/WatcherService";
-import { BuildCacheService } from "./services/BuildCacheService";
-import { DashboardService } from "./services/DashboardService";
-import { LogAnalyzer } from "./services/LogAnalyzer";
-
+import { createContainer, type DIContainer } from "./di/container";
+import { DeployWatcher } from "./services/DeployWatcher";
+import { ErrorHandler } from "./errors/ErrorHandler";
+import { ProcessManager } from "./utils/processManager";
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
-import { ProcessManager } from "./utils/processManager";
-import type { AppConfig, CLIArguments } from "./types/config";
+import type { CLIArguments } from "./types/args";
 
 async function main() {
-	const processManager = ProcessManager.getInstance();
-	const { config, positionals, values } = await ConfigManager.load();
+    const processManager = ProcessManager.getInstance();
+    const { config, positionals, values } = await ConfigManager.load();
+
+    // Handler de versão
+    if (values.version) {
+        Logger.log(`v${pkg.version}`);
+        await processManager.shutdown(0);
+    }
+
+    // Identifica comando
+    const commandNames = [
+        "deploy", "build", "start", "dev", "doctor", "run", 
+        "debug", "logs", "docs", "audit", "profiles", 
+        "deps", "tomcat", "encoding", "init", "config", 
+        "history", "redo", "health", "completion", "help"
+    ];
+    const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
+
+    // Mostra banner (exceto em help ou TUI)
+    if (!values.help && !values.tui) {
+        Logger.banner(commandName, config.project.profile, config.project.encoding);
+        if (config.project.encoding) {
+            Logger.config("Encoding", config.project.encoding);
+        }
+        if (config.tomcat.embedded) {
+            Logger.config("Tomcat", `Embutido ${config.tomcat.version}`);
+        }
+    }
+
+    // Handler de help
+    if (values.help) {
+        const { HelpCommand } = await import("./commands/HelpCommand");
+        new HelpCommand().execute(config, values as CLIArguments);
+        await processManager.shutdown(0);
+    }
 
-	if (values.version) {
-		Logger.log(`v${pkg.version}`);
-		await processManager.shutdown(0);
-	}
+    // Inicializa Container de DI
+    let container: DIContainer;
+    try {
+        container = createContainer(config);
+        container.initialize();
+    } catch (error) {
+        await ErrorHandler.getInstance().handle(error, { phase: "di-initialization" });
+        return;
+    }
 
-	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles", "deps", "tomcat"];
-	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
+    const services = container.getAllServices();
+    const commands = container.getAllCommands();
 
-	if (!values.help && !values.tui) {
-		Logger.banner(commandName, config.project.profile, config.project.encoding);
-		if (config.project.encoding) {
-			Logger.config("Encoding", config.project.encoding);
-		}
-		if (config.tomcat.embedded) {
-			Logger.config("Tomcat", `Embutido ${config.tomcat.version}`);
-		}
-	}
+    // Configura ações da TUI
+    if (values.tui) {
+        const deployCmd = commands.deploy;
+        services.dashboardService.onAction("r", () => {
+            services.dashboardService.log(Logger.C.warning + "Restart manual solicitado via TUI...");
+            deployCmd.execute(config, { watch: true, incremental: false });
+        });
+    }
 
-	if (values.help) {
-		new HelpCommand().execute(config, values);
-		await processManager.shutdown(0);
-	}
+    // Caso especial: Watch Mode para Deploy/Dev
+    if ((commandName === "deploy" || commandName === "dev") && values.watch) {
+        const deployCmd = commands.deploy;
+        const watcher = new DeployWatcher(config, deployCmd);
+        
+        try {
+            await watcher.start();
+        } catch (error) {
+            await ErrorHandler.getInstance().handle(error, { phase: "watch-mode", command: commandName });
+        }
+    } else {
+        // Executa comando do Registry
+        const registry = new CommandRegistry();
+        
+        // Registra todos os comandos
+        registry.register("build", commands.build);
+        registry.register("start", commands.start);
+        registry.register("doctor", commands.doctor);
+        registry.register("run", commands.run);
+        registry.register("debug", commands.debug);
+        registry.register("logs", commands.logs);
+        registry.register("docs", commands.docs);
+        registry.register("audit", commands.audit);
+        registry.register("profiles", commands.profiles);
+        registry.register("deps", commands.deps);
+        registry.register("tomcat", commands.tomcat);
+        registry.register("encoding", commands.encoding);
+        registry.register("deploy", commands.deploy);
+        registry.register("dev", commands.dev);
+        registry.register("init", commands.init);
+        registry.register("config", commands.config);
+        registry.register("history", commands.history);
+        registry.register("redo", commands.redo);
+        registry.register("health", commands.health);
+        registry.register("completion", commands.completion);
 
-	// 1. Instanciar Serviços (Injeção de Dependência)
-	const projectService = new ProjectService(config.project);
-	const buildCacheService = new BuildCacheService();
-	const buildService = new BuildService(config.project, config.tomcat, projectService, buildCacheService);
-	const tomcatService = new TomcatService(config.tomcat);
-	tomcatService.setProjectService(projectService);
-	const auditService = new AuditService(config.tomcat);
-	
-	// Xavva 2.0: Dashboard & LogAnalyzer
-	const logAnalyzer = new LogAnalyzer(config.project);
-	const dashboard = new DashboardService(config);
-	Logger.setDashboard(dashboard);
+        // Configura flags específicas
+        if (commandName === "debug") values.debug = true;
+        if (commandName === "run") values.debug = false;
 
-	// 2. Registrar Comandos
-	const registry = new CommandRegistry();
-	
-	const deployCmd = new DeployCommand(tomcatService, buildService);
-	const logsCmd = new LogsCommand(dashboard, logAnalyzer);
-	
-	registry.register("build", new BuildCommand(buildService));
-	registry.register("start", new StartCommand(tomcatService));
-	registry.register("doctor", new DoctorCommand());
-	registry.register("run", new RunCommand());
-	registry.register("debug", new RunCommand());
-	registry.register("logs", logsCmd);
-	registry.register("docs", new DocsCommand());
-	registry.register("audit", new AuditCommand(auditService));
-	registry.register("profiles", new ProfilesCommand(projectService));
-	registry.register("deps", new DepsCommand());
-	registry.register("tomcat", new TomcatCommand());
-	registry.register("deploy", deployCmd);
-	registry.register("dev", deployCmd);
+        // Registra comando no histórico antes da execução
+        const startTime = Date.now();
+        let success = true;
 
-	// Caso especial: Watch Mode para Deploy/Dev
-	if ((commandName === "deploy" || commandName === "dev") && values.watch) {
-		// Registrar ação de restart manual na TUI
-		if (dashboard.isTuiActive()) {
-			dashboard.onAction("r", () => {
-				dashboard.log(Logger.C.warning + "Restart manual solicitado via TUI...");
-				deployCmd.execute(config, false, true); // Executa deploy completo mas mantém o watch
-			});
-		}
+        try {
+            await registry.execute(commandName, config, values as CLIArguments, positionals);
+        } catch (error) {
+            success = false;
+            await ErrorHandler.getInstance().handle(error, { phase: "command-execution", command: commandName });
+        } finally {
+            // Salva no histórico
+            const duration = (Date.now() - startTime) / 1000;
+            const filteredPositionals = positionals.filter(p => p !== commandName && !commandNames.includes(p));
+            services.historyService.add({
+                command: commandName,
+                args: [...filteredPositionals, ...Object.entries(values)
+                    .filter(([, v]) => v !== undefined && typeof v !== "object")
+                    .flatMap(([k, v]) => [`--${k}`, String(v)])],
+                success,
+                duration
+            }).catch(() => { /* ignore history errors */ });
 
-		const watcher = new WatcherService(config, deployCmd);
-		await watcher.start();
-	} else {
-		// 3. Executar do Registro
-		if (commandName === "debug") values.debug = true;
-		if (commandName === "run") values.debug = false;
-		
-		await registry.execute(commandName, config, values, positionals);
-	}
+            // Envia notificação para comandos longos
+            if (duration > 5 && commandName !== "logs" && commandName !== "history") {
+                const { NotificationService } = await import("./services/NotificationService");
+                if (success) {
+                    if (commandName === "build" || commandName === "deploy") {
+                        NotificationService.buildSuccess(duration);
+                    } else if (commandName === "start") {
+                        NotificationService.deployComplete(config.project.appName);
+                    }
+                } else {
+                    NotificationService.buildFailed(`Comando ${commandName} falhou`);
+                }
+            }
+        }
+    }
 }
 
+// Entry point com tratamento global de erros
 main().catch(async (error) => {
-	console.error(error);
-	await ProcessManager.getInstance().shutdown(1);
+    // Erro não tratado - possível bug
+    console.error("Erro fatal não tratado:", error);
+    await ProcessManager.getInstance().shutdown(1);
 });

package/src/services/AuditService.ts

@@ -1,7 +1,8 @@
 import fs from "fs";
 import path from "path";
-import type { TomcatConfig } from "../types/config";
+import type { TomcatConfig } from "../types";
 import { Logger } from "../utils/ui";
+import { AuditError } from "../errors/XavvaError";
 
 export interface Vulnerability {
     id: string;
@@ -125,7 +126,7 @@ export class AuditService {
 
             return { groupId, artifactId, version };
         } catch (e) {
-            return {};
+            throw new AuditError(`Falha ao extrair informações do JAR: ${(e as Error).message}`);
         }
     }
 

package/src/services/BrowserService.ts

@@ -2,30 +2,83 @@ import { Logger } from "../utils/ui";
 import { isWindows, getOpenBrowserArgs } from "../utils/platform";
 
 export class BrowserService {
+    private static debugPort = 9222;
+
     /**
-     * Recarrega a aba ativa do browser (Chrome ou Edge).
-     * Nota: No Linux/Mac, esta funcionalidade é limitada devido às restrições
-     * de automação de GUI. Recomenda-se usar extensões de Live Reload.
+     * Recarrega a aba do browser que corresponde à URL da aplicação.
+     * Usa o Chrome DevTools Protocol (CDP) para encontrar e recarregar a aba correta.
+     * Nota: No Linux/Mac, esta funcionalidade é limitada.
      */
     public static async reload(url: string) {
         // Pequeno delay para garantir que o Tomcat processou o novo contexto
         await new Promise(r => setTimeout(r, 800));
 
         if (!isWindows()) {
-            // No Linux/Mac, tenta notificar via Browser Sync ou similar se disponível
-            // Por enquanto, apenas loga (o usuário pode usar extensões de Live Reload)
             return;
         }
 
+        // Usar heredoc para evitar problemas de escaping
         const psCommand = `
-            $shell = New-Object -ComObject WScript.Shell
-            $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
-            if ($process) {
-                $shell.AppActivate($process.Id)
-                Sleep -m 100
-                $shell.SendKeys("{F5}")
-            }
-        `;
+$ErrorActionPreference = 'SilentlyContinue'
+$debugPort = ${this.debugPort}
+
+function Reload-TabByUrl {
+    param($targetUrl, $port)
+    
+    try {
+        $pages = Invoke-RestMethod -Uri "http://localhost:$port/json/list" -TimeoutSec 2
+        $targetUri = [System.Uri]$targetUrl
+        $targetPath = $targetUri.AbsolutePath.TrimEnd('/')
+        
+        foreach ($page in $pages) {
+            if ($page.type -ne "page") { continue }
+            
+            try {
+                $pageUri = [System.Uri]$page.url
+                if ($pageUri.Host -eq $targetUri.Host -and 
+                    $pageUri.AbsolutePath.TrimEnd('/') -eq $targetPath) {
+                    
+                    $body = @{ id = 1; method = "Page.reload"; params = @{ ignoreCache = $false } } | ConvertTo-Json -Compress
+                    Invoke-RestMethod -Uri "http://localhost:$port/json/reload/$($page.id)" -Method Put -Body $body -ContentType "application/json" -TimeoutSec 2 | Out-Null
+                    return $true
+                }
+            } catch { continue }
+        }
+    } catch { }
+    return $false
+}
+
+$reloaded = Reload-TabByUrl -targetUrl "${url}" -port $debugPort
+
+if (-not $reloaded) {
+    $shell = New-Object -ComObject WScript.Shell
+    $urlObj = [System.Uri]"${url}"
+    $context = $urlObj.AbsolutePath.Trim('/').Split('/')[0]
+    
+    $processes = Get-Process | Where-Object { 
+        ($_.Name -eq "chrome" -or $_.Name -eq "msedge") -and 
+        $_.MainWindowTitle -and
+        ($_.MainWindowTitle -match $context -or $_.MainWindowTitle -match "localhost")
+    }
+    
+    if ($processes) {
+        $targetProcess = $processes | Select-Object -First 1
+        $shell.AppActivate($targetProcess.Id)
+        Start-Sleep -Milliseconds 100
+        $shell.SendKeys("{F5}")
+    } else {
+        $anyBrowser = Get-Process | Where-Object { 
+            $_.Name -eq "chrome" -or $_.Name -eq "msedge" 
+        } | Select-Object -First 1
+        
+        if ($anyBrowser) {
+            $shell.AppActivate($anyBrowser.Id)
+            Start-Sleep -Milliseconds 100
+            $shell.SendKeys("{F5}")
+        }
+    }
+}
+`;
         
         try {
             Bun.spawn(["powershell", "-command", psCommand]);
@@ -35,10 +88,68 @@ export class BrowserService {
     }
 
     /**
-     * Abre a URL no browser padrão do sistema.
+     * Abre a URL no browser com remote debugging habilitado (se possível).
+     * Isso permite recarregar a aba específica posteriormente via CDP.
      */
     public static open(url: string) {
-        const args = getOpenBrowserArgs(url);
-        Bun.spawn(args);
+        if (!isWindows()) {
+            const args = getOpenBrowserArgs(url);
+            Bun.spawn(args);
+            return;
+        }
+
+        const psCommand = `
+$ErrorActionPreference = 'SilentlyContinue'
+$debugPort = ${this.debugPort}
+$targetUrl = "${url}"
+
+$debuggingEnabled = $false
+try {
+    $resp = Invoke-RestMethod -Uri "http://localhost:$debugPort/json/version" -TimeoutSec 1
+    $debuggingEnabled = $true
+} catch { }
+
+# Encontra o executável do Chrome ou Edge
+$browserExe = $null
+$chromePaths = @(
+    ("$env:ProgramFiles" + "\\Google\\Chrome\\Application\\chrome.exe"),
+    ("$env:LOCALAPPDATA" + "\\Google\\Chrome\\Application\\chrome.exe")
+)
+$edgePaths = @(
+    ("$env:ProgramFiles" + "\\Microsoft\\Edge\\Application\\msedge.exe")
+)
+
+foreach ($path in $chromePaths) {
+    if (Test-Path $path) { $browserExe = $path; break }
+}
+if (-not $browserExe) {
+    foreach ($path in $edgePaths) {
+        if (Test-Path $path) { $browserExe = $path; break }
+    }
+}
+
+if ($browserExe) {
+    if ($debuggingEnabled) {
+        try {
+            $body = @{ url = $targetUrl } | ConvertTo-Json -Compress
+            Invoke-RestMethod -Uri "http://localhost:$debugPort/json/new" -Method Put -Body $body -ContentType "application/json" -TimeoutSec 3 | Out-Null
+        } catch {
+            Start-Process $browserExe -ArgumentList $targetUrl
+        }
+    } else {
+        Start-Process $browserExe -ArgumentList $targetUrl, "--remote-debugging-port=$debugPort", "--no-first-run"
+    }
+} else {
+    Start-Process $targetUrl
+}
+`;
+        
+        try {
+            Bun.spawn(["powershell", "-command", psCommand]);
+        } catch (e) {
+            // Fallback para método padrão
+            const args = getOpenBrowserArgs(url);
+            Bun.spawn(args);
+        }
     }
 }

package/src/services/DeployWatcher.ts

@@ -0,0 +1,183 @@
+/**
+ * DeployWatcher - Específico para watch de deploy
+ * Usa FileWatcher genérico e adiciona lógica de deploy
+ */
+
+import { FileWatcher, type FileChangeEvent } from "./FileWatcher";
+import { DeployCommand } from "../commands/DeployCommand";
+import { Logger } from "../utils/ui";
+import type { AppConfig } from "../types/config";
+import { WATCHER_DEBOUNCE_MS, WATCHER_COOLING_MS } from "../utils/constants";
+
+export class DeployWatcher {
+    private fileWatcher: FileWatcher;
+    private isDeploying = false;
+    private pendingFullBuild = false;
+    private modifiedFiles = new Set<string>();
+    private pendingFiles = new Set<string>();
+    private hasPendingChanges = false;
+
+    constructor(
+        private config: AppConfig,
+        private deployCmd: DeployCommand
+    ) {
+        this.fileWatcher = new FileWatcher({
+            recursive: true,
+            debounceMs: WATCHER_DEBOUNCE_MS,
+            coolingMs: WATCHER_COOLING_MS,
+        });
+    }
+
+    /**
+     * Inicia o watch de deploy
+     */
+    async start(): Promise<void> {
+        // Executa deploy inicial
+        await this.run(false);
+
+        // Configura handlers
+        this.setupHandlers();
+
+        // Inicia o watcher
+        this.fileWatcher.start();
+
+        Logger.info("DeployWatcher", "Monitorando alterações...");
+    }
+
+    /**
+     * Para o watching
+     */
+    stop(): void {
+        this.fileWatcher.stop();
+    }
+
+    /**
+     * Configura handlers para diferentes tipos de arquivos
+     */
+    private setupHandlers(): void {
+        // Handler para configurações de build
+        this.fileWatcher.on(/(pom\.xml|build\.gradle|build\.gradle\.kts)$/, (event) => {
+            this.handleBuildConfigChange(event);
+        });
+
+        // Handler para arquivos Java
+        this.fileWatcher.on(/\.java$/, (event) => {
+            this.handleJavaChange(event);
+        });
+
+        // Handler para recursos estáticos (JSP, HTML, CSS, etc)
+        this.fileWatcher.on(/\.(jsp|html|css|js|xml|properties)$/, (event) => {
+            this.handleResourceChange(event);
+        });
+    }
+
+    /**
+     * Trata mudança em arquivo de configuração de build
+     */
+    private async handleBuildConfigChange(event: FileChangeEvent): Promise<void> {
+        if (!event.filename) return;
+
+        Logger.watcher(`Build configuration changed: ${event.filename}`, 'warn');
+        
+        // Limpa cache quando config muda
+        const { BuildCacheService } = await import("./BuildCacheService");
+        new BuildCacheService().clearCache();
+        
+        this.pendingFullBuild = true;
+    }
+
+    /**
+     * Trata mudança em arquivo Java
+     */
+    private handleJavaChange(event: FileChangeEvent): void {
+        if (!event.filename || this.isDeploying) {
+            if (event.filename) {
+                this.pendingFiles.add(event.filename);
+                this.hasPendingChanges = true;
+            }
+            return;
+        }
+
+        Logger.watcher(event.filename, 'watch');
+        this.modifiedFiles.add(event.filename);
+
+        // Debounce para acumular múltiplas mudanças
+        this.scheduleDeploy();
+    }
+
+    /**
+     * Trata mudança em recurso estático
+     */
+    private async handleResourceChange(event: FileChangeEvent): Promise<void> {
+        if (!event.filename) return;
+
+        Logger.watcher(event.filename, 'resource');
+        
+        try {
+            await this.deployCmd.syncResource(this.config, event.filename);
+        } catch (error) {
+            Logger.error(`Falha ao sincronizar recurso: ${event.filename}`);
+        }
+    }
+
+    /**
+     * Agenda deploy após debounce
+     */
+    private scheduleDeploy(): void {
+        // O debounce já é feito pelo FileWatcher
+        // Aqui apenas executamos o deploy
+        const filesToCompile = [...this.modifiedFiles];
+        this.modifiedFiles.clear();
+        
+        this.run(this.pendingFullBuild ? false : true, filesToCompile);
+        this.pendingFullBuild = false;
+    }
+
+    /**
+     * Executa o deploy
+     */
+    private async run(incremental = false, changedFiles?: string[]): Promise<void> {
+        if (this.isDeploying) return;
+        
+        this.isDeploying = true;
+        
+        try {
+            await this.deployCmd.execute(this.config, {
+                watch: true,
+                incremental,
+                changedFiles,
+            });
+        } catch (error) {
+            // Erro já é tratado pelo comando
+        } finally {
+            this.isDeploying = false;
+            
+            // Processa mudanças pendentes
+            if (this.hasPendingChanges) {
+                const pending = [...this.pendingFiles];
+                this.pendingFiles.clear();
+                this.hasPendingChanges = false;
+                
+                Logger.watcher(`Processing ${pending.length} pending change(s)...`, 'warn');
+                
+                setTimeout(() => {
+                    this.run(true, pending);
+                }, 100);
+            }
+        }
+    }
+
+    /**
+     * Verifica se é arquivo de recurso (não Java)
+     */
+    static isResourceFile(filename: string): boolean {
+        return /\.(jsp|html|css|js|xml|properties)$/.test(filename);
+    }
+
+    /**
+     * Verifica se é arquivo de configuração de build
+     */
+    static isBuildConfig(filename: string): boolean {
+        return /^(pom\.xml|build\.gradle|build\.gradle\.kts)$/.test(filename);
+    }
+}