@archznn/xavva 2.4.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.4.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/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/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 });
 		

package/src/services/WatcherService.ts

@@ -9,6 +9,11 @@ export class WatcherService {
     private pendingFullBuild = false;
     private coolingFiles = new Set<string>();
     private debounceTimer?: Timer;
+    
+    // Rastreamento de arquivos modificados para build incremental inteligente
+    private modifiedFiles = new Set<string>();
+    private pendingFiles = new Set<string>(); // Arquivos modificados durante compilação
+    private hasPendingChanges = false;
 
     constructor(private config: AppConfig, private deployCmd: DeployCommand) {}
 
@@ -43,24 +48,57 @@ export class WatcherService {
             if (!isJava) return;
 
             Logger.watcher(filename, 'watch');
+            
+            // Se estiver compilando, acumula na fila de pendentes
+            if (this.isDeploying) {
+                this.pendingFiles.add(filename);
+                this.hasPendingChanges = true;
+                return;
+            }
+            
+            // Acumula arquivos modificados para o próximo build
+            this.modifiedFiles.add(filename);
+            
             clearTimeout(this.debounceTimer);
             
             this.debounceTimer = setTimeout(() => {
-                this.run(this.pendingFullBuild ? false : true);
+                const filesToCompile = [...this.modifiedFiles];
+                this.modifiedFiles.clear();
+                this.run(this.pendingFullBuild ? false : true, filesToCompile);
                 this.pendingFullBuild = false;
             }, WATCHER_DEBOUNCE_MS);
         });
     }
 
-    private async run(incremental = false) {
+    private async run(incremental = false, changedFiles?: string[]) {
         if (this.isDeploying) return;
         this.isDeploying = true;
+        
         try {
-            await this.deployCmd.execute(this.config, { watch: true, incremental });
+            // Passa os arquivos específicos que foram modificados
+            await this.deployCmd.execute(this.config, { 
+                watch: true, 
+                incremental,
+                changedFiles 
+            });
         } catch (e) {
             // Error handled by command
         } finally {
             this.isDeploying = false;
+            
+            // Se houve mudanças durante a compilação, processa imediatamente
+            if (this.hasPendingChanges) {
+                const pending = [...this.pendingFiles];
+                this.pendingFiles.clear();
+                this.hasPendingChanges = false;
+                
+                Logger.watcher(`Processing ${pending.length} pending change(s)...`, 'warn');
+                
+                // Pequeno delay para garantir que os arquivos foram salvos completamente
+                setTimeout(() => {
+                    this.run(true, pending);
+                }, 100);
+            }
         }
     }
 

package/src/types/config.ts

@@ -61,6 +61,7 @@ export interface CLIArguments {
     yes?: boolean;
     war?: boolean;
     cache?: boolean;
+    changedFiles?: string[];
 }
 
 export interface CommandContext {

package/src/utils/constants.ts

@@ -10,8 +10,8 @@ export const DEFAULT_DEBUG_PORT = 5005;
 
 // Timeouts (em milissegundos)
 export const TIMEOUT_SHUTDOWN_MS = 5000;
-export const WATCHER_DEBOUNCE_MS = 1000;
-export const WATCHER_COOLING_MS = 500;
+export const WATCHER_DEBOUNCE_MS = 1500;
+export const WATCHER_COOLING_MS = 1000;
 export const BROWSER_OPEN_DELAY_MS = 800;
 export const DEPLOY_HEALTH_CHECK_DELAY_MS = 1500;
 export const HOTSWAP_DELAY_MS = 500;