@archznn/xavva 2.6.0 → 2.7.0

package/README.md

@@ -20,6 +20,7 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 - 🔧 **Auto-Healing** — Automatic diagnosis and repair of common issues
 - 🐱 **Embedded Tomcat** — Auto-install Tomcat, no manual setup needed
 - 📦 **WAR Generation** — Build as .war file or exploded directory
+- 🔤 **Encoding Converter** — Convert file encodings (UTF-8, Windows-1252, ISO-8859-1) and fix mojibake
 
 ---
 
@@ -56,6 +57,9 @@ xavva deps --update-safe
 # Check for security vulnerabilities
 xavva audit
 
+# Convert file encoding (UTF-8 → Windows-1252)
+xavva encoding convert --to cp1252 --backup src/main/java/
+
 # Use embedded Tomcat (auto-install)
 xavva dev --yes
 ```
@@ -91,6 +95,7 @@ xavva dev --yes
 | `xavva profiles` | List available Maven/Gradle profiles                      |
 | `xavva docs`     | Generate endpoint documentation                           |
 | `xavva tomcat`   | Manage embedded Tomcat installations                      |
+| `xavva encoding` | Convert file encodings (UTF-8, CP1252, ISO-8859-1)        |
 
 ---
 
@@ -126,6 +131,56 @@ xavva dev --tomcat-version 9.0.115
 
 ---
 
+## 🔤 File Encoding
+
+The `xavva encoding` command helps you convert file encodings and fix mojibake (corrupted characters):
+
+```bash
+# Detect encoding of a file
+xavva encoding detect src/main/java/MyClass.java
+
+# Convert from UTF-8 to Windows-1252 (with backup)
+xavva encoding convert --from utf-8 --to cp1252 --backup src/main/java/
+
+# Convert a single file
+xavva encoding convert --to cp1252 --backup src/main/java/MyClass.java
+
+# Fix mojibake (e.g., "A��o" → "Ação")
+xavva encoding fix src/main/java/MyClass.java
+
+# List encodings of all files in src/
+xavva encoding list
+
+# Simulate conversion without modifying files
+xavva encoding convert --from utf-8 --to cp1252 --dry-run src/
+```
+
+### Supported Encodings
+
+- **utf-8** / **utf8** — UTF-8 (default)
+- **windows-1252** / **cp1252** — Windows CP1252 (ANSI)
+- **iso-8859-1** / **latin1** — ISO-8859-1 (Latin-1)
+
+### Configuration
+
+Set default encoding in `xavva.json`:
+
+```json
+{
+  "project": {
+    "encoding": "cp1252"
+  }
+}
+```
+
+Then use without `--to`:
+
+```bash
+xavva encoding convert --backup src/main/java/
+```
+
+---
+
 ## 🔍 Dependency Analysis
 
 The `xavva deps` command provides comprehensive dependency analysis:

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.6.0",
+	"version": "2.7.0",
 	"description": "Ultra-fast CLI tool for Java/Tomcat development with Hot-Reload and Zero Config. Supports Windows, Linux and macOS.",
 	"module": "src/index.ts",
 	"type": "module",

package/src/commands/DeployCommand.ts

@@ -260,10 +260,11 @@ export class DeployCommand implements Command {
                 if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
 
                 fs.copyFileSync(filename, targetPath);
-                if (!config.project.quiet) Logger.success(`Synced ${path.basename(filename)} directly to Tomcat!`);
+                Logger.success(`${path.basename(filename)} updated → Tomcat`);
                 
                 const appUrl = `http://localhost:${config.tomcat.port}/${appFolder}`;
                 await BrowserService.reload(appUrl);
+                Logger.ready(`Browser reloaded`);
             } catch (e) {
                 Logger.error(`Failed to sync resource: ${filename}`);
             }

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/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;
+}