@archznn/xavva 3.1.3 → 3.2.0

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,7 +6,7 @@
 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 {
@@ -14,16 +14,16 @@ export class TestCommand implements Command {
 
     private showHelp(): void {
         Logger.section("Test Runner");
-        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva test [options] [filter]`);
+        Logger.log(`${C.bold}Usage:${C.reset} xavva test [options] [filter]`);
         Logger.newline();
-        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
+        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(`${Logger.C.bold}Examples:${Logger.C.reset}`);
+        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`);