@archznn/xavva 3.1.2 → 3.2.0

package/src/errors/errorMessages.ts

@@ -0,0 +1,235 @@
+/**
+ * Mensagens de erro contextuais com sugestões e auto-fix
+ */
+
+import { Logger } from "../logging";
+
+export interface ErrorContext {
+    message: string;
+    suggestion: string;
+    docsUrl?: string;
+    autoFix?: () => Promise<boolean>;
+    command?: string;
+}
+
+export const ErrorMessages: Record<string, ErrorContext> = {
+    // Build errors
+    MAVEN_NOT_FOUND: {
+        message: "Maven não encontrado no PATH",
+        suggestion: "Instale o Maven ou adicione ao PATH\n" +
+                   "  • Windows: choco install maven\n" +
+                   "  • macOS: brew install maven\n" +
+                   "  • Linux: sudo apt install maven",
+        docsUrl: "https://maven.apache.org/install.html",
+        command: "xavva doctor --fix",
+    },
+    
+    GRADLE_NOT_FOUND: {
+        message: "Gradle não encontrado no PATH",
+        suggestion: "Instale o Gradle ou adicione ao PATH\n" +
+                   "  • Windows: choco install gradle\n" +
+                   "  • macOS: brew install gradle\n" +
+                   "  • Linux: sdk install gradle",
+        docsUrl: "https://gradle.org/install/",
+        command: "xavva doctor --fix",
+    },
+    
+    BUILD_FAILED: {
+        message: "Build falhou",
+        suggestion: "Use --verbose para ver detalhes completos\n" +
+                   "Verifique se todas as dependências estão disponíveis",
+        command: "xavva build --verbose",
+    },
+    
+    // Tomcat errors
+    TOMCAT_NOT_FOUND: {
+        message: "Tomcat não encontrado",
+        suggestion: "Defina TOMCAT_HOME ou use Tomcat embutido\n" +
+                   "Execute 'xavva dev --yes' para instalação automática",
+        command: "xavva dev --yes",
+    },
+    
+    TOMCAT_PORT_IN_USE: {
+        message: "Porta {port} já está em uso",
+        suggestion: "Escolha outra porta ou pare o processo atual",
+        command: "xavva dev --port 8081",
+    },
+    
+    // Java errors
+    JAVA_NOT_FOUND: {
+        message: "Java não encontrado no PATH",
+        suggestion: "Instale JDK 11+ ou defina JAVA_HOME\n" +
+                   "Execute 'xavva doctor --fix' para configuração automática",
+        command: "xavva doctor --fix",
+    },
+    
+    JAVA_VERSION_TOO_OLD: {
+        message: "Versão do Java muito antiga ({version})",
+        suggestion: "JDK 11+ é necessário\n" +
+                   "Execute 'xavva doctor --fix' para instalar JDK moderno",
+        command: "xavva doctor --fix",
+    },
+    
+    // Config errors
+    CONFIG_INVALID: {
+        message: "Configuração inválida em xavva.json",
+        suggestion: "Verifique sintaxe JSON e campos obrigatórios\n" +
+                   "Execute 'xavva config' para ver configuração atual",
+        command: "xavva config",
+    },
+    
+    // Network errors
+    DOWNLOAD_FAILED: {
+        message: "Falha no download",
+        suggestion: "Verifique conexão de internet\n" +
+                   "Tente novamente em alguns instantes",
+    },
+    
+    TIMEOUT: {
+        message: "Tempo de espera esgotado",
+        suggestion: "Operação demorou muito tempo\n" +
+                   "Verifique conexão ou tente aumentar o timeout",
+    },
+    
+    // File system errors
+    PERMISSION_DENIED: {
+        message: "Permissão negada",
+        suggestion: "Execute com permissões adequadas\n" +
+                   "Windows: Execute como Administrador\n" +
+                   "Linux/macOS: Use sudo se necessário",
+    },
+    
+    DISK_FULL: {
+        message: "Disco cheio",
+        suggestion: "Libere espaço em disco\n" +
+                   "Execute 'xavva clean' para limpar arquivos temporários",
+        command: "xavva clean",
+    },
+    
+    // Port errors
+    PORT_UNAVAILABLE: {
+        message: "Porta não disponível",
+        suggestion: "Porta pode estar em uso ou bloqueada pelo firewall\n" +
+                   "Use outra porta: xavva dev --port 8081",
+        command: "xavva dev --port 8081",
+    },
+    
+    // Watch errors
+    WATCH_TOO_MANY_FILES: {
+        message: "Muitos arquivos para monitorar",
+        suggestion: "Exclua node_modules do watch\n" +
+                   "Adicione ao .gitignore ou use --exclude",
+    },
+};
+
+/**
+ * Obtém mensagem de erro contextual
+ */
+export function getErrorMessage(code: string, params: Record<string, string> = {}): ErrorContext {
+    const template = ErrorMessages[code] || {
+        message: `Erro desconhecido: ${code}`,
+        suggestion: "Consulte a documentação ou reporte o problema",
+    };
+    
+    // Substitui parâmetros
+    let message = template.message;
+    for (const [key, value] of Object.entries(params)) {
+        message = message.replace(`{${key}}`, value);
+    }
+    
+    return {
+        ...template,
+        message,
+    };
+}
+
+/**
+ * Mostra erro com contexto
+ */
+export function showContextualError(code: string, params: Record<string, string> = {}): void {
+    const logger = Logger.getInstance();
+    const error = getErrorMessage(code, params);
+    
+    logger.error(error.message);
+    
+    if (error.suggestion) {
+        logger.newline();
+        logger.info("💡 Dica:");
+        for (const line of error.suggestion.split('\n')) {
+            logger.info(`   ${line}`);
+        }
+    }
+    
+    if (error.command) {
+        logger.newline();
+        logger.info(`🔧 Tente: ${error.command}`);
+    }
+    
+    if (error.docsUrl) {
+        logger.newline();
+        logger.url("📖 Documentação", error.docsUrl);
+    }
+}
+
+/**
+ * Tenta executar auto-fix para um erro
+ */
+export async function tryAutoFix(code: string): Promise<boolean> {
+    const error = ErrorMessages[code];
+    
+    if (!error?.autoFix) {
+        return false;
+    }
+    
+    const logger = Logger.getInstance();
+    logger.info(`🔧 Tentando correção automática...`);
+    
+    try {
+        return await error.autoFix();
+    } catch (e) {
+        logger.error(`Auto-fix falhou: ${(e as Error).message}`);
+        return false;
+    }
+}
+
+/**
+ * Detecta código de erro baseado na mensagem
+ */
+export function detectErrorCode(message: string): string | null {
+    const patterns: Record<string, RegExp[]> = {
+        MAVEN_NOT_FOUND: [/mvn[\s\w]*not found/i, /maven.*not.*found/i, /cannot find.*mvn/i],
+        GRADLE_NOT_FOUND: [/gradle[\s\w]*not found/i, /cannot find.*gradle/i],
+        JAVA_NOT_FOUND: [/java[\s\w]*not found/i, /cannot find.*java/i, /no java/i],
+        BUILD_FAILED: [/build failed/i, /compilation failed/i, /failed to compile/i],
+        TOMCAT_PORT_IN_USE: [/port.*in use/i, /address already in use/i, /bind.*failed/i],
+        PERMISSION_DENIED: [/permission denied/i, /access denied/i, /eacces/i],
+        DISK_FULL: [/disk full/i, /no space left/i, /enospc/i],
+        TIMEOUT: [/timeout/i, /timed out/i, /etimedout/i],
+    };
+    
+    for (const [code, regexes] of Object.entries(patterns)) {
+        for (const regex of regexes) {
+            if (regex.test(message)) {
+                return code;
+            }
+        }
+    }
+    
+    return null;
+}
+
+/**
+ * Mostra erro genérico com detecção automática
+ */
+export function showSmartError(error: Error | string): void {
+    const message = error instanceof Error ? error.message : error;
+    const code = detectErrorCode(message);
+    
+    if (code) {
+        showContextualError(code);
+    } else {
+        const logger = Logger.getInstance();
+        logger.error(message);
+        logger.info("Use --verbose para mais detalhes ou consulte a documentação");
+    }
+}

package/src/index.ts

@@ -7,7 +7,7 @@ import { ErrorHandler } from "./errors/ErrorHandler";
 import { ProcessManager } from "./utils/processManager";
 import { LoggerLevel } from "./utils/LoggerLevel";
 import pkg from "../package.json";
-import { Logger } from "./utils/ui";
+import { Logger, C } from "./utils/ui";
 import type { CLIArguments } from "./types/args";
 
 async function main() {
@@ -32,7 +32,7 @@ async function main() {
         "debug", "logs", "docs", "audit", "profiles", 
         "deps", "tomcat", "encoding", "init", "config", 
         "history", "redo", "health", "completion", "changelog",
-        "test", "db", "http", "docker", "help"
+        "test", "db", "http", "docker", "help", "clean", "ide"
     ];
     const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
@@ -49,9 +49,15 @@ async function main() {
 
     // Handler de help
     if (values.help) {
-        const { HelpCommand } = await import("./commands/HelpCommand");
-        new HelpCommand().execute(config, values as CLIArguments);
-        await processManager.shutdown(0);
+        // Se for help de comando específico, deixa o comando tratar
+        if (commandName !== "help" && commandName !== "deploy") {
+            // O comando específico vai tratar o --help
+        } else {
+            // Help geral
+            const { HelpCommand } = await import("./commands/HelpCommand");
+            new HelpCommand().execute(config, values as CLIArguments);
+            await processManager.shutdown(0);
+        }
     }
 
     // Inicializa Container de DI
@@ -71,7 +77,7 @@ async function main() {
     if (values.tui) {
         const deployCmd = commands.deploy;
         services.dashboardService.onAction("r", () => {
-            services.dashboardService.log(Logger.C.warning + "Restart manual solicitado via TUI...");
+            services.dashboardService.log(C.warning + "Restart manual solicitado via TUI...");
             deployCmd.execute(config, { watch: true, incremental: false });
         });
     }
@@ -116,6 +122,8 @@ async function main() {
         registry.register("db", commands.db);
         registry.register("http", commands.http);
         registry.register("docker", commands.docker);
+        registry.register("clean", commands.clean);
+        registry.register("ide", commands.ide);
 
         // Configura flags específicas
         if (commandName === "debug") values.debug = true;
@@ -158,6 +166,12 @@ async function main() {
             }
         }
     }
+
+    // Só encerra o processo se não estiver em modo watch ou TUI
+    // (esses modos precisam continuar rodando)
+    if (!values.watch && !values.tui) {
+        await ProcessManager.getInstance().shutdown(0);
+    }
 }
 
 // Entry point com tratamento global de erros

package/src/logging/FileLogger.ts

@@ -0,0 +1,235 @@
+/**
+ * FileLogger - Persistência de logs em arquivo
+ * 
+ * Salva logs em formato JSON Lines (.jsonl) para fácil integração
+ * com ferramentas de análise como ELK, Datadog, etc.
+ * 
+ * Características:
+ * - Rotação automática por data
+ * - Limite de tamanho por arquivo
+ * - Limite de arquivos retidos
+ * - Formato estruturado (JSON)
+ */
+
+import { existsSync, mkdirSync, appendFileSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import type { LogEntry } from './types';
+import { FILE_LOG } from './constants';
+
+export interface FileLoggerOptions {
+  logDir: string;
+  maxFiles: number;
+  maxSize: number;
+  enabled: boolean;
+}
+
+export class FileLogger {
+  private options: FileLoggerOptions;
+  private currentFile: string | null = null;
+  private currentSize = 0;
+  private initialized = false;
+
+  constructor(options: Partial<FileLoggerOptions> = {}) {
+    this.options = {
+      logDir: '.xavva/logs',
+      maxFiles: FILE_LOG.maxFiles,
+      maxSize: FILE_LOG.maxSize,
+      enabled: true,
+      ...options,
+    };
+  }
+
+  /**
+   * Inicializa o diretório de logs
+   */
+  private initialize(): void {
+    if (this.initialized || !this.options.enabled) return;
+    
+    try {
+      if (!existsSync(this.options.logDir)) {
+        mkdirSync(this.options.logDir, { recursive: true });
+      }
+      this.initialized = true;
+    } catch (error) {
+      console.error('Falha ao inicializar diretório de logs:', error);
+      this.options.enabled = false;
+    }
+  }
+
+  /**
+   * Obtém o nome do arquivo de log atual
+   */
+  private getCurrentFileName(): string {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return join(this.options.logDir, `xavva-${year}-${month}-${day}.jsonl`);
+  }
+
+  /**
+   * Verifica se precisa rotacionar para novo arquivo
+   */
+  private checkRotation(): void {
+    const newFile = this.getCurrentFileName();
+    
+    if (this.currentFile !== newFile) {
+      // Mudou de dia, atualiza arquivo
+      this.currentFile = newFile;
+      this.currentSize = existsSync(newFile) ? statSync(newFile).size : 0;
+      this.cleanupOldFiles();
+    } else if (this.currentFile && this.currentSize > this.options.maxSize) {
+      // Arquivo muito grande, cria novo com sufixo
+      const timestamp = Date.now();
+      this.currentFile = this.currentFile.replace('.jsonl', `-${timestamp}.jsonl`);
+      this.currentSize = 0;
+    }
+  }
+
+  /**
+   * Remove arquivos de log antigos
+   */
+  private cleanupOldFiles(): void {
+    try {
+      if (!existsSync(this.options.logDir)) return;
+      
+      const files = readdirSync(this.options.logDir)
+        .filter(f => f.startsWith('xavva-') && f.endsWith('.jsonl'))
+        .map(f => ({
+          name: f,
+          path: join(this.options.logDir, f),
+          time: statSync(join(this.options.logDir, f)).mtime.getTime(),
+        }))
+        .sort((a, b) => b.time - a.time); // Mais recente primeiro
+      
+      // Remove arquivos excedentes
+      const filesToRemove = files.slice(this.options.maxFiles);
+      for (const file of filesToRemove) {
+        try {
+          unlinkSync(file.path);
+        } catch {
+          // Ignora erros de deleção
+        }
+      }
+    } catch {
+      // Ignora erros de cleanup
+    }
+  }
+
+  /**
+   * Escreve uma entrada de log no arquivo
+   */
+  write(entry: LogEntry): void {
+    if (!this.options.enabled) return;
+    
+    this.initialize();
+    this.checkRotation();
+    
+    if (!this.currentFile) return;
+    
+    try {
+      // Formata como JSON Lines
+      const logLine = JSON.stringify({
+        timestamp: entry.timestamp.toISOString(),
+        level: entry.level,
+        message: entry.message.replace(/\x1b\[\d+m/g, ''), // Remove ANSI
+        traceId: entry.context?.traceId,
+        metadata: entry.metadata,
+      }) + '\n';
+      
+      appendFileSync(this.currentFile, logLine);
+      this.currentSize += Buffer.byteLength(logLine);
+    } catch (error) {
+      // Falha silenciosa - não deve quebrar a aplicação por causa de log em arquivo
+      if (process.env.XAVVA_DEBUG) {
+        console.error('Falha ao escrever log em arquivo:', error);
+      }
+    }
+  }
+
+  /**
+   * Habilita/desabilita logging em arquivo
+   */
+  setEnabled(enabled: boolean): void {
+    this.options.enabled = enabled;
+  }
+
+  /**
+   * Verifica se está habilitado
+   */
+  isEnabled(): boolean {
+    return this.options.enabled;
+  }
+
+  /**
+   * Obtém caminho do diretório de logs
+   */
+  getLogDir(): string {
+    return this.options.logDir;
+  }
+
+  /**
+   * Lista arquivos de log existentes
+   */
+  listLogFiles(): { name: string; path: string; size: number; modified: Date }[] {
+    try {
+      if (!existsSync(this.options.logDir)) return [];
+      
+      return readdirSync(this.options.logDir)
+        .filter(f => f.startsWith('xavva-') && f.endsWith('.jsonl'))
+        .map(f => {
+          const path = join(this.options.logDir, f);
+          const stats = statSync(path);
+          return {
+            name: f,
+            path,
+            size: stats.size,
+            modified: stats.mtime,
+          };
+        })
+        .sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Limpa todos os arquivos de log
+   */
+  clearAll(): void {
+    try {
+      const files = this.listLogFiles();
+      for (const file of files) {
+        unlinkSync(file.path);
+      }
+      this.currentFile = null;
+      this.currentSize = 0;
+    } catch {
+      // Ignora erros
+    }
+  }
+}
+
+// Instância global
+let globalFileLogger: FileLogger | null = null;
+
+/**
+ * Obtém instância global do FileLogger
+ */
+export function getFileLogger(options?: Partial<FileLoggerOptions>): FileLogger {
+  if (!globalFileLogger) {
+    globalFileLogger = new FileLogger(options);
+  }
+  return globalFileLogger;
+}
+
+/**
+ * Configura o FileLogger global
+ */
+export function configureFileLogger(options: Partial<FileLoggerOptions>): void {
+  if (globalFileLogger) {
+    globalFileLogger = new FileLogger({ ...globalFileLogger, ...options });
+  } else {
+    globalFileLogger = new FileLogger(options);
+  }
+}