@archznn/xavva 1.6.5

package/src/commands/HelpCommand.ts

@@ -0,0 +1,49 @@
+import type { Command } from "./Command";
+import type { AppConfig } from "../types/config";
+import pkg from "../../package.json";
+
+export class HelpCommand implements Command {
+    async execute(_config: AppConfig): Promise<void> {
+        console.log(`
+🛠️  Xavva CLI v${pkg.version}
+-------------------------------
+A Xavva automatiza o ciclo de vida de aplicações Java (Tomcat).
+Se nenhum comando for fornecido, 'deploy' será executado por padrão.
+
+Comandos principais:
+  dev           🚀 MODO COMPLETO: Deploy + Watch + Debug + Clean.
+  deploy        (Padrão) Builda o projeto, move para webapps e inicia o Tomcat.
+  start         Apenas inicia o servidor (útil quando o .war já foi gerado).
+  build         Executa apenas a compilação (mvn package ou gradle build).
+  doctor        🩺 Verifica o ambiente (Java, Tomcat, Maven, etc).
+  docs          📖 Swagger-like: Exibe endpoints e URLs de JSPs.
+  audit         🛡️ JAR Audit: Busca vulnerabilidades (CVEs) nas dependências.
+  run           🚀 Executa uma classe main (Uso: xavva run NomeDaClasse).
+  debug         🐞 Debuga uma classe main (Uso: xavva debug NomeDaClasse).
+  logs          📋 Monitora o catalina.out do Tomcat em tempo real.
+
+Opções:
+  -w, --watch   👀 Hot Reload: monitora arquivos e redeploya automaticamente.
+  -d, --debug   🐞 Habilita debug Java (JPDA) na porta 5005.
+  -c, --clean   🧹 Logs coloridos e simplificados (recomendado).
+  -q, --quiet   🤫 Mostra apenas mensagens essenciais nos logs.
+  -V, --verbose 📣 Mostra logs completos do Maven/Gradle.
+  -s, --no-build Pula o build (usa o que já estiver na pasta target/build).
+  -P, --profile Define o profile (ex: -P prod).
+  --fix         🔧 Corrige problemas automaticamente no 'doctor'.
+
+Exemplos de uso:
+  xavva dev           A melhor experiência de dev local.
+  xavva -w -c         Inicia com auto-reload e logs limpos.
+  xavva deploy -d     Builda e inicia com debugger habilitado.
+  xavva start -c      Apenas sobe o servidor com logs limpos.
+  xavva build -P dev  Apenas compila usando o profile 'dev'.
+
+Opções de Configuração:
+  -p, --path    Caminho do Tomcat (padrão via config.ts)
+  -t, --tool    Ferramenta (maven/gradle)
+  -n, --name    Nome do .war (ex: -n ROOT)
+  --port        Porta HTTP (padrão: 8080)
+        `);
+    }
+}

package/src/commands/LogsCommand.ts

@@ -0,0 +1,64 @@
+import type { Command } from "./Command";
+import type { AppConfig } from "../types/config";
+import { Logger } from "../utils/ui";
+import path from "path";
+import fs from "fs";
+
+export class LogsCommand implements Command {
+    async execute(config: AppConfig): Promise<void> {
+        const logPath = path.join(config.tomcat.path, "logs", "catalina.out");
+
+        if (!fs.existsSync(logPath)) {
+            Logger.error(`Arquivo de log não encontrado: ${logPath}`);
+            return;
+        }
+
+        Logger.section(`Monitoring Logs: ${logPath}`);
+        if (config.tomcat.grep) {
+            Logger.info("Filter", config.tomcat.grep);
+        }
+
+        const stats = fs.statSync(logPath);
+        let currentSize = stats.size;
+
+        const colorize = (line: string): string => {
+            if (line.match(/SEVERE|ERROR|Exception|Error/i)) return `\x1b[31m${line}\x1b[0m`;
+            if (line.match(/WARNING|WARN/i)) return `\x1b[33m${line}\x1b[0m`;
+            if (line.match(/INFO/i)) return `\x1b[36m${line}\x1b[0m`;
+            if (line.match(/DEBUG/i)) return `\x1b[90m${line}\x1b[0m`;
+            return line;
+        };
+
+        fs.watch(logPath, (event) => {
+            if (event === "change") {
+                const newStats = fs.statSync(logPath);
+                if (newStats.size > currentSize) {
+                    const stream = fs.createReadStream(logPath, {
+                        start: currentSize,
+                        end: newStats.size
+                    });
+
+                    stream.on("data", (chunk) => {
+                        const lines = chunk.toString().split("\n");
+                        lines.forEach(line => {
+                            if (!line.trim()) return;
+                            
+                            if (config.tomcat.grep && !line.toLowerCase().includes(config.tomcat.grep.toLowerCase())) {
+                                return;
+                            }
+
+                            process.stdout.write(colorize(line) + "\n");
+                        });
+                    });
+
+                    currentSize = newStats.size;
+                } else if (newStats.size < currentSize) {
+                    currentSize = newStats.size;
+                    Logger.warn("Arquivo de log foi resetado/rotacionado.");
+                }
+            }
+        });
+
+        return new Promise(() => {});
+    }
+}

package/src/commands/RunCommand.ts

@@ -0,0 +1,283 @@
+import type { Command } from "./Command";
+import type { AppConfig } 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> {
+        let className = config.project.grep;
+        
+        if (!className) {
+            className = await this.loadFromHistory();
+            if (!className) {
+                Logger.error(`Uso: xavva ${this.debug ? "debug" : "run"} NomeDaClasse`);
+                return;
+            }
+        }
+
+        if (!className.includes(".")) {
+            const discoveredClass = await this.discoverClass(className);
+            if (!discoveredClass) return;
+            className = discoveredClass;
+        }
+
+        this.saveToHistory(className);
+
+        if (this.debug) {
+            Logger.section(`Interactive Debug: ${className}`);
+        } else {
+            Logger.section(`Running: ${className}`);
+        }
+        
+        const { localCp, dependencyCp } = await this.getClasspath(config);
+        const pathingJar = await this.createPathingJar(dependencyCp);
+        
+        const finalCp = `${localCp};${pathingJar}`;
+
+        const args = [
+            "-classpath", finalCp,
+        ];
+
+        if (this.debug) {
+            args.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
+        }
+
+        args.push(className);
+
+        if (this.debug) {
+            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`);
+        } else {
+            Logger.warn(`🚀 Executando ${className}...`);
+        }
+
+        const bin = "java";
+        
+        return new Promise((resolve) => {
+            const child = spawn(bin, args, {
+                stdio: "inherit",
+                shell: true
+            });
+
+            child.on("exit", () => {
+                Logger.log(`Sessão de ${this.debug ? "debug" : "execução"} encerrada.`);
+                resolve();
+            });
+        });
+    }
+
+    private async discoverClass(simpleName: string): Promise<string | null> {
+        const fs = require("fs");
+        const glob = require("glob");
+        const basePaths = [
+            path.join(process.cwd(), "src/main/java"),
+            path.join(process.cwd(), "src/test/java"),
+            path.join(process.cwd(), "src")
+        ];
+        
+        const files: string[] = [];
+        const seenFiles = new Set<string>();
+
+        for (const srcPath of basePaths) {
+            if (fs.existsSync(srcPath)) {
+                const pattern = path.join(srcPath, "**", `${simpleName}.java`).replace(/\\/g, "/");
+                const found = glob.sync(pattern);
+                found.forEach((f: string) => {
+                    const abs = path.resolve(f);
+                    if (!seenFiles.has(abs)) {
+                        files.push(abs);
+                        seenFiles.add(abs);
+                    }
+                });
+            }
+        }
+
+        if (files.length === 0) {
+            for (const srcPath of basePaths) {
+                if (fs.existsSync(srcPath)) {
+                    const pattern = path.join(srcPath, "**", `*${simpleName}*.java`).replace(/\\/g, "/");
+                    const found = glob.sync(pattern);
+                    found.forEach((f: string) => {
+                        const abs = path.resolve(f);
+                        if (!seenFiles.has(abs)) {
+                            files.push(abs);
+                            seenFiles.add(abs);
+                        }
+                    });
+                }
+            }
+            if (files.length === 0) {
+                Logger.error(`Classe "${simpleName}" não encontrada nos diretórios de código (src/main/java, src/test/java, src).`);
+                return null;
+            }
+        }
+
+        const classes = files.map((file: string) => {
+            const content = fs.readFileSync(file, "utf8");
+            const packageMatch = content.match(/^package\s+([^;]+);/m);
+            const packageName = packageMatch ? packageMatch[1] : "";
+            const fileName = path.basename(file, ".java");
+            return packageName ? `${packageName}.${fileName}` : fileName;
+        });
+
+        const uniqueClasses = Array.from(new Set(classes));
+
+        if (uniqueClasses.length === 1) {
+            return uniqueClasses[0];
+        }
+
+        Logger.warn(`Múltiplas classes encontradas para "${simpleName}":`);
+        uniqueClasses.forEach((c, i) => {
+            Logger.log(`  [${i + 1}] ${c}`);
+        });
+
+        const readline = require("readline").createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        return new Promise((resolve) => {
+            readline.question(`\n  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
+                readline.close();
+                const idx = parseInt(answer) - 1;
+                if (!isNaN(idx) && uniqueClasses[idx]) {
+                    resolve(uniqueClasses[idx]);
+                } else {
+                    Logger.error("Operação cancelada.");
+                    resolve(null);
+                }
+            });
+        });
+    }
+
+    private async loadFromHistory(): Promise<string | null> {
+        const fs = require("fs");
+        const xavvaDir = path.join(process.cwd(), ".xavva");
+        const historyFile = path.join(xavvaDir, "history.json");
+
+        if (!fs.existsSync(historyFile)) return null;
+
+        try {
+            const history: string[] = JSON.parse(fs.readFileSync(historyFile, "utf8"));
+            if (history.length === 0) return null;
+
+            Logger.warn(`Classes executadas recentemente:`);
+            history.slice(0, 5).forEach((c, i) => {
+                Logger.log(`  [${i + 1}] ${c}${i === 0 ? " (Enter)" : ""}`);
+            });
+
+            const readline = require("readline").createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+
+            return new Promise((resolve) => {
+                readline.question(`\n  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
+                    readline.close();
+                    if (!answer.trim()) {
+                        resolve(history[0]);
+                        return;
+                    }
+                    const idx = parseInt(answer) - 1;
+                    if (!isNaN(idx) && history[idx]) {
+                        resolve(history[idx]);
+                    } else {
+                        resolve(null);
+                    }
+                });
+            });
+        } catch (e) {
+            return null;
+        }
+    }
+
+    private saveToHistory(className: string) {
+        const fs = require("fs");
+        const xavvaDir = path.join(process.cwd(), ".xavva");
+        const historyFile = path.join(xavvaDir, "history.json");
+
+        if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir);
+
+        let history: string[] = [];
+        if (fs.existsSync(historyFile)) {
+            try {
+                history = JSON.parse(fs.readFileSync(historyFile, "utf8"));
+            } catch (e) {}
+        }
+
+        history = [className, ...history.filter(c => c !== className)].slice(0, 10);
+        
+        fs.writeFileSync(historyFile, JSON.stringify(history, null, 2));
+    }
+
+    private async createPathingJar(dependencyCp: string): Promise<string> {
+        const fs = require("fs");
+        const xavvaDir = path.join(process.cwd(), ".xavva");
+        const jarPath = path.join(xavvaDir, "classpath.jar");
+
+        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;
+        }).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;
+            } else {
+                wrappedCp += "\r\n " + chunk;
+            }
+        }
+
+        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);
+
+        Bun.spawnSync(["jar", "cfm", jarPath, manifestPath]);
+        return jarPath;
+    }
+
+    private async getClasspath(config: AppConfig): Promise<{ localCp: string, dependencyCp: string }> {
+        const fs = require("fs");
+        const xavvaDir = path.join(process.cwd(), ".xavva");
+        const cpFile = path.join(xavvaDir, "classpath.txt");
+
+        if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir);
+
+        if (!fs.existsSync(cpFile)) {
+            const stopSpinner = Logger.spinner("Generating project classpath");
+            try {
+                if (config.project.buildTool === 'maven') {
+                    Bun.spawnSync(["mvn", "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                } else {
+                    fs.writeFileSync(cpFile, "."); 
+                }
+            } catch (e) {}
+            stopSpinner();
+        }
+
+        const dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
+        
+        const localFolders = [
+            "target/classes",
+            "target/test-classes",
+            "build/classes/java/main",
+            "build/classes/java/test",
+            "."
+        ];
+        
+        const localCp = localFolders
+            .map(p => path.join(process.cwd(), p))
+            .filter(p => fs.existsSync(p))
+            .join(";");
+
+        return { localCp, dependencyCp };
+    }
+}

package/src/commands/StartCommand.ts

@@ -0,0 +1,26 @@
+import type { Command } from "./Command";
+import type { AppConfig } from "../types/config";
+import { TomcatService } from "../services/TomcatService";
+import { Logger } from "../utils/ui";
+
+export class StartCommand implements Command {
+    async execute(config: AppConfig): Promise<void> {
+        const tomcat = new TomcatService(config.tomcat);
+        
+        Logger.section("Start Only");
+        Logger.info("Port", config.tomcat.port);
+        if (config.project.debug) Logger.info("Debugger", "Active (5005)");
+        
+        try {
+            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);
+            
+            await new Promise(() => {}); 
+        } catch (error: any) {
+            Logger.error(error.message);
+            process.exit(1);
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env bun
+import { watch } from "fs";
+import { ConfigManager } from "./utils/config";
+import { BuildCommand } from "./commands/BuildCommand";
+import { DeployCommand } from "./commands/DeployCommand";
+import { StartCommand } from "./commands/StartCommand";
+import { HelpCommand } from "./commands/HelpCommand";
+import { DoctorCommand } from "./commands/DoctorCommand";
+import { RunCommand } from "./commands/RunCommand";
+import { LogsCommand } from "./commands/LogsCommand";
+import { DocsCommand } from "./commands/DocsCommand";
+import { AuditCommand } from "./commands/AuditCommand";
+import { TomcatService } from "./services/TomcatService";
+import { EndpointService } from "./services/EndpointService";
+import pkg from "../package.json";
+import { Logger } from "./utils/ui";
+import path from "path";
+
+async function main() {
+	const { config, positionals, values } = await ConfigManager.load();
+
+	if (values.version) {
+		console.log(`v${pkg.version}`);
+		process.exit(0);
+	}
+
+	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit"];
+	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
+
+	if (!values.help) {
+		Logger.banner(commandName);
+	}
+
+	if (values.help) {
+		new HelpCommand().execute(config);
+		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);
+	}
+}
+
+async function handleDeploy(config: any, values: any) {
+	const tomcat = new TomcatService(config.tomcat);
+	const deployCmd = new DeployCommand(tomcat);
+	
+	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);
+		});
+
+	} else {
+		await deployCmd.execute(config, false, false);
+	}
+}
+
+main().catch(console.error);