@archznn/xavva 1.8.0 → 1.8.1

package/README.md

@@ -1,4 +1,4 @@
-# XAVVA 🚀 (Windows Only) `v1.8.0`
+# XAVVA 🚀 (Windows Only) `v1.8.1`
 
 Xavva é uma CLI de alto desempenho construída com **Bun** para automatizar o ciclo de desenvolvimento de aplicações Java (Maven/Gradle) rodando no Apache Tomcat. Ela foi desenhada especificamente para desenvolvedores que buscam a velocidade de ambientes modernos (como Node.js/Vite) dentro do ecossistema Java Enterprise.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "1.8.0",
+	"version": "1.8.1",
 	"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

@@ -27,16 +27,13 @@ export class DeployCommand implements Command {
             const contextPath = (config.project.appName || "").replace(".war", "");
 
             if (!incremental) {
-                tomcat.clearWebapps(contextPath);
+                await tomcat.killConflict();
+                await tomcat.clearWebapps();
 
-                const buildTask = config.project.skipBuild ? Promise.resolve() : builder.runBuild(incremental);
-                const killTask = tomcat.killConflict();
-                
                 if (!config.project.skipBuild) {
-                    Logger.watcher("Preparing environment and building in parallel", "start");
+                    Logger.watcher("Building project", "start");
+                    await builder.runBuild(incremental);
                 }
-
-                await Promise.all([buildTask, killTask]);
                 
                 if (!config.project.skipBuild) {
                     Logger.build("Full project build and environment ready");

package/src/commands/RunCommand.ts

@@ -1,7 +1,6 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { Logger } from "../utils/ui";
-import { spawn } from "child_process";
 import path from "path";
 
 export class RunCommand implements Command {
@@ -54,19 +53,20 @@ export class RunCommand implements Command {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java") : "java";
+        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java.exe") : "java";
         
-        return new Promise((resolve) => {
-            const child = spawn(bin, javaArgs, {
-                stdio: "inherit",
-                shell: false
-            });
-
-            child.on("exit", () => {
-                Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
-                resolve();
-            });
+        const proc = Bun.spawn([bin, ...javaArgs], {
+            stdout: "inherit",
+            stderr: "inherit",
+            stdin: "inherit",
+            env: {
+                ...process.env,
+                JAVA_OPTS: "-Xms256m -Xmx1024m"
+            } as any
         });
+
+        await proc.exited;
+        Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
     }
 
     private async discoverClass(simpleName: string): Promise<string | null> {

package/src/services/BuildCacheService.ts

@@ -41,7 +41,7 @@ export class BuildCacheService {
         return crypto.createHash("md5").update(hash).digest("hex");
     }
 
-    shouldRebuild(tool: "maven" | "gradle"): boolean {
+    shouldRebuild(tool: "maven" | "gradle", projectService?: any): boolean {
         if (!fs.existsSync(this.cacheFile)) return true;
 
         try {
@@ -51,8 +51,16 @@ export class BuildCacheService {
             // Se o pom/gradle mudou, precisa de rebuild completo
             if (currentHash !== cache.lastConfigHash) return true;
 
-            // Verificar se o artefato (.war) ainda existe
-            // (Esta parte será integrada ao BuildService)
+            // Verificar se o artefato (.war) ainda existe fisicamente
+            if (projectService) {
+                try {
+                    const artifact = projectService.getArtifact();
+                    if (!fs.existsSync(artifact.path)) return true;
+                } catch (e) {
+                    return true;
+                }
+            }
+
             return false;
         } catch (e) {
             return true;

package/src/services/BuildService.ts

@@ -19,16 +19,22 @@ export class BuildService {
 		}
 
 		if (!incremental && !this.projectConfig.skipBuild) {
-			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool)) {
+			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool, this.projectService)) {
 				Logger.success("Build cache hit! Skipping full build.");
 				return;
 			}
 		}
 
 		const command = [];
+		const env = { ...process.env };
 		
 		if (this.projectConfig.buildTool === 'maven') {
 			command.push("mvn");
+
+			if (!this.cache.shouldRebuild('maven', this.projectService)) {
+				command.push("-o");
+			}
+
 			if (incremental) {
 				command.push("compile");
 			} else {
@@ -38,6 +44,8 @@ export class BuildService {
 			}
 			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");
 			if (this.projectConfig.profile) command.push(`-P${this.projectConfig.profile}`);
+
+			env.MAVEN_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
 		} else {
 			command.push("gradle");
 			if (incremental) {
@@ -49,13 +57,16 @@ export class BuildService {
 			}
 			command.push("-x", "test", "-x", "javadoc");
 			if (this.projectConfig.profile) command.push(`-Pprofile=${this.projectConfig.profile}`);
+
+			env.GRADLE_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
 		}
 
 		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
 
 		const proc = Bun.spawn(command, { 
 			stdout: "pipe",
-			stderr: "pipe"
+			stderr: "pipe",
+			env: env as any
 		});
 
 		if (this.projectConfig.verbose) {

package/src/services/TomcatService.ts

@@ -42,28 +42,45 @@ export class TomcatService {
 		}
 	}
 
-	clearWebapps() {
-		const fs = require("fs");
+	async clearWebapps() {
+		const fs = require("fs").promises;
+		const { existsSync } = require("fs");
 		const path = require("path");
 		const webappsPath = path.join(this.activeConfig.path, "webapps");
 		const workPath = path.join(this.activeConfig.path, "work");
 		const tempPath = path.join(this.activeConfig.path, "temp");
 
 		try {
-			[workPath, tempPath].forEach(p => {
-				if (fs.existsSync(p)) {
-					fs.rmSync(p, { recursive: true, force: true });
-					fs.mkdirSync(p);
+			const cleanDir = async (p: string) => {
+				if (existsSync(p)) {
+					await fs.rm(p, { recursive: true, force: true });
+					
+					// Resiliência para Windows: garante que o diretório foi liberado antes do mkdir
+					let retries = 10;
+					while (retries > 0 && existsSync(p)) {
+						await new Promise(r => setTimeout(r, 50));
+						retries--;
+					}
+					
+					await fs.mkdir(p, { recursive: true });
+				}
+			};
+
+			const tasks: Promise<any>[] = [
+				cleanDir(workPath),
+				cleanDir(tempPath)
+			];
+
+			if (existsSync(webappsPath)) {
+				const files = await fs.readdir(webappsPath);
+				for (const file of files) {
+					if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
+					const fullPath = path.join(webappsPath, file);
+					tasks.push(fs.rm(fullPath, { recursive: true, force: true }));
 				}
-			});
-
-			const files = fs.readdirSync(webappsPath);
-			for (const file of files) {
-				const fullPath = path.join(webappsPath, file);
-				if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
-				
-				fs.rmSync(fullPath, { recursive: true, force: true });
 			}
+
+			await Promise.all(tasks);
 		} catch (e) {
 			Logger.warn("Não foi possível limpar totalmente a pasta webapps ou cache.");
 		}