@archznn/xavva 2.5.0 → 2.7.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/HelpCommand.ts

@@ -30,6 +30,7 @@ export class HelpCommand implements Command {
     ${this.c("green", "profiles")}         List available Maven/Gradle profiles
     ${this.c("green", "tomcat")}           Manage embedded Tomcat (install, list, installed, use, status)
     ${this.c("green", "docs")}             Generate endpoint documentation
+    ${this.c("green", "encoding")}         Convert file encoding (detect, convert, fix, list)
 
   ${this.c("yellow", "GENERAL OPTIONS")}
     ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
@@ -65,6 +66,13 @@ export class HelpCommand implements Command {
     ${this.c("cyan", "--strict")}              Fail on critical conflicts (for CI/CD)
     ${this.c("cyan", "-o, --output")} <file>   Export report as JSON
 
+  ${this.c("yellow", "ENCODING OPTIONS")}  ${this.c("dim", "(for xavva encoding)")}
+    ${this.c("cyan", "--from")} <encoding>     Source encoding (auto-detect if not specified)
+    ${this.c("cyan", "--to")} <encoding>       Target encoding (default: from xavva.json or UTF-8)
+    ${this.c("cyan", "--backup")}              Create backup before conversion
+    ${this.c("cyan", "--dry-run")}             Simulate without modifying files
+    ${this.c("cyan", "--src")} <path>          Source directory (default: src/)
+
   ${this.c("yellow", "EXAMPLES")}
     ${this.c("dim", "# Development with hot reload and dashboard")}
     xavva dev --tui --watch
@@ -97,6 +105,13 @@ export class HelpCommand implements Command {
     xavva tomcat status
     xavva tomcat uninstall 9.0.115
 
+    ${this.c("dim", "# Convert file encoding")}
+    xavva encoding detect src/main/java/MinhaClasse.java
+    xavva encoding convert --from utf-8 --to cp1252 src/main/java/
+    xavva encoding convert --to cp1252 --backup src/main/java/MinhaClasse.java
+    xavva encoding fix src/main/java/MinhaClasse.java    # Fix mojibake
+    xavva encoding list                                   # List all file encodings
+
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
     

package/src/commands/LogsCommand.ts

@@ -60,7 +60,7 @@ export class LogsCommand implements Command {
                     currentSize = newStats.size;
                 } else if (newStats.size < currentSize) {
                     currentSize = newStats.size;
-                    dashboard.log(Logger.C.yellow + "Arquivo de log foi resetado/rotacionado.");
+                    dashboard.log(Logger.C.warning + "Arquivo de log foi resetado/rotacionado.");
                 }
             }
         });

package/src/commands/RunCommand.ts

@@ -5,6 +5,14 @@ import path from "path";
 import fs from "fs";
 import { glob } from "glob";
 import readline from "readline";
+import {
+	getJavaPath,
+	getMavenCommand,
+	getGradleCommand,
+	getClasspathSeparator,
+	normalizeClasspathPath,
+	isWindows,
+} from "../utils/platform";
 
 export class RunCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
@@ -36,7 +44,8 @@ export class RunCommand implements Command {
         const { localCp, dependencyCp } = await this.getClasspath(config);
         const pathingJar = await this.createPathingJar(dependencyCp);
         
-        const finalCp = `${localCp};${pathingJar}`;
+        const sep = getClasspathSeparator();
+        const finalCp = `${localCp}${sep}${pathingJar}`;
 
         const javaArgs = [
             "-classpath", finalCp,
@@ -60,7 +69,7 @@ export class RunCommand implements Command {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java.exe") : "java";
+        const bin = getJavaPath();
         
         const proc = Bun.spawn([bin, ...javaArgs], {
             stdout: "inherit",
@@ -220,9 +229,10 @@ export class RunCommand implements Command {
         const xavvaDir = path.join(process.cwd(), ".xavva");
         const jarPath = path.join(xavvaDir, "classpath.jar");
 
-        const paths = dependencyCp.split(";").filter(p => p.trim());
+        const sep = getClasspathSeparator();
+        const paths = dependencyCp.split(sep).filter(p => p.trim());
         const relativePaths = paths.map(p => {
-            let rel = path.relative(xavvaDir, p).replace(/\\/g, "/");
+            let rel = normalizeClasspathPath(path.relative(xavvaDir, p));
             if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
             // Robust URL encoding for Class-Path as per Java Spec
             return encodeURI(rel)
@@ -296,10 +306,9 @@ export class RunCommand implements Command {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
                 if (config.project.buildTool === "maven") {
-                    const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
-                    Bun.spawnSync([mvnCmd, "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                    Bun.spawnSync([getMavenCommand(), "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
                 } else if (config.project.buildTool === "gradle") {
-                    const gradleCmd = process.platform === "win32" ? "gradle.bat" : "gradle";
+                    const gradleCmd = getGradleCommand();
                     const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
                     const normalizedCpFile = cpFile.replace(/\\/g, "/");
                     const initScriptContent = `
@@ -335,9 +344,10 @@ export class RunCommand implements Command {
 
         let dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
         
-        // Normalize platform specific separators to semicolon for consistency
-        if (path.delimiter !== ";") {
-            dependencyCp = dependencyCp.split(path.delimiter).join(";");
+        // Normalize platform specific separators para o separador consistente
+        const sep = getClasspathSeparator();
+        if (path.delimiter !== sep) {
+            dependencyCp = dependencyCp.split(path.delimiter).join(sep);
         }
 
         const localFolders = [
@@ -356,7 +366,7 @@ export class RunCommand implements Command {
         const localCp = localFolders
             .map(p => path.join(process.cwd(), p))
             .filter(p => fs.existsSync(p))
-            .join(";");
+            .join(getClasspathSeparator());
 
         return { localCp, dependencyCp };
     }

package/src/config/versions.ts

@@ -0,0 +1,63 @@
+/**
+ * Configurações centralizadas de versões
+ * Evita hardcoding espalhado pelo código
+ */
+
+export const VERSIONS = {
+    // Versões padrão do Tomcat
+    TOMCAT: {
+        DEFAULT: "10.1.52",
+        AVAILABLE: {
+            "10.1.52": { sha512: "" },
+            "9.0.115": { sha512: "" },
+            "11.0.18": { sha512: "" },
+        },
+    },
+
+    // HotswapAgent
+    HOTSWAP_AGENT: {
+        VERSION: "2.0.3",
+        URL: "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-{version}/hotswap-agent-{version}.jar",
+    },
+
+    // Configurações padrão
+    DEFAULTS: {
+        TOMCAT_PORT: 8080,
+        DEBUG_PORT: 5005,
+        DEBOUNCE_MS: 300,
+        COOLING_MS: 1000,
+    },
+} as const;
+
+// Type helpers
+export type TomcatVersion = keyof typeof VERSIONS.TOMCAT.AVAILABLE;
+
+/**
+ * Obtém URL de download do HotswapAgent
+ */
+export function getHotswapAgentUrl(version: string = VERSIONS.HOTSWAP_AGENT.VERSION): string {
+    return VERSIONS.HOTSWAP_AGENT.URL
+        .replace(/{version}/g, version);
+}
+
+/**
+ * Verifica se versão do Tomcat é suportada
+ */
+export function isSupportedTomcatVersion(version: string): version is TomcatVersion {
+    return version in VERSIONS.TOMCAT.AVAILABLE;
+}
+
+/**
+ * Obtém versões disponíveis do Tomcat
+ */
+export function getAvailableTomcatVersions(): string[] {
+    return Object.keys(VERSIONS.TOMCAT.AVAILABLE);
+}
+
+/**
+ * Obtém SHA512 de uma versão do Tomcat
+ */
+export function getTomcatSha512(version: string): string | undefined {
+    const info = VERSIONS.TOMCAT.AVAILABLE[version as TomcatVersion];
+    return info?.sha512;
+}