@archznn/xavva 2.0.2 → 2.1.0

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

@@ -2,6 +2,9 @@ import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { Logger } from "../utils/ui";
 import path from "path";
+import fs from "fs";
+import { glob } from "glob";
+import readline from "readline";
 
 export class RunCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
@@ -39,6 +42,10 @@ export class RunCommand implements Command {
             "-classpath", finalCp,
         ];
 
+        if (config.project.encoding) {
+            javaArgs.push(`-Dfile.encoding=${config.project.encoding}`);
+        }
+
         if (isDebug) {
             javaArgs.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
         }
@@ -70,8 +77,6 @@ export class RunCommand implements Command {
     }
 
     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"),
@@ -134,14 +139,14 @@ export class RunCommand implements Command {
             Logger.log(`  [${i + 1}] ${c}`);
         });
 
-        const readline = require("readline").createInterface({
+        const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout
         });
 
         return new Promise((resolve) => {
-            readline.question(`  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
-                readline.close();
+            rl.question(`  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
+                rl.close();
                 const idx = parseInt(answer) - 1;
                 if (!isNaN(idx) && uniqueClasses[idx]) {
                     resolve(uniqueClasses[idx]);
@@ -154,7 +159,6 @@ export class RunCommand implements Command {
     }
 
     private async loadFromHistory(): Promise<string | null> {
-        const fs = require("fs");
         const xavvaDir = path.join(process.cwd(), ".xavva");
         const historyFile = path.join(xavvaDir, "history.json");
 
@@ -169,14 +173,14 @@ export class RunCommand implements Command {
                 Logger.log(`  [${i + 1}] ${c}${i === 0 ? " (Enter)" : ""}`);
             });
 
-            const readline = require("readline").createInterface({
+            const rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout
             });
 
             return new Promise((resolve) => {
-                readline.question(`  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
-                    readline.close();
+                rl.question(`  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
+                    rl.close();
                     if (!answer.trim()) {
                         resolve(history[0]);
                         return;
@@ -195,7 +199,6 @@ export class RunCommand implements Command {
     }
 
     private saveToHistory(className: string) {
-        const fs = require("fs");
         const xavvaDir = path.join(process.cwd(), ".xavva");
         const historyFile = path.join(xavvaDir, "history.json");
 
@@ -214,7 +217,6 @@ export class RunCommand implements Command {
     }
 
     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");
 
@@ -285,7 +287,6 @@ export class RunCommand implements Command {
     }
 
     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");
 

package/src/commands/StartCommand.ts

@@ -2,6 +2,7 @@ import type { Command } from "./Command";
 import type { AppConfig } from "../types/config";
 import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
 
 export class StartCommand implements Command {
     constructor(private tomcat: TomcatService) {}
@@ -20,9 +21,10 @@ export class StartCommand implements Command {
             tomcat.start(config, false);
             
             await new Promise(() => {}); 
-        } catch (error: any) {
-            Logger.error(error.message);
-            process.exit(1);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            Logger.error(message);
+            await ProcessManager.getInstance().shutdown(1);
         }
     }
 }

package/src/index.ts

@@ -10,6 +10,8 @@ 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 { DepsCommand } from "./commands/DepsCommand";
 
 import { ProjectService } from "./services/ProjectService";
 import { TomcatService } from "./services/TomcatService";
@@ -22,26 +24,31 @@ import { LogAnalyzer } from "./services/LogAnalyzer";
 
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
+import { ProcessManager } from "./utils/processManager";
 import type { AppConfig, CLIArguments } from "./types/config";
 
 async function main() {
+	const processManager = ProcessManager.getInstance();
 	const { config, positionals, values } = await ConfigManager.load();
 
 	if (values.version) {
 		Logger.log(`v${pkg.version}`);
-		process.exit(0);
+		await processManager.shutdown(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", "deps"];
 	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
 	if (!values.help && !values.tui) {
-		Logger.banner(commandName);
+		Logger.banner(commandName, config.project.profile, config.project.encoding);
+		if (config.project.encoding) {
+			Logger.config("Encoding", config.project.encoding);
+		}
 	}
 
 	if (values.help) {
 		new HelpCommand().execute(config, values);
-		process.exit(0);
+		await processManager.shutdown(0);
 	}
 
 	// 1. Instanciar Serviços (Injeção de Dependência)
@@ -71,6 +78,8 @@ 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("deps", new DepsCommand());
 	registry.register("deploy", deployCmd);
 	registry.register("dev", deployCmd);
 
@@ -95,4 +104,7 @@ async function main() {
 	}
 }
 
-main().catch(console.error);
+main().catch(async (error) => {
+	console.error(error);
+	await ProcessManager.getInstance().shutdown(1);
+});

package/src/services/AuditService.ts

@@ -19,6 +19,32 @@ export interface JarAuditResult {
     vulnerabilities: Vulnerability[];
 }
 
+// Interfaces para resposta da OSV API
+interface OSVEvent {
+    fixed?: string;
+}
+
+interface OSVRange {
+    events: OSVEvent[];
+}
+
+interface OSVAffected {
+    ranges: OSVRange[];
+}
+
+interface OSVVulnerability {
+    id: string;
+    summary?: string;
+    details?: string;
+    affected?: OSVAffected[];
+    database_specific?: { severity?: string };
+    advisories?: { url: string }[];
+}
+
+interface OSVResponse {
+    vulns?: OSVVulnerability[];
+}
+
 export class AuditService {
     constructor(private tomcatConfig: TomcatConfig) {}
 
@@ -120,22 +146,22 @@ export class AuditService {
                 })
             });
 
-            const data = await response.json();
+            const data = (await response.json()) as OSVResponse;
             if (!data.vulns) return [];
 
-            return data.vulns.map((v: any) => ({
+            return data.vulns.map((v) => ({
                 id: v.id,
                 summary: v.summary || v.details?.substring(0, 100) + "...",
                 details: v.details,
                 severity: this.extractSeverity(v),
-                fixedIn: v.affected?.[0]?.ranges?.[0]?.events?.find((e: any) => e.fixed)?.fixed
+                fixedIn: v.affected?.[0]?.ranges?.[0]?.events?.find((e) => e.fixed)?.fixed
             }));
         } catch (e) {
             return [];
         }
     }
 
-    private extractSeverity(vuln: any): string {
+    private extractSeverity(vuln: OSVVulnerability): string {
         if (vuln.database_specific?.severity) return vuln.database_specific.severity;
         if (vuln.advisories?.[0]?.url?.includes("github.com/advisories")) {
             const d = (vuln.details || "").toLowerCase();

package/src/services/BuildCacheService.ts

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import crypto from "crypto";
+import type { ProjectService } from "./ProjectService";
 
 export interface CacheData {
     lastConfigHash: string;
@@ -41,7 +42,7 @@ export class BuildCacheService {
         return crypto.createHash("md5").update(hash).digest("hex");
     }
 
-    shouldRebuild(tool: "maven" | "gradle", projectService?: any): boolean {
+    shouldRebuild(tool: "maven" | "gradle", projectService?: ProjectService): boolean {
         if (!fs.existsSync(this.cacheFile)) return true;
 
         try {

package/src/services/BuildService.ts

@@ -38,7 +38,7 @@ export class BuildService {
 		}
 
 		const command = [];
-		const env: any = { ...process.env };
+		const env: Record<string, string | undefined> = { ...process.env };
 		
 		if (this.projectConfig.buildTool === 'maven') {
 			command.push(process.platform === "win32" ? "mvn.cmd" : "mvn");
@@ -57,6 +57,10 @@ export class BuildService {
 			}
 			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");
 			if (this.projectConfig.profile) command.push(`-P${this.projectConfig.profile}`);
+			if (this.projectConfig.encoding) {
+				command.push(`-Dproject.build.sourceEncoding=${this.projectConfig.encoding}`);
+				command.push(`-Dproject.reporting.outputEncoding=${this.projectConfig.encoding}`);
+			}
 
 			env.MAVEN_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
 		} else {
@@ -70,6 +74,9 @@ export class BuildService {
 			}
 			command.push("-x", "test", "-x", "javadoc");
 			if (this.projectConfig.profile) command.push(`-Pprofile=${this.projectConfig.profile}`);
+			if (this.projectConfig.encoding) {
+				command.push(`-Dfile.encoding=${this.projectConfig.encoding}`);
+			}
 
 			env.GRADLE_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
 		}

package/src/services/DashboardService.ts

@@ -1,4 +1,10 @@
 import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+import { 
+    MAX_LOG_SCROLLBUFFER, 
+    DASHBOARD_REFRESH_INTERVAL_MS,
+    DASHBOARD_LOG_SLICE_LINES 
+} from "../utils/constants";
 import type { AppConfig } from "../types/config";
 import os from "os";
 
@@ -8,7 +14,7 @@ export class DashboardService {
     private maxLogLines: number = 0;
     private status: string = "IDLE";
     private statusColor: string = Logger.C.dim;
-    private gitContext: any = null;
+    private gitContext: { branch: string; commit: string } | null = null;
     private actions: Map<string, () => void> = new Map();
 
     constructor(private config: AppConfig) {
@@ -17,6 +23,23 @@ export class DashboardService {
             this.gitContext = Logger.getGitContext();
             this.maxLogLines = process.stdout.rows - 6;
             this.setupTui();
+            this.registerShutdownHandlers();
+        }
+    }
+
+    private registerShutdownHandlers() {
+        const processManager = ProcessManager.getInstance();
+        processManager.onShutdown(() => {
+            this.restoreTerminal();
+        });
+    }
+
+    private restoreTerminal() {
+        if (this.isTui) {
+            process.stdout.write("\x1B[?1049l"); // Restore buffer
+            process.stdout.write("\x1B[?25h"); // Show cursor
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
         }
     }
 
@@ -72,8 +95,8 @@ export class DashboardService {
         if (this.isTui) {
             const lines = message.split("\n");
             this.logLines.push(...lines);
-            if (this.logLines.length > 1000) { // Limite de scrollbuffer
-                this.logLines = this.logLines.slice(-1000);
+            if (this.logLines.length > MAX_LOG_SCROLLBUFFER) {
+                this.logLines = this.logLines.slice(-DASHBOARD_LOG_SLICE_LINES);
             }
             this.render();
         } else {
@@ -92,8 +115,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`;
 
@@ -111,13 +135,8 @@ export class DashboardService {
         process.stdout.write(output);
     }
 
-    private exit() {
-        if (this.isTui) {
-            process.stdout.write("\x1B[?1049l"); // Restore buffer
-            process.stdout.write("\x1B[?25h"); // Show cursor
-            process.stdin.setRawMode(false);
-            process.stdin.pause();
-        }
-        process.exit(0);
+    private async exit() {
+        this.restoreTerminal();
+        await ProcessManager.getInstance().shutdown(0);
     }
 }