@archznn/xavva 3.1.3 → 3.2.0

package/src/services/DashboardService.ts

@@ -1,4 +1,4 @@
-import { Logger } from "../utils/ui";
+import { Logger, Colors } from "../logging";
 import { ProcessManager } from "../utils/processManager";
 import { 
 	MAX_LOG_SCROLLBUFFER, 
@@ -8,7 +8,7 @@ import {
 import type { AppConfig } from "../types/config";
 import os from "os";
 
-const C = Logger.C;
+const C = Colors;
 
 export class DashboardService {
 	private isTui: boolean;
@@ -19,11 +19,12 @@ export class DashboardService {
 	private gitContext: { branch: string; hash: string } | null = null;
 	private actions: Map<string, () => void> = new Map();
 	private startTime = Date.now();
+	private logger = Logger.getInstance();
 
 	constructor(private config: AppConfig) {
 		this.isTui = config.project.tui;
 		if (this.isTui) {
-			this.gitContext = Logger.getGitContext();
+			this.gitContext = this.getGitContext();
 			this.maxLogLines = process.stdout.rows - 8;
 			this.setupTui();
 			this.registerShutdownHandlers();
@@ -184,4 +185,14 @@ export class DashboardService {
 		this.restoreTerminal();
 		await ProcessManager.getInstance().shutdown(0);
 	}
+
+	private getGitContext(): { branch: string; hash: string } | null {
+		try {
+			const branch = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"]).stdout.toString().trim();
+			const hash = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"]).stdout.toString().trim();
+			return { branch, hash };
+		} catch {
+			return null;
+		}
+	}
 }

package/src/services/DbService.ts

@@ -3,7 +3,7 @@
  * Suporta Flyway e Liquibase
  */
 
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { spawn } from "child_process";
 import fs from "fs";
 import path from "path";
@@ -36,6 +36,7 @@ export interface MigrationResult {
 export class DbService {
     private buildTool: "maven" | "gradle";
     private projectPath: string;
+    private logger = Logger.getInstance();
 
     constructor(buildTool: "maven" | "gradle", projectPath: string = process.cwd()) {
         this.buildTool = buildTool;
@@ -82,15 +83,15 @@ export class DbService {
      */
     async migrate(config?: DbConfig): Promise<MigrationResult> {
         const tool = await this.detectTool();
-        Logger.section("Database Migration");
-        Logger.info("Tool", tool === "auto" ? "auto-detect" : tool);
+        this.logger.section("Database Migration");
+        this.logger.info(`Tool: ${tool === "auto" ? "auto-detect" : tool}`);
 
         if (tool === "auto") {
             return {
                 success: false,
-                message: "No migration tool detected. Please add Flyway or Liquibase to your project.",
+                message: "Nenhuma ferramenta de migração detectada. Adicione Flyway ou Liquibase ao projeto.",
                 migrationsApplied: 0,
-                errors: ["No migration tool found"]
+                errors: ["Nenhuma ferramenta de migração encontrada"]
             };
         }
 
@@ -98,7 +99,7 @@ export class DbService {
             ? await this.runFlywayMigrate(config)
             : await this.runLiquibaseUpdate(config);
 
-        Logger.endSection();
+        this.logger.newline();
         return result;
     }
 
@@ -107,12 +108,12 @@ export class DbService {
      */
     async status(config?: DbConfig): Promise<MigrationStatus[]> {
         const tool = await this.detectTool();
-        Logger.section("Migration Status");
-        Logger.info("Tool", tool);
+        this.logger.section("Migration Status");
+        this.logger.info(`Tool: ${tool}`);
 
         if (tool === "auto") {
-            Logger.warn("No migration tool detected");
-            Logger.endSection();
+            this.logger.warn("Nenhuma ferramenta de migração detectada");
+            this.logger.newline();
             return [];
         }
 
@@ -122,18 +123,18 @@ export class DbService {
 
         // Print status table
         if (statuses.length > 0) {
-            Logger.divider();
+            this.logger.divider();
             for (const status of statuses) {
-                const stateColor = status.state === "applied" ? Logger.C.success 
-                    : status.state === "failed" ? Logger.C.error 
-                    : Logger.C.warning;
-                Logger.info(status.version, `${stateColor}${status.state}${Logger.C.reset} - ${status.description}`);
+                const stateStr = status.state === "applied" ? "✓ aplicada" 
+                    : status.state === "failed" ? "✗ falhou" 
+                    : "⏳ pendente";
+                this.logger.info(`${status.version}: ${stateStr} - ${status.description}`);
             }
         } else {
-            Logger.info("Status", "No migrations found");
+            this.logger.info("Status: Nenhuma migração encontrada");
         }
 
-        Logger.endSection();
+        this.logger.newline();
         return statuses;
     }
 
@@ -141,8 +142,8 @@ export class DbService {
      * Reseta o banco (drop all + migrate)
      */
     async reset(config?: DbConfig): Promise<MigrationResult> {
-        Logger.section("Database Reset");
-        Logger.warn("This will DROP ALL DATA in the database!");
+        this.logger.section("Database Reset");
+        this.logger.warn("Isso vai APAGAR TODOS OS DADOS do banco!");
 
         const tool = await this.detectTool();
         
@@ -152,10 +153,10 @@ export class DbService {
             return await this.runLiquibaseDropAll(config);
         }
 
-        Logger.endSection();
+        this.logger.newline();
         return {
             success: false,
-            message: "No migration tool detected",
+            message: "Nenhuma ferramenta de migração detectada",
             migrationsApplied: 0,
             errors: []
         };
@@ -165,7 +166,7 @@ export class DbService {
      * Popula dados de teste/seed
      */
     async seed(config?: DbConfig, seedFile?: string): Promise<MigrationResult> {
-        Logger.section("Database Seed");
+        this.logger.section("Database Seed");
 
         // Procurar arquivos de seed
         const seedPaths = [
@@ -179,18 +180,18 @@ export class DbService {
         if (!seedPath) {
             return {
                 success: false,
-                message: "No seed file found. Create seed.sql in src/test/resources/ or project root.",
+                message: "Arquivo seed não encontrado. Crie seed.sql em src/test/resources/ ou raiz do projeto.",
                 migrationsApplied: 0,
-                errors: ["Seed file not found"]
+                errors: ["Arquivo seed não encontrado"]
             };
         }
 
-        Logger.info("Seed file", seedPath);
+        this.logger.info(`Seed file: ${seedPath}`);
 
         // Executar seed via JDBC ou comando SQL
         const result = await this.executeSeed(seedPath, config);
         
-        Logger.endSection();
+        this.logger.newline();
         return result;
     }
 
@@ -237,7 +238,7 @@ export class DbService {
                 : [process.platform === "win32" ? "gradle.bat" : "gradle", gradleTask, "-q"];
 
             const env = config ? this.buildEnv(config) : process.env;
-            const spinner = Logger.spinner("Running migrations");
+            const spinner = this.logger.spinner("Executando migrações");
 
             const child = spawn(cmd, args, {
                 cwd: this.projectPath,
@@ -252,13 +253,13 @@ export class DbService {
             child.stderr?.on("data", (data) => stderr += data.toString());
 
             child.on("close", (code) => {
-                spinner(code === 0);
+                spinner.stop(code === 0);
                 
                 if (code === 0) {
-                    Logger.success("Migrations completed successfully");
+                    this.logger.success("Migrações concluídas com sucesso");
                 } else {
-                    Logger.error("Migration failed");
-                    if (stderr) Logger.dim(stderr.slice(0, 500));
+                    this.logger.error("Falha na migração");
+                    if (stderr) this.logger.debug(stderr.slice(0, 500));
                 }
 
                 resolve({
@@ -304,9 +305,9 @@ export class DbService {
         const sql = fs.readFileSync(seedPath, "utf-8");
         const statements = sql.split(";").filter(s => s.trim());
 
-        Logger.info("Statements", statements.length);
-        Logger.success("Seed file ready for execution");
-        Logger.dim("Use your database client to execute the seed file");
+        this.logger.info(`Statements: ${statements.length}`);
+        this.logger.success("Arquivo seed pronto para execução");
+        this.logger.debug("Use seu cliente de banco de dados para executar o seed");
 
         return {
             success: true,

package/src/services/DependencyAnalyzerService.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import type { ProjectConfig } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 
 export interface Dependency {
 	groupId: string;
@@ -606,24 +606,24 @@ export class DependencyAnalyzerService {
 	generateReport(result: DependencyAnalysisResult): string {
 		const lines: string[] = [];
 		lines.push("");
-		lines.push(`${Logger.C.primary}══════════════════════════════════════════════════════════${Logger.C.reset}`);
-		lines.push(`${Logger.C.bold}📊 ANÁLISE DE DEPENDÊNCIAS${Logger.C.reset}`);
-		lines.push(`${Logger.C.primary}══════════════════════════════════════════════════════════${Logger.C.reset}`);
+		lines.push(`${C.primary}══════════════════════════════════════════════════════════${C.reset}`);
+		lines.push(`${C.bold}📊 ANÁLISE DE DEPENDÊNCIAS${C.reset}`);
+		lines.push(`${C.primary}══════════════════════════════════════════════════════════${C.reset}`);
 		lines.push("");
 		
 		// Estatísticas
-		lines.push(`${Logger.C.dim}Estatísticas:${Logger.C.reset}`);
+		lines.push(`${C.dim}Estatísticas:${C.reset}`);
 		lines.push(`  Total: ${result.stats.total} dependências`);
 		lines.push(`  Diretas: ${result.stats.direct} | Transitivas: ${result.stats.transitive}`);
 		lines.push("");
 
 		// Conflitos
 		if (result.conflicts.length > 0) {
-			lines.push(`${Logger.C.warning}⚠️  CONFLITOS DE VERSÃO (${result.conflicts.length})${Logger.C.reset}`);
+			lines.push(`${C.warning}⚠️  CONFLITOS DE VERSÃO (${result.conflicts.length})${C.reset}`);
 			for (const conflict of result.conflicts) {
 				const icon = conflict.severity === "error" ? "✖" : "▲";
-				const color = conflict.severity === "error" ? Logger.C.error : Logger.C.warning;
-				lines.push(`  ${color}${icon}${Logger.C.reset} ${conflict.groupId}:${conflict.artifactId}`);
+				const color = conflict.severity === "error" ? C.error : C.warning;
+				lines.push(`  ${color}${icon}${C.reset} ${conflict.groupId}:${conflict.artifactId}`);
 				lines.push(`     Versões: ${conflict.versions.join(", ")}`);
 			}
 			lines.push("");
@@ -635,23 +635,23 @@ export class DependencyAnalyzerService {
 			const minorUpdates = result.updates.filter(u => !u.isMajor);
 
 			if (minorUpdates.length > 0) {
-				lines.push(`${Logger.C.success}⬆️  ATUALIZAÇÕES DISPONÍVEIS (${minorUpdates.length})${Logger.C.reset}`);
+				lines.push(`${C.success}⬆️  ATUALIZAÇÕES DISPONÍVEIS (${minorUpdates.length})${C.reset}`);
 				for (const update of minorUpdates.slice(0, 5)) {
-					lines.push(`  ${Logger.C.success}↑${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
-					lines.push(`     ${update.currentVersion} → ${Logger.C.success}${update.latestVersion}${Logger.C.reset}`);
+					lines.push(`  ${C.success}↑${C.reset} ${update.groupId}:${update.artifactId}`);
+					lines.push(`     ${update.currentVersion} → ${C.success}${update.latestVersion}${C.reset}`);
 				}
 				if (minorUpdates.length > 5) {
-					lines.push(`  ${Logger.C.dim}... e mais ${minorUpdates.length - 5}${Logger.C.reset}`);
+					lines.push(`  ${C.dim}... e mais ${minorUpdates.length - 5}${C.reset}`);
 				}
 				lines.push("");
 			}
 
 			if (majorUpdates.length > 0) {
-				lines.push(`${Logger.C.warning}⚠️  ATUALIZAÇÕES MAJOR (${majorUpdates.length})${Logger.C.reset}`);
-				lines.push(`  ${Logger.C.dim}Podem conter breaking changes${Logger.C.reset}`);
+				lines.push(`${C.warning}⚠️  ATUALIZAÇÕES MAJOR (${majorUpdates.length})${C.reset}`);
+				lines.push(`  ${C.dim}Podem conter breaking changes${C.reset}`);
 				for (const update of majorUpdates.slice(0, 3)) {
-					lines.push(`  ${Logger.C.warning}!${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
-					lines.push(`     ${update.currentVersion} → ${Logger.C.warning}${update.latestVersion}${Logger.C.reset}`);
+					lines.push(`  ${C.warning}!${C.reset} ${update.groupId}:${update.artifactId}`);
+					lines.push(`     ${update.currentVersion} → ${C.warning}${update.latestVersion}${C.reset}`);
 				}
 				lines.push("");
 			}
@@ -659,11 +659,11 @@ export class DependencyAnalyzerService {
 
 		// Resumo
 		if (result.conflicts.length === 0 && result.updates.length === 0) {
-			lines.push(`${Logger.C.success}✔ Todas as dependências estão atualizadas!${Logger.C.reset}`);
+			lines.push(`${C.success}✔ Todas as dependências estão atualizadas!${C.reset}`);
 		}
 
 		lines.push("");
-		lines.push(`${Logger.C.dim}Dica: Execute 'xavva audit' para verificar vulnerabilidades${Logger.C.reset}`);
+		lines.push(`${C.dim}Dica: Execute 'xavva audit' para verificar vulnerabilidades${C.reset}`);
 		
 		return lines.join("\n");
 	}

package/src/services/DependencyCacheService.ts

@@ -0,0 +1,303 @@
+/**
+ * Serviço de Cache de Análise de Dependências
+ * 
+ * Evita re-parsear pom.xml/build.gradle em cada comando,
+ * invalidando cache apenas quando o arquivo mudar.
+ */
+
+import { createHash } from "crypto";
+import { readFile, stat, mkdir, writeFile, access } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import os from "os";
+import { CACHE } from "../config/versions";
+import { Logger } from "../logging";
+
+export interface DependencyTree {
+    dependencies: Dependency[];
+    directCount: number;
+    transitiveCount: number;
+    conflicts: DependencyConflict[];
+    timestamp: number;
+}
+
+export interface Dependency {
+    groupId: string;
+    artifactId: string;
+    version: string;
+    scope?: string;
+    isTransitive: boolean;
+}
+
+export interface DependencyConflict {
+    artifactId: string;
+    versions: string[];
+}
+
+interface CacheEntry {
+    fileHash: string;
+    fileMtime: number;
+    dependencyTree: DependencyTree;
+    cachedAt: number;
+}
+
+export class DependencyCacheService {
+    private logger = Logger.getInstance();
+    private cacheDir: string;
+    private memoryCache: Map<string, CacheEntry> = new Map();
+    
+    constructor() {
+        this.cacheDir = path.join(os.homedir(), '.xavva', 'dependency-cache');
+    }
+
+    /**
+     * Obtém árvore de dependências (do cache ou parseia)
+     */
+    async getDependencyTree(buildFilePath: string): Promise<DependencyTree> {
+        const cacheKey = this.getCacheKey(buildFilePath);
+        
+        // Verifica memory cache primeiro
+        const memoryEntry = this.memoryCache.get(cacheKey);
+        if (memoryEntry && await this.isCacheValid(buildFilePath, memoryEntry)) {
+            this.logger.debug(`Cache de dependências (memory): ${path.basename(buildFilePath)}`);
+            return memoryEntry.dependencyTree;
+        }
+        
+        // Verifica disk cache
+        const diskEntry = await this.loadFromDisk(cacheKey);
+        if (diskEntry && await this.isCacheValid(buildFilePath, diskEntry)) {
+            this.logger.debug(`Cache de dependências (disk): ${path.basename(buildFilePath)}`);
+            // Promove para memory cache
+            this.memoryCache.set(cacheKey, diskEntry);
+            return diskEntry.dependencyTree;
+        }
+        
+        // Parseia e cacheia
+        this.logger.debug(`Parseando dependências: ${path.basename(buildFilePath)}`);
+        const tree = await this.parseDependencies(buildFilePath);
+        await this.setCache(buildFilePath, tree);
+        
+        return tree;
+    }
+
+    /**
+     * Invalida cache para um arquivo específico
+     */
+    async invalidateCache(buildFilePath: string): Promise<void> {
+        const cacheKey = this.getCacheKey(buildFilePath);
+        this.memoryCache.delete(cacheKey);
+        
+        const cachePath = path.join(this.cacheDir, `${cacheKey}.json`);
+        if (existsSync(cachePath)) {
+            await Bun.file(cachePath).delete();
+        }
+    }
+
+    /**
+     * Limpa todo o cache
+     */
+    async clearCache(): Promise<void> {
+        this.memoryCache.clear();
+        
+        if (!existsSync(this.cacheDir)) return;
+        
+        const files = await Array.fromAsync(Bun.file(this.cacheDir).stream());
+        for (const file of files) {
+            // Limpa arquivos de cache
+        }
+        
+        this.logger.info("Cache de dependências limpo");
+    }
+
+    /**
+     * Verifica se cache ainda é válido
+     */
+    private async isCacheValid(buildFilePath: string, entry: CacheEntry): Promise<boolean> {
+        // Verifica idade do cache
+        const cacheAge = Date.now() - entry.cachedAt;
+        if (cacheAge > CACHE.MAX_AGE_MS) {
+            return false;
+        }
+        
+        // Verifica se arquivo mudou
+        try {
+            const stats = await stat(buildFilePath);
+            if (stats.mtimeMs !== entry.fileMtime) {
+                return false;
+            }
+            
+            // Verifica hash para garantir
+            const currentHash = await this.computeFileHash(buildFilePath);
+            return currentHash === entry.fileHash;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Salva no cache
+     */
+    private async setCache(buildFilePath: string, tree: DependencyTree): Promise<void> {
+        const cacheKey = this.getCacheKey(buildFilePath);
+        
+        const stats = await stat(buildFilePath);
+        const fileHash = await this.computeFileHash(buildFilePath);
+        
+        const entry: CacheEntry = {
+            fileHash,
+            fileMtime: stats.mtimeMs,
+            dependencyTree: tree,
+            cachedAt: Date.now(),
+        };
+        
+        // Salva em memory
+        this.memoryCache.set(cacheKey, entry);
+        
+        // Salva em disk
+        await this.saveToDisk(cacheKey, entry);
+    }
+
+    /**
+     * Carrega do disk cache
+     */
+    private async loadFromDisk(cacheKey: string): Promise<CacheEntry | null> {
+        const cachePath = path.join(this.cacheDir, `${cacheKey}.json`);
+        
+        if (!existsSync(cachePath)) {
+            return null;
+        }
+        
+        try {
+            const content = await readFile(cachePath, 'utf-8');
+            return JSON.parse(content);
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Salva no disk cache
+     */
+    private async saveToDisk(cacheKey: string, entry: CacheEntry): Promise<void> {
+        await mkdir(this.cacheDir, { recursive: true });
+        
+        const cachePath = path.join(this.cacheDir, `${cacheKey}.json`);
+        await writeFile(cachePath, JSON.stringify(entry, null, 2));
+    }
+
+    /**
+     * Computa hash do arquivo
+     */
+    private async computeFileHash(filePath: string): Promise<string> {
+        const content = await readFile(filePath);
+        return createHash('md5').update(content).digest('hex');
+    }
+
+    /**
+     * Gera chave de cache única
+     */
+    private getCacheKey(filePath: string): string {
+        // Hash do path absoluto para evitar colisões
+        return createHash('md5').update(path.resolve(filePath)).digest('hex').slice(0, 16);
+    }
+
+    /**
+     * Parseia dependências do arquivo de build
+     * (Implementação básica - pode ser expandida)
+     */
+    private async parseDependencies(buildFilePath: string): Promise<DependencyTree> {
+        const content = await readFile(buildFilePath, 'utf-8');
+        const ext = path.extname(buildFilePath);
+        
+        if (ext === '.xml') {
+            return this.parseMavenDependencies(content);
+        } else if (ext === '.gradle' || ext === '.kts') {
+            return this.parseGradleDependencies(content);
+        }
+        
+        throw new Error(`Formato de arquivo não suportado: ${ext}`);
+    }
+
+    /**
+     * Parseia dependências Maven (pom.xml)
+     */
+    private parseMavenDependencies(xmlContent: string): DependencyTree {
+        const dependencies: Dependency[] = [];
+        const conflicts: DependencyConflict[] = [];
+        
+        // Parse básico de dependencies
+        const depRegex = /<dependency>[\s\S]*?<\/dependency>/g;
+        const matches = xmlContent.match(depRegex) || [];
+        
+        for (const match of matches) {
+            const groupId = this.extractXmlTag(match, 'groupId');
+            const artifactId = this.extractXmlTag(match, 'artifactId');
+            const version = this.extractXmlTag(match, 'version');
+            const scope = this.extractXmlTag(match, 'scope');
+            
+            if (groupId && artifactId) {
+                dependencies.push({
+                    groupId,
+                    artifactId,
+                    version: version || 'managed',
+                    scope: scope || 'compile',
+                    isTransitive: false,
+                });
+            }
+        }
+        
+        return {
+            dependencies,
+            directCount: dependencies.length,
+            transitiveCount: 0,
+            conflicts,
+            timestamp: Date.now(),
+        };
+    }
+
+    /**
+     * Parseia dependências Gradle
+     */
+    private parseGradleDependencies(content: string): DependencyTree {
+        const dependencies: Dependency[] = [];
+        
+        // Parse básico de dependencies
+        const lines = content.split('\n');
+        const depRegex = /(implementation|api|compileOnly|runtimeOnly|testImplementation)\s*['"]([^'"]+)['"]/;
+        
+        for (const line of lines) {
+            const match = line.match(depRegex);
+            if (match) {
+                const scope = match[1];
+                const coords = match[2].split(':');
+                
+                if (coords.length >= 2) {
+                    dependencies.push({
+                        groupId: coords[0],
+                        artifactId: coords[1],
+                        version: coords[2] || 'unspecified',
+                        scope,
+                        isTransitive: false,
+                    });
+                }
+            }
+        }
+        
+        return {
+            dependencies,
+            directCount: dependencies.length,
+            transitiveCount: 0,
+            conflicts: [],
+            timestamp: Date.now(),
+        };
+    }
+
+    /**
+     * Extrai valor de tag XML
+     */
+    private extractXmlTag(xml: string, tag: string): string | null {
+        const regex = new RegExp(`<${tag}>([^<]+)</${tag}>`);
+        const match = xml.match(regex);
+        return match ? match[1].trim() : null;
+    }
+}