@archznn/xavva 2.9.0 → 3.1.0

package/src/commands/HelpCommand.ts

@@ -38,6 +38,12 @@ export class HelpCommand implements Command {
     ${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
@@ -56,6 +62,7 @@ export class HelpCommand implements Command {
     ${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
 
@@ -139,6 +146,43 @@ export class HelpCommand implements Command {
     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:
     

package/src/commands/HttpCommand.ts

@@ -0,0 +1,134 @@
+/**
+ * Comando de HTTP Client
+ * xavva http <method> <url> [options]
+ * xavva http --interactive
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { HttpService, type HttpRequest } from "../services/HttpService";
+import { EndpointService } from "../services/EndpointService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+import fs from "fs";
+import path from "path";
+
+export class HttpCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        
+        // Modo interativo
+        if (args?.interactive || positionals?.length === 1) {
+            const baseUrl = `http://localhost:${config.tomcat.port}`;
+            const service = new HttpService(baseUrl);
+            await service.interactive();
+            return;
+        }
+
+        // Extrai método e URL
+        const method = (positionals?.[1] || "GET").toUpperCase() as HttpRequest["method"];
+        let url = positionals?.[2] || "/";
+
+        // Se URL não começar com http, adiciona base
+        const baseUrl = args?.["base-url"] || `http://localhost:${config.tomcat.port}`;
+        if (!url.startsWith("http")) {
+            url = `${baseUrl}${url.startsWith("/") ? url : `/${url}`}`;
+        }
+
+        // Parse headers
+        const headers = this.parseHeaders(args);
+
+        // Parse body
+        let body: string | object | undefined;
+        if (args?.body) {
+            body = this.parseBody(args.body as string);
+        } else if (args?.file) {
+            const filePath = args.file as string;
+            if (fs.existsSync(filePath)) {
+                body = fs.readFileSync(filePath, "utf-8");
+            } else {
+                Logger.error(`File not found: ${filePath}`);
+                await processManager.shutdown(1);
+                return;
+            }
+        }
+
+        // Parse query params
+        const params = this.parseParams(args);
+
+        // Cria request
+        const request: HttpRequest = {
+            method,
+            url,
+            headers,
+            body,
+            params,
+            timeout: args?.timeout ? parseInt(args.timeout as string) : 30000
+        };
+
+        // Executa
+        const service = new HttpService();
+        
+        try {
+            await service.request(request);
+        } catch (error) {
+            await processManager.shutdown(1);
+        }
+    }
+
+    private parseHeaders(args?: CLIArguments): Record<string, string> | undefined {
+        const headers: Record<string, string> = {};
+        
+        // Formato: --header "Authorization: Bearer token"
+        const headerArgs = args?.header;
+        if (headerArgs) {
+            const headerList = Array.isArray(headerArgs) ? headerArgs : [headerArgs];
+            for (const h of headerList) {
+                const match = h.match(/^([^:]+):\s*(.+)$/);
+                if (match) {
+                    headers[match[1]] = match[2];
+                }
+            }
+        }
+
+        // Content-Type shorthand
+        if (args?.["content-type"]) {
+            headers["Content-Type"] = args["content-type"] as string;
+        }
+
+        // Accept shorthand
+        if (args?.accept) {
+            headers["Accept"] = args.accept as string;
+        }
+
+        return Object.keys(headers).length > 0 ? headers : undefined;
+    }
+
+    private parseBody(bodyStr: string): string | object {
+        // Tenta parsear como JSON
+        try {
+            return JSON.parse(bodyStr);
+        } catch {
+            // Retorna como string
+            return bodyStr;
+        }
+    }
+
+    private parseParams(args?: CLIArguments): Record<string, string> | undefined {
+        const params: Record<string, string> = {};
+        
+        // Formato: --param "key=value"
+        const paramArgs = args?.param;
+        if (paramArgs) {
+            const paramList = Array.isArray(paramArgs) ? paramArgs : [paramArgs];
+            for (const p of paramList) {
+                const [key, value] = p.split("=");
+                if (key && value !== undefined) {
+                    params[key] = value;
+                }
+            }
+        }
+
+        return Object.keys(params).length > 0 ? params : undefined;
+    }
+}

package/src/commands/InitCommand.ts

@@ -104,6 +104,12 @@ export class InitCommand implements Command {
             default: "UTF-8"
         });
 
+        // Multi-environment setup
+        const enableMultiEnv = await confirm({
+            message: "Configure multiple environments?",
+            default: false
+        });
+
         // Build config object
         const config: Record<string, unknown> = {
             appName,
@@ -142,6 +148,70 @@ export class InitCommand implements Command {
             config.tomcatPath = tomcatPath;
         }
 
+        // Add environments if enabled
+        if (enableMultiEnv) {
+            Logger.newline();
+            Logger.dim("Environment Configuration:");
+            
+            const environments: Record<string, unknown> = {};
+            
+            // Dev environment
+            const devPort = await number({
+                message: "Dev environment port:",
+                default: port
+            }) || port;
+            environments.dev = {
+                port: devPort,
+                profile: "dev"
+            };
+            
+            // Test environment
+            const testPort = await number({
+                message: "Test environment port:",
+                default: port + 1
+            }) || port + 1;
+            environments.test = {
+                port: testPort,
+                profile: "test"
+            };
+            
+            // Staging environment
+            const hasStaging = await confirm({
+                message: "Add staging environment?",
+                default: true
+            });
+            
+            if (hasStaging) {
+                const stagingPort = await number({
+                    message: "Staging environment port:",
+                    default: port + 2
+                }) || port + 2;
+                environments.staging = {
+                    port: stagingPort,
+                    profile: "staging"
+                };
+            }
+            
+            config.environments = environments;
+            
+            // Add DB config example
+            const addDbExample = await confirm({
+                message: "Add database configuration example?",
+                default: true
+            });
+            
+            if (addDbExample) {
+                environments.dev = {
+                    ...environments.dev,
+                    db: {
+                        url: "jdbc:h2:mem:devdb",
+                        username: "sa",
+                        password: ""
+                    }
+                };
+            }
+        }
+
         // Save file
         Logger.newline();
         Logger.step("Saving configuration...");

package/src/commands/TestCommand.ts

@@ -0,0 +1,63 @@
+/**
+ * Comando de execução de testes
+ * xavva test [options] [filter]
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { TestService } from "../services/TestService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class TestCommand implements Command {
+    private service: TestService | null = null;
+
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        
+        // Extrai filtros de teste dos positionals (após o comando "test")
+        const filter = positionals?.slice(1).join(" ") || undefined;
+        
+        // Opções
+        const watch = args?.watch || false;
+        const coverage = args?.coverage || false;
+        const verbose = args?.verbose || false;
+        const failFast = args?.["fail-fast"] || false;
+        const parallel = args?.parallel || false;
+
+        this.service = new TestService(config.project.buildTool);
+
+        try {
+            if (watch) {
+                this.service.startWatch({
+                    coverage,
+                    filter,
+                    verbose,
+                    failFast,
+                    parallel
+                });
+
+                // Mantém processo rodando
+                process.on("SIGINT", () => {
+                    this.service?.stopWatch();
+                    processManager.shutdown(0);
+                });
+            } else {
+                const result = await this.service.runTests({
+                    coverage,
+                    filter,
+                    verbose,
+                    failFast,
+                    parallel
+                });
+
+                if (!result.success) {
+                    await processManager.shutdown(1);
+                }
+            }
+        } catch (error) {
+            Logger.error(`Test execution failed: ${(error as Error).message}`);
+            await processManager.shutdown(1);
+        }
+    }
+}

package/src/di/container.ts

@@ -30,7 +30,12 @@ import { HistoryCommand } from "../commands/HistoryCommand";
 import { RedoCommand } from "../commands/RedoCommand";
 import { HealthCommand } from "../commands/HealthCommand";
 import { CompletionCommand } from "../commands/CompletionCommand";
+import { ChangelogCommand } from "../commands/ChangelogCommand";
 import { HistoryService } from "../services/HistoryService";
+import { TestCommand } from "../commands/TestCommand";
+import { DbCommand } from "../commands/DbCommand";
+import { HttpCommand } from "../commands/HttpCommand";
+import { DockerCommand } from "../commands/DockerCommand";
 import { NotificationService } from "../services/NotificationService";
 import type { Command } from "../commands/Command";
 import { Logger } from "../utils/ui";
@@ -68,6 +73,11 @@ export interface Commands {
     redo: RedoCommand;
     health: HealthCommand;
     completion: CompletionCommand;
+    changelog: ChangelogCommand;
+    test: TestCommand;
+    db: DbCommand;
+    http: HttpCommand;
+    docker: DockerCommand;
 }
 
 export class DIContainer {
@@ -163,6 +173,11 @@ export class DIContainer {
             redo: new RedoCommand(),
             health: new HealthCommand(),
             completion: new CompletionCommand(),
+            changelog: new ChangelogCommand(),
+            test: new TestCommand(),
+            db: new DbCommand(),
+            http: new HttpCommand(),
+            docker: new DockerCommand(),
         };
     }
 

package/src/index.ts

@@ -5,6 +5,7 @@ import { createContainer, type DIContainer } from "./di/container";
 import { DeployWatcher } from "./services/DeployWatcher";
 import { ErrorHandler } from "./errors/ErrorHandler";
 import { ProcessManager } from "./utils/processManager";
+import { LoggerLevel } from "./utils/LoggerLevel";
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
 import type { CLIArguments } from "./types/args";
@@ -19,12 +20,19 @@ async function main() {
         await processManager.shutdown(0);
     }
 
+    // Configura debug level
+    if (values["debug-level"]) {
+        LoggerLevel.setLevel(values["debug-level"]);
+        LoggerLevel.verbose(`Debug level set to: ${values["debug-level"]}`, {});
+    }
+
     // Identifica comando
     const commandNames = [
         "deploy", "build", "start", "dev", "doctor", "run", 
         "debug", "logs", "docs", "audit", "profiles", 
         "deps", "tomcat", "encoding", "init", "config", 
-        "history", "redo", "health", "completion", "help"
+        "history", "redo", "health", "completion", "changelog",
+        "test", "db", "http", "docker", "help"
     ];
     const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
@@ -103,6 +111,11 @@ async function main() {
         registry.register("redo", commands.redo);
         registry.register("health", commands.health);
         registry.register("completion", commands.completion);
+        registry.register("changelog", commands.changelog);
+        registry.register("test", commands.test);
+        registry.register("db", commands.db);
+        registry.register("http", commands.http);
+        registry.register("docker", commands.docker);
 
         // Configura flags específicas
         if (commandName === "debug") values.debug = true;