@archznn/xavva 2.8.0 → 3.0.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-2.9.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,11 @@ 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
 
 ---
 
@@ -39,6 +44,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 +70,18 @@ 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
+
+# Enable shell completions (bash example)
+eval "$(xavva completion bash)"
 ```
 
 ---
@@ -96,6 +116,19 @@ 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)  |
 
 ---
 
@@ -278,6 +311,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.8.0",
+	"version": "3.0.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/HelpCommand.ts

@@ -38,6 +38,7 @@ 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("yellow", "GENERAL OPTIONS")}
     ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
@@ -56,6 +57,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 +141,16 @@ 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("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
     

package/src/commands/InitCommand.ts

@@ -1,7 +1,7 @@
 import { input, select, confirm, number } from "@inquirer/prompts";
-import { writeFile, access } from "fs/promises";
+import { writeFile, access, readFile } from "fs/promises";
 import { join } from "path";
-import { constants } from "fs";
+import { constants, existsSync } from "fs";
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { Logger } from "../utils/ui";
@@ -9,78 +9,106 @@ 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.section("Project Setup Wizard");
+        Logger.info("Let's configure your Xavva project");
         Logger.newline();
 
-        // Detectar build tool
+        // Detect build tool and available profiles
         const buildTool = await this.detectBuildTool();
+        const availableProfiles = await this.detectProfiles(buildTool);
         
-        // Nome da aplicação
+        // Application name
         const appName = await input({
-            message: "Nome da aplicação:",
+            message: "Application name:",
             default: process.cwd().split(/[/\\]/).pop() || "my-app",
-            validate: (value) => value.length > 0 || "Nome é obrigatório"
+            validate: (value) => value.length > 0 || "Name is required"
         });
 
-        // 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"
-        });
+        // Profile selection with explanation
+        Logger.newline();
+        Logger.dim("The profile is used to activate Maven/Gradle build configurations");
+        Logger.dim("(e.g., 'dev' for development, 'prod' for production)");
+        
+        let profile: string;
+        
+        if (availableProfiles.length > 0) {
+            // Profiles found in build file
+            const profileChoices = [
+                ...availableProfiles.map(p => ({ 
+                    name: `${p.name}${p.description ? ` - ${p.description}` : ''}`, 
+                    value: p.name 
+                })),
+                { name: "Other (custom)", value: "custom" }
+            ];
+            
+            profile = await select({
+                message: "Select a profile from your build file:",
+                choices: profileChoices,
+                default: availableProfiles.find(p => p.name === "dev")?.name || availableProfiles[0]?.name
+            });
+        } else {
+            // No profiles detected, show common options
+            profile = await select({
+                message: "Default profile:",
+                choices: [
+                    { name: "dev - Development environment", value: "dev" },
+                    { name: "test - Testing environment", value: "test" },
+                    { name: "prod - Production environment", value: "prod" },
+                    { name: "Other (custom)", value: "custom" }
+                ],
+                default: "dev"
+            });
+        }
 
-        const customProfile = profile === "custom" ? await input({
-            message: "Nome do profile:",
-            default: "local"
-        }) : profile;
+        if (profile === "custom") {
+            profile = await input({
+                message: "Profile name:",
+                default: "local",
+                validate: (value) => value.length > 0 || "Profile name is required"
+            });
+        }
 
-        // Porta do Tomcat
+        // Tomcat port
         const port = await number({
-            message: "Porta do Tomcat:",
+            message: "Tomcat port:",
             default: 8080,
-            validate: (value) => (value && value > 0 && value < 65536) || "Porta inválida"
+            validate: (value) => (value && value > 0 && value < 65536) || "Invalid port"
         }) || 8080;
 
-        // Configurações opcionais
+        // Optional settings
         Logger.newline();
-        Logger.dim("Configurações avançadas:");
+        Logger.dim("Advanced settings:");
         
         const useEmbedded = await confirm({
-            message: "Usar Tomcat embutido (auto-download)?",
+            message: "Use embedded Tomcat (auto-download)?",
             default: true
         });
 
         const enableCache = await confirm({
-            message: "Habilitar cache de build?",
+            message: "Enable build cache?",
             default: true
         });
 
         const enableTui = await confirm({
-            message: "Habilitar dashboard TUI?",
+            message: "Enable TUI dashboard?",
             default: true
         });
 
         const encoding = await select({
-            message: "Encoding:",
+            message: "Source encoding:",
             choices: [
-                { name: "UTF-8", value: "UTF-8" },
-                { name: "ISO-8859-1", value: "ISO-8859-1" },
+                { name: "UTF-8 (recommended)", value: "UTF-8" },
+                { name: "ISO-8859-1 (Latin-1)", value: "ISO-8859-1" },
                 { name: "Windows-1252", value: "Windows-1252" }
             ],
             default: "UTF-8"
         });
 
-        // Montar configuração
+        // Build config object
         const config: Record<string, unknown> = {
             appName,
             buildTool,
-            profile: customProfile,
+            profile,
             port,
             cache: enableCache,
             tui: enableTui,
@@ -89,60 +117,127 @@ export class InitCommand implements Command {
 
         if (useEmbedded) {
             config.embedded = true;
-            config.tomcatVersion = "10.1.52";
+            config.tomcatVersion = await select({
+                message: "Tomcat version:",
+                choices: [
+                    { name: "10.1.52 (Jakarta EE 10, recommended)", value: "10.1.52" },
+                    { name: "9.0.115 (Java EE 8)", value: "9.0.115" },
+                    { name: "11.0.18 (Jakarta EE 11, preview)", value: "11.0.18" }
+                ],
+                default: "10.1.52"
+            });
         } else {
             const tomcatPath = await input({
-                message: "Caminho do Tomcat (CATALINA_HOME):",
+                message: "Tomcat path (CATALINA_HOME):",
                 validate: async (value) => {
-                    if (!value) return "Caminho é obrigatório";
+                    if (!value) return "Path is required";
                     try {
                         await access(value, constants.R_OK);
                         return true;
                     } catch {
-                        return "Caminho não acessível";
+                        return "Path not accessible";
                     }
                 }
             });
             config.tomcatPath = tomcatPath;
         }
 
-        // Salvar arquivo
+        // Save file
         Logger.newline();
-        Logger.step("Salvando configuração...");
+        Logger.step("Saving configuration...");
 
         const configPath = join(process.cwd(), "xavva.json");
         await writeFile(configPath, JSON.stringify(config, null, 2));
 
-        Logger.success(`Configuração salva em ${configPath}`);
+        Logger.success(`Configuration saved to ${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.ready("Project configured!");
+        Logger.info("Next steps:");
+        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva build${Logger.C.reset}  ${Logger.C.gray}- Compile project${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.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva health${Logger.C.reset} ${Logger.C.gray}- Check environment${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");
+        const hasPom = existsSync(join(process.cwd(), "pom.xml"));
+        const hasGradle = existsSync(join(process.cwd(), "build.gradle")) || 
+                          existsSync(join(process.cwd(), "build.gradle.kts"));
+
+        if (hasPom && !hasGradle) {
+            Logger.info("Detected: Maven project");
             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;
+        }
+        
+        if (hasGradle && !hasPom) {
+            Logger.info("Detected: Gradle project");
+            return "gradle";
+        }
+
+        if (hasPom && hasGradle) {
+            Logger.warn("Both pom.xml and build.gradle found");
+            const choice = await select({
+                message: "Select build tool:",
+                choices: [
+                    { name: "Maven (pom.xml)", value: "maven" },
+                    { name: "Gradle (build.gradle)", value: "gradle" }
+                ]
+            });
+            return choice;
+        }
+
+        // Neither found
+        const choice = await select({
+            message: "Build tool:",
+            choices: [
+                { name: "Maven", value: "maven" },
+                { name: "Gradle", value: "gradle" }
+            ]
+        });
+        return choice;
+    }
+
+    private async detectProfiles(buildTool: "maven" | "gradle"): Promise<Array<{name: string, description?: string}>> {
+        const profiles: Array<{name: string, description?: string}> = [];
+        
+        try {
+            if (buildTool === "maven") {
+                const pomPath = join(process.cwd(), "pom.xml");
+                if (existsSync(pomPath)) {
+                    const content = await readFile(pomPath, "utf-8");
+                    // Parse profiles from pom.xml
+                    const profileMatches = content.matchAll(/<profile>[\s\S]*?<id>([^<]+)<\/id>[\s\S]*?<\/profile>/g);
+                    for (const match of profileMatches) {
+                        const profileContent = match[0];
+                        const id = match[1].trim();
+                        // Try to extract description or properties
+                        const descMatch = profileContent.match(/<description>([^<]+)<\/description>/);
+                        const desc = descMatch ? descMatch[1].trim() : undefined;
+                        profiles.push({ name: id, description: desc });
+                    }
+                }
+            } else {
+                const gradlePath = join(process.cwd(), "build.gradle");
+                const gradleKtsPath = join(process.cwd(), "build.gradle.kts");
+                const gradleFile = existsSync(gradlePath) ? gradlePath : gradleKtsPath;
+                
+                if (existsSync(gradleFile)) {
+                    const content = await readFile(gradleFile, "utf-8");
+                    // Look for common profile-like configurations
+                    // Gradle doesn't have built-in profiles like Maven, but can use:
+                    // - Properties (-Pprofile=dev)
+                    // - Custom configurations
+                    // - apply from: "profiles/${profile}.gradle"
+                    const profileMatches = content.matchAll(/(?:apply from:|def\s+\w*[Pp]rofile|ext\.\w*[Pp]rofile)\s*=\s*["']([^"']+)["']/g);
+                    for (const match of profileMatches) {
+                        profiles.push({ name: match[1] });
+                    }
+                }
             }
+        } catch {
+            // Ignore errors, return empty profiles
         }
+        
+        return profiles;
     }
 }

package/src/di/container.ts

@@ -30,6 +30,7 @@ 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 { NotificationService } from "../services/NotificationService";
 import type { Command } from "../commands/Command";
@@ -68,6 +69,7 @@ export interface Commands {
     redo: RedoCommand;
     health: HealthCommand;
     completion: CompletionCommand;
+    changelog: ChangelogCommand;
 }
 
 export class DIContainer {
@@ -163,6 +165,7 @@ export class DIContainer {
             redo: new RedoCommand(),
             health: new HealthCommand(),
             completion: new CompletionCommand(),
+            changelog: new ChangelogCommand(),
         };
     }
 

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,18 @@ 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", "help"
     ];
     const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
@@ -103,6 +110,7 @@ async function main() {
         registry.register("redo", commands.redo);
         registry.register("health", commands.health);
         registry.register("completion", commands.completion);
+        registry.register("changelog", commands.changelog);
 
         // Configura flags específicas
         if (commandName === "debug") values.debug = true;

package/src/types/args.ts

@@ -9,6 +9,7 @@ export interface BaseArgs {
     version?: boolean;
     verbose?: boolean;
     quiet?: boolean;
+    "debug-level"?: "silent" | "error" | "warn" | "info" | "verbose" | "trace" | "silly";
 }
 
 // ===== Args de Configuração de Projeto =====

package/src/utils/ChangelogGenerator.ts

@@ -0,0 +1,255 @@
+import { execSync } from "child_process";
+import { writeFileSync } from "fs";
+import { join } from "path";
+
+interface Commit {
+    hash: string;
+    date: string;
+    message: string;
+    type: string;
+    scope?: string;
+    subject: string;
+    breaking: boolean;
+}
+
+interface Version {
+    version: string;
+    date: string;
+    commits: Commit[];
+}
+
+export class ChangelogGenerator {
+    private static readonly TYPES: Record<string, { title: string; emoji: string }> = {
+        feat: { title: "Features", emoji: "✨" },
+        fix: { title: "Bug Fixes", emoji: "🐛" },
+        docs: { title: "Documentation", emoji: "📚" },
+        style: { title: "Styles", emoji: "💎" },
+        refactor: { title: "Code Refactoring", emoji: "♻️" },
+        perf: { title: "Performance", emoji: "⚡" },
+        test: { title: "Tests", emoji: "🧪" },
+        build: { title: "Build System", emoji: "🏗️" },
+        ci: { title: "CI/CD", emoji: "🔄" },
+        chore: { title: "Chores", emoji: "🔧" },
+        revert: { title: "Reverts", emoji: "⏪" },
+    };
+
+    static generate(): string {
+        const commits = this.getCommits();
+        const versions = this.groupByVersion(commits);
+        return this.formatChangelog(versions);
+    }
+
+    static generateAndSave(outputPath: string = "CHANGELOG.md"): void {
+        const changelog = this.generate();
+        writeFileSync(outputPath, changelog);
+    }
+
+    private static getCommits(): Commit[] {
+        try {
+            // Get commits in format: hash|date|message
+            const log = execSync(
+                'git log --pretty=format:"%h|%ad|%s" --date=short --no-merges',
+                { encoding: "utf-8", cwd: process.cwd() }
+            );
+
+            return log
+                .trim()
+                .split("\n")
+                .map(line => this.parseCommit(line))
+                .filter((c): c is Commit => c !== null);
+        } catch {
+            return [];
+        }
+    }
+
+    private static parseCommit(line: string): Commit | null {
+        const match = line.match(/^([^|]+)\|([^|]+)\|(.+)$/);
+        if (!match) return null;
+
+        const [, hash, date, message] = match;
+        const parsed = this.parseConventionalCommit(message);
+
+        return {
+            hash,
+            date,
+            message,
+            ...parsed,
+        };
+    }
+
+    private static parseConventionalCommit(message: string): Omit<Commit, "hash" | "date" | "message"> {
+        // Pattern: type(scope)!: subject
+        // or: type!: subject
+        // or: type(scope): subject
+        // or: type: subject
+        const pattern = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)$/;
+        const match = message.match(pattern);
+
+        if (match) {
+            const [, type, scope, breaking, subject] = match;
+            return {
+                type,
+                scope,
+                subject,
+                breaking: !!breaking || subject.includes("BREAKING CHANGE"),
+            };
+        }
+
+        // Fallback: treat as chore if doesn't match conventional commit
+        return {
+            type: "chore",
+            subject: message,
+            breaking: message.includes("BREAKING CHANGE"),
+        };
+    }
+
+    private static groupByVersion(commits: Commit[]): Version[] {
+        // Group by version tags
+        const versions: Version[] = [];
+        let currentVersion = "Unreleased";
+        let currentDate = new Date().toISOString().split("T")[0];
+        let currentCommits: Commit[] = [];
+
+        // Try to get version tags
+        const tags = this.getVersionTags();
+        
+        if (tags.length === 0) {
+            // No tags, all commits are unreleased
+            return [{
+                version: "Unreleased",
+                date: currentDate,
+                commits,
+            }];
+        }
+
+        // Process commits and assign to versions
+        const versionMap = new Map<string, Commit[]>();
+        
+        for (const commit of commits) {
+            // Find which version this commit belongs to
+            const version = this.findVersionForCommit(commit.hash, tags);
+            if (!versionMap.has(version)) {
+                versionMap.set(version, []);
+            }
+            versionMap.get(version)!.push(commit);
+        }
+
+        // Convert to array
+        for (const [version, versionCommits] of versionMap) {
+            const tagDate = this.getTagDate(version === "Unreleased" ? null : version);
+            versions.push({
+                version,
+                date: tagDate || currentDate,
+                commits: versionCommits,
+            });
+        }
+
+        // Sort by version (newest first)
+        return versions.sort((a, b) => this.compareVersions(b.version, a.version));
+    }
+
+    private static getVersionTags(): string[] {
+        try {
+            const tags = execSync("git tag -l 'v*' --sort=-v:refname", { encoding: "utf-8" });
+            return tags.trim().split("\n").filter(Boolean);
+        } catch {
+            return [];
+        }
+    }
+
+    private static findVersionForCommit(hash: string, tags: string[]): string {
+        try {
+            // Check if commit is after a specific tag
+            for (const tag of tags) {
+                const result = execSync(`git merge-base --is-ancestor ${hash} ${tag} && echo "in" || echo "out"`, {
+                    encoding: "utf-8",
+                    cwd: process.cwd(),
+                });
+                if (result.trim() === "in") {
+                    return tag;
+                }
+            }
+        } catch {
+            // Ignore errors
+        }
+        return "Unreleased";
+    }
+
+    private static getTagDate(tag: string | null): string | null {
+        if (!tag) return null;
+        try {
+            const date = execSync(`git log -1 --format=%ad --date=short ${tag}`, { encoding: "utf-8" });
+            return date.trim();
+        } catch {
+            return null;
+        }
+    }
+
+    private static compareVersions(a: string, b: string): number {
+        if (a === "Unreleased") return -1;
+        if (b === "Unreleased") return 1;
+        
+        const parse = (v: string) => v.replace(/^v/, "").split(".").map(Number);
+        const aParts = parse(a);
+        const bParts = parse(b);
+        
+        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+            const aPart = aParts[i] || 0;
+            const bPart = bParts[i] || 0;
+            if (aPart !== bPart) return aPart - bPart;
+        }
+        return 0;
+    }
+
+    private static formatChangelog(versions: Version[]): string {
+        const lines: string[] = [
+            "# Changelog\n",
+            "All notable changes to this project will be documented in this file.\n",
+            "The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),",
+            "and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n",
+        ];
+
+        for (const version of versions) {
+            lines.push(this.formatVersion(version));
+        }
+
+        return lines.join("\n");
+    }
+
+    private static formatVersion(version: Version): string {
+        const lines: string[] = [
+            `## [${version.version}] - ${version.date}`,
+            "",
+        ];
+
+        // Group commits by type
+        const byType = new Map<string, Commit[]>();
+        for (const commit of version.commits) {
+            if (!byType.has(commit.type)) {
+                byType.set(commit.type, []);
+            }
+            byType.get(commit.type)!.push(commit);
+        }
+
+        // Output in conventional order
+        const typeOrder = Object.keys(this.TYPES);
+        
+        for (const type of typeOrder) {
+            const commits = byType.get(type);
+            if (!commits || commits.length === 0) continue;
+
+            const { title, emoji } = this.TYPES[type];
+            lines.push(`### ${emoji} ${title}\n`);
+
+            for (const commit of commits) {
+                const scope = commit.scope ? `**${commit.scope}**: ` : "";
+                const breaking = commit.breaking ? " 💥 **BREAKING CHANGE**" : "";
+                lines.push(`- ${scope}${commit.subject} ([${commit.hash}])${breaking}`);
+            }
+
+            lines.push("");
+        }
+
+        return lines.join("\n");
+    }
+}

package/src/utils/LoggerLevel.ts

@@ -0,0 +1,138 @@
+import { Logger } from "./ui";
+
+export type LogLevel = "silent" | "error" | "warn" | "info" | "verbose" | "trace" | "silly";
+
+interface LogLevelConfig {
+    value: number;
+    color: string;
+    prefix: string;
+}
+
+export class LoggerLevel {
+    private static currentLevel: LogLevel = "info";
+    private static readonly levels: Record<LogLevel, LogLevelConfig> = {
+        silent: { value: 0, color: "", prefix: "" },
+        error: { value: 1, color: Logger.C.error, prefix: "ERR" },
+        warn: { value: 2, color: Logger.C.warning, prefix: "WRN" },
+        info: { value: 3, color: Logger.C.info, prefix: "INF" },
+        verbose: { value: 4, color: Logger.C.primary, prefix: "VRB" },
+        trace: { value: 5, color: Logger.C.gray, prefix: "TRC" },
+        silly: { value: 6, color: Logger.C.darkGray, prefix: "SLY" },
+    };
+
+    static setLevel(level: LogLevel): void {
+        this.currentLevel = level;
+    }
+
+    static getLevel(): LogLevel {
+        return this.currentLevel;
+    }
+
+    static shouldLog(level: LogLevel): boolean {
+        return this.levels[level].value <= this.levels[this.currentLevel].value;
+    }
+
+    private static log(level: LogLevel, message: string, ...args: unknown[]): void {
+        if (!this.shouldLog(level)) return;
+        
+        const config = this.levels[level];
+        const formatted = args.length > 0 
+            ? this.formatMessage(message, args)
+            : message;
+        
+        if (level === "error") {
+            Logger.error(formatted);
+        } else if (level === "warn") {
+            Logger.warn(formatted);
+        } else {
+            console.log(`${Logger.C.gray}│${Logger.C.reset}  ${config.color}[${config.prefix}]${Logger.C.reset} ${formatted}`);
+        }
+    }
+
+    private static formatMessage(message: string, args: unknown[]): string {
+        return args.reduce((msg, arg, index) => {
+            const placeholder = `%${index + 1}`;
+            const str = typeof arg === "object" 
+                ? JSON.stringify(arg, null, 2)
+                : String(arg);
+            return msg.replace(placeholder, str);
+        }, message);
+    }
+
+    // Public logging methods
+    static error(message: string, ...args: unknown[]): void {
+        this.log("error", message, ...args);
+    }
+
+    static warn(message: string, ...args: unknown[]): void {
+        this.log("warn", message, ...args);
+    }
+
+    static info(message: string, ...args: unknown[]): void {
+        this.log("info", message, ...args);
+    }
+
+    static verbose(message: string, ...args: unknown[]): void {
+        this.log("verbose", message, ...args);
+    }
+
+    static trace(message: string, ...args: unknown[]): void {
+        this.log("trace", message, ...args);
+    }
+
+    static silly(message: string, ...args: unknown[]): void {
+        this.log("silly", message, ...args);
+    }
+
+    // Utility methods for specific debug scenarios
+    static debugCommand(command: string, args: string[]): void {
+        if (this.shouldLog("verbose")) {
+            this.verbose("Executing: %1 %2", command, args.join(" "));
+        }
+    }
+
+    static debugSpawn(cmd: string, options: Record<string, unknown>): void {
+        if (this.shouldLog("trace")) {
+            this.trace("Spawn: %1 with options: %2", cmd, options);
+        }
+    }
+
+    static debugHttp(method: string, url: string, status?: number): void {
+        if (this.shouldLog("verbose")) {
+            const statusStr = status !== undefined ? ` -> ${status}` : "";
+            this.verbose("HTTP %1 %2%3", method.toUpperCase(), url, statusStr);
+        }
+    }
+
+    static debugFile(operation: string, path: string, details?: unknown): void {
+        if (this.shouldLog("trace")) {
+            this.trace("File %1: %2 %3", operation, path, details || "");
+        }
+    }
+
+    static debugConfig(key: string, value: unknown): void {
+        if (this.shouldLog("silly")) {
+            this.silly("Config: %1 = %2", key, value);
+        }
+    }
+
+    static debugPerformance(operation: string, durationMs: number): void {
+        if (this.shouldLog("verbose")) {
+            this.verbose("Performance: %1 took %2ms", operation, durationMs);
+        }
+    }
+
+    static debugTiming(label: string): () => void {
+        if (!this.shouldLog("verbose")) {
+            return () => {}; // No-op
+        }
+        
+        const start = performance.now();
+        this.verbose("Timing started: %1", label);
+        
+        return () => {
+            const duration = Math.round(performance.now() - start);
+            this.verbose("Timing ended: %1 took %2ms", label, duration);
+        };
+    }
+}