@archznn/xavva 2.6.0 → 2.8.0

package/src/commands/HelpCommand.ts

@@ -30,6 +30,14 @@ 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("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
@@ -65,6 +73,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 +112,33 @@ 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("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/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;
+}

package/src/di/container.ts

@@ -0,0 +1,249 @@
+/**
+ * Container de Injeção de Dependência (DI) simplificado
+ * Centraliza a criação e injeção de serviços
+ */
+
+import type { AppConfig } from "../types/config";
+import { ProjectService } from "../services/ProjectService";
+import { TomcatService } from "../services/TomcatService";
+import { BuildService } from "../services/BuildService";
+import { BuildCacheService } from "../services/BuildCacheService";
+import { AuditService } from "../services/AuditService";
+import { DashboardService } from "../services/DashboardService";
+import { LogAnalyzer } from "../services/LogAnalyzer";
+import { DeployCommand } from "../commands/DeployCommand";
+import { BuildCommand } from "../commands/BuildCommand";
+import { StartCommand } from "../commands/StartCommand";
+import { LogsCommand } from "../commands/LogsCommand";
+import { AuditCommand } from "../commands/AuditCommand";
+import { ProfilesCommand } from "../commands/ProfilesCommand";
+import { RunCommand } from "../commands/RunCommand";
+import { HelpCommand } from "../commands/HelpCommand";
+import { DoctorCommand } from "../commands/DoctorCommand";
+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";
+
+export interface Services {
+    projectService: ProjectService;
+    tomcatService: TomcatService;
+    buildCacheService: BuildCacheService;
+    buildService: BuildService;
+    auditService: AuditService;
+    dashboardService: DashboardService;
+    logAnalyzer: LogAnalyzer;
+    historyService: HistoryService;
+}
+
+export interface Commands {
+    deploy: DeployCommand;
+    dev: DeployCommand;
+    build: BuildCommand;
+    start: StartCommand;
+    logs: LogsCommand;
+    audit: AuditCommand;
+    profiles: ProfilesCommand;
+    run: RunCommand;
+    debug: RunCommand;
+    help: HelpCommand;
+    doctor: DoctorCommand;
+    deps: DepsCommand;
+    tomcat: TomcatCommand;
+    encoding: EncodingCommand;
+    docs: DocsCommand;
+    init: InitCommand;
+    config: ConfigCommand;
+    history: HistoryCommand;
+    redo: RedoCommand;
+    health: HealthCommand;
+    completion: CompletionCommand;
+}
+
+export class DIContainer {
+    private config: AppConfig;
+    private services: Partial<Services> = {};
+    private commands: Partial<Commands> = {};
+    private isInitialized = false;
+
+    constructor(config: AppConfig) {
+        this.config = config;
+    }
+
+    /**
+     * Inicializa todos os serviços e comandos
+     */
+    initialize(): void {
+        if (this.isInitialized) {
+            Logger.debug("DI Container já inicializado");
+            return;
+        }
+
+        this.initializeServices();
+        this.initializeCommands();
+        this.isInitialized = true;
+    }
+
+    private initializeServices(): void {
+        // Serviços base (sem dependências ou com dependências simples)
+        const projectService = new ProjectService(this.config.project);
+        const buildCacheService = new BuildCacheService();
+        const dashboardService = new DashboardService(this.config);
+        const logAnalyzer = new LogAnalyzer(this.config.project);
+
+        // Configura Logger com dashboard
+        Logger.setDashboard(dashboardService);
+
+        // Serviços com dependências
+        const buildService = new BuildService(
+            this.config.project,
+            this.config.tomcat,
+            projectService,
+            buildCacheService
+        );
+
+        const tomcatService = new TomcatService(this.config.tomcat);
+        tomcatService.setProjectService(projectService);
+
+        const auditService = new AuditService(this.config.tomcat);
+        const historyService = new HistoryService();
+
+        this.services = {
+            projectService,
+            buildCacheService,
+            buildService,
+            tomcatService,
+            auditService,
+            dashboardService,
+            logAnalyzer,
+            historyService,
+        };
+    }
+
+    private initializeCommands(): void {
+        const { tomcatService, buildService, auditService, dashboardService, logAnalyzer } = this.services;
+
+        if (!tomcatService || !buildService || !auditService || !dashboardService || !logAnalyzer) {
+            throw new Error("Serviços não inicializados corretamente");
+        }
+
+        // Comandos que compartilham instâncias
+        const deployCmd = new DeployCommand(tomcatService, buildService);
+        const logsCmd = new LogsCommand(dashboardService, logAnalyzer);
+
+        this.commands = {
+            deploy: deployCmd,
+            dev: deployCmd, // dev reusa deploy
+            build: new BuildCommand(buildService),
+            start: new StartCommand(tomcatService),
+            logs: logsCmd,
+            audit: new AuditCommand(auditService),
+            profiles: new ProfilesCommand(this.services.projectService!),
+            run: new RunCommand(),
+            debug: new RunCommand(),
+            help: new HelpCommand(),
+            doctor: new DoctorCommand(),
+            deps: new DepsCommand(),
+            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(),
+        };
+    }
+
+    /**
+     * Obtém um serviço pelo nome
+     */
+    getService<K extends keyof Services>(name: K): Services[K] {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        const service = this.services[name];
+        if (!service) {
+            throw new Error(`Serviço '${name}' não encontrado no container`);
+        }
+        return service;
+    }
+
+    /**
+     * Obtém um comando pelo nome
+     */
+    getCommand<K extends keyof Commands>(name: K): Commands[K] {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        const command = this.commands[name];
+        if (!command) {
+            throw new Error(`Comando '${name}' não encontrado no container`);
+        }
+        return command;
+    }
+
+    /**
+     * Obtém todos os serviços
+     */
+    getAllServices(): Services {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        return this.services as Services;
+    }
+
+    /**
+     * Obtém todos os comandos
+     */
+    getAllCommands(): Commands {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        return this.commands as Commands;
+    }
+
+    /**
+     * Registra um serviço customizado (útil para testes)
+     */
+    registerService<K extends keyof Services>(name: K, service: Services[K]): void {
+        this.services[name] = service;
+    }
+
+    /**
+     * Registra um comando customizado (útil para testes)
+     */
+    registerCommand<K extends keyof Commands>(name: K, command: Commands[K]): void {
+        this.commands[name] = command;
+    }
+}
+
+// Singleton para uso global
+let globalContainer: DIContainer | null = null;
+
+export function createContainer(config: AppConfig): DIContainer {
+    globalContainer = new DIContainer(config);
+    return globalContainer;
+}
+
+export function getContainer(): DIContainer {
+    if (!globalContainer) {
+        throw new Error("Container não inicializado. Chame createContainer primeiro.");
+    }
+    return globalContainer;
+}
+
+export function resetContainer(): void {
+    globalContainer = null;
+}