@archznn/xavva 1.6.5 → 1.8.0

package/src/commands/RunCommand.ts

@@ -1,19 +1,18 @@
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+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 {
-    constructor(private debug: boolean = true) {}
-
-    async execute(config: AppConfig): Promise<void> {
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const isDebug = args?.debug !== false; // Default to true if not specified, matching previous behavior
         let className = config.project.grep;
         
         if (!className) {
             className = await this.loadFromHistory();
             if (!className) {
-                Logger.error(`Uso: xavva ${this.debug ? "debug" : "run"} NomeDaClasse`);
+                Logger.error(`Uso: xavva ${isDebug ? "debug" : "run"} NomeDaClasse`);
                 return;
             }
         }
@@ -26,7 +25,7 @@ export class RunCommand implements Command {
 
         this.saveToHistory(className);
 
-        if (this.debug) {
+        if (isDebug) {
             Logger.section(`Interactive Debug: ${className}`);
         } else {
             Logger.section(`Running: ${className}`);
@@ -37,33 +36,34 @@ export class RunCommand implements Command {
         
         const finalCp = `${localCp};${pathingJar}`;
 
-        const args = [
+        const javaArgs = [
             "-classpath", finalCp,
         ];
 
-        if (this.debug) {
-            args.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
+        if (isDebug) {
+            javaArgs.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
         }
 
-        args.push(className);
+        javaArgs.push(className);
 
-        if (this.debug) {
+        if (isDebug) {
             Logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
-            Logger.log(`${"\x1b[36m"}Dica:${"\x1b[0m"} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.\n`);
+            Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
+            Logger.newline();
         } else {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = "java";
+        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java") : "java";
         
         return new Promise((resolve) => {
-            const child = spawn(bin, args, {
+            const child = spawn(bin, javaArgs, {
                 stdio: "inherit",
-                shell: true
+                shell: false
             });
 
             child.on("exit", () => {
-                Logger.log(`Sessão de ${this.debug ? "debug" : "execução"} encerrada.`);
+                Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
                 resolve();
             });
         });
@@ -140,7 +140,7 @@ export class RunCommand implements Command {
         });
 
         return new Promise((resolve) => {
-            readline.question(`\n  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
+            readline.question(`  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
                 readline.close();
                 const idx = parseInt(answer) - 1;
                 if (!isNaN(idx) && uniqueClasses[idx]) {
@@ -175,7 +175,7 @@ export class RunCommand implements Command {
             });
 
             return new Promise((resolve) => {
-                readline.question(`\n  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
+                readline.question(`  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
                     readline.close();
                     if (!answer.trim()) {
                         resolve(history[0]);
@@ -221,22 +221,62 @@ export class RunCommand implements Command {
         const paths = dependencyCp.split(";").filter(p => p.trim());
         const relativePaths = paths.map(p => {
             let rel = path.relative(xavvaDir, p).replace(/\\/g, "/");
-            if (fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
-            return rel;
+            if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
+            // Robust URL encoding for Class-Path as per Java Spec
+            return encodeURI(rel)
+                .replace(/#/g, '%23')
+                .replace(/\?/g, '%3F')
+                .replace(/%5B/g, '[')
+                .replace(/%5D/g, ']');
         }).join(" ");
 
-        let wrappedCp = "";
-        const maxLen = 70;
-        for (let i = 0; i < relativePaths.length; i += maxLen) {
-            const chunk = relativePaths.substring(i, i + maxLen);
-            if (i === 0) {
-                wrappedCp += chunk;
+        const header = "Class-Path: ";
+        let manifestContent = "Manifest-Version: 1.0\r\n";
+        
+        let currentLine = header;
+        const parts = relativePaths.split(" ");
+        
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i] + (i < parts.length - 1 ? " " : "");
+            
+            // Se adicionar o próximo 'part' exceder 70 bytes (margem de segurança antes do CRLF)
+            if (Buffer.from(currentLine + part).length > 70) {
+                // Se a parte em si for muito longa, precisamos quebrá-la
+                if (Buffer.from(" " + part).length > 70) {
+                    let remainingPart = part;
+                    while (remainingPart.length > 0) {
+                        const spaceLeft = 70 - Buffer.from(currentLine).length;
+                        
+                        // Encontra quantos caracteres de 'remainingPart' cabem no espaço restante
+                        let fitCount = 0;
+                        let fitBytes = 0;
+                        for (let j = 0; j < remainingPart.length; j++) {
+                            const charBytes = Buffer.from(remainingPart[j]).length;
+                            if (fitBytes + charBytes > spaceLeft) break;
+                            fitBytes += charBytes;
+                            fitCount++;
+                        }
+
+                        if (fitCount > 0) {
+                            currentLine += remainingPart.substring(0, fitCount);
+                            remainingPart = remainingPart.substring(fitCount);
+                        }
+
+                        if (remainingPart.length > 0) {
+                            manifestContent += currentLine + "\r\n";
+                            currentLine = " ";
+                        }
+                    }
+                } else {
+                    manifestContent += currentLine + "\r\n";
+                    currentLine = " " + part;
+                }
             } else {
-                wrappedCp += "\r\n " + chunk;
+                currentLine += part;
             }
         }
+        manifestContent += currentLine + "\r\n\r\n";
 
-        const manifestContent = `Manifest-Version: 1.0\r\nClass-Path: ${wrappedCp}\r\n\r\n`;
         const manifestPath = path.join(xavvaDir, "MANIFEST.MF");
         fs.writeFileSync(manifestPath, manifestContent);
 
@@ -254,22 +294,59 @@ export class RunCommand implements Command {
         if (!fs.existsSync(cpFile)) {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
-                if (config.project.buildTool === 'maven') {
+                if (config.project.buildTool === "maven") {
                     Bun.spawnSync(["mvn", "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                } else if (config.project.buildTool === "gradle") {
+                    const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
+                    const normalizedCpFile = cpFile.replace(/\\/g, "/");
+                    const initScriptContent = `
+                        allprojects {
+                            afterEvaluate { project ->
+                                if (project.plugins.hasPlugin('java')) {
+                                    tasks.register('printClasspath') {
+                                        doLast {
+                                            def cp = project.sourceSets.main.runtimeClasspath.asPath
+                                            def file = new File("${normalizedCpFile}")
+                                            if (!file.exists()) {
+                                                file.text = cp
+                                            } else {
+                                                file.text = file.text + File.pathSeparator + cp
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    `.trim().replace(/^ {24}/gm, ""); // Remove excess indentation
+                    fs.writeFileSync(initScriptPath, initScriptContent);
+                    Bun.spawnSync(["gradle", "-q", "printClasspath", "-I", initScriptPath]);
+                    if (fs.existsSync(initScriptPath)) fs.unlinkSync(initScriptPath);
                 } else {
                     fs.writeFileSync(cpFile, "."); 
                 }
-            } catch (e) {}
+            } catch (e) {
+                Logger.error(`Falha ao gerar classpath: ${e}`);
+            }
             stopSpinner();
         }
 
-        const dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
+        let dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
         
+        // Normalize platform specific separators to semicolon for consistency
+        if (path.delimiter !== ";") {
+            dependencyCp = dependencyCp.split(path.delimiter).join(";");
+        }
+
         const localFolders = [
             "target/classes",
             "target/test-classes",
             "build/classes/java/main",
             "build/classes/java/test",
+            "build/classes/kotlin/main",
+            "build/resources/main",
+            "build/resources/test",
+            "bin/main",
+            "bin/test",
             "."
         ];
         

package/src/commands/StartCommand.ts

@@ -4,8 +4,10 @@ import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 
 export class StartCommand implements Command {
+    constructor(private tomcat: TomcatService) {}
+
     async execute(config: AppConfig): Promise<void> {
-        const tomcat = new TomcatService(config.tomcat);
+        const tomcat = this.tomcat;
         
         Logger.section("Start Only");
         Logger.info("Port", config.tomcat.port);
@@ -15,7 +17,7 @@ export class StartCommand implements Command {
             Logger.step("Checking ports");
             await tomcat.killConflict();
             Logger.step("Starting Tomcat");
-            tomcat.start(config.project.cleanLogs, config.project.debug, config.project.skipScan, config.project.quiet);
+            tomcat.start(config, false);
             
             await new Promise(() => {}); 
         } catch (error: any) {

package/src/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
-import { watch } from "fs";
 import { ConfigManager } from "./utils/config";
+import { CommandRegistry } from "./commands/CommandRegistry";
 import { BuildCommand } from "./commands/BuildCommand";
 import { DeployCommand } from "./commands/DeployCommand";
 import { StartCommand } from "./commands/StartCommand";
@@ -10,17 +10,23 @@ import { RunCommand } from "./commands/RunCommand";
 import { LogsCommand } from "./commands/LogsCommand";
 import { DocsCommand } from "./commands/DocsCommand";
 import { AuditCommand } from "./commands/AuditCommand";
+
+import { ProjectService } from "./services/ProjectService";
 import { TomcatService } from "./services/TomcatService";
-import { EndpointService } from "./services/EndpointService";
+import { BuildService } from "./services/BuildService";
+import { AuditService } from "./services/AuditService";
+import { WatcherService } from "./services/WatcherService";
+import { BuildCacheService } from "./services/BuildCacheService";
+
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
-import path from "path";
+import type { AppConfig, CLIArguments } from "./types/config";
 
 async function main() {
 	const { config, positionals, values } = await ConfigManager.load();
 
 	if (values.version) {
-		console.log(`v${pkg.version}`);
+		Logger.log(`v${pkg.version}`);
 		process.exit(0);
 	}
 
@@ -32,123 +38,45 @@ async function main() {
 	}
 
 	if (values.help) {
-		new HelpCommand().execute(config);
+		new HelpCommand().execute(config, values);
 		process.exit(0);
 	}
 
-	switch (commandName) {
-		case "build":
-			await new BuildCommand().execute(config);
-			break;
-		case "start":
-			await new StartCommand().execute(config);
-			break;
-		case "doctor":
-			await new DoctorCommand().execute(config, values);
-			break;
-		case "run":
-			await new RunCommand(false).execute(config);
-			break;
-		case "debug":
-			await new RunCommand(true).execute(config);
-			break;
-		case "logs":
-			await new LogsCommand().execute(config);
-			break;
-		case "docs":
-			await new DocsCommand().execute(config);
-			break;
-		case "audit":
-			await new AuditCommand().execute(config);
-			break;
-		case "dev":
-		case "deploy":
-			await handleDeploy(config, values);
-			break;
-		default:
-			console.error(`Comando desconhecido: ${commandName}`);
-			new HelpCommand().execute(config);
-			process.exit(1);
-	}
-}
+	// 1. Instanciar Serviços (Injeção de Dependência)
+	const projectService = new ProjectService(config.project);
+	const buildCacheService = new BuildCacheService();
+	const buildService = new BuildService(config.project, config.tomcat, projectService, buildCacheService);
+	const tomcatService = new TomcatService(config.tomcat);
+	tomcatService.setProjectService(projectService);
+	const auditService = new AuditService(config.tomcat);
 
-async function handleDeploy(config: any, values: any) {
-	const tomcat = new TomcatService(config.tomcat);
-	const deployCmd = new DeployCommand(tomcat);
+	// 2. Registrar Comandos
+	const registry = new CommandRegistry();
 	
-	if (values.watch) {
-		let isDeploying = false;
-
-		const run = async (incremental = false) => {
-			if (isDeploying) return;
-			isDeploying = true;
-			try {
-				await deployCmd.execute(config, incremental, true);
-			} catch (e) {
-			} finally {
-				isDeploying = false;
-			}
-		};
-
-		await run(false);
-
-		let debounceTimer: Timer;
-		watch(process.cwd(), { recursive: true }, async (event, filename) => {
-			if (!filename) return;
-
-			const isJava = filename.endsWith(".java") || filename === "pom.xml" || filename === "build.gradle";
-			const isResource = filename.endsWith(".jsp") || filename.endsWith(".html") || 
-							   filename.endsWith(".css") || filename.endsWith(".js") || 
-							   filename.endsWith(".xml") || filename.endsWith(".properties");
-			
-			const isIgnored = filename.includes("target") || 
-							  filename.includes("build") || 
-							  filename.includes("node_modules") || 
-							  filename.split(/[/\\]/).some(part => part.startsWith("."));
-
-			if (isIgnored) return;
-
-			if (isResource && !isJava) {
-				const isJsp = filename.endsWith(".jsp");
-				let jspUrl = "";
-				let isPrivate = false;
-
-				if (isJsp) {
-					const parts = filename.split(/[/\\]/);
-					const webappIndex = parts.indexOf("webapp");
-					if (webappIndex !== -1) {
-						const relPath = parts.slice(webappIndex + 1).join("/");
-						isPrivate = relPath.startsWith("WEB-INF") || relPath.startsWith("META-INF");
-						const contextPath = (config.project.appName || "").replace(".war", "");
-						jspUrl = `http://localhost:${config.tomcat.port}${contextPath ? "/" + contextPath : ""}/${relPath}`;
-					}
-				}
-
-				if (isJsp && isPrivate) {
-					console.log(`\n  ${"\x1b[33m"}🔒${"\x1b[0m"} JSP Privado alterado (WEB-INF): ${filename}`);
-					console.log(`     ${"\x1b[90m"}Nota: Este arquivo não é acessível via URL direta.${"\x1b[0m"}`);
-				} else if (isJsp && jspUrl) {
-					console.log(`\n  ${"\x1b[32m"}📄${"\x1b[0m"} JSP Atualizado: ${"\x1b[4m"}${jspUrl}${"\x1b[0m"}`);
-				} else {
-					console.log(`\n  ${"\x1b[35m"}⚡${"\x1b[0m"} Recurso alterado: ${filename}`);
-				}
-
-				await deployCmd.syncResource(config, filename);
-				return;
-			}
-
-			if (!isJava) return;
-
-			console.log(`\n  ${"\x1b[33m"}👀${"\x1b[0m"} Alteração detectada em: ${filename}`);
-			clearTimeout(debounceTimer);
-			
-			debounceTimer = setTimeout(() => {
-				run(true);
-			}, 1000);
-		});
-
+	const deployCmd = new DeployCommand(tomcatService, buildService);
+	
+	registry.register("build", new BuildCommand(buildService));
+	registry.register("start", new StartCommand(tomcatService));
+	registry.register("doctor", new DoctorCommand());
+	registry.register("run", new RunCommand());
+	registry.register("debug", new RunCommand());
+	registry.register("logs", new LogsCommand());
+	registry.register("docs", new DocsCommand());
+	registry.register("audit", new AuditCommand(auditService));
+	registry.register("deploy", deployCmd);
+	registry.register("dev", deployCmd);
+
+	// Caso especial: Watch Mode para Deploy/Dev
+	if ((commandName === "deploy" || commandName === "dev") && values.watch) {
+		const watcher = new WatcherService(config, deployCmd);
+		await watcher.start();
 	} else {
-		await deployCmd.execute(config, false, false);
+		// 3. Executar do Registro
+		// Ajusta flags baseadas no nome do comando para comandos compartilhados
+		if (commandName === "debug") values.debug = true;
+		if (commandName === "run") values.debug = false;
+		
+		await registry.execute(commandName, config, values);
 	}
 }
 

package/src/services/AuditService.ts

@@ -34,7 +34,6 @@ export class AuditService {
 
         const stopSpinner = Logger.spinner(`Auditando ${jars.length} dependências`);
 
-        // Process in chunks to avoid overwhelming the API
         const chunkSize = 10;
         for (let i = 0; i < jars.length; i += chunkSize) {
             const chunk = jars.slice(i, i + chunkSize);
@@ -52,7 +51,6 @@ export class AuditService {
         const info = await this.extractJarInfo(jarPath);
         
         if (!info.artifactId || !info.version) {
-            // Fallback to filename parsing if pom.properties is missing
             const match = jarName.match(/(.+)-([\d\.]+.*)\.jar/);
             if (match) {
                 info.artifactId = info.artifactId || match[1];
@@ -70,12 +68,10 @@ export class AuditService {
     }
 
     private async extractJarInfo(jarPath: string): Promise<{ groupId?: string, artifactId?: string, version?: string }> {
-        // We use PowerShell to quickly peek inside the JAR for pom.properties
-        // This is faster than extracting the whole JAR
         const normalizedPath = jarPath.split(path.sep).join("/");
         const psCommand = `
             Add-Type -AssemblyName System.IO.Compression.FileSystem
-            $zip = [System.IO.Compression.ZipFile]::OpenRead("${normalizedPath}")
+            $zip = [System.IO.Compression.ZipFile]::OpenRead($env:JAR_PATH)
             $entry = $zip.Entries | Where-Object { $_.FullName -match "pom.properties$" } | Select-Object -First 1
             if ($entry) {
                 $stream = $entry.Open()
@@ -89,7 +85,12 @@ export class AuditService {
         `;
 
         try {
-            const proc = Bun.spawn(["powershell", "-command", psCommand]);
+            const proc = Bun.spawn(["powershell", "-command", psCommand], {
+                env: {
+                    ...process.env,
+                    JAR_PATH: normalizedPath
+                }
+            });
             const output = await new Response(proc.stdout).text();
             
             const groupId = output.match(/groupId=(.*)/)?.[1]?.trim();
@@ -137,7 +138,6 @@ export class AuditService {
     private extractSeverity(vuln: any): string {
         if (vuln.database_specific?.severity) return vuln.database_specific.severity;
         if (vuln.advisories?.[0]?.url?.includes("github.com/advisories")) {
-            // Try to infer from details if common keywords exist
             const d = (vuln.details || "").toLowerCase();
             if (d.includes("critical")) return "CRITICAL";
             if (d.includes("high")) return "HIGH";

package/src/services/BrowserService.ts

@@ -0,0 +1,41 @@
+import { Logger } from "../utils/ui";
+
+export class BrowserService {
+    /**
+     * Recarrega a aba ativa do browser (Chrome ou Edge) no Windows.
+     */
+    public static async reload(url: string) {
+        if (process.platform !== 'win32') return;
+        
+        // Pequeno delay para garantir que o Tomcat processou o novo contexto
+        await new Promise(r => setTimeout(r, 800));
+
+        const psCommand = `
+            $shell = New-Object -ComObject WScript.Shell
+            $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
+            if ($process) {
+                $shell.AppActivate($process.Id)
+                Sleep -m 100
+                $shell.SendKeys("{F5}")
+            }
+        `;
+        
+        try {
+            Bun.spawn(["powershell", "-command", psCommand]);
+        } catch (e) {
+            Logger.warn("Não foi possível recarregar o browser automaticamente.");
+        }
+    }
+
+    /**
+     * Abre a URL no browser padrão do sistema.
+     */
+    public static open(url: string) {
+        if (process.platform === 'win32') {
+            Bun.spawn(["cmd", "/c", "start", url]);
+        } else {
+            const start = process.platform === 'darwin' ? 'open' : 'xdg-open';
+            Bun.spawn([start, url]);
+        }
+    }
+}

package/src/services/BuildCacheService.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+export interface CacheData {
+    lastConfigHash: string;
+    lastBuildTime: number;
+}
+
+export class BuildCacheService {
+    private cacheDir: string;
+    private cacheFile: string;
+
+    constructor() {
+        this.cacheDir = path.join(process.cwd(), ".xavva");
+        this.cacheFile = path.join(this.cacheDir, "build-cache.json");
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+
+    getHash(filePath: string): string {
+        if (!fs.existsSync(filePath)) return "";
+        const content = fs.readFileSync(filePath);
+        return crypto.createHash("md5").update(content).digest("hex");
+    }
+
+    getConfigHash(tool: "maven" | "gradle"): string {
+        const file = tool === "maven" ? "pom.xml" : "build.gradle";
+        const configPath = path.join(process.cwd(), file);
+        let hash = this.getHash(configPath);
+
+        // Se for gradle, também checar build.gradle.kts e settings
+        if (tool === "gradle") {
+            const kts = path.join(process.cwd(), "build.gradle.kts");
+            const settings = path.join(process.cwd(), "settings.gradle");
+            if (fs.existsSync(kts)) hash += this.getHash(kts);
+            if (fs.existsSync(settings)) hash += this.getHash(settings);
+        }
+
+        return crypto.createHash("md5").update(hash).digest("hex");
+    }
+
+    shouldRebuild(tool: "maven" | "gradle"): boolean {
+        if (!fs.existsSync(this.cacheFile)) return true;
+
+        try {
+            const currentHash = this.getConfigHash(tool);
+            const cache: CacheData = JSON.parse(fs.readFileSync(this.cacheFile, "utf-8"));
+            
+            // 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)
+            return false;
+        } catch (e) {
+            return true;
+        }
+    }
+
+    saveCache(tool: "maven" | "gradle") {
+        const data: CacheData = {
+            lastConfigHash: this.getConfigHash(tool),
+            lastBuildTime: Date.now()
+        };
+        fs.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2));
+    }
+
+    clearCache() {
+        if (fs.existsSync(this.cacheFile)) {
+            fs.unlinkSync(this.cacheFile);
+        }
+    }
+}