@archznn/xavva 3.1.2 → 3.2.0

package/src/commands/EncodingCommand.ts

@@ -1,7 +1,7 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { EncodingService } from "../services/EncodingService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import path from "path";
 import { existsSync } from "fs";
 import { ProcessManager } from "../utils/processManager";
@@ -16,6 +16,13 @@ export class EncodingCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
         
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            await processManager.shutdown(0);
+            return;
+        }
+
         // Parse subcomando
         const subcommand = positionals?.[1] || "help";
         const fileArg = positionals?.[2]; // Arquivo específico (opcional)
@@ -47,19 +54,19 @@ export class EncodingCommand implements Command {
         Logger.log("Gerencia conversão de encoding de arquivos de texto");
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Uso:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Uso:${C.reset}`);
         Logger.log("  xavva encoding <subcomando> [arquivo] [opções]");
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Subcomandos:${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.secondary}detect${Logger.C.reset} [arquivo]          Detecta encoding de um arquivo ou diretório`);
-        Logger.log(`  ${Logger.C.secondary}convert${Logger.C.reset} [arquivo]          Converte arquivo(s) para outro encoding`);
-        Logger.log(`  ${Logger.C.secondary}fix${Logger.C.reset} [arquivo]              Tenta corrigir mojibake automaticamente`);
-        Logger.log(`  ${Logger.C.secondary}list${Logger.C.reset}                     Lista encodings de todos os arquivos do projeto`);
-        Logger.log(`  ${Logger.C.secondary}help${Logger.C.reset}                     Mostra esta ajuda`);
+        Logger.log(`${C.primary}Subcomandos:${C.reset}`);
+        Logger.log(`  ${C.secondary}detect${C.reset} [arquivo]          Detecta encoding de um arquivo ou diretório`);
+        Logger.log(`  ${C.secondary}convert${C.reset} [arquivo]          Converte arquivo(s) para outro encoding`);
+        Logger.log(`  ${C.secondary}fix${C.reset} [arquivo]              Tenta corrigir mojibake automaticamente`);
+        Logger.log(`  ${C.secondary}list${C.reset}                     Lista encodings de todos os arquivos do projeto`);
+        Logger.log(`  ${C.secondary}help${C.reset}                     Mostra esta ajuda`);
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Opções:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Opções:${C.reset}`);
         Logger.log(`  --from <encoding>      Encoding de origem (padrão: auto-detect)`);
         Logger.log(`  --to <encoding>        Encoding de destino (padrão: do xavva.json ou UTF-8)`);
         Logger.log(`  --backup               Cria backup antes de converter`);
@@ -68,13 +75,13 @@ export class EncodingCommand implements Command {
         Logger.log(`  --src <path>           Diretório fonte (padrão: src/)`);
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Encodings suportados:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Encodings suportados:${C.reset}`);
         Logger.log(`  utf-8, utf8            UTF-8 (padrão)`);
         Logger.log(`  windows-1252, cp1252   Windows CP1252 (ANSI)`);
         Logger.log(`  iso-8859-1, latin1     ISO-8859-1 (Latin-1)`);
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Exemplos:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Exemplos:${C.reset}`);
         Logger.log(`  xavva encoding detect src/main/java/MinhaClasse.java`);
         Logger.log(`  xavva encoding convert --from utf-8 --to cp1252 src/main/java/`);
         Logger.log(`  xavva encoding convert --to cp1252 --backup src/main/java/MinhaClasse.java`);
@@ -128,13 +135,13 @@ export class EncodingCommand implements Command {
             Logger.info("Arquivos analisados", String(detections.size));
             Logger.newline();
 
-            Logger.log(`${Logger.C.primary}Distribuição por encoding:${Logger.C.reset}`);
+            Logger.log(`${C.primary}Distribuição por encoding:${C.reset}`);
             for (const [encoding, count] of byEncoding) {
                 Logger.config(encoding, `${count} arquivo(s)`);
             }
 
             Logger.newline();
-            Logger.log(`${Logger.C.primary}Arquivos com baixa confiança:${Logger.C.reset}`);
+            Logger.log(`${C.primary}Arquivos com baixa confiança:${C.reset}`);
             let lowConfidenceFound = false;
             for (const [file, detection] of detections) {
                 if (detection.confidence < 0.8) {
@@ -332,18 +339,18 @@ export class EncodingCommand implements Command {
         // Ordena arquivos
         const sortedFiles = Array.from(detections.entries()).sort((a, b) => a[0].localeCompare(b[0]));
 
-        Logger.log(`${Logger.C.primary}Arquivos:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Arquivos:${C.reset}`);
         for (const [file, detection] of sortedFiles) {
             const relativePath = path.relative(srcDir, file);
             const confidenceStr = detection.confidence >= 0.9 ? "" : 
-                ` ${Logger.C.gray}(${Math.round(detection.confidence * 100)}%)${Logger.C.reset}`;
-            const bomStr = detection.hasBOM ? ` ${Logger.C.warning}[BOM]${Logger.C.reset}` : "";
+                ` ${C.gray}(${Math.round(detection.confidence * 100)}%)${C.reset}`;
+            const bomStr = detection.hasBOM ? ` ${C.warning}[BOM]${C.reset}` : "";
             
             const encodingColor = detection.encoding === (config.project.encoding || "utf-8") 
-                ? Logger.C.success 
-                : Logger.C.warning;
+                ? C.success 
+                : C.warning;
             
-            Logger.log(`  ${encodingColor}${detection.encoding.padEnd(12)}${Logger.C.reset} ${relativePath}${confidenceStr}${bomStr}`);
+            Logger.log(`  ${encodingColor}${detection.encoding.padEnd(12)}${C.reset} ${relativePath}${confidenceStr}${bomStr}`);
         }
 
         Logger.endSection();

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,14 +8,40 @@ 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";
 
 export class HttpCommand implements Command {
+    private showHelp(): void {
+        Logger.section("HTTP Client");
+        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(`${C.bold}Methods:${C.reset} GET, POST, PUT, DELETE, PATCH`);
+        Logger.newline();
+        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(`${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`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
         
         // Modo interativo
         if (args?.interactive || positionals?.length === 1) {

package/src/commands/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'");
+    }
+}