@archznn/xavva 3.1.3 → 3.2.0

package/src/commands/HealthCommand.ts

@@ -4,7 +4,7 @@ import { platform, totalmem, freemem, arch } from "os";
 import { existsSync } from "fs";
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 
 const execAsync = promisify(exec);
 
@@ -50,16 +50,16 @@ export class HealthCommand implements Command {
 
         for (const check of checks) {
             const icon = check.status === "ok" 
-                ? `${Logger.C.success}✓${Logger.C.reset}`
+                ? `${C.success}✓${C.reset}`
                 : check.status === "warning"
-                ? `${Logger.C.warning}⚠${Logger.C.reset}`
-                : `${Logger.C.error}✗${Logger.C.reset}`;
+                ? `${C.warning}⚠${C.reset}`
+                : `${C.error}✗${C.reset}`;
 
-            Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${icon} ${Logger.C.bold}${check.name}${Logger.C.reset}`);
-            Logger.log(`${Logger.C.gray}│${Logger.C.reset}     ${check.message}`);
+            Logger.log(`${C.gray}│${C.reset}  ${icon} ${C.bold}${check.name}${C.reset}`);
+            Logger.log(`${C.gray}│${C.reset}     ${check.message}`);
             
             if (check.details) {
-                Logger.log(`${Logger.C.gray}│${Logger.C.reset}     ${Logger.C.dim}${check.details}${Logger.C.reset}`);
+                Logger.log(`${C.gray}│${C.reset}     ${C.dim}${check.details}${C.reset}`);
             }
 
             if (check.status === "error") errors++;

package/src/commands/HelpCommand.ts

@@ -1,8 +1,11 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import pkg from "../../package.json";
+import { Logger } from "../logging";
 
 export class HelpCommand implements Command {
+    private logger = Logger.getInstance();
+
     async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
         const v = pkg.version;
         const c = this.c;
@@ -18,6 +21,7 @@ export class HelpCommand implements Command {
    ${c("green", "deploy")}     Build and deploy to Tomcat
    ${c("green", "build")}      Compile project
    ${c("green", "start")}      Start Tomcat server
+   ${c("green", "clean")}      Clean cache, build, and logs
    ${c("green", "run")}        Run a Java class
    ${c("green", "logs")}       Stream Tomcat logs
 
@@ -37,27 +41,42 @@ export class HelpCommand implements Command {
    ${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("yellow", "TESTING & DB")}
+   ${c("brightMagenta", "test")}        Run JUnit/TestNG tests
+   ${c("brightMagenta", "db")}          Database migrations
    ${c("brightMagenta", "http")}        HTTP client for API testing
    ${c("brightMagenta", "docker")}      Docker integration
 
+ ${c("yellow", "ADVANCED")}
+   ${c("blue", "ide")}           Generate IDE config (vscode|idea|eclipse)
+   ${c("blue", "docs")}          Generate API documentation
+   ${c("blue", "changelog")}     Generate changelog from git
+
  ${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
+   -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 mode
+   -d, --debug            JPDA debugger       -c, --clean            Clean build
+   -W, --war              Build .war          --cache                Use build cache
+   --env <name>           Environment         -y, --yes              Auto-install
+   --profile              Show performance    --dry-run              Simulate only
+   -V, --verbose          Detailed output     -h, --help             Show help
+   -v, --version          Show 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 dev --tui --watch                # Dev mode with dashboard
+   xavva deploy --war --port 8081         # Build WAR for port 8081
+   xavva clean                            # Clean cache and build
+   xavva test --watch --coverage          # Test with coverage
+   xavva doctor --fix                     # Auto-fix issues
+   xavva ide --ide vscode                 # Generate VS Code config
+   xavva deps --update-safe               # Update dependencies
+   xavva deploy --dry-run                 # Simulate deployment
+   xavva build --profile                  # Show performance profile
    xavva docker init && xavva docker up   # Docker setup
+   xavva tomcat install 10.1.52 --mirror auto   # Install with best mirror
+   xavva tomcat cache stats               # Show download cache stats
 
  ${c("gray", "Run 'xavva <command> --help' for detailed options")}
  ${c("gray", "Docs: github.com/leorsousa05/Xavva")}
@@ -74,6 +93,7 @@ export class HelpCommand implements Command {
             green: "\x1b[32m",
             yellow: "\x1b[33m",
             blue: "\x1b[34m",
+            magenta: "\x1b[35m",
             cyan: "\x1b[36m",
             brightMagenta: "\x1b[95m",
         };

package/src/commands/HistoryCommand.ts

@@ -1,7 +1,7 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { HistoryService } from "../services/HistoryService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 
 export class HistoryCommand implements Command {
     private historyService = new HistoryService();
@@ -33,13 +33,13 @@ export class HistoryCommand implements Command {
             const date = new Date(entry.timestamp);
             const time = date.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
             const icon = entry.success 
-                ? `${Logger.C.success}✓${Logger.C.reset}` 
-                : `${Logger.C.error}✗${Logger.C.reset}`;
+                ? `${C.success}✓${C.reset}` 
+                : `${C.error}✗${C.reset}`;
             
             const args = entry.args.length > 0 ? entry.args.join(" ") : "";
-            const duration = entry.duration ? `${Logger.C.gray}(${entry.duration.toFixed(1)}s)${Logger.C.reset}` : "";
+            const duration = entry.duration ? `${C.gray}(${entry.duration.toFixed(1)}s)${C.reset}` : "";
             
-            Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.dim}${time}${Logger.C.reset} ${icon} ${Logger.C.white}xavva ${entry.command}${Logger.C.reset} ${Logger.C.gray}${args}${Logger.C.reset} ${duration}`);
+            Logger.log(`${C.gray}│${C.reset}  ${C.dim}${time}${C.reset} ${icon} ${C.white}xavva ${entry.command}${C.reset} ${C.gray}${args}${C.reset} ${duration}`);
         }
 
         Logger.endSection();

package/src/commands/HttpCommand.ts

@@ -8,7 +8,7 @@ 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 { Logger, C } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 import fs from "fs";
 import path from "path";
@@ -16,19 +16,19 @@ 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.log(`${C.bold}Usage:${C.reset} xavva http <method> <path> [options]`);
+        Logger.log(`${C.bold}   or:${C.reset} xavva http --interactive`);
         Logger.newline();
-        Logger.log(`${Logger.C.bold}Methods:${Logger.C.reset} GET, POST, PUT, DELETE, PATCH`);
+        Logger.log(`${C.bold}Methods:${C.reset} GET, POST, PUT, DELETE, PATCH`);
         Logger.newline();
-        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
+        Logger.log(`${C.bold}Options:${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(`${C.bold}Examples:${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`);

package/src/commands/IdeCommand.ts

@@ -0,0 +1,313 @@
+/**
+ * Comando IDE - Gera configurações para editores
+ * 
+ * Suporta:
+ * - VS Code (.vscode/)
+ * - IntelliJ IDEA (.idea/)
+ * - Eclipse (.settings/)
+ */
+
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { Logger } from "../logging";
+
+interface IdeConfig {
+    name: string;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+}
+
+export class IdeCommand implements Command {
+    private logger = Logger.getInstance();
+
+    async execute(config: AppConfig, args: CLIArguments): Promise<void> {
+        const ide = (args as any).ide as 'vscode' | 'idea' | 'eclipse' | undefined;
+        
+        if (!ide) {
+            this.logger.error("Especifique a IDE: --ide vscode|idea|eclipse");
+            return;
+        }
+
+        this.logger.section(`Gerando configuração para ${ide.toUpperCase()}`);
+
+        switch (ide) {
+            case 'vscode':
+                await this.generateVSCode(config);
+                break;
+            case 'idea':
+                await this.generateIdea(config);
+                break;
+            case 'eclipse':
+                await this.generateEclipse(config);
+                break;
+            default:
+                this.logger.error(`IDE não suportada: ${ide}`);
+        }
+    }
+
+    private async generateVSCode(config: AppConfig): Promise<void> {
+        const vscodeDir = path.join(process.cwd(), ".vscode");
+        
+        // launch.json - Configuração de debug
+        const launchConfig = {
+            version: "0.2.0",
+            configurations: [
+                {
+                    type: "java",
+                    name: "Debug (Attach) - Xavva",
+                    request: "attach",
+                    hostName: "localhost",
+                    port: config.project.debugPort,
+                },
+                {
+                    type: "java",
+                    name: "Debug (Launch) - Current File",
+                    request: "launch",
+                    mainClass: "${file}",
+                },
+            ],
+        };
+
+        // tasks.json - Tarefas de build
+        const tasksConfig = {
+            version: "2.0.0",
+            tasks: [
+                {
+                    label: "xavva: build",
+                    type: "shell",
+                    command: "xavva build",
+                    group: "build",
+                    problemMatcher: ["$javac"],
+                },
+                {
+                    label: "xavva: deploy",
+                    type: "shell",
+                    command: "xavva deploy",
+                    group: "build",
+                    problemMatcher: ["$javac"],
+                },
+                {
+                    label: "xavva: dev",
+                    type: "shell",
+                    command: "xavva dev",
+                    group: "build",
+                    isBackground: true,
+                    problemMatcher: {
+                        pattern: {
+                            regexp: ".",
+                        },
+                        background: {
+                            activeOnStart: true,
+                            beginsPattern: ".",
+                            endsPattern: ".",
+                        },
+                    },
+                },
+                {
+                    label: "xavva: test",
+                    type: "shell",
+                    command: "xavva test",
+                    group: "test",
+                },
+            ],
+        };
+
+        // settings.json - Configurações do workspace
+        const settingsConfig = {
+            "java.configuration.updateBuildConfiguration": "automatic",
+            "java.compile.nullAnalysis.mode": "automatic",
+            "editor.formatOnSave": true,
+            "files.exclude": {
+                "**/target": true,
+                "**/build": true,
+                "**/.xavva": true,
+                "**/.gradle": true,
+            },
+        };
+
+        // extensions.json - Recomendações
+        const extensionsConfig = {
+            recommendations: [
+                "vscjava.vscode-java-pack",
+                "vscjava.vscode-java-debug",
+                "vscjava.vscode-maven",
+                "redhat.vscode-xml",
+            ],
+        };
+
+        await mkdir(vscodeDir, { recursive: true });
+        
+        await writeFile(
+            path.join(vscodeDir, "launch.json"),
+            JSON.stringify(launchConfig, null, 4)
+        );
+        await writeFile(
+            path.join(vscodeDir, "tasks.json"),
+            JSON.stringify(tasksConfig, null, 4)
+        );
+        await writeFile(
+            path.join(vscodeDir, "settings.json"),
+            JSON.stringify(settingsConfig, null, 4)
+        );
+        await writeFile(
+            path.join(vscodeDir, "extensions.json"),
+            JSON.stringify(extensionsConfig, null, 4)
+        );
+
+        this.logger.success("Configuração VS Code gerada!");
+        this.logger.info("Arquivos criados:");
+        this.logger.info("  • .vscode/launch.json - Configuração de debug");
+        this.logger.info("  • .vscode/tasks.json - Tarefas de build");
+        this.logger.info("  • .vscode/settings.json - Configurações do workspace");
+        this.logger.info("  • .vscode/extensions.json - Extensões recomendadas");
+        this.logger.newline();
+        this.logger.info("💡 Instale as extensões recomendadas para melhor experiência");
+    }
+
+    private async generateIdea(config: AppConfig): Promise<void> {
+        const ideaDir = path.join(process.cwd(), ".idea");
+        const runConfigsDir = path.join(ideaDir, "runConfigurations");
+
+        // runConfigurations/Xavva_Deploy.xml
+        const deployConfig = `<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Xavva - Deploy" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="xavva deploy" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="false" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>`;
+
+        // runConfigurations/Xavva_Dev.xml
+        const devConfig = `<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Xavva - Dev Mode" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="xavva dev" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="false" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>`;
+
+        // External Tools - xavva.xml
+        const externalTools = `<toolSet name="Xavva">
+  <tool name="Build" showInMainMenu="false" showInEditor="false" showInProject="false" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
+    <exec>
+      <option name="COMMAND" value="xavva" />
+      <option name="PARAMETERS" value="build" />
+      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
+    </exec>
+  </tool>
+  <tool name="Deploy" showInMainMenu="false" showInEditor="false" showInProject="false" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
+    <exec>
+      <option name="COMMAND" value="xavva" />
+      <option name="PARAMETERS" value="deploy" />
+      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
+    </exec>
+  </tool>
+</toolSet>`;
+
+        await mkdir(runConfigsDir, { recursive: true });
+        await mkdir(path.join(ideaDir, "externalTools"), { recursive: true });
+
+        await writeFile(path.join(runConfigsDir, "Xavva_Deploy.xml"), deployConfig);
+        await writeFile(path.join(runConfigsDir, "Xavva_Dev.xml"), devConfig);
+        await writeFile(
+            path.join(ideaDir, "externalTools", "xavva.xml"),
+            externalTools
+        );
+
+        this.logger.success("Configuração IntelliJ IDEA gerada!");
+        this.logger.info("Arquivos criados:");
+        this.logger.info("  • .idea/runConfigurations/Xavva_Deploy.xml");
+        this.logger.info("  • .idea/runConfigurations/Xavva_Dev.xml");
+        this.logger.info("  • .idea/externalTools/xavva.xml");
+        this.logger.newline();
+        this.logger.info("💡 Reinicie o IntelliJ para carregar as configurações");
+    }
+
+    private async generateEclipse(config: AppConfig): Promise<void> {
+        const settingsDir = path.join(process.cwd(), ".settings");
+
+        // External tool builders
+        const builderConfig = `<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+    <name>${config.project.appName || "project"}</name>
+    <comment></comment>
+    <projects>
+    </projects>
+    <buildSpec>
+        <buildCommand>
+            <name>org.eclipse.jdt.core.javabuilder</name>
+            <arguments>
+            </arguments>
+        </buildCommand>
+        <buildCommand>
+            <name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>
+            <triggers>full,incremental,</triggers>
+            <arguments>
+                <dictionary>
+                    <key>LaunchConfigHandle</key>
+                    <value>&lt;project&gt;/.externalToolBuilders/Xavva Deploy.launch</value>
+                </dictionary>
+            </arguments>
+        </buildCommand>
+    </buildSpec>
+    <natures>
+        <nature>org.eclipse.jdt.core.javanature</nature>
+    </natures>
+</projectDescription>`;
+
+        // External tool launcher
+        const launcherConfig = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n' +
+'<launchConfiguration type="org.eclipse.ui.externaltools.ProgramBuilderLaunchConfigurationType">\n' +
+'    <booleanAttribute key="org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND" value="false"/>\n' +
+'    <stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="xavva"/>\n' +
+'    <stringAttribute key="org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS" value="deploy"/>\n' +
+'    <booleanAttribute key="org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED" value="true"/>\n' +
+'    <stringAttribute key="org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY" value="${workspace_loc:/${project_name}}"/>\n' +
+'</launchConfiguration>';
+
+        const externalToolsDir = path.join(process.cwd(), ".externalToolBuilders");
+        await mkdir(externalToolsDir, { recursive: true });
+        await mkdir(settingsDir, { recursive: true });
+
+        await writeFile(
+            path.join(process.cwd(), ".project"),
+            builderConfig
+        );
+        await writeFile(
+            path.join(externalToolsDir, "Xavva Deploy.launch"),
+            launcherConfig
+        );
+
+        this.logger.success("Configuração Eclipse gerada!");
+        this.logger.info("Arquivos criados:");
+        this.logger.info("  • .project");
+        this.logger.info("  • .externalToolBuilders/Xavva Deploy.launch");
+        this.logger.newline();
+        this.logger.info("💡 Importe o projeto como 'Existing Projects into Workspace'");
+    }
+}

package/src/commands/InitCommand.ts

@@ -4,14 +4,15 @@ import { join } from "path";
 import { constants, existsSync } from "fs";
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 
 export class InitCommand implements Command {
+    private logger = Logger.getInstance();
+
     async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
-        Logger.banner("init");
-        Logger.section("Project Setup Wizard");
-        Logger.info("Let's configure your Xavva project");
-        Logger.newline();
+        this.logger.section("Project Setup Wizard");
+        this.logger.info("Vamos configurar seu projeto Xavva");
+        this.logger.newline();
 
         // Detect build tool and available profiles
         const buildTool = await this.detectBuildTool();
@@ -25,9 +26,9 @@ export class InitCommand implements Command {
         });
 
         // 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)");
+        this.logger.newline();
+        console.log("The profile is used to activate Maven/Gradle build configurations");
+        console.log("(e.g., 'dev' for development, 'prod' for production)");
         
         let profile: string;
         
@@ -76,8 +77,8 @@ export class InitCommand implements Command {
         }) || 8080;
 
         // Optional settings
-        Logger.newline();
-        Logger.dim("Advanced settings:");
+        this.logger.newline();
+        console.log("Advanced settings:");
         
         const useEmbedded = await confirm({
             message: "Use embedded Tomcat (auto-download)?",
@@ -150,8 +151,8 @@ export class InitCommand implements Command {
 
         // Add environments if enabled
         if (enableMultiEnv) {
-            Logger.newline();
-            Logger.dim("Environment Configuration:");
+            this.logger.newline();
+            console.log("Environment Configuration:");
             
             const environments: Record<string, unknown> = {};
             
@@ -213,20 +214,20 @@ export class InitCommand implements Command {
         }
 
         // Save file
-        Logger.newline();
-        Logger.step("Saving configuration...");
+        this.logger.newline();
+        this.logger.step("Saving configuration...");
 
         const configPath = join(process.cwd(), "xavva.json");
         await writeFile(configPath, JSON.stringify(config, null, 2));
 
-        Logger.success(`Configuration saved to ${configPath}`);
-        Logger.newline();
-        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 health${Logger.C.reset} ${Logger.C.gray}- Check environment${Logger.C.reset}`);
-        Logger.done();
+        this.logger.success(`Configuration saved to ${configPath}`);
+        this.logger.newline();
+        this.logger.ready("Project configured!");
+        this.logger.info("Next steps:");
+        console.log(`  │   xavva build   - Compile project`);
+        console.log(`  │   xavva deploy  - Build + deploy`);
+        console.log(`  │   xavva health  - Check environment`);
+        this.logger.newline();
     }
 
     private async detectBuildTool(): Promise<"maven" | "gradle"> {
@@ -235,17 +236,17 @@ export class InitCommand implements Command {
                           existsSync(join(process.cwd(), "build.gradle.kts"));
 
         if (hasPom && !hasGradle) {
-            Logger.info("Detected: Maven project");
+            this.logger.info("Detected: Maven project");
             return "maven";
         }
         
         if (hasGradle && !hasPom) {
-            Logger.info("Detected: Gradle project");
+            this.logger.info("Detected: Gradle project");
             return "gradle";
         }
 
         if (hasPom && hasGradle) {
-            Logger.warn("Both pom.xml and build.gradle found");
+            this.logger.warn("Both pom.xml and build.gradle found");
             const choice = await select({
                 message: "Select build tool:",
                 choices: [

package/src/commands/LogsCommand.ts

@@ -2,11 +2,13 @@ import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { DashboardService } from "../services/DashboardService";
 import { LogAnalyzer } from "../services/LogAnalyzer";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import path from "path";
 import fs from "fs";
 
 export class LogsCommand implements Command {
+    private logger = Logger.getInstance();
+
     constructor(private dashboard?: DashboardService, private logAnalyzer?: LogAnalyzer) {}
 
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
@@ -14,18 +16,18 @@ export class LogsCommand implements Command {
 
         if (!fs.existsSync(logPath)) {
             const errorMsg = `Arquivo de log não encontrado: ${logPath}`;
-            if (this.dashboard) this.dashboard.log(Logger.C.red + errorMsg);
-            else Logger.error(errorMsg);
+            if (this.dashboard) this.dashboard.log(errorMsg);
+            else this.logger.error(errorMsg);
             return;
         }
 
         const analyzer = this.logAnalyzer || new LogAnalyzer(config.project);
         const dashboard = this.dashboard || new DashboardService(config);
 
-        dashboard.setStatus("LOGGING", Logger.C.green);
+        dashboard.setStatus("LOGGING", "running");
         
         if (args?.grep) {
-            dashboard.log(`${Logger.C.dim}Filter:${Logger.C.reset} ${Logger.C.bold}${args.grep}${Logger.C.reset}`);
+            dashboard.log(`Filter: ${args.grep}`);
         }
 
         const stats = fs.statSync(logPath);
@@ -60,7 +62,7 @@ export class LogsCommand implements Command {
                     currentSize = newStats.size;
                 } else if (newStats.size < currentSize) {
                     currentSize = newStats.size;
-                    dashboard.log(Logger.C.warning + "Arquivo de log foi resetado/rotacionado.");
+                    dashboard.log("Arquivo de log foi resetado/rotacionado.");
                 }
             }
         });