@archznn/xavva 2.3.0 → 2.5.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
 
-[![Version](https://img.shields.io/badge/version-2.3.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.4.0-blue.svg)](https://github.com/leorsousa05/Xavva)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.
@@ -102,16 +102,25 @@ Xavva can automatically download and manage a Tomcat installation for you:
 # First time usage - auto-install Tomcat
 xavva dev --yes
 
-# Or install manually
-xavva tomcat install
+# List available versions to download
+xavva tomcat list
+
+# List already installed versions
+xavva tomcat installed
+
+# Install a specific version
+xavva tomcat install 9.0.115
+
+# Switch to a version for this project
+xavva tomcat use 9.0.115
 
 # Check Tomcat status
 xavva tomcat status
 
-# List available versions
-xavva tomcat list
+# Remove a version
+xavva tomcat uninstall 9.0.115
 
-# Use specific version
+# Or use with flags
 xavva dev --tomcat-version 9.0.115
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.3.0",
+	"version": "2.5.0",
 	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
 	"module": "src/index.ts",
 	"type": "module",

package/src/commands/Command.ts

@@ -1,5 +1,5 @@
 import type { AppConfig, CLIArguments } from "../types/config";
 
 export interface Command {
-    execute(config: AppConfig, args?: CLIArguments): Promise<void>;
+    execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void>;
 }

package/src/commands/CommandRegistry.ts

@@ -19,18 +19,18 @@ export class CommandRegistry {
         return this.commands.get(name);
     }
 
-    async execute(name: string, config: AppConfig, args: CLIArguments): Promise<void> {
+    async execute(name: string, config: AppConfig, args: CLIArguments, positionals?: string[]): Promise<void> {
         const command = this.commands.get(name);
         const processManager = ProcessManager.getInstance();
         
         if (!command) {
             Logger.error(`Comando desconhecido: ${name}`);
-            await new HelpCommand().execute(config);
+            await new HelpCommand().execute(config, args, positionals);
             await processManager.shutdown(2);
         }
 
         try {
-            await command.execute(config, args);
+            await command.execute(config, args, positionals);
         } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             Logger.error(`Erro ao executar comando '${name}': ${message}`);

package/src/commands/DeployCommand.ts

@@ -14,6 +14,7 @@ export class DeployCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
         const incremental = args?.watch && args?.incremental;
         const isWatching = !!args?.watch;
+        const changedFiles = args?.changedFiles;
         const tomcat = this.tomcat;
         const builder = this.builder;
 
@@ -46,11 +47,11 @@ export class DeployCommand implements Command {
             }
 
             if (incremental) {
-                const actualAppFolder = await builder.syncClasses(); 
+                const actualAppFolder = await builder.syncClasses(changedFiles); 
                 const actualContextPath = contextPath || actualAppFolder || "";
                 const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
                 await BrowserService.reload(actualAppUrl);
-                Logger.success("redeploy completed");
+                Logger.success(`redeploy completed (${changedFiles?.length || 'all'} file(s))`);
                 return;
             }
 
@@ -98,7 +99,7 @@ export class DeployCommand implements Command {
             const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
             
             tomcat.onReady = async () => {
-                await this.handleServerReady(config, finalAppUrl, finalContextPath, tomcat, incremental);
+                await this.handleServerReady(config, finalAppUrl, finalContextPath, tomcat, !!incremental);
             };
 
             tomcat.start(config, isWatching);

package/src/commands/HelpCommand.ts

@@ -28,7 +28,7 @@ export class HelpCommand implements Command {
     ${this.c("green", "audit")}            Security audit of JAR files
     ${this.c("green", "doctor")}           Diagnose and fix environment issues
     ${this.c("green", "profiles")}         List available Maven/Gradle profiles
-    ${this.c("green", "tomcat")}           Manage embedded Tomcat (install, list, status)
+    ${this.c("green", "tomcat")}           Manage embedded Tomcat (install, list, installed, use, status)
     ${this.c("green", "docs")}             Generate endpoint documentation
 
   ${this.c("yellow", "GENERAL OPTIONS")}
@@ -90,9 +90,12 @@ export class HelpCommand implements Command {
     xavva audit --fix
 
     ${this.c("dim", "# Manage embedded Tomcat")}
-    xavva tomcat install
+    xavva tomcat list              # List available versions
+    xavva tomcat installed         # List installed versions
+    xavva tomcat install 9.0.115   # Install specific version
+    xavva tomcat use 9.0.115       # Switch to version for this project
     xavva tomcat status
-    xavva tomcat list
+    xavva tomcat uninstall 9.0.115
 
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:

package/src/commands/TomcatCommand.ts

@@ -3,32 +3,47 @@ import type { AppConfig, CLIArguments } from "../types/config";
 import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
 import { Logger } from "../utils/ui";
 import path from "path";
+import fs from "fs";
 
 export class TomcatCommand implements Command {
-    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
-        const action = args?.["tomcat-action"] || "status";
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        // A ação vem como positional após "tomcat" (ex: xavva tomcat list)
+        const tomcatIndex = positionals?.indexOf("tomcat") ?? -1;
+        const action = positionals && tomcatIndex >= 0 && positionals[tomcatIndex + 1] 
+            ? positionals[tomcatIndex + 1] 
+            : "status";
+        
+        // Argumentos extras após a ação (ex: xavva tomcat install 9.0.115)
+        const extraArgs = positionals && tomcatIndex >= 0 ? positionals.slice(tomcatIndex + 2) : [];
         
         switch (action) {
             case "install":
-                await this.handleInstall(config, args);
+                await this.handleInstall(config, args, extraArgs);
                 break;
             case "list":
                 this.handleList();
                 break;
+            case "installed":
+                this.handleInstalled();
+                break;
+            case "use":
+                await this.handleUse(config, args, extraArgs);
+                break;
             case "uninstall":
-                await this.handleUninstall(config, args);
+                await this.handleUninstall(config, args, extraArgs);
                 break;
             case "status":
                 await this.handleStatus(config);
                 break;
             default:
                 Logger.error(`Ação desconhecida: ${action}`);
-                Logger.info("Ações disponíveis", "install, list, uninstall, status");
+                Logger.info("Ações disponíveis", "install, list, installed, use, uninstall, status");
         }
     }
 
-    private async handleInstall(config: AppConfig, args?: CLIArguments): Promise<void> {
-        const version = args?.["tomcat-version"] || config.tomcat.version || "10.1.52";
+    private async handleInstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
         
         // Detectar webapp path
         const webappPath = config.project.buildTool === "maven"
@@ -57,7 +72,7 @@ export class TomcatCommand implements Command {
     }
 
     private handleList(): void {
-        Logger.section("Versões Disponíveis");
+        Logger.section("Versões Disponíveis para Download");
         const versions = EmbeddedTomcatService.getAvailableVersions();
         
         for (const version of versions) {
@@ -66,10 +81,90 @@ export class TomcatCommand implements Command {
         
         Logger.newline();
         Logger.info("Versão padrão", "10.1.52");
+        Logger.newline();
+        Logger.info("Dica", "Use 'xavva tomcat installed' para ver versões já instaladas");
+    }
+
+    private handleInstalled(): void {
+        const installed = EmbeddedTomcatService.listInstalledVersions();
+        
+        Logger.section("Versões Instaladas");
+        
+        if (installed.length === 0) {
+            Logger.warn("Nenhuma versão instalada");
+            Logger.info("Dica", "Use 'xavva tomcat install <version>' para instalar");
+            return;
+        }
+        
+        for (const version of installed) {
+            Logger.log(`  ${Logger.C.success}✓${Logger.C.reset} ${version}`);
+        }
+        
+        Logger.newline();
+        Logger.info("Para usar uma versão", "xavva tomcat use <version>");
+    }
+
+    private async handleUse(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        const version = extraArgs[0] || args?.["tomcat-version"];
+        
+        if (!version) {
+            Logger.error("Versão não especificada");
+            Logger.info("Uso", "xavva tomcat use <version>");
+            Logger.info("Exemplo", "xavva tomcat use 9.0.115");
+            Logger.newline();
+            Logger.info("Versões instaladas", "");
+            this.handleInstalled();
+            return;
+        }
+        
+        // Verifica se a versão está instalada
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath: "."
+        });
+        
+        if (!service.checkInstallation()) {
+            Logger.warn(`Tomcat ${version} não está instalado`);
+            Logger.newline();
+            Logger.info("Opções", "");
+            Logger.log(`  ${Logger.C.primary}1.${Logger.C.reset} Instalar agora: xavva tomcat install ${version}`);
+            Logger.log(`  ${Logger.C.primary}2.${Logger.C.reset} Ver instaladas: xavva tomcat installed`);
+            return;
+        }
+        
+        // Salva a versão no xavva.json do projeto
+        await this.saveTomcatVersion(version);
+        
+        Logger.success(`Tomcat ${version} configurado para este projeto!`);
+        Logger.newline();
+        Logger.info("Próximos comandos", "");
+        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva dev    # Iniciar desenvolvimento`);
+        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva deploy # Fazer deploy`);
+    }
+
+    private async saveTomcatVersion(version: string): Promise<void> {
+        const xavvaJsonPath = path.join(process.cwd(), "xavva.json");
+        let config: any = {};
+        
+        if (fs.existsSync(xavvaJsonPath)) {
+            try {
+                config = JSON.parse(fs.readFileSync(xavvaJsonPath, "utf-8"));
+            } catch (e) {
+                // Arquivo existe mas é inválido, começa do zero
+            }
+        }
+        
+        if (!config.tomcat) config.tomcat = {};
+        config.tomcat.version = version;
+        config.tomcat.embedded = true;
+        
+        fs.writeFileSync(xavvaJsonPath, JSON.stringify(config, null, 2));
     }
 
-    private async handleUninstall(config: AppConfig, args?: CLIArguments): Promise<void> {
-        const version = args?.["tomcat-version"] || config.tomcat.version || "10.1.52";
+    private async handleUninstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
         
         const service = new EmbeddedTomcatService({
             version,

package/src/index.ts

@@ -105,7 +105,7 @@ async function main() {
 		if (commandName === "debug") values.debug = true;
 		if (commandName === "run") values.debug = false;
 		
-		await registry.execute(commandName, config, values);
+		await registry.execute(commandName, config, values, positionals);
 	}
 }
 

package/src/services/BuildService.ts

@@ -129,19 +129,121 @@ export class BuildService {
 		await this.fastSync(srcDir, destDir);
 	}
 
-	async syncClasses(customSrc?: string): Promise<string | null> {
+	async syncClasses(changedFiles?: string[]): Promise<string | null> {
 		const appFolder = this.projectService.getInferredAppName();
 		const webappPath = path.join(this.tomcatConfig.path, "webapps", appFolder);
 		const targetLib = path.join(webappPath, "WEB-INF", "classes");
-		const sourceDir = customSrc || this.projectService.getClassesDir();
+		const sourceDir = this.projectService.getClassesDir();
 
 		if (!existsSync(sourceDir)) return null;
 		if (!existsSync(targetLib)) mkdirSync(targetLib, { recursive: true });
 
-		await this.fastSync(sourceDir, targetLib);
+		// Se temos uma lista específica de arquivos modificados, sincroniza apenas eles
+		if (changedFiles && changedFiles.length > 0) {
+			await this.syncSpecificFiles(changedFiles, sourceDir, targetLib);
+		} else {
+			// Caso contrário, sincroniza tudo (comportamento padrão)
+			await this.fastSync(sourceDir, targetLib);
+		}
+		
 		return appFolder;
 	}
 
+	/**
+	 * Sincroniza apenas arquivos específicos baseado nos arquivos .java modificados.
+	 * Converte .java para .class e sincroniza apenas os arquivos realmente modificados.
+	 */
+	private async syncSpecificFiles(changedFiles: string[], sourceDir: string, targetLib: string): Promise<void> {
+		const tasks: Promise<void>[] = [];
+		const syncedCount = { value: 0 };
+		
+		for (const javaFile of changedFiles) {
+			// Converte caminho do .java para caminho do .class
+			// Ex: src/main/java/com/example/Foo.java -> target/classes/com/example/Foo.class
+			const relativePath = this.javaToClassPath(javaFile);
+			if (!relativePath) continue;
+			
+			const sourcePath = path.join(sourceDir, relativePath);
+			const targetPath = path.join(targetLib, relativePath);
+			
+			if (!existsSync(sourcePath)) {
+				// Se o .class não existe, talvez seja um arquivo excluído ou inner class
+				// Neste caso, faz sync completo como fallback
+				continue;
+			}
+			
+			tasks.push((async () => {
+				const targetDir = path.dirname(targetPath);
+				if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
+				
+				const srcStat = statSync(sourcePath);
+				const destStat = existsSync(targetPath) ? statSync(targetPath) : null;
+				
+				if (!destStat || srcStat.mtimeMs > destStat.mtimeMs) {
+					await fs.copyFile(sourcePath, targetPath);
+					syncedCount.value++;
+				}
+			})());
+		}
+		
+		await Promise.all(tasks);
+		
+		// Se não conseguimos sincronizar nenhum arquivo específico, faz sync completo
+		if (syncedCount.value === 0) {
+			await this.fastSync(sourceDir, targetLib);
+		} else if (!this.projectConfig.quiet) {
+			Logger.info("sync", `${syncedCount.value} classe(s) sincronizada(s)`);
+		}
+	}
+	
+	/**
+	 * Converte caminho de arquivo .java para caminho relativo de .class
+	 */
+	private javaToClassPath(javaFile: string): string | null {
+		// Remove prefixos comuns de diretórios source
+		const parts = javaFile.split(/[/\\]/);
+		
+		// Encontra o índice após "java" ou "src/main/java" ou "src"
+		let startIndex = -1;
+		
+		for (let i = 0; i < parts.length; i++) {
+			if (parts[i] === "java" && i > 0 && (parts[i-1] === "main" || parts[i-1] === "test")) {
+				startIndex = i + 1;
+				break;
+			}
+		}
+		
+		// Se não encontrou padrão maven, tenta achar "src"
+		if (startIndex === -1) {
+			const srcIndex = parts.indexOf("src");
+			if (srcIndex !== -1 && srcIndex < parts.length - 1) {
+				// Pula "src" e possível "main/java"
+				if (parts[srcIndex + 1] === "main" && parts[srcIndex + 2] === "java") {
+					startIndex = srcIndex + 3;
+				} else {
+					startIndex = srcIndex + 1;
+				}
+			}
+		}
+		
+		// Se ainda não encontrou, assume que o caminho já é relativo ao package
+		if (startIndex === -1) {
+			startIndex = 0;
+		}
+		
+		// Pega o caminho relativo
+		const relativeParts = parts.slice(startIndex);
+		if (relativeParts.length === 0) return null;
+		
+		// Substitui extensão .java por .class
+		const fileName = relativeParts[relativeParts.length - 1];
+		if (!fileName || !fileName.endsWith(".java")) return null;
+		
+		relativeParts[relativeParts.length - 1] = fileName.replace(".java", ".class");
+		
+		return path.join(...relativeParts);
+	}
+
 	private async fastSync(src: string, dest: string) {
 		const entries = readdirSync(src, { withFileTypes: true });