@archznn/xavva 2.6.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/TomcatService.ts

@@ -1,4 +1,6 @@
-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";
@@ -21,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;
@@ -136,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;
 
@@ -173,10 +176,10 @@ export class TomcatService {
 			const stats = statSync(agentPath);
 			Logger.debug(`Escrito: ${stats.size} bytes`);
 			
-			Logger.success("HotswapAgent v2.0.3 installed globally!");
+			Logger.success(`HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION} installed globally!`);
 			return agentPath;
 		} catch (e: any) {
-			Logger.warn(`Falha ao baixar HotswapAgent: ${e.message}`);
+			throw new NetworkError(url, e);
 			Logger.warn("Usando hot swap padrão da JVM.");
 			
 			// Limpa arquivo parcial se existir
@@ -331,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";

package/src/utils/PathUtils.ts

@@ -0,0 +1,221 @@
+/**
+ * Utilitários para manipulação de paths
+ * Centraliza lógica comum de normalização e resolução de caminhos
+ */
+
+import path from "path";
+
+export class PathUtils {
+    /**
+     * Normaliza separadores de path para forward slash
+     */
+    static normalizeSeparators(filePath: string): string {
+        return filePath.replace(/\\/g, "/");
+    }
+
+    /**
+     * Converte caminho relativo para absoluto a partir do cwd
+     */
+    static resolveFromCwd(relativePath: string): string {
+        return path.resolve(process.cwd(), relativePath);
+    }
+
+    /**
+     * Obtém caminho relativo a partir do diretório raiz do projeto
+     */
+    static relativeToProject(absolutePath: string): string {
+        return path.relative(process.cwd(), absolutePath);
+    }
+
+    /**
+     * Verifica se caminho está dentro do diretório src/main/java (Maven) ou equivalente
+     */
+    static isSourceFile(filePath: string): boolean {
+        const normalized = this.normalizeSeparators(filePath);
+        return /src\/(main|test)\/(java|resources)/.test(normalized);
+    }
+
+    /**
+     * Extrai package de um arquivo Java baseado no caminho
+     */
+    static extractPackageFromPath(javaFilePath: string): string | null {
+        const normalized = this.normalizeSeparators(javaFilePath);
+        
+        // Procura por src/main/java ou src/test/java
+        const match = normalized.match(/src\/(?:main|test)\/java\/(.*)\/[^/]+\.java$/);
+        if (match) {
+            return match[1].replace(/\//g, ".");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Converte caminho de .java para .class
+     */
+    static javaToClassPath(javaPath: string): string {
+        return javaPath.replace(/\.java$/i, ".class");
+    }
+
+    /**
+     * Converte caminho relativo do source para caminho no diretório de classes
+     */
+    static sourceToClassesPath(
+        sourcePath: string, 
+        classesDir: string,
+        sourceRoots: string[] = ["src/main/java", "src/test/java", "src"]
+    ): string {
+        const normalized = this.normalizeSeparators(sourcePath);
+        
+        for (const root of sourceRoots) {
+            const normalizedRoot = this.normalizeSeparators(root);
+            const index = normalized.indexOf(normalizedRoot);
+            if (index !== -1) {
+                const relativePart = normalized.slice(index + normalizedRoot.length + 1);
+                const classFile = this.javaToClassPath(relativePart);
+                return path.join(classesDir, classFile);
+            }
+        }
+        
+        // Fallback: assume que é relativo ao classesDir
+        return path.join(classesDir, path.basename(this.javaToClassPath(sourcePath)));
+    }
+
+    /**
+     * Encontra o webapp root a partir de um caminho de recurso
+     */
+    static findWebappRoot(resourcePath: string): string | null {
+        const normalized = this.normalizeSeparators(resourcePath);
+        const parts = normalized.split("/");
+        
+        const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+        
+        if (rootIndex !== -1) {
+            return parts.slice(0, rootIndex + 1).join("/");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Obtém caminho relativo dentro do webapp
+     */
+    static getWebappRelativePath(resourcePath: string): string | null {
+        const normalized = this.normalizeSeparators(resourcePath);
+        const parts = normalized.split("/");
+        
+        const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+        
+        if (rootIndex !== -1 && rootIndex < parts.length - 1) {
+            return parts.slice(rootIndex + 1).join("/");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Verifica se é arquivo de recurso web (JSP, HTML, etc)
+     */
+    static isWebResource(filePath: string): boolean {
+        return /\.(jsp|html|htm|css|js|xml|properties|json|png|jpg|jpeg|gif|svg|ico)$/i.test(filePath);
+    }
+
+    /**
+     * Verifica se é arquivo Java
+     */
+    static isJavaFile(filePath: string): boolean {
+        return /\.java$/i.test(filePath);
+    }
+
+    /**
+     * Verifica se é arquivo de build/configuração
+     */
+    static isBuildConfig(filePath: string): boolean {
+        return /(pom\.xml|build\.gradle|build\.gradle\.kts|settings\.gradle)$/i.test(filePath);
+    }
+
+    /**
+     * Combina múltiplos paths de forma segura
+     */
+    static combinePaths(...parts: string[]): string {
+        return path.join(...parts);
+    }
+
+    /**
+     * Obtém diretório do arquivo
+     */
+    static getDir(filePath: string): string {
+        return path.dirname(filePath);
+    }
+
+    /**
+     * Obtém nome do arquivo
+     */
+    static getFilename(filePath: string): string {
+        return path.basename(filePath);
+    }
+
+    /**
+     * Obtém extensão do arquivo
+     */
+    static getExtension(filePath: string): string {
+        return path.extname(filePath).toLowerCase();
+    }
+
+    /**
+     * Remove extensão do arquivo
+     */
+    static removeExtension(filePath: string): string {
+        const ext = path.extname(filePath);
+        return ext ? filePath.slice(0, -ext.length) : filePath;
+    }
+
+    /**
+     * Verifica se caminho está dentro de diretório ignorado
+     */
+    static isIgnoredPath(filePath: string, ignoredDirs: string[] = []): boolean {
+        const normalized = this.normalizeSeparators(filePath);
+        const defaultIgnored = ["target", "build", "node_modules", ".git", ".xavva"];
+        const allIgnored = [...defaultIgnored, ...ignoredDirs];
+        
+        return allIgnored.some(dir => {
+            // Match exato ou como diretório
+            const pattern = new RegExp(`(^|/)${dir}($|/)`);
+            return pattern.test(normalized);
+        });
+    }
+
+    /**
+     * Resolve caminho de contexto WAR
+     */
+    static resolveContextPath(appName: string): string {
+        return appName.replace(/\.war$/i, "");
+    }
+}
+
+// Exporta funções standalone para conveniência
+export const {
+    normalizeSeparators,
+    resolveFromCwd,
+    relativeToProject,
+    isSourceFile,
+    extractPackageFromPath,
+    javaToClassPath,
+    sourceToClassesPath,
+    findWebappRoot,
+    getWebappRelativePath,
+    isWebResource,
+    isJavaFile,
+    isBuildConfig,
+    combinePaths,
+    getDir,
+    getFilename,
+    getExtension,
+    removeExtension,
+    isIgnoredPath,
+    resolveContextPath,
+} = PathUtils;

package/src/utils/config.ts

@@ -38,6 +38,12 @@ export class ConfigManager {
                 yes: { type: "boolean", short: "y" },
                 war: { type: "boolean", short: "W" },
                 cache: { type: "boolean" },
+                from: { type: "string" },
+                to: { type: "string" },
+                backup: { type: "boolean" },
+                "dry-run": { type: "boolean" },
+                force: { type: "boolean" },
+                src: { type: "string" },
             },
             strict: false,
             allowPositionals: true,