@archznn/xavva 3.1.1 → 3.1.3

package/README.md

@@ -2,7 +2,7 @@
 
 > Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows, Linux & macOS
 
-[![Version](https://img.shields.io/badge/version-3.1.1-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-3.1.3-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.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "3.1.1",
+	"version": "3.1.3",
 	"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",

package/src/commands/DbCommand.ts

@@ -10,8 +10,35 @@ import { Logger } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 
 export class DbCommand implements Command {
+    private showHelp(): void {
+        Logger.section("Database Command");
+        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva db <action> [options]`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Actions:${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.primary}status${Logger.C.reset}     Show migration status`);
+        Logger.log(`  ${Logger.C.primary}migrate${Logger.C.reset}    Run pending migrations`);
+        Logger.log(`  ${Logger.C.primary}reset${Logger.C.reset}      Reset database (⚠️ destructive)`);
+        Logger.log(`  ${Logger.C.primary}seed${Logger.C.reset}       Populate with test data`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
+        Logger.log(`  --force           Confirm destructive operations`);
+        Logger.log(`  --env <name>      Use environment config`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Examples:${Logger.C.reset}`);
+        Logger.log(`  xavva db status`);
+        Logger.log(`  xavva db migrate`);
+        Logger.log(`  xavva db reset --force`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
+
         const action = positionals?.[1] || "status";
         
         const service = new DbService(config.project.buildTool);

package/src/commands/DockerCommand.ts

@@ -10,8 +10,39 @@ import { Logger } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 
 export class DockerCommand implements Command {
+    private showHelp(): void {
+        Logger.section("Docker Command");
+        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva docker <action> [options]`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Actions:${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.primary}init${Logger.C.reset}       Generate Dockerfile & docker-compose.yml`);
+        Logger.log(`  ${Logger.C.primary}build${Logger.C.reset}      Build Docker image`);
+        Logger.log(`  ${Logger.C.primary}run${Logger.C.reset}        Run development container`);
+        Logger.log(`  ${Logger.C.primary}up${Logger.C.reset}         Start with docker-compose`);
+        Logger.log(`  ${Logger.C.primary}down${Logger.C.reset}       Stop containers`);
+        Logger.log(`  ${Logger.C.primary}status${Logger.C.reset}     Show container status`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
+        Logger.log(`  --name <n>        Image name`);
+        Logger.log(`  --tag <t>         Image tag`);
+        Logger.log(`  --port <p>        Port mapping`);
+        Logger.log(`  -d, --detached    Run in background`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Examples:${Logger.C.reset}`);
+        Logger.log(`  xavva docker init`);
+        Logger.log(`  xavva docker build --tag myapp:1.0`);
+        Logger.log(`  xavva docker up -d`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
+
         const action = positionals?.[1] || "status";
 
         const service = new DockerService();

package/src/commands/EncodingCommand.ts

@@ -16,6 +16,13 @@ export class EncodingCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
         
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            await processManager.shutdown(0);
+            return;
+        }
+
         // Parse subcomando
         const subcommand = positionals?.[1] || "help";
         const fileArg = positionals?.[2]; // Arquivo específico (opcional)

package/src/commands/HelpCommand.ts

@@ -4,202 +4,63 @@ import pkg from "../../package.json";
 
 export class HelpCommand implements Command {
     async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
-        const version = pkg.version;
+        const v = pkg.version;
+        const c = this.c;
         
         console.log(`
-  ${this.c("cyan", "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓")}
-  ${this.c("cyan", "▓")}                                              ${this.c("cyan", "▓")}
-  ${this.c("cyan", "▓")}   ${this.c("bold", "XAVVA")} ${this.c("dim", `v${version}`)} ${this.c("gray", "— Java/Tomcat Dev CLI")}           ${this.c("cyan", "▓")}
-  ${this.c("cyan", "▓")}                                              ${this.c("cyan", "▓")}
-  ${this.c("cyan", "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓")}
-
-  ${this.c("yellow", "USAGE")}
-    xavva <command> [options]
-
-  ${this.c("yellow", "COMMANDS")}
-    ${this.c("green", "dev")}              Start development mode (build + deploy + watch)
-    ${this.c("green", "deploy")}           Build and deploy to Tomcat (default)
-    ${this.c("green", "build")}            Compile project only
-    ${this.c("green", "start")}            Start Tomcat server only
-    ${this.c("green", "run")} <class>      Run a Java class with automatic classpath
-    ${this.c("green", "debug")} <class>    Debug a Java class (port 5005)
-    ${this.c("green", "logs")}             Stream and analyze Tomcat logs
-    ${this.c("green", "deps")}             Analyze dependencies (conflicts, updates)
-    ${this.c("green", "audit")}            Security audit of JAR files
-    ${this.c("green", "doctor")}           Diagnose and fix environment issues
-    ${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("cyan", "changelog")}         Generate changelog from conventional commits
-
-    ${this.c("magenta", "test")}             Run tests (JUnit/TestNG)
-    ${this.c("magenta", "db")}               Database migrations (Flyway/Liquibase)
-    ${this.c("magenta", "http")}             HTTP client for API testing
-    ${this.c("magenta", "docker")}           Docker integration (build, run, compose)
-
-  ${this.c("yellow", "GENERAL OPTIONS")}
-    ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
-    ${this.c("cyan", "-t, --tool")} <tool>     Build tool: maven | gradle
-    ${this.c("cyan", "-n, --name")} <name>     Application name (WAR context)
-    ${this.c("cyan", "--port")} <port>        Tomcat port (default: 8080)
-    ${this.c("cyan", "-P, --profile")} <prof>  Maven/Gradle profile
-    ${this.c("cyan", "-e, --encoding")} <enc>  Source encoding (utf8, cp1252)
-    
-    ${this.c("cyan", "-w, --watch")}          Enable file watching (hot reload)
-    ${this.c("cyan", "--tui")}                Interactive dashboard mode
-    ${this.c("cyan", "-d, --debug")}          Enable JPDA debugger
-    ${this.c("cyan", "--dp")} <port>          Debugger port (default: 5005)
-    
-    ${this.c("cyan", "-c, --clean")}          Clean before build
-    ${this.c("cyan", "-s, --no-build")}       Skip initial build
-    ${this.c("cyan", "-q, --quiet")}          Minimal output
-    ${this.c("cyan", "-V, --verbose")}        Detailed output
-    ${this.c("cyan", "--debug-level")} <lvl>   Debug level: error|warn|info|verbose|trace|silly
-    ${this.c("cyan", "-h, --help")}           Show this help
-    ${this.c("cyan", "-v, --version")}        Show version
-
-  ${this.c("yellow", "BUILD OPTIONS")}  ${this.c("dim", "(for deploy, dev, build)")}
-    ${this.c("cyan", "-W, --war")}             Generate .war file instead of exploded directory
-    ${this.c("cyan", "--cache")}              Use build cache (skip if no changes)
-
-  ${this.c("yellow", "TOMCAT OPTIONS")}  ${this.c("dim", "(for embedded Tomcat)")}
-    ${this.c("cyan", "--tomcat-version")} <v>   Tomcat version to install (default: 10.1.52)
-    ${this.c("cyan", "-y, --yes")}             Auto-install without confirmation
-
-  ${this.c("yellow", "DEPS OPTIONS")}  ${this.c("dim", "(for xavva deps)")}
-    ${this.c("cyan", "--update-safe")}         Update only non-breaking dependencies
-    ${this.c("cyan", "--fix")}                 Show fix suggestions for conflicts
-    ${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
-
-    ${this.c("dim", "# Deploy to specific Tomcat installation")}
-    xavva deploy -p /opt/tomcat --port 8081
-
-    ${this.c("dim", "# Build and deploy as .war file")}
-    xavva deploy --war
-
-    ${this.c("dim", "# Run a class with debugging")}
-    xavva debug com.example.MyClass
-
-    ${this.c("dim", "# Use embedded Tomcat (auto-install)")}
-    xavva dev --yes
-    xavva dev --tomcat-version 9.0.115
-
-    ${this.c("dim", "# Analyze and update dependencies")}
-    xavva deps --verbose
-    xavva deps --update-safe
-
-    ${this.c("dim", "# Security audit with auto-fix")}
-    xavva audit --fix
-
-    ${this.c("dim", "# Manage embedded Tomcat")}
-    xavva tomcat list              # List available versions
-    xavva tomcat installed         # List installed versions
-    xavva tomcat install 9.0.115   # Install specific version
-    xavva tomcat use 9.0.115       # Switch to version for this project
-    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("dim", "# Changelog")}
-    xavva changelog generate       # Generate CHANGELOG.md
-    xavva changelog check          # Validate conventional commits
-    xavva changelog preview        # Preview without saving
-    
-    ${this.c("dim", "# Debug levels")}
-    xavva deploy --debug-level verbose  # Verbose logging
-    xavva deploy --debug-level trace    # Trace all operations
-    xavva deploy --debug-level silly    # Everything including config
-
-    ${this.c("dim", "# Multi-environment")}
-    xavva deploy --env staging          # Deploy to staging environment
-    xavva dev --env dev                 # Use dev environment config
-
-    ${this.c("dim", "# Test runner")}
-    xavva test                          # Run all tests
-    xavva test --watch                  # Watch mode
-    xavva test --coverage               # Generate coverage report
-    xavva test UserServiceTest          # Run specific test class
-
-    ${this.c("dim", "# Database migrations")}
-    xavva db status                     # Show migration status
-    xavva db migrate                    # Run pending migrations
-    xavva db reset --force              # Reset database (drops all!)
-    xavva db seed                       # Populate with test data
-
-    ${this.c("dim", "# HTTP Client")}
-    xavva http GET /api/users           # Test endpoint
-    xavva http POST /api/users --body '{"name":"John"}'
-    xavva http GET /api/users --param page=1 --param size=10
-
-    ${this.c("dim", "# Docker")}
-    xavva docker init                   # Generate Dockerfile & compose
-    xavva docker build                  # Build image
-    xavva docker up                     # Start with docker-compose
-    xavva docker run                    # Run dev container
-
-  ${this.c("yellow", "CONFIGURATION")}
-    Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
-    
-    ${this.c("dim", `{
-      "project": {
-        "appName": "my-app",
-        "buildTool": "maven",
-        "tui": true
-      },
-      "tomcat": {
-        "path": "C:/apache-tomcat",
-        "port": 8080
-      }
-    }`)}
-
-  ${this.c("gray", "────────────────────────────────────────────────────────────")}
-  ${this.c("gray", "Docs: github.com/leorsousa05/Xavva  |  License: MIT")}
+ ${c("cyan", "◆")} ${c("bold", "XAVVA")} ${c("dim", `v${v}`)} ${c("gray", "— Java/Tomcat Dev CLI")}
+
+ ${c("yellow", "USAGE")}
+   xavva <command> [options]
+
+ ${c("yellow", "CORE COMMANDS")}
+   ${c("green", "dev")}        Start dev mode (build + deploy + watch + hot reload)
+   ${c("green", "deploy")}     Build and deploy to Tomcat
+   ${c("green", "build")}      Compile project
+   ${c("green", "start")}      Start Tomcat server
+   ${c("green", "run")}        Run a Java class
+   ${c("green", "logs")}       Stream Tomcat logs
+
+ ${c("yellow", "ANALYSIS")}
+   ${c("cyan", "deps")}        Analyze dependencies (conflicts, updates)
+   ${c("cyan", "audit")}       Security vulnerability scan
+   ${c("cyan", "doctor")}      Diagnose environment issues
+   ${c("cyan", "health")}      Check environment health
+   ${c("cyan", "profiles")}    List Maven/Gradle profiles
+
+ ${c("yellow", "UTILITIES")}
+   ${c("magenta", "init")}         Initialize project (wizard)
+   ${c("magenta", "config")}       View/edit configuration
+   ${c("magenta", "encoding")}     Convert file encodings
+   ${c("magenta", "tomcat")}       Manage embedded Tomcat
+   ${c("magenta", "history")}      Command history
+   ${c("magenta", "redo")}         Repeat last command
+   ${c("magenta", "completion")}   Shell completions
+
+ ${c("yellow", "NEW v3.1")}
+   ${c("brightMagenta", "test")}        Run JUnit/TestNG tests (--watch, --coverage)
+   ${c("brightMagenta", "db")}          Database migrations (Flyway/Liquibase)
+   ${c("brightMagenta", "http")}        HTTP client for API testing
+   ${c("brightMagenta", "docker")}      Docker integration
+
+ ${c("yellow", "GLOBAL OPTIONS")}
+   -p, --path <path>      Tomcat path      --port <n>             Port (8080)
+   -t, --tool <tool>      maven|gradle     -P, --profile <p>      Build profile
+   -n, --name <name>      App name         -e, --encoding <enc>   UTF-8|cp1252
+   -w, --watch            Watch mode       --tui                  Dashboard
+   -d, --debug            JPDA debugger    -c, --clean            Clean build
+   -W, --war              Build .war       --env <name>           Environment
+   -h, --help             Show help        -v, --version          Version
+
+ ${c("yellow", "EXAMPLES")}
+   xavva dev --tui --watch           # Dev mode with dashboard
+   xavva deploy --war --port 8081    # Build WAR for port 8081
+   xavva test --watch                # Test watch mode
+   xavva deps --update-safe          # Update dependencies
+   xavva docker init && xavva docker up   # Docker setup
+
+ ${c("gray", "Run 'xavva <command> --help' for detailed options")}
+ ${c("gray", "Docs: github.com/leorsousa05/Xavva")}
 `);
     }
 
@@ -214,6 +75,7 @@ export class HelpCommand implements Command {
             yellow: "\x1b[33m",
             blue: "\x1b[34m",
             cyan: "\x1b[36m",
+            brightMagenta: "\x1b[95m",
         };
         return `${colors[color] || ""}${text}\x1b[0m`;
     }

package/src/commands/HttpCommand.ts

@@ -14,8 +14,34 @@ import fs from "fs";
 import path from "path";
 
 export class HttpCommand implements Command {
+    private showHelp(): void {
+        Logger.section("HTTP Client");
+        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva http <method> <path> [options]`);
+        Logger.log(`${Logger.C.bold}   or:${Logger.C.reset} xavva http --interactive`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Methods:${Logger.C.reset} GET, POST, PUT, DELETE, PATCH`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
+        Logger.log(`  --body <data>        Request body (JSON)`);
+        Logger.log(`  --param <k=v>        Query parameter (can use multiple)`);
+        Logger.log(`  --header <h>         Custom header`);
+        Logger.log(`  --base-url <url>     Override base URL`);
+        Logger.log(`  -i, --interactive    Interactive mode`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Examples:${Logger.C.reset}`);
+        Logger.log(`  xavva http GET /api/users`);
+        Logger.log(`  xavva http POST /api/users --body '{"name":"John"}'`);
+        Logger.log(`  xavva http GET /api/users --param page=1 --param size=10`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
         
         // Modo interativo
         if (args?.interactive || positionals?.length === 1) {

package/src/commands/TestCommand.ts

@@ -12,8 +12,32 @@ import { ProcessManager } from "../utils/processManager";
 export class TestCommand implements Command {
     private service: TestService | null = null;
 
+    private showHelp(): void {
+        Logger.section("Test Runner");
+        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva test [options] [filter]`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
+        Logger.log(`  -w, --watch          Watch mode (run on file change)`);
+        Logger.log(`      --coverage       Generate JaCoCo coverage report`);
+        Logger.log(`      --fail-fast      Stop on first failure`);
+        Logger.log(`      --parallel       Run tests in parallel`);
+        Logger.log(`  -V, --verbose        Verbose output`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Examples:${Logger.C.reset}`);
+        Logger.log(`  xavva test                    # Run all tests`);
+        Logger.log(`  xavva test --watch            # Watch mode`);
+        Logger.log(`  xavva test --coverage         # With coverage`);
+        Logger.log(`  xavva test UserServiceTest    # Run specific test`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
         
         // Extrai filtros de teste dos positionals (após o comando "test")
         const filter = positionals?.slice(1).join(" ") || undefined;

package/src/commands/TomcatCommand.ts

@@ -6,7 +6,32 @@ import path from "path";
 import fs from "fs";
 
 export class TomcatCommand implements Command {
+    private showHelp(): void {
+        Logger.section("Tomcat Command");
+        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva tomcat <action> [options]`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Actions:${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.primary}list${Logger.C.reset}         List available Tomcat versions`);
+        Logger.log(`  ${Logger.C.primary}installed${Logger.C.reset}    List installed versions`);
+        Logger.log(`  ${Logger.C.primary}install${Logger.C.reset}      Install a version`);
+        Logger.log(`  ${Logger.C.primary}use${Logger.C.reset}          Set version for this project`);
+        Logger.log(`  ${Logger.C.primary}uninstall${Logger.C.reset}    Remove a version`);
+        Logger.log(`  ${Logger.C.primary}status${Logger.C.reset}       Show current configuration`);
+        Logger.newline();
+        Logger.log(`${Logger.C.bold}Examples:${Logger.C.reset}`);
+        Logger.log(`  xavva tomcat list`);
+        Logger.log(`  xavva tomcat install 9.0.115`);
+        Logger.log(`  xavva tomcat use 10.1.52`);
+        Logger.log(`  xavva tomcat status`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
+
         // A ação vem como positional após "tomcat" (ex: xavva tomcat list)
         const tomcatIndex = positionals?.indexOf("tomcat") ?? -1;
         const action = positionals && tomcatIndex >= 0 && positionals[tomcatIndex + 1] 

package/src/index.ts

@@ -49,9 +49,15 @@ async function main() {
 
     // Handler de help
     if (values.help) {
-        const { HelpCommand } = await import("./commands/HelpCommand");
-        new HelpCommand().execute(config, values as CLIArguments);
-        await processManager.shutdown(0);
+        // Se for help de comando específico, deixa o comando tratar
+        if (commandName !== "help" && commandName !== "deploy") {
+            // O comando específico vai tratar o --help
+        } else {
+            // Help geral
+            const { HelpCommand } = await import("./commands/HelpCommand");
+            new HelpCommand().execute(config, values as CLIArguments);
+            await processManager.shutdown(0);
+        }
     }
 
     // Inicializa Container de DI