@archznn/xavva 2.9.0 → 3.1.0

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-2.6.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-3.1.0-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.
@@ -21,6 +21,16 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 - 🐱 **Embedded Tomcat** — Auto-install Tomcat, no manual setup needed
 - 📦 **WAR Generation** — Build as .war file or exploded directory
 - 🔤 **Encoding Converter** — Convert file encodings (UTF-8, Windows-1252, ISO-8859-1) and fix mojibake
+- 🧙 **Interactive Wizard** — `xavva init` for easy project setup
+- 🔔 **Desktop Notifications** — Get notified when builds/deploys complete
+- 📜 **Command History** — Track and replay commands with `xavva history` and `xavva redo`
+- 🏥 **Health Check** — Verify environment (Java, ports, memory, disk) with `xavva health`
+- 🔮 **Shell Completions** — Auto-complete for bash, zsh, and fish
+- 🧪 **Test Runner** — Run JUnit/TestNG tests with watch mode and coverage
+- 🗄️ **Database Migrations** — Flyway/Liquibase integration
+- 🌐 **HTTP Client** — Test APIs without leaving the terminal
+- 🐳 **Docker Integration** — Generate configs, build and run containers
+- 🌍 **Multi-Environment** — Dev, test, staging configurations
 
 ---
 
@@ -39,6 +49,9 @@ bunx @archznn/xavva dev
 ## 🚀 Quick Start
 
 ```bash
+# Initialize project configuration (interactive wizard)
+xavva init
+
 # Start development mode with dashboard
 xavva dev --tui
 
@@ -62,6 +75,41 @@ xavva encoding convert --to cp1252 --backup src/main/java/
 
 # Use embedded Tomcat (auto-install)
 xavva dev --yes
+
+# Check environment health
+xavva health
+
+# View command history
+xavva history
+
+# Repeat last command
+xavva redo
+
+# Run tests
+xavva test
+xavva test --watch
+xavva test --coverage
+
+# Database migrations
+xavva db status
+xavva db migrate
+xavva db reset --force
+
+# HTTP API testing
+xavva http GET /api/users
+xavva http POST /api/users --body '{"name":"John"}'
+
+# Docker integration
+xavva docker init
+xavva docker build
+xavva docker up
+
+# Multi-environment
+xavva deploy --env staging
+xavva dev --env dev
+
+# Enable shell completions (bash example)
+eval "$(xavva completion bash)"
 ```
 
 ---
@@ -96,6 +144,69 @@ xavva dev --yes
 | `xavva docs`     | Generate endpoint documentation                           |
 | `xavva tomcat`   | Manage embedded Tomcat installations                      |
 | `xavva encoding` | Convert file encodings (UTF-8, CP1252, ISO-8859-1)        |
+| `xavva health`   | Check environment health (Java, ports, memory, disk)      |
+
+### Project Management
+
+| Command                 | Description                                    |
+| ----------------------- | ---------------------------------------------- |
+| `xavva init`            | Initialize project configuration (wizard)      |
+| `xavva config`          | View current configuration                     |
+| `xavva config --interactive` | Edit configuration interactively         |
+| `xavva history`         | Show command history                           |
+| `xavva history --clear` | Clear command history                          |
+| `xavva redo`            | Repeat the last executed command               |
+| `xavva completion <shell>` | Generate shell completions (bash/zsh/fish)  |
+
+### Testing & Database
+
+| Command | Description |
+|---------|-------------|
+| `xavva test` | Run all tests (JUnit/TestNG) |
+| `xavva test --watch` | Run tests in watch mode |
+| `xavva test --coverage` | Generate coverage report |
+| `xavva test <filter>` | Run specific test class |
+| `xavva db status` | Show migration status |
+| `xavva db migrate` | Run pending migrations |
+| `xavva db reset --force` | Reset database (⚠️ destructive) |
+| `xavva db seed` | Populate with test data |
+
+### HTTP Client
+
+| Command | Description |
+|---------|-------------|
+| `xavva http GET <path>` | Send GET request |
+| `xavva http POST <path> --body '{}'` | Send POST request |
+| `xavva http <path> --param key=value` | Add query parameters |
+| `xavva http <path> --header "Auth: token"` | Add custom headers |
+
+### Docker
+
+| Command | Description |
+|---------|-------------|
+| `xavva docker init` | Generate Dockerfile & docker-compose.yml |
+| `xavva docker build` | Build Docker image |
+| `xavva docker up` | Start with docker-compose |
+| `xavva docker down` | Stop containers |
+| `xavva docker run` | Run development container |
+| `xavva docker status` | Show container status |
+
+### Multi-Environment
+
+| Command | Description |
+|---------|-------------|
+| `xavva deploy --env <name>` | Deploy to specific environment |
+| `xavva dev --env <name>` | Use environment configuration |
+
+Configure environments in `xavva.json`:
+```json
+{
+  "environments": {
+    "dev": { "port": 8080, "profile": "dev" },
+    "staging": { "port": 8081, "profile": "staging" }
+  }
+}
+```
 
 ---
 
@@ -278,6 +389,82 @@ Create `xavva.json` in your project root:
 | `--cache`              | Use build cache (faster)        |
 | `-y, --yes`            | Auto-install Tomcat (no prompt) |
 | `-V, --verbose`        | Detailed output                 |
+| `-i, --interactive`    | Interactive mode (for config)   |
+
+---
+
+## 🧙 Interactive Wizard
+
+Initialize a new project with the interactive setup wizard:
+
+```bash
+xavva init
+```
+
+The wizard will guide you through:
+- Build tool selection (auto-detected from pom.xml or build.gradle)
+- Application name
+- Profile selection (detects profiles from your build file)
+- Tomcat port configuration
+- Embedded Tomcat settings
+- Build cache and TUI preferences
+
+---
+
+## 🏥 Health Check
+
+Verify your development environment:
+
+```bash
+# Check all components
+xavva health
+
+# Checks include:
+# - Java version (JDK 11+ recommended)
+# - Maven/Gradle availability
+# - Tomcat configuration
+# - Port availability
+# - Memory and disk space
+```
+
+---
+
+## 📜 Command History
+
+Track and replay your commands:
+
+```bash
+# Show recent commands
+xavva history
+
+# Show more entries
+xavva history --limit 20
+
+# Clear history
+xavva history --clear
+
+# Repeat last command
+xavva redo
+```
+
+---
+
+## 🔮 Shell Completions
+
+Enable tab completion for your shell:
+
+```bash
+# Bash (add to ~/.bashrc)
+eval "$(xavva completion bash)"
+
+# Zsh (add to ~/.zshrc)
+eval "$(xavva completion zsh)"
+
+# Fish
+xavva completion fish > ~/.config/fish/completions/xavva.fish
+```
+
+Supported shells: `bash`, `zsh`, `fish`
 
 ---
 

package/package.json

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

package/src/commands/ChangelogCommand.ts

@@ -0,0 +1,128 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { ChangelogGenerator } from "../utils/ChangelogGenerator";
+import { Logger } from "../utils/ui";
+import { existsSync } from "fs";
+
+export class ChangelogCommand implements Command {
+    async execute(_config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        // Pula o nome do comando "changelog" e pega a ação
+        const action = positionals?.find(p => !["changelog", "gen"].includes(p)) || "generate";
+        const output = args?.["output"] || args?.["o"] || "CHANGELOG.md";
+
+        Logger.banner("changelog");
+
+        switch (action) {
+            case "generate":
+            case "gen":
+                await this.generate(output);
+                break;
+            case "check":
+            case "validate":
+                await this.validate();
+                break;
+            case "preview":
+                await this.preview();
+                break;
+            default:
+                this.showHelp();
+        }
+    }
+
+    private async generate(output: string): Promise<void> {
+        Logger.section("Generating Changelog");
+        Logger.step("Analyzing git history...");
+
+        try {
+            ChangelogGenerator.generateAndSave(output);
+            
+            if (existsSync(output)) {
+                Logger.success(`Changelog generated: ${output}`);
+            } else {
+                Logger.error("Failed to generate changelog");
+            }
+        } catch (error) {
+            Logger.error(`Error: ${error}`);
+        }
+
+        Logger.done();
+    }
+
+    private async validate(): Promise<void> {
+        Logger.section("Validating Conventional Commits");
+        
+        // Check if commits follow conventional commit format
+        const { execSync } = await import("child_process");
+        
+        try {
+            const log = execSync(
+                'git log --pretty=format:"%s" --no-merges -20',
+                { encoding: "utf-8" }
+            );
+
+            const commits = log.trim().split("\n");
+            const conventionalPattern = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?(!)?: .+/;
+            
+            let valid = 0;
+            let invalid = 0;
+
+            for (const commit of commits) {
+                const isValid = conventionalPattern.test(commit);
+                if (isValid) {
+                    valid++;
+                    Logger.success(commit.slice(0, 60));
+                } else {
+                    invalid++;
+                    Logger.warn(commit.slice(0, 60));
+                }
+            }
+
+            Logger.newline();
+            Logger.info("Summary", `${valid} valid, ${invalid} need improvement`);
+            
+            if (invalid > 0) {
+                Logger.dim("\nValid conventional commit types:");
+                Logger.dim("  feat, fix, docs, style, refactor, perf,");
+                Logger.dim("  test, build, ci, chore, revert");
+                Logger.dim("\nExample: feat(auth): add login endpoint");
+            }
+        } catch (error) {
+            Logger.error(`Failed to validate: ${error}`);
+        }
+
+        Logger.done();
+    }
+
+    private async preview(): Promise<void> {
+        Logger.section("Changelog Preview");
+        
+        try {
+            const changelog = ChangelogGenerator.generate();
+            // Show only first 50 lines
+            const lines = changelog.split("\n").slice(0, 50);
+            Logger.log(lines.join("\n"));
+            
+            if (changelog.split("\n").length > 50) {
+                Logger.dim("\n... (truncated, use 'generate' to see full)");
+            }
+        } catch (error) {
+            Logger.error(`Failed to generate preview: ${error}`);
+        }
+
+        Logger.done();
+    }
+
+    private showHelp(): void {
+        Logger.section("Changelog Commands");
+        Logger.info("Usage: xavva changelog <action> [options]");
+        Logger.newline();
+        Logger.log("Actions:");
+        Logger.log(`  ${Logger.C.primary}generate${Logger.C.reset}  Generate CHANGELOG.md (default)`);
+        Logger.log(`  ${Logger.C.primary}check${Logger.C.reset}     Validate conventional commits`);
+        Logger.log(`  ${Logger.C.primary}preview${Logger.C.reset}   Preview changelog without saving`);
+        Logger.newline();
+        Logger.log("Options:");
+        Logger.log(`  ${Logger.C.primary}-o, --output${Logger.C.reset}  Output file (default: CHANGELOG.md)`);
+        Logger.done();
+    }
+}

package/src/commands/ConfigCommand.ts

@@ -141,6 +141,54 @@ export class ConfigCommand implements Command {
                 default: String(config.tomcatPath || "")
             });
         }
+
+        // Edit environments
+        const editEnvs = await confirm({
+            message: "Editar environments?",
+            default: false
+        });
+
+        if (editEnvs) {
+            await this.editEnvironments(config);
+        }
+    }
+
+    private async editEnvironments(config: Record<string, unknown>): Promise<void> {
+        const environments = (config.environments as Record<string, unknown>) || {};
+        
+        const envNames = Object.keys(environments);
+        if (envNames.length > 0) {
+            Logger.info("Environments existentes:", envNames.join(", "));
+        }
+
+        const addNew = await confirm({
+            message: "Adicionar novo environment?",
+            default: envNames.length === 0
+        });
+
+        if (addNew) {
+            const name = await input({
+                message: "Nome do environment:",
+                default: "staging"
+            });
+
+            const port = await number({
+                message: `Porta para ${name}:`,
+                default: 8080
+            });
+
+            const profile = await input({
+                message: `Profile para ${name}:`,
+                default: name
+            });
+
+            environments[name] = {
+                port,
+                profile
+            };
+        }
+
+        config.environments = environments;
     }
 
     private async editBuild(config: Record<string, unknown>): Promise<void> {

package/src/commands/DbCommand.ts

@@ -0,0 +1,126 @@
+/**
+ * Comando de migrações de banco de dados
+ * xavva db <action> [options]
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { DbService, type DbConfig } from "../services/DbService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class DbCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        const action = positionals?.[1] || "status";
+        
+        const service = new DbService(config.project.buildTool);
+
+        // Extrair config de DB do environment ou args
+        const dbConfig = this.extractDbConfig(config, args);
+
+        try {
+            switch (action) {
+                case "migrate":
+                case "up":
+                    const migrateResult = await service.migrate(dbConfig);
+                    if (!migrateResult.success) {
+                        Logger.error(migrateResult.message);
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "status":
+                case "info":
+                    await service.status(dbConfig);
+                    break;
+
+                case "reset":
+                case "clean":
+                case "drop":
+                    if (!args?.force) {
+                        Logger.warn("This will DELETE all data in the database!");
+                        Logger.info("Use", "--force to confirm");
+                        await processManager.shutdown(1);
+                        return;
+                    }
+                    const resetResult = await service.reset(dbConfig);
+                    if (!resetResult.success) {
+                        await processManager.shutdown(1);
+                    }
+                    // Roda migrações novamente após reset
+                    await service.migrate(dbConfig);
+                    break;
+
+                case "seed":
+                    const seedResult = await service.seed(dbConfig, args?.src);
+                    if (!seedResult.success) {
+                        Logger.error(seedResult.message);
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "create":
+                    await this.createMigration(service, args);
+                    break;
+
+                default:
+                    Logger.error(`Unknown db action: ${action}`);
+                    Logger.info("Actions", "migrate, status, reset, seed, create");
+                    await processManager.shutdown(1);
+            }
+        } catch (error) {
+            Logger.error(`Database command failed: ${(error as Error).message}`);
+            await processManager.shutdown(1);
+        }
+    }
+
+    private extractDbConfig(config: AppConfig, args?: CLIArguments): DbConfig | undefined {
+        // Tenta pegar do environment config
+        const envName = config.project.environment;
+        const envConfig = envName && config.project.environments?.[envName];
+        
+        if (envConfig?.db) {
+            return {
+                url: envConfig.db.url || process.env.JDBC_URL || "",
+                username: envConfig.db.username || process.env.JDBC_USER || "",
+                password: envConfig.db.password || process.env.JDBC_PASSWORD || "",
+                driver: envConfig.db.driver
+            };
+        }
+
+        // Fallback para env vars
+        if (process.env.JDBC_URL) {
+            return {
+                url: process.env.JDBC_URL,
+                username: process.env.JDBC_USER || "",
+                password: process.env.JDBC_PASSWORD || ""
+            };
+        }
+
+        return undefined;
+    }
+
+    private async createMigration(service: DbService, args?: CLIArguments): Promise<void> {
+        const name = args?.name || "new_migration";
+        Logger.section("Create Migration");
+        Logger.info("Name", name);
+        
+        // Detecta ferramenta
+        const tool = await service.detectTool();
+        
+        if (tool === "flyway") {
+            const timestamp = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14);
+            const filename = `V${timestamp}__${name}.sql`;
+            const filepath = `src/main/resources/db/migration/${filename}`;
+            
+            Logger.success(`Create file: ${filepath}`);
+            Logger.dim("-- Add your SQL here");
+        } else if (tool === "liquibase") {
+            const filename = `${name}.sql`;
+            Logger.success(`Add to changelog: db/changelog/${filename}`);
+        } else {
+            Logger.warn("No migration tool detected");
+        }
+    }
+}

package/src/commands/DockerCommand.ts

@@ -0,0 +1,122 @@
+/**
+ * Comando de integração Docker
+ * xavva docker <action> [options]
+ */
+
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { DockerService, type DockerConfig } from "../services/DockerService";
+import { Logger } from "../utils/ui";
+import { ProcessManager } from "../utils/processManager";
+
+export class DockerCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        const processManager = ProcessManager.getInstance();
+        const action = positionals?.[1] || "status";
+
+        const service = new DockerService();
+
+        // Verifica se Docker está disponível
+        const isAvailable = await service.isDockerAvailable();
+        if (!isAvailable) {
+            Logger.error("Docker is not available");
+            Logger.info("Install", "https://docs.docker.com/get-docker/");
+            await processManager.shutdown(1);
+            return;
+        }
+
+        const dockerConfig: DockerConfig = {
+            imageName: (args?.name as string) || config.project.appName,
+            tag: (args?.tag as string) || "latest",
+            port: args?.port ? parseInt(args.port as string) : config.tomcat.port,
+            javaVersion: (args?.["java-version"] as string) || "17",
+            tomcatVersion: config.tomcat.version
+        };
+
+        try {
+            switch (action) {
+                case "init":
+                    await this.handleInit(service, dockerConfig);
+                    break;
+
+                case "build":
+                    const built = await service.buildImage(dockerConfig.tag);
+                    if (!built) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "run":
+                case "dev":
+                    const running = await service.runDevMode(dockerConfig.port);
+                    if (!running) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "up":
+                    const up = await service.composeUp(args?.detached);
+                    if (!up) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "down":
+                case "stop":
+                    const down = await service.composeDown();
+                    if (!down) {
+                        await processManager.shutdown(1);
+                    }
+                    break;
+
+                case "status":
+                case "ps":
+                    await service.showContainerStatus();
+                    break;
+
+                case "push":
+                    await this.handlePush(service, dockerConfig, args);
+                    break;
+
+                default:
+                    Logger.error(`Unknown docker action: ${action}`);
+                    Logger.info("Actions", "init, build, run, up, down, status, push");
+                    await processManager.shutdown(1);
+            }
+        } catch (error) {
+            Logger.error(`Docker command failed: ${(error as Error).message}`);
+            await processManager.shutdown(1);
+        }
+    }
+
+    private async handleInit(service: DockerService, config: DockerConfig): Promise<void> {
+        Logger.section("Docker Init");
+        Logger.info("Generating", "Docker configuration files");
+
+        await service.generateDockerfile(config);
+        await service.generateCompose(config);
+
+        Logger.divider();
+        Logger.info("Next steps", "");
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker build${Logger.C.reset}  ${Logger.C.gray}- Build image${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker up${Logger.C.reset}      ${Logger.C.gray}- Start containers${Logger.C.reset}`);
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker run${Logger.C.reset}     ${Logger.C.gray}- Run dev mode${Logger.C.reset}`);
+        Logger.endSection();
+    }
+
+    private async handlePush(service: DockerService, config: DockerConfig, args?: CLIArguments): Promise<void> {
+        const registry = args?.registry as string || "docker.io";
+        const namespace = args?.namespace as string || "";
+        
+        const fullImageName = namespace 
+            ? `${registry}/${namespace}/${config.imageName}:${config.tag}`
+            : `${registry}/${config.imageName}:${config.tag}`;
+
+        Logger.section("Docker Push");
+        Logger.info("Image", fullImageName);
+        Logger.info("Registry", registry);
+
+        Logger.success("Use: docker push " + fullImageName);
+        Logger.dim("Make sure you're logged in: docker login " + registry);
+    }
+}