@archznn/xavva 2.7.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.7.0",
+	"version": "2.8.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",
@@ -41,6 +41,8 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"glob": "^13.0.6"
+		"@inquirer/prompts": "^8.3.2",
+		"glob": "^13.0.6",
+		"node-notifier": "^10.0.1"
 	}
 }

package/src/commands/CompletionCommand.ts

@@ -0,0 +1,212 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export class CompletionCommand implements Command {
+    private readonly commands = [
+        "init", "config", "build", "deploy", "start", "stop", "restart",
+        "logs", "run", "audit", "deps", "docs", "doctor", "profiles",
+        "tomcat", "encoding", "history", "redo", "health", "completion", "help"
+    ];
+
+    private readonly flags: Record<string, string[]> = {
+        "*": ["--help", "--version", "-v", "--verbose", "--quiet", "-q"],
+        "init": [],
+        "config": ["--interactive", "-i"],
+        "build": ["--clean", "-c", "--profile", "-p", "--no-build", "--cache"],
+        "deploy": ["--watch", "-w", "--clean", "-c", "--profile", "-p", "--debug", "--tui"],
+        "start": ["--debug", "--tui"],
+        "stop": [],
+        "restart": ["--debug"],
+        "logs": ["--grep", "-g", "--follow", "-f"],
+        "run": [],
+        "audit": ["--fix", "--strict"],
+        "deps": ["--output", "-o"],
+        "docs": [],
+        "doctor": [],
+        "profiles": [],
+        "tomcat": ["--tomcat-version", "--tomcat-action"],
+        "encoding": ["--from", "--to", "--backup"],
+        "history": ["--clear", "--limit"],
+        "redo": [],
+        "health": [],
+        "completion": ["bash", "zsh", "fish"]
+    };
+
+    async execute(_config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const shell = positionals?.[0] || "bash";
+
+        switch (shell) {
+            case "bash":
+                console.log(this.generateBash());
+                break;
+            case "zsh":
+                console.log(this.generateZsh());
+                break;
+            case "fish":
+                console.log(this.generateFish());
+                break;
+            default:
+                Logger.banner("completion");
+                Logger.section("Shell Completion");
+                Logger.info("Uso: xavva completion <shell>");
+                Logger.newline();
+                Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva completion bash${Logger.C.reset}  ${Logger.C.gray}# Bash${Logger.C.reset}`);
+                Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva completion zsh${Logger.C.reset}   ${Logger.C.gray}# Zsh${Logger.C.reset}`);
+                Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva completion fish${Logger.C.reset}  ${Logger.C.gray}# Fish${Logger.C.reset}`);
+                Logger.endSection();
+                Logger.dim("Adicione ao seu shell:");
+                Logger.log(`  ${Logger.C.gray}# Bash: echo 'eval "$(xavva completion bash)"' >> ~/.bashrc${Logger.C.reset}`);
+                Logger.log(`  ${Logger.C.gray}# Zsh:  echo 'eval "$(xavva completion zsh)"' >> ~/.zshrc${Logger.C.reset}`);
+                Logger.log(`  ${Logger.C.gray}# Fish: xavva completion fish > ~/.config/fish/completions/xavva.fish${Logger.C.reset}`);
+        }
+    }
+
+    private generateBash(): string {
+        const cmds = this.commands.join(" ");
+        const flagCases = Object.entries(this.flags)
+            .filter(([cmd]) => cmd !== "*")
+            .map(([cmd, flags]) => `
+            ${cmd})
+                opts="${flags.join(" ")}"
+                ;;`)
+            .join("");
+
+        return `# xavva completion for bash
+_xavva_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Comandos principais
+    local commands="${cmds}"
+    local global_flags="${this.flags["*"].join(" ")}"
+    
+    # Primeiro argumento: comandos
+    if [ \${COMP_CWORD} -eq 1 ]; then
+        COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+        return 0
+    fi
+    
+    # Flags específicas por comando
+    local cmd="\${COMP_WORDS[1]}"
+    case \${cmd} in${flagCases}
+            *)
+                opts="\${global_flags}"
+                ;;
+    esac
+    
+    if [[ \${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+}
+
+complete -F _xavva_completion xavva
+`;
+    }
+
+    private generateZsh(): string {
+        const cmds = this.commands.map(c => `"${c}"`).join(" ");
+        
+        return `#compdef xavva
+
+# xavva completion for zsh
+
+_xavva() {
+    local curcontext="$curcontext" state line
+    typeset -A opt_args
+
+    _arguments -C \\
+        '1: :_xavva_commands' \\
+        '*:: :->args'
+
+    case $line[1] in
+        config)
+            _arguments \\
+                '(-i --interactive)'{-i,--interactive}'[Modo interativo]'
+            ;;
+        build)
+            _arguments \\
+                '(-c --clean)'{-c,--clean}'[Clean build]' \\
+                '(-p --profile)'{-p,--profile}'[Profile]:profile:(dev test prod)' \\
+                '--cache[Enable cache]'
+            ;;
+        deploy)
+            _arguments \\
+                '(-w --watch)'{-w,--watch}'[Watch mode]' \\
+                '(-c --clean)'{-c,--clean}'[Clean build]' \\
+                '(-p --profile)'{-p,--profile}'[Profile]:profile:(dev test prod)' \\
+                '--debug[Debug mode]' \\
+                '--tui[Enable TUI]'
+            ;;
+        logs)
+            _arguments \\
+                '(-g --grep)'{-g,--grep}'[Filter pattern]:pattern:' \\
+                '(-f --follow)'{-f,--follow}'[Follow mode]'
+            ;;
+        history)
+            _arguments \\
+                '--clear[Clear history]' \\
+                '--limit[Limit entries]:number:'
+            ;;
+        completion)
+            _arguments \\
+                '1:shell:(bash zsh fish)'
+            ;;
+    esac
+}
+
+_xavva_commands() {
+    local commands=(${cmds})
+    _describe -t commands 'xavva commands' commands
+}
+
+compdef _xavva xavva
+`;
+    }
+
+    private generateFish(): string {
+        const lines: string[] = [
+            "# xavva completion for fish",
+            "",
+            `# Comandos principais`,
+            `complete -c xavva -n "not __fish_seen_subcommand_from ${this.commands.join(" ")}" -a "${this.commands.join(" ")}"`,
+            "",
+            `# Flags globais`,
+        ];
+
+        // Global flags
+        for (const flag of this.flags["*"]) {
+            const short = flag.startsWith("-") && flag.length === 2 ? flag : "";
+            const long = flag.startsWith("--") ? flag : "";
+            if (short && long) {
+                lines.push(`complete -c xavva -s ${short[1]} -l ${long.slice(2)}`);
+            } else if (short) {
+                lines.push(`complete -c xavva -s ${short[1]}`);
+            } else if (long) {
+                lines.push(`complete -c xavva -l ${long.slice(2)}`);
+            }
+        }
+
+        // Command-specific flags
+        for (const [cmd, flags] of Object.entries(this.flags)) {
+            if (cmd === "*") continue;
+            
+            lines.push("");
+            lines.push(`# ${cmd}`);
+            for (const flag of flags) {
+                if (flag.startsWith("--")) {
+                    lines.push(`complete -c xavva -n "__fish_seen_subcommand_from ${cmd}" -l ${flag.slice(2)}`);
+                } else if (flag.startsWith("-") && flag.length === 2) {
+                    lines.push(`complete -c xavva -n "__fish_seen_subcommand_from ${cmd}" -s ${flag[1]}`);
+                } else {
+                    lines.push(`complete -c xavva -n "__fish_seen_subcommand_from ${cmd}" -a "${flag}"`);
+                }
+            }
+        }
+
+        return lines.join("\n");
+    }
+}

package/src/commands/ConfigCommand.ts

@@ -0,0 +1,184 @@
+import { input, select, confirm, number, editor } from "@inquirer/prompts";
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export class ConfigCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const interactive = args?.["interactive"] || args?.["i"] || false;
+        const configPath = join(process.cwd(), "xavva.json");
+
+        if (!interactive) {
+            // Modo view: mostrar configuração atual
+            Logger.banner("config");
+            Logger.section("Configuração Atual");
+            
+            Logger.config("App Name", config.project.appName);
+            Logger.config("Build Tool", config.project.buildTool);
+            Logger.config("Profile", config.project.profile);
+            Logger.config("Port", config.tomcat.port);
+            Logger.config("Cache", config.project.cache ?? true);
+            Logger.config("TUI", config.project.tui);
+            Logger.config("Encoding", config.project.encoding || "UTF-8");
+            
+            if (config.tomcat.embedded) {
+                Logger.config("Tomcat", "embedded");
+                Logger.config("Version", config.tomcat.version || "10.1.52");
+            } else {
+                Logger.config("Tomcat Path", config.tomcat.path);
+            }
+
+            Logger.endSection();
+            Logger.dim("Use --interactive ou -i para editar");
+            return;
+        }
+
+        // Modo interativo
+        Logger.banner("config --interactive");
+        Logger.section("Editor Interativo");
+
+        if (!existsSync(configPath)) {
+            Logger.warn("xavva.json não encontrado. Execute 'xavva init' primeiro.");
+            return;
+        }
+
+        // Carregar config atual
+        let currentConfig: Record<string, unknown>;
+        try {
+            const content = await readFile(configPath, "utf-8");
+            currentConfig = JSON.parse(content);
+        } catch {
+            Logger.error("Erro ao ler xavva.json");
+            return;
+        }
+
+        // Menu de opções
+        const action = await select({
+            message: "O que deseja editar?",
+            choices: [
+                { name: "Informações básicas (nome, profile)", value: "basic" },
+                { name: "Configurações do Tomcat (porta, path)", value: "tomcat" },
+                { name: "Opções de build (cache, encoding)", value: "build" },
+                { name: "Editor de texto (JSON completo)", value: "json" }
+            ]
+        });
+
+        switch (action) {
+            case "basic":
+                await this.editBasic(currentConfig);
+                break;
+            case "tomcat":
+                await this.editTomcat(currentConfig);
+                break;
+            case "build":
+                await this.editBuild(currentConfig);
+                break;
+            case "json":
+                await this.editJson(currentConfig, configPath);
+                return;
+        }
+
+        // Salvar
+        await writeFile(configPath, JSON.stringify(currentConfig, null, 2));
+        Logger.success("Configuração salva!");
+    }
+
+    private async editBasic(config: Record<string, unknown>): Promise<void> {
+        config.appName = await input({
+            message: "Nome da aplicação:",
+            default: String(config.appName || "")
+        });
+
+        config.profile = await select({
+            message: "Profile:",
+            choices: [
+                { name: "dev", value: "dev" },
+                { name: "test", value: "test" },
+                { name: "prod", value: "prod" },
+                { name: "custom", value: "custom" }
+            ],
+            default: String(config.profile || "dev")
+        });
+
+        if (config.profile === "custom") {
+            config.profile = await input({
+                message: "Nome do profile:",
+                default: "local"
+            });
+        }
+    }
+
+    private async editTomcat(config: Record<string, unknown>): Promise<void> {
+        config.port = await number({
+            message: "Porta:",
+            default: Number(config.port || 8080)
+        });
+
+        const useEmbedded = await confirm({
+            message: "Usar Tomcat embutido?",
+            default: Boolean(config.embedded ?? true)
+        });
+
+        config.embedded = useEmbedded;
+
+        if (useEmbedded) {
+            config.tomcatVersion = await select({
+                message: "Versão do Tomcat:",
+                choices: [
+                    { name: "10.1.52 (recomendada)", value: "10.1.52" },
+                    { name: "9.0.115", value: "9.0.115" },
+                    { name: "11.0.18", value: "11.0.18" }
+                ],
+                default: String(config.tomcatVersion || "10.1.52")
+            });
+            delete config.tomcatPath;
+        } else {
+            config.tomcatPath = await input({
+                message: "Caminho do Tomcat:",
+                default: String(config.tomcatPath || "")
+            });
+        }
+    }
+
+    private async editBuild(config: Record<string, unknown>): Promise<void> {
+        config.cache = await confirm({
+            message: "Habilitar cache de build?",
+            default: Boolean(config.cache ?? true)
+        });
+
+        config.tui = await confirm({
+            message: "Habilitar dashboard TUI?",
+            default: Boolean(config.tui ?? true)
+        });
+
+        config.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: String(config.encoding || "UTF-8")
+        });
+    }
+
+    private async editJson(config: Record<string, unknown>, path: string): Promise<void> {
+        const current = JSON.stringify(config, null, 2);
+        const edited = await editor({
+            message: "Edite o JSON:",
+            default: current,
+            postfix: ".json"
+        });
+
+        try {
+            const parsed = JSON.parse(edited);
+            await writeFile(path, JSON.stringify(parsed, null, 2));
+            Logger.success("Configuração salva!");
+        } catch {
+            Logger.error("JSON inválido!");
+        }
+    }
+}