@archznn/xavva 3.1.2 → 3.2.0

package/src/commands/InitCommand.ts

@@ -4,14 +4,15 @@ import { join } from "path";
 import { constants, existsSync } from "fs";
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 
 export class InitCommand implements Command {
+    private logger = Logger.getInstance();
+
     async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
-        Logger.banner("init");
-        Logger.section("Project Setup Wizard");
-        Logger.info("Let's configure your Xavva project");
-        Logger.newline();
+        this.logger.section("Project Setup Wizard");
+        this.logger.info("Vamos configurar seu projeto Xavva");
+        this.logger.newline();
 
         // Detect build tool and available profiles
         const buildTool = await this.detectBuildTool();
@@ -25,9 +26,9 @@ export class InitCommand implements Command {
         });
 
         // Profile selection with explanation
-        Logger.newline();
-        Logger.dim("The profile is used to activate Maven/Gradle build configurations");
-        Logger.dim("(e.g., 'dev' for development, 'prod' for production)");
+        this.logger.newline();
+        console.log("The profile is used to activate Maven/Gradle build configurations");
+        console.log("(e.g., 'dev' for development, 'prod' for production)");
         
         let profile: string;
         
@@ -76,8 +77,8 @@ export class InitCommand implements Command {
         }) || 8080;
 
         // Optional settings
-        Logger.newline();
-        Logger.dim("Advanced settings:");
+        this.logger.newline();
+        console.log("Advanced settings:");
         
         const useEmbedded = await confirm({
             message: "Use embedded Tomcat (auto-download)?",
@@ -150,8 +151,8 @@ export class InitCommand implements Command {
 
         // Add environments if enabled
         if (enableMultiEnv) {
-            Logger.newline();
-            Logger.dim("Environment Configuration:");
+            this.logger.newline();
+            console.log("Environment Configuration:");
             
             const environments: Record<string, unknown> = {};
             
@@ -213,20 +214,20 @@ export class InitCommand implements Command {
         }
 
         // Save file
-        Logger.newline();
-        Logger.step("Saving configuration...");
+        this.logger.newline();
+        this.logger.step("Saving configuration...");
 
         const configPath = join(process.cwd(), "xavva.json");
         await writeFile(configPath, JSON.stringify(config, null, 2));
 
-        Logger.success(`Configuration saved to ${configPath}`);
-        Logger.newline();
-        Logger.ready("Project configured!");
-        Logger.info("Next steps:");
-        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva build${Logger.C.reset}  ${Logger.C.gray}- Compile project${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva deploy${Logger.C.reset} ${Logger.C.gray}- Build + deploy${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva health${Logger.C.reset} ${Logger.C.gray}- Check environment${Logger.C.reset}`);
-        Logger.done();
+        this.logger.success(`Configuration saved to ${configPath}`);
+        this.logger.newline();
+        this.logger.ready("Project configured!");
+        this.logger.info("Next steps:");
+        console.log(`  │   xavva build   - Compile project`);
+        console.log(`  │   xavva deploy  - Build + deploy`);
+        console.log(`  │   xavva health  - Check environment`);
+        this.logger.newline();
     }
 
     private async detectBuildTool(): Promise<"maven" | "gradle"> {
@@ -235,17 +236,17 @@ export class InitCommand implements Command {
                           existsSync(join(process.cwd(), "build.gradle.kts"));
 
         if (hasPom && !hasGradle) {
-            Logger.info("Detected: Maven project");
+            this.logger.info("Detected: Maven project");
             return "maven";
         }
         
         if (hasGradle && !hasPom) {
-            Logger.info("Detected: Gradle project");
+            this.logger.info("Detected: Gradle project");
             return "gradle";
         }
 
         if (hasPom && hasGradle) {
-            Logger.warn("Both pom.xml and build.gradle found");
+            this.logger.warn("Both pom.xml and build.gradle found");
             const choice = await select({
                 message: "Select build tool:",
                 choices: [

package/src/commands/LogsCommand.ts

@@ -2,11 +2,13 @@ import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { DashboardService } from "../services/DashboardService";
 import { LogAnalyzer } from "../services/LogAnalyzer";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import path from "path";
 import fs from "fs";
 
 export class LogsCommand implements Command {
+    private logger = Logger.getInstance();
+
     constructor(private dashboard?: DashboardService, private logAnalyzer?: LogAnalyzer) {}
 
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
@@ -14,18 +16,18 @@ export class LogsCommand implements Command {
 
         if (!fs.existsSync(logPath)) {
             const errorMsg = `Arquivo de log não encontrado: ${logPath}`;
-            if (this.dashboard) this.dashboard.log(Logger.C.red + errorMsg);
-            else Logger.error(errorMsg);
+            if (this.dashboard) this.dashboard.log(errorMsg);
+            else this.logger.error(errorMsg);
             return;
         }
 
         const analyzer = this.logAnalyzer || new LogAnalyzer(config.project);
         const dashboard = this.dashboard || new DashboardService(config);
 
-        dashboard.setStatus("LOGGING", Logger.C.green);
+        dashboard.setStatus("LOGGING", "running");
         
         if (args?.grep) {
-            dashboard.log(`${Logger.C.dim}Filter:${Logger.C.reset} ${Logger.C.bold}${args.grep}${Logger.C.reset}`);
+            dashboard.log(`Filter: ${args.grep}`);
         }
 
         const stats = fs.statSync(logPath);
@@ -60,7 +62,7 @@ export class LogsCommand implements Command {
                     currentSize = newStats.size;
                 } else if (newStats.size < currentSize) {
                     currentSize = newStats.size;
-                    dashboard.log(Logger.C.warning + "Arquivo de log foi resetado/rotacionado.");
+                    dashboard.log("Arquivo de log foi resetado/rotacionado.");
                 }
             }
         });

package/src/commands/ProfilesCommand.ts

@@ -1,7 +1,7 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { ProjectService } from "../services/ProjectService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 
 export class ProfilesCommand implements Command {
     constructor(private projectService: ProjectService) {}
@@ -15,18 +15,18 @@ export class ProfilesCommand implements Command {
 
         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}`);
+            Logger.log(`  ${C.dim}Dica: Perfis Maven são definidos em <profiles> no pom.xml.${C.reset}`);
             return;
         }
 
         Logger.log(`
-  ${Logger.C.primary}Perfis detectados:${Logger.C.reset}`);
+  ${C.primary}Perfis detectados:${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}`);
+            const active = config.project.profile === p ? ` ${C.success}(Ativo)${C.reset}` : "";
+            Logger.log(`  ${C.bold}➜${C.reset} ${p}${active}`);
         });
 
         Logger.newline();
-        Logger.log(`  ${Logger.C.dim}Para usar um perfil: xavva build -P nome-do-perfil${Logger.C.reset}`);
+        Logger.log(`  ${C.dim}Para usar um perfil: xavva build -P nome-do-perfil${C.reset}`);
     }
 }

package/src/commands/RedoCommand.ts

@@ -1,7 +1,7 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { HistoryService } from "../services/HistoryService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 
 export class RedoCommand implements Command {
@@ -17,7 +17,7 @@ export class RedoCommand implements Command {
 
         const args = lastEntry.args.length > 0 ? lastEntry.args.join(" ") : "";
         Logger.banner("redo");
-        Logger.info(`Repetindo: ${Logger.C.white}xavva ${lastEntry.command}${Logger.C.reset} ${Logger.C.gray}${args}${Logger.C.reset}`);
+        Logger.info(`Repetindo: ${C.white}xavva ${lastEntry.command}${C.reset} ${C.gray}${args}${C.reset}`);
         Logger.newline();
 
         // Re-executar o comando

package/src/commands/RunCommand.ts

@@ -1,20 +1,25 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import path from "path";
 import fs from "fs";
 import { glob } from "glob";
 import readline from "readline";
+import { BuildService } from "../services/BuildService";
 import {
-	getJavaPath,
-	getMavenCommand,
-	getGradleCommand,
-	getClasspathSeparator,
-	normalizeClasspathPath,
-	isWindows,
+    getJavaPath,
+    getMavenCommand,
+    getGradleCommand,
+    getClasspathSeparator,
+    normalizeClasspathPath,
+    isWindows,
 } from "../utils/platform";
 
 export class RunCommand implements Command {
+    private logger = Logger.getInstance();
+
+    constructor(private buildService?: BuildService) {}
+
     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;
@@ -22,7 +27,7 @@ export class RunCommand implements Command {
         if (!className) {
             className = await this.loadFromHistory();
             if (!className) {
-                Logger.error(`Uso: xavva ${isDebug ? "debug" : "run"} NomeDaClasse`);
+                this.logger.error(`Uso: xavva ${isDebug ? "debug" : "run"} NomeDaClasse`);
                 return;
             }
         }
@@ -36,11 +41,14 @@ export class RunCommand implements Command {
         this.saveToHistory(className);
 
         if (isDebug) {
-            Logger.section(`Interactive Debug: ${className}`);
+            this.logger.section(`Interactive Debug: ${className}`);
         } else {
-            Logger.section(`Running: ${className}`);
+            this.logger.section(`Running: ${className}`);
         }
         
+        // Verifica se as classes estão compiladas, se não, compila
+        await this.ensureCompiled(config);
+        
         const { localCp, dependencyCp } = await this.getClasspath(config);
         const pathingJar = await this.createPathingJar(dependencyCp);
         
@@ -62,11 +70,11 @@ export class RunCommand implements Command {
         javaArgs.push(className);
 
         if (isDebug) {
-            Logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
-            Logger.log(`${Logger.C.primary}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
-            Logger.newline();
+            this.logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
+            console.log(`Dica: No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
+            this.logger.newline();
         } else {
-            Logger.warn(`🚀 Executando ${className}...`);
+            this.logger.warn(`🚀 Executando ${className}...`);
         }
 
         const bin = getJavaPath();
@@ -82,7 +90,7 @@ export class RunCommand implements Command {
         });
 
         await proc.exited;
-        Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
+        this.logger.info(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
     }
 
     private async discoverClass(simpleName: string): Promise<string | null> {
@@ -124,7 +132,7 @@ export class RunCommand implements Command {
                 }
             }
             if (files.length === 0) {
-                Logger.error(`Classe "${simpleName}" não encontrada nos diretórios de código (src/main/java, src/test/java, src).`);
+                this.logger.error(`Classe "${simpleName}" não encontrada nos diretórios de código (src/main/java, src/test/java, src).`);
                 return null;
             }
         }
@@ -143,9 +151,9 @@ export class RunCommand implements Command {
             return uniqueClasses[0];
         }
 
-        Logger.warn(`Múltiplas classes encontradas para "${simpleName}":`);
+        this.logger.warn(`Múltiplas classes encontradas para "${simpleName}":`);
         uniqueClasses.forEach((c, i) => {
-            Logger.log(`  [${i + 1}] ${c}`);
+            console.log(`  [${i + 1}] ${c}`);
         });
 
         const rl = readline.createInterface({
@@ -160,7 +168,7 @@ export class RunCommand implements Command {
                 if (!isNaN(idx) && uniqueClasses[idx]) {
                     resolve(uniqueClasses[idx]);
                 } else {
-                    Logger.error("Operação cancelada.");
+                    this.logger.error("Operação cancelada.");
                     resolve(null);
                 }
             });
@@ -177,9 +185,9 @@ export class RunCommand implements Command {
             const history: string[] = JSON.parse(fs.readFileSync(historyFile, "utf8"));
             if (history.length === 0) return null;
 
-            Logger.warn(`Classes executadas recentemente:`);
+            this.logger.warn(`Classes executadas recentemente:`);
             history.slice(0, 5).forEach((c, i) => {
-                Logger.log(`  [${i + 1}] ${c}${i === 0 ? " (Enter)" : ""}`);
+                console.log(`  [${i + 1}] ${c}${i === 0 ? " (Enter)" : ""}`);
             });
 
             const rl = readline.createInterface({
@@ -296,6 +304,38 @@ export class RunCommand implements Command {
         return jarPath;
     }
 
+    /**
+     * Verifica se as classes compiladas existem, se não, executa o build
+     * Usa build incremental (apenas compile, sem clean) para evitar conflitos
+     * com o Tomcat que pode estar rodando e usando arquivos em target/
+     */
+    private async ensureCompiled(config: AppConfig): Promise<void> {
+        // Usa build incremental (sem clean) para evitar problemas quando Tomcat está rodando
+        if (this.buildService) {
+            this.logger.step("Compilando projeto...");
+            await this.buildService.runBuild(true); // true = incremental, sem clean
+        } else {
+            // Fallback: executa build via comando direto (apenas compile, sem clean)
+            this.logger.step("Compilando projeto (fallback)...");
+            const buildCmd = config.project.buildTool === "maven" 
+                ? [getMavenCommand(), "compile", "-DskipTests"] 
+                : [getGradleCommand(), "classes", "-x", "test"];
+            
+            const spinner = this.logger.spinner("Compilando");
+            const proc = Bun.spawn(buildCmd, {
+                stdout: "pipe",
+                stderr: "pipe",
+            });
+            
+            await proc.exited;
+            spinner.stop();
+            
+            if (proc.exitCode !== 0) {
+                throw new Error("Falha ao compilar o projeto. Verifique os erros acima.");
+            }
+        }
+    }
+
     private async getClasspath(config: AppConfig): Promise<{ localCp: string, dependencyCp: string }> {
         const xavvaDir = path.join(process.cwd(), ".xavva");
         const cpFile = path.join(xavvaDir, "classpath.txt");
@@ -303,7 +343,7 @@ export class RunCommand implements Command {
         if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir);
 
         if (!fs.existsSync(cpFile)) {
-            const stopSpinner = Logger.spinner("Generating project classpath");
+            const spinner = this.logger.spinner("Generating project classpath");
             try {
                 if (config.project.buildTool === "maven") {
                     Bun.spawnSync([getMavenCommand(), "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
@@ -337,9 +377,9 @@ export class RunCommand implements Command {
                     fs.writeFileSync(cpFile, "."); 
                 }
             } catch (e) {
-                Logger.error(`Falha ao gerar classpath: ${e}`);
+                this.logger.error(`Falha ao gerar classpath: ${e}`);
             }
-            stopSpinner();
+            spinner.stop();
         }
 
         let dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";

package/src/commands/StartCommand.ts

@@ -1,29 +1,31 @@
 import type { Command } from "./Command";
 import type { AppConfig } from "../types/config";
 import { TomcatService } from "../services/TomcatService";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { ProcessManager } from "../utils/processManager";
 
 export class StartCommand implements Command {
+    private logger = Logger.getInstance();
+
     constructor(private tomcat: TomcatService) {}
 
     async execute(config: AppConfig): Promise<void> {
         const tomcat = this.tomcat;
         
-        Logger.section("Start Only");
-        Logger.info("Port", config.tomcat.port);
-        if (config.project.debug) Logger.info("Debugger", "Active (5005)");
+        this.logger.section("Start Only");
+        this.logger.config("Port", config.tomcat.port);
+        if (config.project.debug) this.logger.config("Debugger", "Active (5005)");
         
         try {
-            Logger.step("Checking ports");
+            this.logger.step("Checking ports");
             await tomcat.killConflict();
-            Logger.step("Starting Tomcat");
+            this.logger.step("Starting Tomcat");
             tomcat.start(config, false);
             
             await new Promise(() => {}); 
         } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            Logger.error(message);
+            this.logger.error(message);
             await ProcessManager.getInstance().shutdown(1);
         }
     }

package/src/commands/TestCommand.ts

@@ -6,14 +6,38 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { TestService } from "../services/TestService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 
 export class TestCommand implements Command {
     private service: TestService | null = null;
 
+    private showHelp(): void {
+        Logger.section("Test Runner");
+        Logger.log(`${C.bold}Usage:${C.reset} xavva test [options] [filter]`);
+        Logger.newline();
+        Logger.log(`${C.bold}Options:${C.reset}`);
+        Logger.log(`  -w, --watch          Watch mode (run on file change)`);
+        Logger.log(`      --coverage       Generate JaCoCo coverage report`);
+        Logger.log(`      --fail-fast      Stop on first failure`);
+        Logger.log(`      --parallel       Run tests in parallel`);
+        Logger.log(`  -V, --verbose        Verbose output`);
+        Logger.newline();
+        Logger.log(`${C.bold}Examples:${C.reset}`);
+        Logger.log(`  xavva test                    # Run all tests`);
+        Logger.log(`  xavva test --watch            # Watch mode`);
+        Logger.log(`  xavva test --coverage         # With coverage`);
+        Logger.log(`  xavva test UserServiceTest    # Run specific test`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
         
         // Extrai filtros de teste dos positionals (após o comando "test")
         const filter = positionals?.slice(1).join(" ") || undefined;