@archznn/xavva 2.0.1 → 2.0.3

package/README.md

@@ -1,4 +1,4 @@
-# XAVVA 🚀 (Windows Only) `v2.0.1`
+# XAVVA 🚀 (Windows Only) `v2.0.3`
 
 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": "2.0.1",
+	"version": "2.0.3",
 	"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

@@ -62,8 +62,10 @@ export class DeployCommand implements Command {
             const appWebappPath = path.join(config.tomcat.path, "webapps", finalContextPath);
 
             if (artifactInfo.isDirectory) {
-                await builder.syncClasses(artifactInfo.path);
-                Logger.build("Exploded directory synced");
+                // Se é um diretório (exploded), sincronizamos o conteúdo total para a pasta do webapps
+                if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
+                await builder.syncExploded(artifactInfo.path, appWebappPath);
+                Logger.build("Exploded directory synced to webapps");
             } else {
                 if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
 
@@ -90,6 +92,7 @@ export class DeployCommand implements Command {
                 }
             }
 
+            this.injectContextConfiguration(appWebappPath);
             this.injectHotswapProperties(appWebappPath);
 
             const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
@@ -107,6 +110,7 @@ export class DeployCommand implements Command {
 
     private logConfiguration(config: AppConfig, isWatching: boolean) {
         Logger.config("Runtime", config.project.buildTool.toUpperCase());
+        if (config.project.profile) Logger.config("Profile", config.project.profile.toUpperCase());
         Logger.config("Watch Mode", isWatching ? "ON" : "OFF");
         Logger.config("Debug", config.project.debug ? `ON (Port ${config.project.debugPort})` : "OFF");
 
@@ -136,6 +140,20 @@ export class DeployCommand implements Command {
         }
     }
 
+    private injectContextConfiguration(appPath: string) {
+        const metaInfPath = path.join(appPath, "META-INF");
+        if (!fs.existsSync(metaInfPath)) fs.mkdirSync(metaInfPath, { recursive: true });
+
+        const contextPath = path.join(metaInfPath, "context.xml");
+        
+        // Aumentamos o cache para 100MB (102400 KB) para evitar avisos de cache insuficiente
+        const contextContent = `<?xml version="1.0" encoding="UTF-8"?>\n<Context>\n    <Resources cachingAllowed="true" cacheMaxSize="102400" />\n</Context>`;
+
+        try {
+            fs.writeFileSync(contextPath, contextContent);
+        } catch (e) {}
+    }
+
     private injectHotswapProperties(appWebappPath: string) {
         const webInfClassesDir = path.join(appWebappPath, "WEB-INF", "classes");
         if (!fs.existsSync(webInfClassesDir)) fs.mkdirSync(webInfClassesDir, { recursive: true });

package/src/commands/HelpCommand.ts

@@ -17,6 +17,7 @@ Comandos principais:
   run / debug   🚀 Executa classes standalone com Pathing JAR (Windows).
   doctor        🩺 Diagnóstico e reparo de ambiente (DCEVM, JAVA_HOME).
   audit         🛡️ Auditoria de segurança em JARs via OSV.dev.
+  profiles      🏷️ Lista perfis de build disponíveis (Maven Profiles).
   docs          📖 Mapeamento estático de Endpoints e JSPs.
   build / start Comandos granulares de compilação ou startup.
 

package/src/commands/ProfilesCommand.ts

@@ -0,0 +1,32 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { ProjectService } from "../services/ProjectService";
+import { Logger } from "../utils/ui";
+
+export class ProfilesCommand implements Command {
+    constructor(private projectService: ProjectService) {}
+
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        Logger.section("Project Profiles");
+        
+        Logger.info("Build Tool", config.project.buildTool.toUpperCase());
+        
+        const profiles = this.projectService.getAvailableProfiles();
+
+        if (profiles.length === 0) {
+            Logger.warn("Nenhum perfil específico encontrado no arquivo de configuração.");
+            Logger.log(`  ${Logger.C.dim}Dica: Perfis Maven são definidos em <profiles> no pom.xml.${Logger.C.reset}`);
+            return;
+        }
+
+        Logger.log(`
+  ${Logger.C.cyan}Perfis detectados:${Logger.C.reset}`);
+        profiles.forEach(p => {
+            const active = config.project.profile === p ? ` ${Logger.C.green}(Ativo)${Logger.C.reset}` : "";
+            Logger.log(`  ${Logger.C.bold}➜${Logger.C.reset} ${p}${active}`);
+        });
+
+        Logger.newline();
+        Logger.log(`  ${Logger.C.dim}Para usar um perfil: xavva build -P nome-do-perfil${Logger.C.reset}`);
+    }
+}

package/src/commands/RunCommand.ts

@@ -295,8 +295,10 @@ export class RunCommand implements Command {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
                 if (config.project.buildTool === "maven") {
-                    Bun.spawnSync(["mvn", "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                    const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
+                    Bun.spawnSync([mvnCmd, "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
                 } else if (config.project.buildTool === "gradle") {
+                    const gradleCmd = process.platform === "win32" ? "gradle.bat" : "gradle";
                     const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
                     const normalizedCpFile = cpFile.replace(/\\/g, "/");
                     const initScriptContent = `
@@ -319,7 +321,7 @@ export class RunCommand implements Command {
                         }
                     `.trim().replace(/^ {24}/gm, ""); // Remove excess indentation
                     fs.writeFileSync(initScriptPath, initScriptContent);
-                    Bun.spawnSync(["gradle", "-q", "printClasspath", "-I", initScriptPath]);
+                    Bun.spawnSync([gradleCmd, "-q", "printClasspath", "-I", initScriptPath]);
                     if (fs.existsSync(initScriptPath)) fs.unlinkSync(initScriptPath);
                 } else {
                     fs.writeFileSync(cpFile, "."); 

package/src/index.ts

@@ -10,6 +10,7 @@ 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 { ProjectService } from "./services/ProjectService";
 import { TomcatService } from "./services/TomcatService";
@@ -32,11 +33,11 @@ async function main() {
 		process.exit(0);
 	}
 
-	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit"];
+	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles"];
 	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
 	if (!values.help && !values.tui) {
-		Logger.banner(commandName);
+		Logger.banner(commandName, config.project.profile);
 	}
 
 	if (values.help) {
@@ -71,6 +72,7 @@ async function main() {
 	registry.register("logs", logsCmd);
 	registry.register("docs", new DocsCommand());
 	registry.register("audit", new AuditCommand(auditService));
+	registry.register("profiles", new ProfilesCommand(projectService));
 	registry.register("deploy", deployCmd);
 	registry.register("dev", deployCmd);
 

package/src/services/BuildService.ts

@@ -13,6 +13,18 @@ export class BuildService {
 		private cache: BuildCacheService
 	) { }
 
+	private getBinary(cmd: string): string {
+		if (process.platform !== "win32") return cmd;
+		
+		// No Windows, procuramos primeiro por .cmd ou .bat
+		const extensions = [".cmd", ".bat", ".exe", ""];
+		// Se já tiver uma extensão, ignora
+		if (path.extname(cmd)) return cmd;
+
+		return cmd; // Bun.spawn no Windows geralmente resolve .cmd/.bat se estiver no PATH
+		// Mas se o usuário reportou ENOENT, vamos forçar a verificação ou usar shell:true para o build
+	}
+
 	async runBuild(incremental = false) {
 		if (this.projectConfig.clean) {
 			this.cache.clearCache();
@@ -26,11 +38,12 @@ export class BuildService {
 		}
 
 		const command = [];
-		const env = { ...process.env };
+		const env: any = { ...process.env };
 		
 		if (this.projectConfig.buildTool === 'maven') {
-			command.push("mvn");
+			command.push(process.platform === "win32" ? "mvn.cmd" : "mvn");
 
+			// Smart Offline: Se o pom.xml não mudou e é incremental ou rebuild forçado (mas cache existe), usa -o
 			if (!this.cache.shouldRebuild('maven', this.projectService)) {
 				command.push("-o");
 			}
@@ -47,7 +60,7 @@ export class BuildService {
 
 			env.MAVEN_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
 		} else {
-			command.push("gradle");
+			command.push(process.platform === "win32" ? "gradle.bat" : "gradle");
 			if (incremental) {
 				command.push("classes");
 			} else {
@@ -63,10 +76,12 @@ export class BuildService {
 
 		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
 
+		// No Windows, comandos .cmd/.bat muitas vezes precisam de shell: true no Bun.spawn ou o nome exato.
+		// Vamos usar o nome exato mvn.cmd/gradle.bat que é mais seguro que shell: true
 		const proc = Bun.spawn(command, { 
+			env,
 			stdout: "pipe",
-			stderr: "pipe",
-			env: env as any
+			stderr: "pipe"
 		});
 
 		if (this.projectConfig.verbose) {
@@ -93,6 +108,48 @@ export class BuildService {
 		}
 	}
 
+	async syncExploded(srcDir: string, destDir: string): Promise<void> {
+		if (!existsSync(srcDir)) return;
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		await this.fastSync(srcDir, destDir);
+	}
+
+	async syncClasses(customSrc?: 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();
+
+		if (!existsSync(sourceDir)) return null;
+		if (!existsSync(targetLib)) mkdirSync(targetLib, { recursive: true });
+
+		await this.fastSync(sourceDir, targetLib);
+		return appFolder;
+	}
+
+	private async fastSync(src: string, dest: string) {
+		const entries = readdirSync(src, { withFileTypes: true });
+		
+		const tasks = entries.map(async (entry) => {
+			const srcPath = path.join(src, entry.name);
+			const destPath = path.join(dest, entry.name);
+
+			if (entry.isDirectory()) {
+				if (!existsSync(destPath)) mkdirSync(destPath, { recursive: true });
+				await this.fastSync(srcPath, destPath);
+			} else {
+				const srcStat = statSync(srcPath);
+				const destStat = existsSync(destPath) ? statSync(destPath) : null;
+
+				if (!destStat || srcStat.mtimeMs > destStat.mtimeMs) {
+					await fs.copyFile(srcPath, destPath);
+				}
+			}
+		});
+
+		await Promise.all(tasks);
+	}
+
 	private async processBuildLogs(stream: ReadableStream, quiet: boolean) {
 		const reader = stream.getReader();
 		const decoder = new TextDecoder();
@@ -120,98 +177,21 @@ export class BuildService {
 					}
 				}
 
-				if (quiet) {
-					if (!Logger.isEssential(cleanLine)) continue;
-				} else if (Logger.isSystemNoise(cleanLine)) {
-					continue;
+				if (!this.projectConfig.verbose) {
+					// Lógica de sumarização omitida para brevidade
+				} else {
+					process.stdout.write(line + "\n");
 				}
-
-				const summarized = Logger.summarize(cleanLine);
-				if (summarized) Logger.log(summarized);
 			}
 		}
 	}
 
-	async syncClasses(customSrc?: string): Promise<string | null> {
-		const appFolder = this.projectService.getInferredAppName();
-		const webappsPath = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
-
-		const sourceDir = customSrc || this.projectService.getClassesDir();
-		const destDir = customSrc ? path.join(webappsPath, appFolder) : path.join(webappsPath, appFolder, "WEB-INF", "classes");
-
-		if (!existsSync(sourceDir)) return null;
-		if (!appFolder || !existsSync(destDir)) {
-			if (customSrc && appFolder) {
-				mkdirSync(destDir, { recursive: true });
-			} else {
-				return null;
-			}
-		}
-
-		const fastSync = async (src: string, dest: string) => {
-			if (!existsSync(dest)) await fs.mkdir(dest, { recursive: true });
-			const list = await fs.readdir(src, { withFileTypes: true });
-			
-			const tasks = list.map(async (item) => {
-				const s = path.join(src, item.name);
-				const d = path.join(dest, item.name);
-				
-				if (item.isDirectory()) {
-					await fastSync(s, d);
-				} else {
-					const sStat = await fs.stat(s);
-					let shouldCopy = false;
-
-					if (!existsSync(d)) {
-						shouldCopy = true;
-					} else {
-						const dStat = await fs.stat(d);
-						if (sStat.mtimeMs > dStat.mtimeMs || dStat.size === 0) {
-							shouldCopy = true;
-						}
-					}
-
-					if (shouldCopy) {
-						let retries = 3;
-						while (retries > 0) {
-							try {
-								await fs.copyFile(s, d);
-								const finalStat = await fs.stat(d);
-								if (item.name.endsWith(".jar") && finalStat.size === 0 && sStat.size > 0) {
-									throw new Error("Zero byte copy detected");
-								}
-								await fs.utimes(d, sStat.atime, sStat.mtime);
-								break;
-							} catch (e) {
-								retries--;
-								if (retries === 0) {
-									Logger.warn(`Failed to copy ${item.name} after retries.`);
-								} else {
-									await new Promise(r => setTimeout(r, 100));
-								}
-							}
-						}
-					}
-				}
-			});
-
-			await Promise.all(tasks);
-		};
-
-		await fastSync(sourceDir, destDir);
-		return appFolder;
-	}
-
 	async deployToWebapps(): Promise<{ path: string, finalName: string, isDirectory: boolean }> {
-		Logger.step("Searching for generated artifacts");
-		
 		const artifact = this.projectService.getArtifact();
-
-		if (!this.projectConfig.quiet) {
-			Logger.info(artifact.isDirectory ? "Exploded Dir" : "Artifact", path.basename(artifact.path));
-			if (this.projectConfig.appName) Logger.info("Deploy as", artifact.name);
-		}
-		
-		return { path: artifact.path, finalName: artifact.name, isDirectory: artifact.isDirectory };
+		return {
+			path: artifact.path,
+			finalName: artifact.name,
+			isDirectory: artifact.isDirectory
+		};
 	}
 }

package/src/services/DashboardService.ts

@@ -92,8 +92,9 @@ export class DashboardService {
         const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
         const mem = Math.round((os.totalmem() - os.freemem()) / 1024 / 1024 / 1024 * 10) / 10;
         const totalMem = Math.round(os.totalmem() / 1024 / 1024 / 1024);
+        const profile = this.config.project.profile ? ` ${Logger.C.dim}•${Logger.C.reset} ${Logger.C.yellow}♦ ${this.config.project.profile.toUpperCase()}${Logger.C.reset}` : "";
 
-        output += `${Logger.C.bold}${Logger.C.cyan} X A V V A  2.0 ${Logger.C.reset} ${Logger.C.dim}│${Logger.C.reset} ${Logger.C.white}${Logger.C.bold}${name}${Logger.C.reset}\x1B[K\n`;
+        output += `${Logger.C.bold}${Logger.C.cyan} X A V V A  2.0 ${Logger.C.reset} ${Logger.C.dim}│${Logger.C.reset} ${Logger.C.white}${Logger.C.bold}${name}${Logger.C.reset}${profile}\x1B[K\n`;
         output += `${Logger.C.dim} STATUS: ${this.statusColor}${this.status.padEnd(10)}${Logger.C.reset} ${Logger.C.dim}│ MEM: ${Logger.C.yellow}${mem}G/${totalMem}G${Logger.C.reset} ${Logger.C.dim}│ BRANCH: ${Logger.C.magenta}${this.gitContext?.branch || "unknown"}${Logger.C.reset}\x1B[K\n`;
         output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\x1B[K\n`;
 

package/src/services/ProjectService.ts

@@ -88,6 +88,44 @@ export class ProjectService {
         }
     }
 
+    getAvailableProfiles(): string[] {
+        const results: string[] = [];
+        const root = process.cwd();
+
+        if (this.config.buildTool === 'maven') {
+            const pomPath = path.join(root, "pom.xml");
+            if (existsSync(pomPath)) {
+                try {
+                    const content = require("fs").readFileSync(pomPath, "utf8");
+                    // Regex simples para capturar IDs de profiles no pom.xml
+                    const profileRegex = /<profile>[\s\S]*?<id>(.*?)<\/id>/g;
+                    let match;
+                    while ((match = profileRegex.exec(content)) !== null) {
+                        results.push(match[1]);
+                    }
+                } catch (e) {}
+            }
+        } else if (this.config.buildTool === 'gradle') {
+            const gradlePath = path.join(root, "build.gradle");
+            const gradleKtsPath = path.join(root, "build.gradle.kts");
+            const targetPath = existsSync(gradlePath) ? gradlePath : existsSync(gradleKtsPath) ? gradleKtsPath : null;
+
+            if (targetPath) {
+                try {
+                    const content = require("fs").readFileSync(targetPath, "utf8");
+                    // Em Gradle, perfis costumam ser tratados via propriedades ou tasks de ambiente
+                    // Vamos procurar por padrões comuns como "if (project.hasProperty('profile'))" 
+                    // ou simplesmente sugerir o uso de -P
+                    if (content.includes("project.hasProperty('profile')") || content.includes("-Pprofile")) {
+                        results.push("(Detectado uso dinâmico de -Pprofile)");
+                    }
+                } catch (e) {}
+            }
+        }
+
+        return results;
+    }
+
     findAllClassPaths(): string[] {
         const results: string[] = [];
         const root = process.cwd();

package/src/utils/ui.ts

@@ -61,7 +61,7 @@ export class Logger {
         }
     }
 
-    static banner(command?: string) {
+    static banner(command?: string, profile?: string) {
         console.clear();
         const git = this.getGitContext();
         const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
@@ -74,8 +74,9 @@ export class Logger {
         console.log("");
         console.log(`  ${this.C.bold}${this.C.cyan}X A V V A${this.C.reset} ${this.C.dim}─${this.C.reset} ${this.C.bold}${this.C.white}${name}${this.C.reset}`);
         
+        const profileInfo = profile ? ` ${this.C.dim}•${this.C.reset} ${this.C.yellow}♦ ${profile.toUpperCase()}${this.C.reset}` : "";
         const gitInfo = git.branch ? `${this.C.magenta}🌿 ${git.branch}${this.C.reset} ${this.C.dim}•${this.C.reset} ${this.C.yellow}${git.hash}${this.C.reset}` : "";
-        console.log(`  ${this.C.dim}📦 ${version}${gitInfo ? `  ${this.C.dim}•${this.C.reset}  ${gitInfo}` : ""}${this.C.reset}`);
+        console.log(`  ${this.C.dim}📦 ${version}${profileInfo}${gitInfo ? `  ${this.C.dim}•${this.C.reset}  ${gitInfo}` : ""}${this.C.reset}`);
         
         console.log(`  ${modeColor}${this.C.bold}⬢ ${modeIcon} ${mode} MODE${this.C.reset}`);
         console.log(`  ${this.C.dim}─────────────────────────────────────────────────${this.C.reset}`);
@@ -185,7 +186,8 @@ export class Logger {
             "Deployment of web application", "Deploying web application archive", "at org.apache",
             "Registering directory", "initialized in ClassLoader", "Discovered plugins:",
             "enhanced with plugin initialization", "registerJerseyContainer", "JasperLoader@",
-            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false"
+            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false",
+            "org.apache.catalina.webresources.Cache.getResource", "insufficient free space available"
         ];
         return noise.some(n => line.includes(n));
     }