@archznn/xavva 2.5.0 → 2.7.0

package/README.md

@@ -1,8 +1,8 @@
 # XAVVA CLI 🚀
 
-> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
+> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows, Linux & macOS
 
-[![Version](https://img.shields.io/badge/version-2.4.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.6.0-blue.svg)](https://github.com/leorsousa05/Xavva)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.
@@ -20,12 +20,13 @@ 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
 
 ---
 
 ## 📦 Installation
 
-```powershell
+```bash
 # Via NPM
 npm install -g @archznn/xavva
 
@@ -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:
@@ -196,12 +251,14 @@ Create `xavva.json` in your project root:
     "tui": false
   },
   "tomcat": {
-    "path": "C:/apache-tomcat",
+    "path": "/home/user/apache-tomcat",
     "port": 8080
   }
 }
 ```
 
+> **Note:** On Windows use `"path": "C:/apache-tomcat"` format.
+
 ### CLI Options
 
 | Option                 | Description                     |
@@ -224,6 +281,25 @@ Create `xavva.json` in your project root:
 
 ---
 
+## 💻 Platform Support
+
+Xavva works on all major platforms:
+
+| Platform | Status | Notes |
+|----------|--------|-------|
+| Windows  | ✅ Full | PowerShell for system integration |
+| Linux    | ✅ Full | Bash/Zsh auto-configuration |
+| macOS    | ✅ Full | Native terminal support |
+
+### Requirements
+
+- **Bun** runtime (latest version)
+- **Java** 11 or higher (JDK)
+- **Maven** 3.6+ or **Gradle** 7+
+- **Git** (optional, for version info)
+
+---
+
 ## 🏗️ Architecture
 
 Xavva uses a modular service-oriented architecture:

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.5.0",
-	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
+	"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",
 	"bin": {
@@ -19,6 +19,8 @@
 		"gradle",
 		"hot-reload",
 		"windows",
+		"linux",
+		"macos",
 		"cli",
 		"bun"
 	],

package/src/commands/DeployCommand.ts

@@ -7,6 +7,11 @@ import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 import { EndpointService } from "../services/EndpointService";
 import { BrowserService } from "../services/BrowserService";
+import {
+	getJavaPath,
+	getWarExtractCommand,
+	isWindows,
+} from "../utils/platform";
 
 export class DeployCommand implements Command {
     constructor(private tomcat: TomcatService, private builder: BuildService) {}
@@ -78,15 +83,28 @@ export class DeployCommand implements Command {
                         Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
                         Logger.server("extracted WAR");
                     } catch (e) {
-                        const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
-                        Bun.spawnSync(["powershell", "-command", extractCmd], {
-                            env: {
-                                ...process.env,
-                                ARTIFACT_PATH: artifactInfo.path,
-                                DEST_PATH: appWebappPath
+                        // Fallback para extração com jar (funciona em todas as plataformas)
+                        if (isWindows()) {
+                            const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
+                            Bun.spawnSync(["powershell", "-command", extractCmd], {
+                                env: {
+                                    ...process.env,
+                                    ARTIFACT_PATH: artifactInfo.path,
+                                    DEST_PATH: appWebappPath
+                                }
+                            });
+                        } else {
+                            // Linux/Mac: usa unzip ou jar
+                            try {
+                                Bun.spawnSync(["unzip", "-q", "-o", artifactInfo.path, "-d", appWebappPath]);
+                            } catch {
+                                // Fallback final para jar
+                                Bun.spawnSync(getWarExtractCommand(artifactInfo.path, appWebappPath), {
+                                    cwd: appWebappPath
+                                });
                             }
-                        });
-                        Logger.server("extracted WAR (legacy)");
+                        }
+                        Logger.server("extracted WAR (fallback)");
                     }
                 } else {
                     Logger.server("webapp up to date");
@@ -117,13 +135,7 @@ export class DeployCommand implements Command {
         Logger.config("watch", isWatching);
         Logger.config("debug", config.project.debug ? `port ${config.project.debugPort}` : false);
 
-        let javaBin = "java";
-        if (process.env.JAVA_HOME) {
-            const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
-            if (fs.existsSync(homeBin)) javaBin = homeBin;
-        }
-        
-        const javaVer = Bun.spawnSync([javaBin, "-version"]);
+        const javaVer = Bun.spawnSync([getJavaPath(), "-version"]);
         const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
         const hasDcevm = ["dcevm", "jetbrains", "trava", "jbr"].some(v => output.includes(v));
         
@@ -248,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/DoctorCommand.ts

@@ -4,6 +4,17 @@ import { Logger } from "../utils/ui";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import {
+	getCatalinaScript,
+	getWhichCommand,
+	getJbrDownloadUrl,
+	getTarExtractCommand,
+	getJavaPath,
+	getJavaBinary,
+	isWindows,
+	isLinux,
+	isMacOS,
+} from "../utils/platform";
 
 export class DoctorCommand implements Command {
 	async execute(config: AppConfig, values: CLIArguments = {}): Promise<void> {
@@ -25,7 +36,7 @@ export class DoctorCommand implements Command {
 
 		if (!jvmInfo.dcevm) {
 			Logger.log(
-				`    ${Logger.C.yellow}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
+				`    ${Logger.C.warning}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
 			);
 			if (values.fix) {
 				await this.installDCEVM();
@@ -41,12 +52,12 @@ export class DoctorCommand implements Command {
 
 		if (tomcatOk) {
 			const binOk = fs.existsSync(
-				path.join(config.tomcat.path, "bin", "catalina.bat"),
+				path.join(config.tomcat.path, "bin", getCatalinaScript()),
 			);
 			this.check(
 				"Tomcat Bin",
 				binOk,
-				binOk ? "OK" : "catalina.bat não encontrado",
+				binOk ? "OK" : `${getCatalinaScript()} não encontrado`,
 			);
 		}
 
@@ -211,10 +222,7 @@ export class DoctorCommand implements Command {
 
 	private checkBinary(name: string): boolean {
 		try {
-			const proc = Bun.spawnSync([
-				process.platform === "win32" ? "where" : "which",
-				name,
-			]);
+			const proc = Bun.spawnSync(getWhichCommand(name));
 			return proc.exitCode === 0;
 		} catch {
 			return false;
@@ -224,11 +232,7 @@ export class DoctorCommand implements Command {
     private checkJVM(): { name: string, dcevm: boolean } {
         try {
             // Tentar primeiro o binário do JAVA_HOME para evitar cache do Path
-            let javaBin = "java";
-            if (process.env.JAVA_HOME) {
-                const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
-                if (fs.existsSync(homeBin)) javaBin = homeBin;
-            }
+            let javaBin = getJavaPath();
 
             const proc = Bun.spawnSync([javaBin, "-version"]);
             const output = (proc.stderr.toString() + proc.stdout.toString()).toLowerCase();
@@ -251,8 +255,8 @@ export class DoctorCommand implements Command {
         Logger.section("Instalação do JetBrains Runtime (JBR 21)");
         Logger.log("Baixando JDK moderna com DCEVM nativo (JBR 21 SDK)...");
         
-        // URL para o JetBrains Runtime 21 SDK Windows x64
-        const url = "https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-21.0.6-windows-x64-b895.97.tar.gz";
+        // URL para o JetBrains Runtime 21 SDK (multiplataforma)
+        const url = getJbrDownloadUrl("21");
         const installDir = path.join(os.homedir(), ".xavva", "jdk-dcevm");
         
         // Limpar instalação anterior se existir
@@ -272,21 +276,15 @@ export class DoctorCommand implements Command {
             
             Logger.success("Download concluído. Extraindo binários...");
             
-            // Usar PowerShell para extrair .tar.gz (nativo no Windows 10/11)
-            const extractCmd = `tar -xzf $env:TAR_PATH -C $env:INSTALL_DIR`;
-            Bun.spawnSync(["powershell", "-command", extractCmd], {
-                env: {
-                    ...process.env,
-                    TAR_PATH: tarPath,
-                    INSTALL_DIR: installDir
-                }
-            });
+            // Extrair .tar.gz usando comando apropriado para a plataforma
+            const extractCmd = getTarExtractCommand(tarPath, installDir);
+            Bun.spawnSync(extractCmd);
             
             fs.rmSync(tarPath);
 
-            // Busca recursiva para encontrar onde está o bin/java.exe
+            // Busca recursiva para encontrar onde está o bin/java
             const findJdkRoot = (dir: string): string | null => {
-                if (fs.existsSync(path.join(dir, "bin", "java.exe"))) return dir;
+                if (fs.existsSync(path.join(dir, "bin", getJavaBinary()))) return dir;
                 const subdirs = fs.readdirSync(dir, { withFileTypes: true })
                     .filter(d => d.isDirectory())
                     .map(d => path.join(dir, d.name));
@@ -299,55 +297,110 @@ export class DoctorCommand implements Command {
 
             const jdkPath = findJdkRoot(installDir) || installDir;
             const binPath = path.join(jdkPath, "bin");
-			            
-			                                    Logger.process("Configurando variáveis de ambiente do SISTEMA...");
-			                        
-			                                                const setEnvCmd = `
-			                                                    $jdk = $env:JDK_PATH;
-			                                                    $bin = $env:BIN_PATH;
-			                                                    try {
-			                                                        [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
-			                                                        $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
-			                                                        $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
-			                                                        $normalizedBin = $bin.TrimEnd('\\').ToLower();
-			                                                        
-			                                                        $exists = $false;
-			                                                        foreach ($p in $paths) {
-			                                                            if ($p.TrimEnd('\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
-			                                                        }
-			                                    
-			                                                        if (-not $exists) {
-			                                                            $newPath = "$bin;" + $pathVar;
-			                                                            [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
-			                                                        }
-			                                                        Write-Output "OK";
-			                                                    } catch {
-			                                                        Write-Error $_.Exception.Message;
-			                                                    }
-			                                                `.replace(/\n/g, ' ');
-			                                    			                                    const result = Bun.spawnSync(["powershell", "-command", setEnvCmd], {
-                                                                            env: {
-                                                                                ...process.env,
-                                                                                JDK_PATH: jdkPath,
-                                                                                BIN_PATH: binPath
-                                                                            }
-                                                                        });
-			                                    const output = result.stdout.toString() + result.stderr.toString();
-			                        
-			                                    if (output.includes("ACCESS_DENIED")) {
-			                                        Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
-			                                        Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
-			                                        Logger.info("JAVA_HOME manual", jdkPath);
-			                                    } else {
-			                                        Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
-			                                        Logger.info("JAVA_HOME", jdkPath);
-			                                    }
-			                        
-			                                    Logger.newline();
-			                                    Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
-			                                } catch (e) {
-			                        
-			            			Logger.error(`Falha na instalação: ${e.message}`);
-		}
-	}
+            
+            if (isWindows()) {
+                await this.configureWindowsEnv(jdkPath, binPath);
+            } else {
+                await this.configureUnixEnv(jdkPath, binPath);
+            }
+        } catch (e: any) {
+            Logger.error(`Falha na instalação: ${e.message}`);
+        }
+    }
+
+    private async configureWindowsEnv(jdkPath: string, binPath: string) {
+        Logger.process("Configurando variáveis de ambiente do SISTEMA...");
+
+        const setEnvCmd = `
+            $jdk = $env:JDK_PATH;
+            $bin = $env:BIN_PATH;
+            try {
+                [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
+                $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
+                $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
+                $normalizedBin = $bin.TrimEnd('\\\\').ToLower();
+                
+                $exists = $false;
+                foreach ($p in $paths) {
+                    if ($p.TrimEnd('\\\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
+                }
+
+                if (-not $exists) {
+                    $newPath = "$bin;" + $pathVar;
+                    [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
+                }
+                Write-Output "OK";
+            } catch {
+                Write-Error $_.Exception.Message;
+            }
+        `.replace(/\n/g, ' ');
+
+        const result = Bun.spawnSync(["powershell", "-command", setEnvCmd], {
+            env: {
+                ...process.env,
+                JDK_PATH: jdkPath,
+                BIN_PATH: binPath
+            }
+        });
+        const output = result.stdout.toString() + result.stderr.toString();
+
+        if (output.includes("ACCESS_DENIED")) {
+            Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
+            Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
+            Logger.info("JAVA_HOME manual", jdkPath);
+        } else {
+            Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
+            Logger.info("JAVA_HOME", jdkPath);
+        }
+
+        Logger.newline();
+        Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
+    }
+
+    private async configureUnixEnv(jdkPath: string, binPath: string) {
+        Logger.process("Configurando variáveis de ambiente...");
+
+        const shell = process.env.SHELL || "/bin/bash";
+        let rcFile = path.join(os.homedir(), ".bashrc");
+        
+        if (shell.includes("zsh")) {
+            rcFile = path.join(os.homedir(), ".zshrc");
+        } else if (shell.includes("fish")) {
+            rcFile = path.join(os.homedir(), ".config/fish/config.fish");
+        }
+
+        // Verifica se já existe JAVA_HOME configurado
+        const exportLine = `export JAVA_HOME="${jdkPath}"`;
+        const pathLine = `export PATH="${binPath}:$PATH"`;
+
+        let rcContent = "";
+        if (fs.existsSync(rcFile)) {
+            rcContent = fs.readFileSync(rcFile, "utf8");
+        }
+
+        // Remove linhas antigas do Xavva JBR
+        const lines = rcContent.split("\n");
+        const filteredLines = lines.filter(line => 
+            !line.includes("# Xavva JBR") && 
+            !line.includes("JAVA_HOME=") &&
+            !line.includes("# Added by Xavva")
+        );
+
+        // Adiciona novas configurações
+        filteredLines.push("# Added by Xavva - JetBrains Runtime (DCEVM)");
+        filteredLines.push(exportLine);
+        filteredLines.push(pathLine);
+
+        fs.writeFileSync(rcFile, filteredLines.join("\n") + "\n");
+
+        Logger.success(`DCEVM configurado em ${rcFile}`);
+        Logger.info("JAVA_HOME", jdkPath);
+        Logger.newline();
+        Logger.warn("IMPORTANTE: Execute 'source " + rcFile + "' ou reinicie seu terminal para aplicar permanentemente.");
+        Logger.info("Dica", "Para esta sessão, o JAVA_HOME já foi configurado temporariamente.");
+        
+        // Configura JAVA_HOME temporariamente para o processo atual
+        process.env.JAVA_HOME = jdkPath;
+        process.env.PATH = `${binPath}:${process.env.PATH}`;
+    }
 }