@archznn/xavva 2.7.0 → 2.9.0

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

package/src/commands/HelpCommand.ts

@@ -31,6 +31,13 @@ export class HelpCommand implements Command {
     ${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("cyan", "init")}              Initialize project configuration (wizard)
+    ${this.c("cyan", "config")}            View/edit configuration (--interactive)
+    ${this.c("cyan", "history")}           Show command history
+    ${this.c("cyan", "redo")}              Repeat last command
+    ${this.c("cyan", "health")}            Check environment health
+    ${this.c("cyan", "completion")}        Generate shell completions (bash/zsh/fish)
 
   ${this.c("yellow", "GENERAL OPTIONS")}
     ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
@@ -112,6 +119,26 @@ export class HelpCommand implements Command {
     xavva encoding fix src/main/java/MinhaClasse.java    # Fix mojibake
     xavva encoding list                                   # List all file encodings
 
+    ${this.c("dim", "# Initialize new project")}
+    xavva init                     # Interactive wizard
+    
+    ${this.c("dim", "# Manage configuration")}
+    xavva config                   # View current config
+    xavva config --interactive     # Edit config interactively
+    
+    ${this.c("dim", "# Command history")}
+    xavva history                  # Show recent commands
+    xavva history --clear          # Clear history
+    xavva redo                     # Repeat last command
+    
+    ${this.c("dim", "# Health check")}
+    xavva health                   # Check environment health
+    
+    ${this.c("dim", "# Shell completions")}
+    xavva completion bash          # Generate bash completions
+    xavva completion zsh           # Generate zsh completions
+    eval "$(xavva completion bash)" # Enable in current shell
+
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
     

package/src/commands/HistoryCommand.ts

@@ -0,0 +1,49 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { HistoryService } from "../services/HistoryService";
+import { Logger } from "../utils/ui";
+
+export class HistoryCommand implements Command {
+    private historyService = new HistoryService();
+
+    async execute(_config: AppConfig, args?: CLIArguments): Promise<void> {
+        const clear = args?.["clear"] || false;
+        const limit = parseInt(String(args?.["limit"] || "10"));
+
+        if (clear) {
+            await this.historyService.clear();
+            Logger.success("Histórico limpo!");
+            return;
+        }
+
+        const entries = await this.historyService.getRecent(limit);
+        const stats = await this.historyService.getStats();
+
+        Logger.banner("history");
+        Logger.section(`Últimos ${entries.length} comandos`);
+
+        if (entries.length === 0) {
+            Logger.dim("Nenhum comando no histórico");
+            Logger.endSection();
+            return;
+        }
+
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            const date = new Date(entry.timestamp);
+            const time = date.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
+            const icon = entry.success 
+                ? `${Logger.C.success}✓${Logger.C.reset}` 
+                : `${Logger.C.error}✗${Logger.C.reset}`;
+            
+            const args = entry.args.length > 0 ? entry.args.join(" ") : "";
+            const duration = entry.duration ? `${Logger.C.gray}(${entry.duration.toFixed(1)}s)${Logger.C.reset}` : "";
+            
+            Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.dim}${time}${Logger.C.reset} ${icon} ${Logger.C.white}xavva ${entry.command}${Logger.C.reset} ${Logger.C.gray}${args}${Logger.C.reset} ${duration}`);
+        }
+
+        Logger.endSection();
+        Logger.info(`Total: ${stats.total} | Sucesso: ${stats.successful} | Falha: ${stats.failed}`);
+        Logger.dim("Use 'xavva redo' para repetir o último comando");
+    }
+}

package/src/commands/InitCommand.ts

@@ -0,0 +1,243 @@
+import { input, select, confirm, number } from "@inquirer/prompts";
+import { writeFile, access, readFile } from "fs/promises";
+import { join } from "path";
+import { constants, existsSync } from "fs";
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export class InitCommand implements Command {
+    async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
+        Logger.banner("init");
+        Logger.section("Project Setup Wizard");
+        Logger.info("Let's configure your Xavva project");
+        Logger.newline();
+
+        // Detect build tool and available profiles
+        const buildTool = await this.detectBuildTool();
+        const availableProfiles = await this.detectProfiles(buildTool);
+        
+        // Application name
+        const appName = await input({
+            message: "Application name:",
+            default: process.cwd().split(/[/\\]/).pop() || "my-app",
+            validate: (value) => value.length > 0 || "Name is required"
+        });
+
+        // Profile selection with explanation
+        Logger.newline();
+        Logger.dim("The profile is used to activate Maven/Gradle build configurations");
+        Logger.dim("(e.g., 'dev' for development, 'prod' for production)");
+        
+        let profile: string;
+        
+        if (availableProfiles.length > 0) {
+            // Profiles found in build file
+            const profileChoices = [
+                ...availableProfiles.map(p => ({ 
+                    name: `${p.name}${p.description ? ` - ${p.description}` : ''}`, 
+                    value: p.name 
+                })),
+                { name: "Other (custom)", value: "custom" }
+            ];
+            
+            profile = await select({
+                message: "Select a profile from your build file:",
+                choices: profileChoices,
+                default: availableProfiles.find(p => p.name === "dev")?.name || availableProfiles[0]?.name
+            });
+        } else {
+            // No profiles detected, show common options
+            profile = await select({
+                message: "Default profile:",
+                choices: [
+                    { name: "dev - Development environment", value: "dev" },
+                    { name: "test - Testing environment", value: "test" },
+                    { name: "prod - Production environment", value: "prod" },
+                    { name: "Other (custom)", value: "custom" }
+                ],
+                default: "dev"
+            });
+        }
+
+        if (profile === "custom") {
+            profile = await input({
+                message: "Profile name:",
+                default: "local",
+                validate: (value) => value.length > 0 || "Profile name is required"
+            });
+        }
+
+        // Tomcat port
+        const port = await number({
+            message: "Tomcat port:",
+            default: 8080,
+            validate: (value) => (value && value > 0 && value < 65536) || "Invalid port"
+        }) || 8080;
+
+        // Optional settings
+        Logger.newline();
+        Logger.dim("Advanced settings:");
+        
+        const useEmbedded = await confirm({
+            message: "Use embedded Tomcat (auto-download)?",
+            default: true
+        });
+
+        const enableCache = await confirm({
+            message: "Enable build cache?",
+            default: true
+        });
+
+        const enableTui = await confirm({
+            message: "Enable TUI dashboard?",
+            default: true
+        });
+
+        const encoding = await select({
+            message: "Source encoding:",
+            choices: [
+                { name: "UTF-8 (recommended)", value: "UTF-8" },
+                { name: "ISO-8859-1 (Latin-1)", value: "ISO-8859-1" },
+                { name: "Windows-1252", value: "Windows-1252" }
+            ],
+            default: "UTF-8"
+        });
+
+        // Build config object
+        const config: Record<string, unknown> = {
+            appName,
+            buildTool,
+            profile,
+            port,
+            cache: enableCache,
+            tui: enableTui,
+            encoding
+        };
+
+        if (useEmbedded) {
+            config.embedded = true;
+            config.tomcatVersion = await select({
+                message: "Tomcat version:",
+                choices: [
+                    { name: "10.1.52 (Jakarta EE 10, recommended)", value: "10.1.52" },
+                    { name: "9.0.115 (Java EE 8)", value: "9.0.115" },
+                    { name: "11.0.18 (Jakarta EE 11, preview)", value: "11.0.18" }
+                ],
+                default: "10.1.52"
+            });
+        } else {
+            const tomcatPath = await input({
+                message: "Tomcat path (CATALINA_HOME):",
+                validate: async (value) => {
+                    if (!value) return "Path is required";
+                    try {
+                        await access(value, constants.R_OK);
+                        return true;
+                    } catch {
+                        return "Path not accessible";
+                    }
+                }
+            });
+            config.tomcatPath = tomcatPath;
+        }
+
+        // Save file
+        Logger.newline();
+        Logger.step("Saving configuration...");
+
+        const configPath = join(process.cwd(), "xavva.json");
+        await writeFile(configPath, JSON.stringify(config, null, 2));
+
+        Logger.success(`Configuration saved to ${configPath}`);
+        Logger.newline();
+        Logger.ready("Project configured!");
+        Logger.info("Next steps:");
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva build${Logger.C.reset}  ${Logger.C.gray}- Compile project${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva deploy${Logger.C.reset} ${Logger.C.gray}- Build + deploy${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva health${Logger.C.reset} ${Logger.C.gray}- Check environment${Logger.C.reset}`);
+        Logger.done();
+    }
+
+    private async detectBuildTool(): Promise<"maven" | "gradle"> {
+        const hasPom = existsSync(join(process.cwd(), "pom.xml"));
+        const hasGradle = existsSync(join(process.cwd(), "build.gradle")) || 
+                          existsSync(join(process.cwd(), "build.gradle.kts"));
+
+        if (hasPom && !hasGradle) {
+            Logger.info("Detected: Maven project");
+            return "maven";
+        }
+        
+        if (hasGradle && !hasPom) {
+            Logger.info("Detected: Gradle project");
+            return "gradle";
+        }
+
+        if (hasPom && hasGradle) {
+            Logger.warn("Both pom.xml and build.gradle found");
+            const choice = await select({
+                message: "Select build tool:",
+                choices: [
+                    { name: "Maven (pom.xml)", value: "maven" },
+                    { name: "Gradle (build.gradle)", value: "gradle" }
+                ]
+            });
+            return choice;
+        }
+
+        // Neither found
+        const choice = await select({
+            message: "Build tool:",
+            choices: [
+                { name: "Maven", value: "maven" },
+                { name: "Gradle", value: "gradle" }
+            ]
+        });
+        return choice;
+    }
+
+    private async detectProfiles(buildTool: "maven" | "gradle"): Promise<Array<{name: string, description?: string}>> {
+        const profiles: Array<{name: string, description?: string}> = [];
+        
+        try {
+            if (buildTool === "maven") {
+                const pomPath = join(process.cwd(), "pom.xml");
+                if (existsSync(pomPath)) {
+                    const content = await readFile(pomPath, "utf-8");
+                    // Parse profiles from pom.xml
+                    const profileMatches = content.matchAll(/<profile>[\s\S]*?<id>([^<]+)<\/id>[\s\S]*?<\/profile>/g);
+                    for (const match of profileMatches) {
+                        const profileContent = match[0];
+                        const id = match[1].trim();
+                        // Try to extract description or properties
+                        const descMatch = profileContent.match(/<description>([^<]+)<\/description>/);
+                        const desc = descMatch ? descMatch[1].trim() : undefined;
+                        profiles.push({ name: id, description: desc });
+                    }
+                }
+            } else {
+                const gradlePath = join(process.cwd(), "build.gradle");
+                const gradleKtsPath = join(process.cwd(), "build.gradle.kts");
+                const gradleFile = existsSync(gradlePath) ? gradlePath : gradleKtsPath;
+                
+                if (existsSync(gradleFile)) {
+                    const content = await readFile(gradleFile, "utf-8");
+                    // Look for common profile-like configurations
+                    // Gradle doesn't have built-in profiles like Maven, but can use:
+                    // - Properties (-Pprofile=dev)
+                    // - Custom configurations
+                    // - apply from: "profiles/${profile}.gradle"
+                    const profileMatches = content.matchAll(/(?:apply from:|def\s+\w*[Pp]rofile|ext\.\w*[Pp]rofile)\s*=\s*["']([^"']+)["']/g);
+                    for (const match of profileMatches) {
+                        profiles.push({ name: match[1] });
+                    }
+                }
+            }
+        } catch {
+            // Ignore errors, return empty profiles
+        }
+        
+        return profiles;
+    }
+}

package/src/commands/RedoCommand.ts

@@ -0,0 +1,36 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { HistoryService } from "../services/HistoryService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class RedoCommand implements Command {
+    private historyService = new HistoryService();
+
+    async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
+        const lastEntry = await this.historyService.getLast();
+
+        if (!lastEntry) {
+            Logger.error("Nenhum comando no histórico");
+            return;
+        }
+
+        const args = lastEntry.args.length > 0 ? lastEntry.args.join(" ") : "";
+        Logger.banner("redo");
+        Logger.info(`Repetindo: ${Logger.C.white}xavva ${lastEntry.command}${Logger.C.reset} ${Logger.C.gray}${args}${Logger.C.reset}`);
+        Logger.newline();
+
+        // Re-executar o comando
+        const proc = Bun.spawn([
+            "bun", "run", "src/index.ts", 
+            lastEntry.command, 
+            ...lastEntry.args
+        ], {
+            stdio: "inherit",
+            cwd: process.cwd()
+        });
+
+        await proc.exited;
+        ProcessManager.getInstance().shutdown(proc.exitCode || 0);
+    }
+}