@archznn/xavva 3.1.2 → 3.2.0

package/src/logging/index.ts

@@ -0,0 +1,93 @@
+/**
+ * Sistema de Logging do XAVVA CLI
+ * 
+ * Exporta todas as funcionalidades de logging para uso em toda a aplicação.
+ * 
+ * @example
+ * ```typescript
+ * import { Logger, OperationLogger, ProgressLogger, TableLogger } from '../logging';
+ * 
+ * // Log simples
+ * Logger.info('Iniciando processo');
+ * Logger.success('Concluído');
+ * 
+ * // Operação complexa
+ * const op = new OperationLogger('deploy');
+ * op.start();
+ * const buildStep = op.step('build');
+ * await build();
+ * buildStep.success();
+ * op.complete();
+ * 
+ * // Progresso
+ * const progress = new ProgressLogger('Download', { total: 100, unit: 'MB' });
+ * progress.update(50);
+ * progress.complete();
+ * 
+ * // Tabela
+ * const table = new TableLogger(['Nome', 'Versão']);
+ * table.add(['Spring', '5.3.0']);
+ * table.print();
+ * ```
+ */
+
+// Tipos
+export type {
+  LogLevel,
+  LogOutputMode,
+  LogContext,
+  LogEntry,
+  LoggerConfig,
+  RateLimitEntry,
+  OperationStep,
+  TableColumn,
+  TableRow,
+} from './types';
+
+// Cores e utilitários
+export {
+  Colors,
+  Icons,
+  colorize,
+  stripAnsi,
+  visualWidth,
+  padText,
+  truncateText,
+  getIcon,
+  supportsColor,
+} from './colors';
+
+// Constantes
+export {
+  DEFAULT_CONFIG,
+  LOG_LEVELS,
+  LEVEL_COLORS,
+  LEVEL_ICONS,
+  LAYOUT,
+  NOISE_PATTERNS,
+  ESSENTIAL_PATTERNS,
+  SPINNER_FRAMES,
+  SPINNER_INTERVAL,
+  FILE_LOG,
+} from './constants';
+
+// Formatadores
+export {
+  formatEntry,
+  formatStatusLine,
+  formatSection,
+  formatConfig,
+  formatUrl,
+  formatFile,
+} from './formatters';
+
+// Logger principal
+export { Logger, logger } from './Logger';
+
+// Loggers especializados
+export { OperationLogger, OperationStepLogger, createOperation } from './OperationLogger';
+export { ProgressLogger, createProgress } from './ProgressLogger';
+export { TableLogger, createTable, printTable } from './TableLogger';
+
+// FileLogger
+export { FileLogger, getFileLogger, configureFileLogger } from './FileLogger';

package/src/logging/types.ts

@@ -0,0 +1,64 @@
+/**
+ * Tipos do sistema de logging
+ */
+
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'success' | 'debug' | 'trace' | 'silly';
+
+export type LogOutputMode = 'pretty' | 'json' | 'minimal' | 'silent';
+
+export interface LogContext {
+  timestamp?: boolean;
+  traceId?: string;
+  indent?: number;
+  prefix?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: Date;
+  context?: LogContext;
+  metadata?: Record<string, unknown>;
+}
+
+export interface LoggerConfig {
+  level: LogLevel;
+  mode: LogOutputMode;
+  timestamps: boolean;
+  colors: boolean;
+  icons: boolean;
+  fileLogging: boolean;
+  logDir: string;
+  maxLogFiles: number;
+  rateLimitWindowMs: number;
+  maxDuplicateLogs: number;
+}
+
+export interface RateLimitEntry {
+  message: string;
+  count: number;
+  firstSeen: number;
+  lastSeen: number;
+}
+
+export interface OperationStep {
+  id: string;
+  name: string;
+  status: 'pending' | 'running' | 'success' | 'failed';
+  startTime?: Date;
+  endTime?: Date;
+  message?: string;
+  error?: Error;
+}
+
+export interface TableColumn {
+  header: string;
+  align?: 'left' | 'center' | 'right';
+  width?: number;
+}
+
+export interface TableRow {
+  cells: string[];
+  styles?: string[];
+}

package/src/plugins/PluginManager.ts

@@ -0,0 +1,325 @@
+/**
+ * Gerenciador de Plugins do XAVVA CLI
+ * 
+ * Responsável por:
+ * - Carregar plugins de npm ou caminhos locais
+ * - Executar hooks em pontos específicos
+ * - Gerenciar comandos de plugins
+ */
+
+import path from "path";
+import { existsSync } from "fs";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import os from "os";
+import type { AppConfig } from "../types/config";
+import { Logger } from "../logging";
+import type { 
+    XavvaPlugin, 
+    LoadedPlugin, 
+    PluginConfig,
+    BuildContext,
+    DeployContext,
+    TestContext,
+} from "./types";
+
+export class PluginManager {
+    private plugins: LoadedPlugin[] = [];
+    private logger = Logger.getInstance();
+    private pluginsDir: string;
+    private config: AppConfig;
+
+    constructor(config: AppConfig) {
+        this.config = config;
+        this.pluginsDir = path.join(os.homedir(), ".xavva", "plugins");
+    }
+
+    /**
+     * Carrega todos os plugins configurados
+     */
+    async loadPlugins(): Promise<void> {
+        const pluginConfigs = this.config.project.plugins as PluginConfig[] || [];
+        
+        if (pluginConfigs.length === 0) {
+            this.logger.debug("Nenhum plugin configurado");
+            return;
+        }
+
+        this.logger.section(`Carregando ${pluginConfigs.length} plugin(s)`);
+
+        for (const pluginConfig of pluginConfigs) {
+            try {
+                await this.loadPlugin(pluginConfig);
+            } catch (error) {
+                this.logger.error(`Falha ao carregar plugin ${pluginConfig.name}: ${(error as Error).message}`);
+            }
+        }
+
+        this.logger.success(`${this.plugins.length} plugin(s) carregado(s)`);
+    }
+
+    /**
+     * Carrega um plugin específico
+     */
+    private async loadPlugin(config: PluginConfig): Promise<void> {
+        const { name, path: pluginPath, config: pluginConfigData } = config;
+
+        this.logger.step(`Carregando: ${name}`);
+
+        // Resolve caminho do plugin
+        const resolvedPath = this.resolvePluginPath(name, pluginPath);
+        
+        // Importa plugin
+        const pluginModule = await import(resolvedPath);
+        const plugin: XavvaPlugin = pluginModule.default || pluginModule;
+
+        // Valida plugin
+        this.validatePlugin(plugin);
+
+        // Inicializa se necessário
+        if (plugin.initialize) {
+            await plugin.initialize(this.config);
+        }
+
+        // Registra plugin
+        this.plugins.push({
+            plugin,
+            path: resolvedPath,
+            config: pluginConfigData,
+        });
+
+        this.logger.info(`  ✓ ${plugin.name} v${plugin.version}`);
+        if (plugin.description) {
+            this.logger.info(`    ${plugin.description}`);
+        }
+    }
+
+    /**
+     * Resolve caminho do plugin
+     */
+    private resolvePluginPath(name: string, customPath?: string): string {
+        // Caminho customizado tem prioridade
+        if (customPath) {
+            if (customPath.startsWith("./") || customPath.startsWith("../")) {
+                return path.resolve(process.cwd(), customPath);
+            }
+            return customPath;
+        }
+
+        // Tenta carregar de node_modules
+        const npmPath = path.join(process.cwd(), "node_modules", name);
+        if (existsSync(npmPath)) {
+            return npmPath;
+        }
+
+        // Tenta carregar do diretório de plugins do Xavva
+        const xavvaPluginPath = path.join(this.pluginsDir, name);
+        if (existsSync(xavvaPluginPath)) {
+            return xavvaPluginPath;
+        }
+
+        // Tenta carregar como caminho relativo
+        const relativePath = path.join(process.cwd(), name);
+        if (existsSync(relativePath)) {
+            return relativePath;
+        }
+
+        throw new Error(`Plugin não encontrado: ${name}`);
+    }
+
+    /**
+     * Valida estrutura do plugin
+     */
+    private validatePlugin(plugin: XavvaPlugin): void {
+        if (!plugin.name) {
+            throw new Error("Plugin deve ter um nome");
+        }
+        
+        if (!plugin.version) {
+            throw new Error("Plugin deve ter uma versão");
+        }
+    }
+
+    /**
+     * Executa hook beforeBuild em todos os plugins
+     */
+    async executeBeforeBuild(context: BuildContext): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.hooks?.beforeBuild) {
+                try {
+                    await plugin.hooks.beforeBuild(context);
+                } catch (error) {
+                    this.logger.warn(`Plugin ${plugin.name} falhou em beforeBuild: ${(error as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Executa hook afterBuild em todos os plugins
+     */
+    async executeAfterBuild(context: BuildContext, success: boolean): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.hooks?.afterBuild) {
+                try {
+                    await plugin.hooks.afterBuild(context, success);
+                } catch (error) {
+                    this.logger.warn(`Plugin ${plugin.name} falhou em afterBuild: ${(error as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Executa hook beforeDeploy em todos os plugins
+     */
+    async executeBeforeDeploy(context: DeployContext): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.hooks?.beforeDeploy) {
+                try {
+                    await plugin.hooks.beforeDeploy(context);
+                } catch (error) {
+                    this.logger.warn(`Plugin ${plugin.name} falhou em beforeDeploy: ${(error as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Executa hook afterDeploy em todos os plugins
+     */
+    async executeAfterDeploy(context: DeployContext, success: boolean): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.hooks?.afterDeploy) {
+                try {
+                    await plugin.hooks.afterDeploy(context, success);
+                } catch (error) {
+                    this.logger.warn(`Plugin ${plugin.name} falhou em afterDeploy: ${(error as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Executa hook beforeTest em todos os plugins
+     */
+    async executeBeforeTest(context: TestContext): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.hooks?.beforeTest) {
+                try {
+                    await plugin.hooks.beforeTest(context);
+                } catch (error) {
+                    this.logger.warn(`Plugin ${plugin.name} falhou em beforeTest: ${(error as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Executa hook afterTest em todos os plugins
+     */
+    async executeAfterTest(context: TestContext, success: boolean): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.hooks?.afterTest) {
+                try {
+                    await plugin.hooks.afterTest(context, success);
+                } catch (error) {
+                    this.logger.warn(`Plugin ${plugin.name} falhou em afterTest: ${(error as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Obtém comandos de todos os plugins
+     */
+    getPluginCommands(): Map<string, import("../commands/Command").Command> {
+        const commands = new Map<string, import("../commands/Command").Command>();
+        
+        for (const { plugin } of this.plugins) {
+            if (plugin.commands) {
+                for (const command of plugin.commands) {
+                    // Assume que comando tem nome ou usa classe
+                    const name = (command as any).name || command.constructor.name.toLowerCase();
+                    commands.set(name, command);
+                }
+            }
+        }
+        
+        return commands;
+    }
+
+    /**
+     * Lista plugins carregados
+     */
+    listPlugins(): Array<{ name: string; version: string; description?: string }> {
+        return this.plugins.map(({ plugin }) => ({
+            name: plugin.name,
+            version: plugin.version,
+            description: plugin.description,
+        }));
+    }
+
+    /**
+     * Destrói todos os plugins
+     */
+    async destroy(): Promise<void> {
+        for (const { plugin } of this.plugins) {
+            if (plugin.destroy) {
+                try {
+                    await plugin.destroy();
+                } catch (error) {
+                    this.logger.warn(`Erro ao destruir plugin ${plugin.name}: ${(error as Error).message}`);
+                }
+            }
+        }
+        this.plugins = [];
+    }
+
+    /**
+     * Instala plugin via npm
+     */
+    async installPlugin(name: string): Promise<void> {
+        this.logger.step(`Instalando plugin: ${name}`);
+        
+        // Cria diretório se não existe
+        await mkdir(this.pluginsDir, { recursive: true });
+
+        // Executa npm install
+        const proc = Bun.spawn([
+            "npm", "install", name, "--prefix", this.pluginsDir, "--no-save"
+        ], {
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+
+        const exitCode = await proc.exited;
+        
+        if (exitCode !== 0) {
+            const error = await new Response(proc.stderr).text();
+            throw new Error(`npm install falhou: ${error}`);
+        }
+
+        this.logger.success(`Plugin ${name} instalado`);
+    }
+
+    /**
+     * Remove plugin
+     */
+    async uninstallPlugin(name: string): Promise<void> {
+        this.logger.step(`Removendo plugin: ${name}`);
+        
+        const proc = Bun.spawn([
+            "npm", "uninstall", name, "--prefix", this.pluginsDir
+        ], {
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+
+        await proc.exited;
+        
+        // Remove da lista de plugins carregados
+        this.plugins = this.plugins.filter(p => p.plugin.name !== name);
+        
+        this.logger.success(`Plugin ${name} removido`);
+    }
+}

package/src/plugins/types.ts

@@ -0,0 +1,82 @@
+/**
+ * Tipos para o Sistema de Plugins do XAVVA CLI
+ */
+
+import type { Command } from "../commands/Command";
+import type { AppConfig } from "../types/config";
+import type { z } from "zod";
+
+// Contextos de hooks
+export interface BuildContext {
+    config: AppConfig;
+    incremental: boolean;
+    changedFiles?: string[];
+}
+
+export interface DeployContext {
+    config: AppConfig;
+    targetPath: string;
+}
+
+export interface TestContext {
+    config: AppConfig;
+    filter?: string;
+    coverage: boolean;
+}
+
+// Hook handlers
+export type BeforeBuildHook = (context: BuildContext) => Promise<void> | void;
+export type AfterBuildHook = (context: BuildContext, success: boolean) => Promise<void> | void;
+export type BeforeDeployHook = (context: DeployContext) => Promise<void> | void;
+export type AfterDeployHook = (context: DeployContext, success: boolean) => Promise<void> | void;
+export type BeforeTestHook = (context: TestContext) => Promise<void> | void;
+export type AfterTestHook = (context: TestContext, success: boolean) => Promise<void> | void;
+
+// Interface do plugin
+export interface XavvaPlugin {
+    /** Nome único do plugin */
+    name: string;
+    
+    /** Versão do plugin (semver) */
+    version: string;
+    
+    /** Descrição */
+    description?: string;
+    
+    /** Comandos adicionados pelo plugin */
+    commands?: Command[];
+    
+    /** Hooks */
+    hooks?: {
+        beforeBuild?: BeforeBuildHook;
+        afterBuild?: AfterBuildHook;
+        beforeDeploy?: BeforeDeployHook;
+        afterDeploy?: AfterDeployHook;
+        beforeTest?: BeforeTestHook;
+        afterTest?: AfterTestHook;
+    };
+    
+    /** Schema de configuração estendida */
+    configSchema?: z.ZodSchema;
+    
+    /** Inicialização do plugin */
+    initialize?(config: AppConfig): Promise<void> | void;
+    
+    /** Cleanup ao finalizar */
+    destroy?(): Promise<void> | void;
+}
+
+// Metadados de plugin carregado
+export interface LoadedPlugin {
+    plugin: XavvaPlugin;
+    path: string;
+    config?: Record<string, unknown>;
+}
+
+// Configuração de plugin no xavva.json
+export interface PluginConfig {
+    name: string;
+    version?: string;
+    path?: string;
+    config?: Record<string, unknown>;
+}

package/src/services/AuditService.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import type { TomcatConfig } from "../types";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { AuditError } from "../errors/XavvaError";
 
 export interface Vulnerability {
@@ -47,6 +47,8 @@ interface OSVResponse {
 }
 
 export class AuditService {
+    private logger = Logger.getInstance();
+
     constructor(private tomcatConfig: TomcatConfig) {}
 
     async runAudit(appName: string): Promise<JarAuditResult[]> {
@@ -59,7 +61,7 @@ export class AuditService {
         const jars = fs.readdirSync(libPath).filter(f => f.endsWith(".jar"));
         const results: JarAuditResult[] = [];
 
-        const stopSpinner = Logger.spinner(`Auditando ${jars.length} dependências`);
+        const stopSpinner = this.logger.spinner(`Auditando ${jars.length} dependências`);
 
         const chunkSize = 10;
         for (let i = 0; i < jars.length; i += chunkSize) {
@@ -69,7 +71,7 @@ export class AuditService {
             results.push(...chunkResults);
         }
 
-        stopSpinner();
+        stopSpinner.stop();
         return results;
     }
 

package/src/services/BuildService.ts

@@ -1,11 +1,13 @@
 import { readdirSync, existsSync, statSync, mkdirSync, promises as fs } from "fs";
 import path from "path";
 import type { ProjectConfig, TomcatConfig } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { BuildCacheService } from "./BuildCacheService";
 import { ProjectService } from "./ProjectService";
 
 export class BuildService {
+	private logger = Logger.getInstance();
+
 	constructor(
 		private projectConfig: ProjectConfig, 
 		private tomcatConfig: TomcatConfig,
@@ -40,7 +42,7 @@ export class BuildService {
 		
 		if (useCache && !incremental && !this.projectConfig.skipBuild) {
 			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool, this.projectService)) {
-				Logger.success("Build cache hit! Skipping full build.");
+				this.logger.success("Cache de build atingido! Pulando build completo.");
 				return;
 			}
 		}
@@ -96,7 +98,7 @@ export class BuildService {
 			env.GRADLE_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
 		}
 
-		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
+		const spinner = this.projectConfig.verbose ? null : this.logger.spinner(incremental ? "Compilação incremental" : "Build completo do projeto");
 
 		// No Windows, comandos .cmd/.bat muitas vezes precisam de shell: true no Bun.spawn ou o nome exato.
 		// Vamos usar o nome exato mvn.cmd/gradle.bat que é mais seguro que shell: true
@@ -114,14 +116,14 @@ export class BuildService {
 		}
 
 		await proc.exited;
-		stopSpinner();
+		spinner?.stop();
 
 		if (proc.exitCode !== 0) {
             if (!this.projectConfig.verbose) {
                 const err = await new Response(proc.stderr).text();
-                Logger.log(err);
+                console.log(err);
             }
-            Logger.error(`${this.projectConfig.buildTool.toUpperCase()} build failed!`);
+            this.logger.error(`${this.projectConfig.buildTool.toUpperCase()} build falhou!`);
             throw new Error("Falha no build do Java!");
         }
 
@@ -141,11 +143,11 @@ export class BuildService {
 		
 		if (existsSync(buildDir)) {
 			try {
-				Logger.step(`Cleaning ${path.basename(buildDir)}/ directory...`);
+				this.logger.debug(`Limpando diretório ${path.basename(buildDir)}/...`);
 				await fs.rm(buildDir, { recursive: true, force: true });
-				Logger.debug(`Removed ${buildDir}`);
+            // Directory removed
 			} catch (e) {
-				Logger.warn(`Could not fully remove ${buildDir}, continuing...`);
+				this.logger.warn(`Não foi possível remover completamente ${buildDir}, continuando...`);
 			}
 		}
 	}
@@ -219,7 +221,7 @@ export class BuildService {
 		if (syncedCount.value === 0) {
 			await this.fastSync(sourceDir, targetLib);
 		} else if (!this.projectConfig.quiet) {
-			Logger.info("sync", `${syncedCount.value} classe(s) sincronizada(s)`);
+			this.logger.info(`${syncedCount.value} classe(s) sincronizada(s)`);
 		}
 	}
 	
@@ -324,15 +326,11 @@ export class BuildService {
 
 				if (!this.projectConfig.verbose) {
 					// Modo não-verbose: usa sumarização existente
-					const formatted = Logger.formatBuildLog(cleanLine, buildTool);
+					const formatted = this.logger.constructor.name === 'Logger' ? '' : cleanLine;
 					if (formatted) console.log(formatted);
 				} else {
-					// Modo verbose: formata mas mantém estrutura
-					const formatted = Logger.formatBuildLog(cleanLine, buildTool);
-					if (formatted) {
-						console.log(formatted);
-					}
-					// Silencia linhas que são noise puro
+					// Modo verbose: mostra todas as linhas
+					console.log(`  ${cleanLine.slice(0, 100)}`);
 				}
 			}
 		}