@archznn/xavva 2.7.0 → 2.8.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,148 @@
+import { input, select, confirm, number } from "@inquirer/prompts";
+import { writeFile, access } from "fs/promises";
+import { join } from "path";
+import { constants } 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("Wizard de Configuração");
+        Logger.info("Vamos configurar seu projeto Xavva");
+        Logger.newline();
+
+        // Detectar build tool
+        const buildTool = await this.detectBuildTool();
+        
+        // Nome da aplicação
+        const appName = await input({
+            message: "Nome da aplicação:",
+            default: process.cwd().split(/[/\\]/).pop() || "my-app",
+            validate: (value) => value.length > 0 || "Nome é obrigatório"
+        });
+
+        // Profile
+        const profile = await select({
+            message: "Profile padrão:",
+            choices: [
+                { name: "desenvolvimento", value: "dev" },
+                { name: "teste", value: "test" },
+                { name: "produção", value: "prod" },
+                { name: "customizado", value: "custom" }
+            ],
+            default: "dev"
+        });
+
+        const customProfile = profile === "custom" ? await input({
+            message: "Nome do profile:",
+            default: "local"
+        }) : profile;
+
+        // Porta do Tomcat
+        const port = await number({
+            message: "Porta do Tomcat:",
+            default: 8080,
+            validate: (value) => (value && value > 0 && value < 65536) || "Porta inválida"
+        }) || 8080;
+
+        // Configurações opcionais
+        Logger.newline();
+        Logger.dim("Configurações avançadas:");
+        
+        const useEmbedded = await confirm({
+            message: "Usar Tomcat embutido (auto-download)?",
+            default: true
+        });
+
+        const enableCache = await confirm({
+            message: "Habilitar cache de build?",
+            default: true
+        });
+
+        const enableTui = await confirm({
+            message: "Habilitar dashboard TUI?",
+            default: true
+        });
+
+        const encoding = await select({
+            message: "Encoding:",
+            choices: [
+                { name: "UTF-8", value: "UTF-8" },
+                { name: "ISO-8859-1", value: "ISO-8859-1" },
+                { name: "Windows-1252", value: "Windows-1252" }
+            ],
+            default: "UTF-8"
+        });
+
+        // Montar configuração
+        const config: Record<string, unknown> = {
+            appName,
+            buildTool,
+            profile: customProfile,
+            port,
+            cache: enableCache,
+            tui: enableTui,
+            encoding
+        };
+
+        if (useEmbedded) {
+            config.embedded = true;
+            config.tomcatVersion = "10.1.52";
+        } else {
+            const tomcatPath = await input({
+                message: "Caminho do Tomcat (CATALINA_HOME):",
+                validate: async (value) => {
+                    if (!value) return "Caminho é obrigatório";
+                    try {
+                        await access(value, constants.R_OK);
+                        return true;
+                    } catch {
+                        return "Caminho não acessível";
+                    }
+                }
+            });
+            config.tomcatPath = tomcatPath;
+        }
+
+        // Salvar arquivo
+        Logger.newline();
+        Logger.step("Salvando configuração...");
+
+        const configPath = join(process.cwd(), "xavva.json");
+        await writeFile(configPath, JSON.stringify(config, null, 2));
+
+        Logger.success(`Configuração salva em ${configPath}`);
+        Logger.newline();
+        Logger.ready("Projeto configurado!");
+        Logger.info("Próximos passos:");
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva build${Logger.C.reset}  ${Logger.C.gray}- Compilar projeto${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 doctor${Logger.C.reset} ${Logger.C.gray}- Verificar ambiente${Logger.C.reset}`);
+        Logger.done();
+    }
+
+    private async detectBuildTool(): Promise<"maven" | "gradle"> {
+        try {
+            await access(join(process.cwd(), "pom.xml"), constants.R_OK);
+            Logger.info("Detectado: Projeto Maven");
+            return "maven";
+        } catch {
+            try {
+                await access(join(process.cwd(), "build.gradle"), constants.R_OK);
+                Logger.info("Detectado: Projeto Gradle");
+                return "gradle";
+            } catch {
+                const choice = await select({
+                    message: "Build tool:",
+                    choices: [
+                        { name: "Maven", value: "maven" },
+                        { name: "Gradle", value: "gradle" }
+                    ]
+                });
+                return choice;
+            }
+        }
+    }
+}

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

package/src/di/container.ts

@@ -24,6 +24,14 @@ import { DepsCommand } from "../commands/DepsCommand";
 import { TomcatCommand } from "../commands/TomcatCommand";
 import { EncodingCommand } from "../commands/EncodingCommand";
 import { DocsCommand } from "../commands/DocsCommand";
+import { InitCommand } from "../commands/InitCommand";
+import { ConfigCommand } from "../commands/ConfigCommand";
+import { HistoryCommand } from "../commands/HistoryCommand";
+import { RedoCommand } from "../commands/RedoCommand";
+import { HealthCommand } from "../commands/HealthCommand";
+import { CompletionCommand } from "../commands/CompletionCommand";
+import { HistoryService } from "../services/HistoryService";
+import { NotificationService } from "../services/NotificationService";
 import type { Command } from "../commands/Command";
 import { Logger } from "../utils/ui";
 
@@ -35,6 +43,7 @@ export interface Services {
     auditService: AuditService;
     dashboardService: DashboardService;
     logAnalyzer: LogAnalyzer;
+    historyService: HistoryService;
 }
 
 export interface Commands {
@@ -53,6 +62,12 @@ export interface Commands {
     tomcat: TomcatCommand;
     encoding: EncodingCommand;
     docs: DocsCommand;
+    init: InitCommand;
+    config: ConfigCommand;
+    history: HistoryCommand;
+    redo: RedoCommand;
+    health: HealthCommand;
+    completion: CompletionCommand;
 }
 
 export class DIContainer {
@@ -101,6 +116,7 @@ export class DIContainer {
         tomcatService.setProjectService(projectService);
 
         const auditService = new AuditService(this.config.tomcat);
+        const historyService = new HistoryService();
 
         this.services = {
             projectService,
@@ -110,6 +126,7 @@ export class DIContainer {
             auditService,
             dashboardService,
             logAnalyzer,
+            historyService,
         };
     }
 
@@ -140,6 +157,12 @@ export class DIContainer {
             tomcat: new TomcatCommand(),
             encoding: new EncodingCommand(),
             docs: new DocsCommand(),
+            init: new InitCommand(),
+            config: new ConfigCommand(),
+            history: new HistoryCommand(),
+            redo: new RedoCommand(),
+            health: new HealthCommand(),
+            completion: new CompletionCommand(),
         };
     }