@archznn/xavva 2.6.0 → 2.8.0

package/src/commands/EncodingCommand.ts

@@ -0,0 +1,351 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { EncodingService } from "../services/EncodingService";
+import { Logger } from "../utils/ui";
+import path from "path";
+import { existsSync } from "fs";
+import { ProcessManager } from "../utils/processManager";
+
+export class EncodingCommand implements Command {
+    private encodingService: EncodingService;
+
+    constructor() {
+        this.encodingService = new EncodingService();
+    }
+
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        
+        // Parse subcomando
+        const subcommand = positionals?.[1] || "help";
+        const fileArg = positionals?.[2]; // Arquivo específico (opcional)
+
+        switch (subcommand) {
+            case "detect":
+                await this.handleDetect(fileArg);
+                break;
+            case "convert":
+                await this.handleConvert(config, args, fileArg);
+                break;
+            case "fix":
+                await this.handleFix(fileArg, args);
+                break;
+            case "list":
+                await this.handleList(config);
+                break;
+            case "help":
+            default:
+                this.showHelp();
+                break;
+        }
+
+        await processManager.shutdown(0);
+    }
+
+    private showHelp() {
+        Logger.section("Encoding Command");
+        Logger.log("Gerencia conversão de encoding de arquivos de texto");
+        Logger.newline();
+        
+        Logger.log(`${Logger.C.primary}Uso:${Logger.C.reset}`);
+        Logger.log("  xavva encoding <subcomando> [arquivo] [opções]");
+        Logger.newline();
+        
+        Logger.log(`${Logger.C.primary}Subcomandos:${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.secondary}detect${Logger.C.reset} [arquivo]          Detecta encoding de um arquivo ou diretório`);
+        Logger.log(`  ${Logger.C.secondary}convert${Logger.C.reset} [arquivo]          Converte arquivo(s) para outro encoding`);
+        Logger.log(`  ${Logger.C.secondary}fix${Logger.C.reset} [arquivo]              Tenta corrigir mojibake automaticamente`);
+        Logger.log(`  ${Logger.C.secondary}list${Logger.C.reset}                     Lista encodings de todos os arquivos do projeto`);
+        Logger.log(`  ${Logger.C.secondary}help${Logger.C.reset}                     Mostra esta ajuda`);
+        Logger.newline();
+        
+        Logger.log(`${Logger.C.primary}Opções:${Logger.C.reset}`);
+        Logger.log(`  --from <encoding>      Encoding de origem (padrão: auto-detect)`);
+        Logger.log(`  --to <encoding>        Encoding de destino (padrão: do xavva.json ou UTF-8)`);
+        Logger.log(`  --backup               Cria backup antes de converter`);
+        Logger.log(`  --dry-run              Simula sem modificar arquivos`);
+        Logger.log(`  --force                Força correção mesmo se detectado como UTF-8`);
+        Logger.log(`  --src <path>           Diretório fonte (padrão: src/)`);
+        Logger.newline();
+        
+        Logger.log(`${Logger.C.primary}Encodings suportados:${Logger.C.reset}`);
+        Logger.log(`  utf-8, utf8            UTF-8 (padrão)`);
+        Logger.log(`  windows-1252, cp1252   Windows CP1252 (ANSI)`);
+        Logger.log(`  iso-8859-1, latin1     ISO-8859-1 (Latin-1)`);
+        Logger.newline();
+        
+        Logger.log(`${Logger.C.primary}Exemplos:${Logger.C.reset}`);
+        Logger.log(`  xavva encoding detect src/main/java/MinhaClasse.java`);
+        Logger.log(`  xavva encoding convert --from utf-8 --to cp1252 src/main/java/`);
+        Logger.log(`  xavva encoding convert --to cp1252 --backup src/main/java/MinhaClasse.java`);
+        Logger.log(`  xavva encoding fix src/main/java/MinhaClasse.java`);
+        Logger.log(`  xavva encoding fix --force src/main/java/MinhaClasse.java  # Força correção`);
+        Logger.log(`  xavva encoding list`);
+        Logger.endSection();
+    }
+
+    private async handleDetect(fileArg?: string) {
+        const target = fileArg || path.join(process.cwd(), "src");
+
+        if (!existsSync(target)) {
+            Logger.error(`Caminho não encontrado: ${target}`);
+            return;
+        }
+
+        Logger.section("Detecção de Encoding");
+        Logger.info("Alvo", target);
+        Logger.newline();
+
+        const stat = await Bun.file(target).stat();
+        
+        if (stat.isFile()) {
+            // Detectar arquivo único
+            const detection = await this.encodingService.detectFileEncoding(target);
+            if (detection) {
+                Logger.info("Arquivo", path.basename(target));
+                Logger.config("Encoding detectado", detection.encoding);
+                Logger.config("Confiança", `${Math.round(detection.confidence * 100)}%`);
+                Logger.config("Tem BOM", detection.hasBOM ? "Sim" : "Não");
+            } else {
+                Logger.error("Não foi possível detectar o encoding");
+            }
+        } else {
+            // Detectar diretório
+            const detections = await this.encodingService.detectDirectoryEncodings(target);
+            
+            if (detections.size === 0) {
+                Logger.warn("Nenhum arquivo de texto encontrado");
+                return;
+            }
+
+            // Agrupa por encoding
+            const byEncoding = new Map<string, number>();
+            for (const [file, detection] of detections) {
+                const count = byEncoding.get(detection.encoding) || 0;
+                byEncoding.set(detection.encoding, count + 1);
+            }
+
+            Logger.info("Arquivos analisados", String(detections.size));
+            Logger.newline();
+
+            Logger.log(`${Logger.C.primary}Distribuição por encoding:${Logger.C.reset}`);
+            for (const [encoding, count] of byEncoding) {
+                Logger.config(encoding, `${count} arquivo(s)`);
+            }
+
+            Logger.newline();
+            Logger.log(`${Logger.C.primary}Arquivos com baixa confiança:${Logger.C.reset}`);
+            let lowConfidenceFound = false;
+            for (const [file, detection] of detections) {
+                if (detection.confidence < 0.8) {
+                    Logger.warn(`${path.relative(target, file)} (${Math.round(detection.confidence * 100)}%)`);
+                    lowConfidenceFound = true;
+                }
+            }
+            if (!lowConfidenceFound) {
+                Logger.success("Todos os arquivos têm confiança alta na detecção");
+            }
+        }
+
+        Logger.endSection();
+    }
+
+    private async handleConvert(config: AppConfig, args?: CLIArguments, fileArg?: string) {
+        const fromEncoding = args?.["from"] as string || "auto";
+        const toEncoding = args?.["to"] as string || config.project.encoding || "utf-8";
+        const backup = args?.["backup"] as boolean || false;
+        const dryRun = args?.["dry-run"] as boolean || false;
+        const srcDir = args?.["src"] as string || path.join(process.cwd(), "src");
+
+        const target = fileArg || srcDir;
+
+        if (!existsSync(target)) {
+            Logger.error(`Caminho não encontrado: ${target}`);
+            return;
+        }
+
+        // Valida encoding de destino
+        if (!this.encodingService.isValidEncoding(toEncoding)) {
+            Logger.error(`Encoding não suportado: "${toEncoding}"`);
+            Logger.info("Encodings suportados", this.encodingService.getSupportedEncodings().join(", "));
+            return;
+        }
+
+        // Valida encoding de origem (se não for auto)
+        if (fromEncoding !== "auto" && !this.encodingService.isValidEncoding(fromEncoding)) {
+            Logger.error(`Encoding não suportado: "${fromEncoding}"`);
+            Logger.info("Encodings suportados", this.encodingService.getSupportedEncodings().join(", "));
+            return;
+        }
+
+        Logger.section("Conversão de Encoding");
+        Logger.info("De", fromEncoding === "auto" ? "auto-detect" : fromEncoding);
+        Logger.info("Para", toEncoding);
+        Logger.info("Alvo", target);
+        if (backup) Logger.config("Backup", "Sim");
+        if (dryRun) Logger.config("Modo", "DRY RUN (simulação)");
+        Logger.newline();
+
+        const stat = await Bun.file(target).stat();
+
+        if (stat.isFile()) {
+            // Converter arquivo único
+            let actualFrom = fromEncoding;
+            
+            if (fromEncoding === "auto") {
+                const detection = await this.encodingService.detectFileEncoding(target);
+                if (detection) {
+                    actualFrom = detection.encoding;
+                    Logger.info("Detectado", `${actualFrom} (${Math.round(detection.confidence * 100)}%)`);
+                } else {
+                    Logger.error("Não foi possível detectar encoding. Use --from para especificar.");
+                    return;
+                }
+            }
+
+            const result = await this.encodingService.convertFile(target, actualFrom, toEncoding, {
+                backup,
+                dryRun
+            });
+
+            if (result.success) {
+                Logger.success(result.message);
+                if (result.unsupportedChars && result.unsupportedChars.length > 0) {
+                    const unique = [...new Set(result.unsupportedChars)].slice(0, 5);
+                    const codes = unique.map(c => `U+${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`);
+                    Logger.warn(`${result.unsupportedChars.length} caractere(s) não suportado(s): ${codes.join(", ")}`);
+                    Logger.info("Dica", "Caracteres não suportados foram substituídos por '?'");
+                }
+            } else {
+                Logger.error(result.message);
+            }
+        } else {
+            // Converter diretório
+            let actualFrom = fromEncoding;
+            
+            if (fromEncoding === "auto") {
+                Logger.warn("Modo auto-detect em diretórios assume UTF-8 ou detecta individualmente");
+                actualFrom = "utf-8"; // Default para diretórios em auto
+            }
+
+            const result = await this.encodingService.convertDirectory(target, actualFrom, toEncoding, {
+                backup,
+                dryRun
+            });
+
+            Logger.newline();
+            Logger.info("Total", String(result.total));
+            Logger.success(`Sucesso: ${result.success}`);
+            if (result.failed > 0) {
+                Logger.warn(`Falhas: ${result.failed}`);
+            }
+            if (result.totalUnsupported > 0) {
+                Logger.warn(`${result.totalUnsupported} caractere(s) substituído(s) por "?"`);
+            }
+        }
+
+        Logger.endSection();
+    }
+
+    private async handleFix(fileArg?: string, args?: CLIArguments) {
+        const backup = args?.["backup"] as boolean || false;
+        const dryRun = args?.["dry-run"] as boolean || false;
+        const force = args?.["force"] as boolean || false;
+        const target = fileArg || path.join(process.cwd(), "src");
+
+        if (!existsSync(target)) {
+            Logger.error(`Caminho não encontrado: ${target}`);
+            return;
+        }
+
+        Logger.section("Correção de Mojibake");
+        Logger.info("Alvo", target);
+        if (backup) Logger.config("Backup", "Sim");
+        if (dryRun) Logger.config("Modo", "DRY RUN (simulação)");
+        Logger.newline();
+
+        const stat = await Bun.file(target).stat();
+
+        if (stat.isFile()) {
+            const result = await this.encodingService.fixMojibake(target, { backup, dryRun, force });
+            
+            if (result.success) {
+                Logger.success(result.message);
+            } else {
+                Logger.warn(result.message);
+            }
+        } else {
+            // Fix em diretório
+            const files = await this.encodingService.findTextFiles(target);
+            let fixed = 0;
+            let skipped = 0;
+            let failed = 0;
+
+            Logger.info("Arquivos encontrados", String(files.length));
+            Logger.newline();
+
+            for (const file of files) {
+                const result = await this.encodingService.fixMojibake(file, { backup, dryRun, force });
+                const relativePath = path.relative(target, file);
+
+                if (result.success && result.detectedFrom !== "utf-8") {
+                    Logger.success(`${relativePath}: ${result.message}`);
+                    fixed++;
+                } else if (result.detectedFrom === "utf-8") {
+                    // Já está em UTF-8, não mostra nada em modo silencioso
+                    skipped++;
+                } else {
+                    Logger.warn(`${relativePath}: ${result.message}`);
+                    failed++;
+                }
+            }
+
+            Logger.newline();
+            Logger.info("Corrigidos", String(fixed));
+            Logger.info("Já em UTF-8", String(skipped));
+            if (failed > 0) Logger.warn(`Não corrigidos: ${failed}`);
+        }
+
+        Logger.endSection();
+    }
+
+    private async handleList(config: AppConfig) {
+        const srcDir = path.join(process.cwd(), "src");
+        
+        if (!existsSync(srcDir)) {
+            Logger.error(`Diretório src/ não encontrado`);
+            return;
+        }
+
+        Logger.section("Lista de Encodings");
+        Logger.info("Diretório", srcDir);
+        Logger.info("Encoding padrão", config.project.encoding || "utf-8 (padrão)");
+        Logger.newline();
+
+        const detections = await this.encodingService.detectDirectoryEncodings(srcDir);
+        
+        if (detections.size === 0) {
+            Logger.warn("Nenhum arquivo de texto encontrado");
+            return;
+        }
+
+        // Ordena arquivos
+        const sortedFiles = Array.from(detections.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+
+        Logger.log(`${Logger.C.primary}Arquivos:${Logger.C.reset}`);
+        for (const [file, detection] of sortedFiles) {
+            const relativePath = path.relative(srcDir, file);
+            const confidenceStr = detection.confidence >= 0.9 ? "" : 
+                ` ${Logger.C.gray}(${Math.round(detection.confidence * 100)}%)${Logger.C.reset}`;
+            const bomStr = detection.hasBOM ? ` ${Logger.C.warning}[BOM]${Logger.C.reset}` : "";
+            
+            const encodingColor = detection.encoding === (config.project.encoding || "utf-8") 
+                ? Logger.C.success 
+                : Logger.C.warning;
+            
+            Logger.log(`  ${encodingColor}${detection.encoding.padEnd(12)}${Logger.C.reset} ${relativePath}${confidenceStr}${bomStr}`);
+        }
+
+        Logger.endSection();
+    }
+}

package/src/commands/HealthCommand.ts

@@ -0,0 +1,302 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform, totalmem, freemem, arch } from "os";
+import { existsSync } from "fs";
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { Logger } from "../utils/ui";
+
+const execAsync = promisify(exec);
+
+interface HealthCheck {
+    name: string;
+    status: "ok" | "warning" | "error";
+    message: string;
+    details?: string;
+}
+
+export class HealthCommand implements Command {
+    async execute(config: AppConfig, _args?: CLIArguments): Promise<void> {
+        Logger.banner("health");
+        Logger.section("Verificando saúde do ambiente");
+
+        const checks: HealthCheck[] = [];
+
+        // Java
+        checks.push(await this.checkJava());
+
+        // Maven/Gradle
+        checks.push(await this.checkBuildTool(config.project.buildTool));
+
+        // Tomcat
+        checks.push(await this.checkTomcat(config));
+
+        // Portas
+        checks.push(await this.checkPorts(config.tomcat.port));
+
+        // Memória
+        checks.push(this.checkMemory());
+
+        // Disco
+        checks.push(await this.checkDisk());
+
+        // Git
+        checks.push(this.checkGit());
+
+        // Exibir resultados
+        Logger.newline();
+        let errors = 0;
+        let warnings = 0;
+
+        for (const check of checks) {
+            const icon = check.status === "ok" 
+                ? `${Logger.C.success}✓${Logger.C.reset}`
+                : check.status === "warning"
+                ? `${Logger.C.warning}⚠${Logger.C.reset}`
+                : `${Logger.C.error}✗${Logger.C.reset}`;
+
+            Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${icon} ${Logger.C.bold}${check.name}${Logger.C.reset}`);
+            Logger.log(`${Logger.C.gray}│${Logger.C.reset}     ${check.message}`);
+            
+            if (check.details) {
+                Logger.log(`${Logger.C.gray}│${Logger.C.reset}     ${Logger.C.dim}${check.details}${Logger.C.reset}`);
+            }
+
+            if (check.status === "error") errors++;
+            if (check.status === "warning") warnings++;
+        }
+
+        Logger.endSection();
+
+        // Summary
+        if (errors === 0 && warnings === 0) {
+            Logger.ready("Ambiente saudável! ✓");
+        } else if (errors === 0) {
+            Logger.warn(`${warnings} aviso(s) encontrado(s)`);
+        } else {
+            Logger.error(`${errors} erro(s) encontrado(s)`);
+        }
+    }
+
+    private async checkJava(): Promise<HealthCheck> {
+        try {
+            const { stdout, stderr } = await execAsync("java -version");
+            const output = stderr || stdout;
+            const versionMatch = output.match(/version "?(\d+\.?\d*)/);
+            const version = versionMatch ? versionMatch[1] : "unknown";
+            const isDCEVM = output.toLowerCase().includes("dcevm") || output.toLowerCase().includes("jbr");
+            
+            const majorVersion = parseInt(version.split(".")[0]);
+            const status = majorVersion >= 11 ? "ok" : "warning";
+            
+            return {
+                name: "Java",
+                status,
+                message: `v${version}${isDCEVM ? " + DCEVM" : ""}`,
+                details: isDCEVM ? "Hot-reload disponível" : "Considere instalar DCEVM para hot-reload"
+            };
+        } catch {
+            return {
+                name: "Java",
+                status: "error",
+                message: "Java não encontrado",
+                details: "Instale o JDK 11+ e configure JAVA_HOME"
+            };
+        }
+    }
+
+    private async checkBuildTool(tool: string): Promise<HealthCheck> {
+        try {
+            if (tool === "maven") {
+                const { stdout } = await execAsync("mvn -version");
+                const version = stdout.match(/Apache Maven (\d+\.\d+\.\d+)/)?.[1] || "unknown";
+                return {
+                    name: "Maven",
+                    status: "ok",
+                    message: `v${version}`
+                };
+            } else {
+                const { stdout } = await execAsync("gradle --version");
+                const version = stdout.match(/Gradle (\d+\.\d+\.\d+)/)?.[1] || "unknown";
+                return {
+                    name: "Gradle",
+                    status: "ok",
+                    message: `v${version}`
+                };
+            }
+        } catch {
+            return {
+                name: tool === "maven" ? "Maven" : "Gradle",
+                status: "error",
+                message: `${tool === "maven" ? "mvn" : "gradle"} não encontrado`,
+                details: `Instale ${tool === "maven" ? "Maven" : "Gradle"} e adicione ao PATH`
+            };
+        }
+    }
+
+    private async checkTomcat(config: AppConfig): Promise<HealthCheck> {
+        if (config.tomcat.embedded) {
+            return {
+                name: "Tomcat",
+                status: "ok",
+                message: `Embutido v${config.tomcat.version || "10.1.52"}`,
+                details: "Auto-download habilitado"
+            };
+        }
+
+        if (existsSync(config.tomcat.path)) {
+            const versionFile = `${config.tomcat.path}/bin/version.sh`;
+            const versionBat = `${config.tomcat.path}/bin/version.bat`;
+            
+            try {
+                const cmd = existsSync(versionBat) ? versionBat : versionFile;
+                const { stdout } = await execAsync(cmd);
+                const version = stdout.match(/Server version: Apache Tomcat\/(\d+\.\d+\.\d+)/)?.[1] || "unknown";
+                return {
+                    name: "Tomcat",
+                    status: "ok",
+                    message: `v${version}`,
+                    details: config.tomcat.path
+                };
+            } catch {
+                return {
+                    name: "Tomcat",
+                    status: "warning",
+                    message: "Caminho existe mas não foi possível verificar versão",
+                    details: config.tomcat.path
+                };
+            }
+        }
+
+        return {
+            name: "Tomcat",
+            status: "error",
+            message: "Caminho não encontrado",
+            details: `Configure CATALINA_HOME ou use Tomcat embutido`
+        };
+    }
+
+    private async checkPorts(port: number): Promise<HealthCheck> {
+        try {
+            let cmd: string;
+            if (platform() === "win32") {
+                cmd = `netstat -an | findstr :${port}`;
+            } else if (platform() === "darwin") {
+                cmd = `lsof -i :${port}`;
+            } else {
+                cmd = `ss -tuln | grep :${port}`;
+            }
+
+            const { stdout } = await execAsync(cmd);
+            const isInUse = stdout.trim().length > 0;
+
+            if (isInUse) {
+                return {
+                    name: "Portas",
+                    status: "warning",
+                    message: `Porta ${port} em uso`,
+                    details: "Outro processo pode estar usando a porta"
+                };
+            }
+
+            return {
+                name: "Portas",
+                status: "ok",
+                message: `Porta ${port} disponível`
+            };
+        } catch {
+            // Comando falhou, assume que porta está livre
+            return {
+                name: "Portas",
+                status: "ok",
+                message: `Porta ${port} parece disponível`
+            };
+        }
+    }
+
+    private checkMemory(): HealthCheck {
+        const total = totalmem();
+        const free = freemem();
+        const used = total - free;
+        const percentUsed = Math.round((used / total) * 100);
+        const freeGB = (free / 1024 / 1024 / 1024).toFixed(1);
+        const totalGB = (total / 1024 / 1024 / 1024).toFixed(1);
+
+        const status = percentUsed > 90 ? "warning" : "ok";
+
+        return {
+            name: "Memória",
+            status,
+            message: `${freeGB}GB livre de ${totalGB}GB`,
+            details: `${percentUsed}% em uso`
+        };
+    }
+
+    private async checkDisk(): Promise<HealthCheck> {
+        try {
+            let cmd: string;
+            if (platform() === "win32") {
+                cmd = "wmic logicaldisk get size,freespace,caption";
+            } else {
+                cmd = "df -h .";
+            }
+
+            const { stdout } = await execAsync(cmd);
+            
+            if (platform() === "win32") {
+                const lines = stdout.trim().split("\n").slice(1);
+                const mainDisk = lines.find(l => l.includes(":")) || "";
+                const parts = mainDisk.trim().split(/\s+/);
+                if (parts.length >= 3) {
+                    const free = parseInt(parts[0]) / 1024 / 1024 / 1024;
+                    const total = parseInt(parts[1]) / 1024 / 1024 / 1024;
+                    const percentFree = Math.round((free / total) * 100);
+                    
+                    return {
+                        name: "Disco",
+                        status: percentFree < 10 ? "warning" : "ok",
+                        message: `${free.toFixed(1)}GB livre`,
+                        details: `${percentFree}% disponível`
+                    };
+                }
+            } else {
+                const match = stdout.match(/(\d+)%/);
+                if (match) {
+                    const used = parseInt(match[1]);
+                    return {
+                        name: "Disco",
+                        status: used > 90 ? "warning" : "ok",
+                        message: `${100 - used}% disponível`,
+                        details: stdout.split("\n")[1]?.split(/\s+/).pop() || ""
+                    };
+                }
+            }
+
+            throw new Error("Could not parse disk info");
+        } catch {
+            return {
+                name: "Disco",
+                status: "warning",
+                message: "Não foi possível verificar",
+                details: "Verifique manualmente"
+            };
+        }
+    }
+
+    private checkGit(): HealthCheck {
+        if (existsSync(".git")) {
+            return {
+                name: "Git",
+                status: "ok",
+                message: "Repositório Git detectado"
+            };
+        }
+
+        return {
+            name: "Git",
+            status: "warning",
+            message: "Sem repositório Git",
+            details: "Execute 'git init' para versionamento"
+        };
+    }
+}