@archznn/xavva 2.2.2 → 2.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
 
-[![Version](https://img.shields.io/badge/version-2.2.2-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.4.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.
@@ -18,6 +18,8 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 - 📦 **Dependency Analysis** — Detect conflicts and outdated dependencies
 - 🎯 **Maven & Gradle** — Native support for both build tools
 - 🔧 **Auto-Healing** — Automatic diagnosis and repair of common issues
+- 🐱 **Embedded Tomcat** — Auto-install Tomcat, no manual setup needed
+- 📦 **WAR Generation** — Build as .war file or exploded directory
 
 ---
 
@@ -42,6 +44,9 @@ xavva dev --tui
 # Deploy to Tomcat
 xavva deploy
 
+# Build and deploy as .war file
+xavva deploy --war
+
 # Analyze dependencies for issues
 xavva deps
 
@@ -50,6 +55,9 @@ xavva deps --update-safe
 
 # Check for security vulnerabilities
 xavva audit
+
+# Use embedded Tomcat (auto-install)
+xavva dev --yes
 ```
 
 ---
@@ -82,6 +90,39 @@ xavva audit
 | `xavva doctor`   | Diagnose environment issues (JAVA_HOME, DCEVM)            |
 | `xavva profiles` | List available Maven/Gradle profiles                      |
 | `xavva docs`     | Generate endpoint documentation                           |
+| `xavva tomcat`   | Manage embedded Tomcat installations                      |
+
+---
+
+## 🐱 Embedded Tomcat
+
+Xavva can automatically download and manage a Tomcat installation for you:
+
+```bash
+# First time usage - auto-install Tomcat
+xavva dev --yes
+
+# List available versions to download
+xavva tomcat list
+
+# List already installed versions
+xavva tomcat installed
+
+# Install a specific version
+xavva tomcat install 9.0.115
+
+# Switch to a version for this project
+xavva tomcat use 9.0.115
+
+# Check Tomcat status
+xavva tomcat status
+
+# Remove a version
+xavva tomcat uninstall 9.0.115
+
+# Or use with flags
+xavva dev --tomcat-version 9.0.115
+```
 
 ---
 
@@ -176,6 +217,9 @@ Create `xavva.json` in your project root:
 | `-d, --debug`          | Enable JPDA debugger            |
 | `-c, --clean`          | Clean logs before start         |
 | `-s, --no-build`       | Skip initial build              |
+| `-W, --war`            | Generate .war file (vs exploded)|
+| `--cache`              | Use build cache (faster)        |
+| `-y, --yes`            | Auto-install Tomcat (no prompt) |
 | `-V, --verbose`        | Detailed output                 |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.2.2",
+	"version": "2.4.0",
 	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
 	"module": "src/index.ts",
 	"type": "module",

package/src/commands/Command.ts

@@ -1,5 +1,5 @@
 import type { AppConfig, CLIArguments } from "../types/config";
 
 export interface Command {
-    execute(config: AppConfig, args?: CLIArguments): Promise<void>;
+    execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void>;
 }

package/src/commands/CommandRegistry.ts

@@ -19,18 +19,18 @@ export class CommandRegistry {
         return this.commands.get(name);
     }
 
-    async execute(name: string, config: AppConfig, args: CLIArguments): Promise<void> {
+    async execute(name: string, config: AppConfig, args: CLIArguments, positionals?: string[]): Promise<void> {
         const command = this.commands.get(name);
         const processManager = ProcessManager.getInstance();
         
         if (!command) {
             Logger.error(`Comando desconhecido: ${name}`);
-            await new HelpCommand().execute(config);
+            await new HelpCommand().execute(config, args, positionals);
             await processManager.shutdown(2);
         }
 
         try {
-            await command.execute(config, args);
+            await command.execute(config, args, positionals);
         } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             Logger.error(`Erro ao executar comando '${name}': ${message}`);

package/src/commands/DepsCommand.ts

@@ -34,7 +34,7 @@ export class DepsCommand implements Command {
 				Logger.log("  • Arquivo pom.xml/build.gradle não encontrado");
 				Logger.log("  • Erro de parsing no arquivo de configuração");
 				Logger.newline();
-				Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} Execute com --verbose para mais detalhes`);
+				Logger.log(`${Logger.C.primary}Dica:${Logger.C.reset} Execute com --verbose para mais detalhes`);
 				return;
 			}
 
@@ -87,7 +87,7 @@ export class DepsCommand implements Command {
 		Logger.section("Sugestões de Correção");
 
 		for (const conflict of result.conflicts) {
-			Logger.log(`\n${Logger.C.cyan}${conflict.groupId}:${conflict.artifactId}${Logger.C.reset}`);
+			Logger.log(`\n${Logger.C.primary}${conflict.groupId}:${conflict.artifactId}${Logger.C.reset}`);
 			
 			if (buildTool === "maven") {
 				Logger.log("  Adicione ao pom.xml:");
@@ -143,7 +143,7 @@ export class DepsCommand implements Command {
 
 				Logger.newline();
 				Logger.log(`${Logger.C.warning}⚠️  Execute 'xavva build' para compilar e aplicar as mudanças${Logger.C.reset}`);
-				Logger.log(`${Logger.C.cyan}💡 Dica:${Logger.C.reset} Execute 'xavva audit' para verificar vulnerabilidades nas novas versões`);
+				Logger.log(`${Logger.C.primary}💡 Dica:${Logger.C.reset} Execute 'xavva audit' para verificar vulnerabilidades nas novas versões`);
 			} else {
 				Logger.warn("Nenhuma dependência foi atualizada");
 			}

package/src/commands/DoctorCommand.ts

@@ -31,7 +31,7 @@ export class DoctorCommand implements Command {
 				await this.installDCEVM();
 			} else {
 				Logger.log(
-					`    ${Logger.C.cyan}Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.${Logger.C.reset}`,
+					`    ${Logger.C.primary}Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.${Logger.C.reset}`,
 				);
 			}
 		}

package/src/commands/HelpCommand.ts

@@ -28,9 +28,10 @@ export class HelpCommand implements Command {
     ${this.c("green", "audit")}            Security audit of JAR files
     ${this.c("green", "doctor")}           Diagnose and fix environment issues
     ${this.c("green", "profiles")}         List available Maven/Gradle profiles
+    ${this.c("green", "tomcat")}           Manage embedded Tomcat (install, list, installed, use, status)
     ${this.c("green", "docs")}             Generate endpoint documentation
 
-  ${this.c("yellow", "OPTIONS")}
+  ${this.c("yellow", "GENERAL OPTIONS")}
     ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
     ${this.c("cyan", "-t, --tool")} <tool>     Build tool: maven | gradle
     ${this.c("cyan", "-n, --name")} <name>     Application name (WAR context)
@@ -43,32 +44,59 @@ export class HelpCommand implements Command {
     ${this.c("cyan", "-d, --debug")}          Enable JPDA debugger
     ${this.c("cyan", "--dp")} <port>          Debugger port (default: 5005)
     
-    ${this.c("cyan", "-c, --clean")}          Clean logs before start
+    ${this.c("cyan", "-c, --clean")}          Clean before build
     ${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", "-h, --help")}           Show this help
     ${this.c("cyan", "-v, --version")}        Show version
 
+  ${this.c("yellow", "BUILD OPTIONS")}  ${this.c("dim", "(for deploy, dev, build)")}
+    ${this.c("cyan", "-W, --war")}             Generate .war file instead of exploded directory
+    ${this.c("cyan", "--cache")}              Use build cache (skip if no changes)
+
+  ${this.c("yellow", "TOMCAT OPTIONS")}  ${this.c("dim", "(for embedded Tomcat)")}
+    ${this.c("cyan", "--tomcat-version")} <v>   Tomcat version to install (default: 10.1.52)
+    ${this.c("cyan", "-y, --yes")}             Auto-install without confirmation
+
+  ${this.c("yellow", "DEPS OPTIONS")}  ${this.c("dim", "(for xavva deps)")}
+    ${this.c("cyan", "--update-safe")}         Update only non-breaking dependencies
+    ${this.c("cyan", "--fix")}                 Show fix suggestions for conflicts
+    ${this.c("cyan", "--strict")}              Fail on critical conflicts (for CI/CD)
+    ${this.c("cyan", "-o, --output")} <file>   Export report as JSON
+
   ${this.c("yellow", "EXAMPLES")}
     ${this.c("dim", "# Development with hot reload and dashboard")}
     xavva dev --tui --watch
 
-    ${this.c("dim", "# Quick deploy to specific Tomcat")}
+    ${this.c("dim", "# Deploy to specific Tomcat installation")}
     xavva deploy -p /opt/tomcat --port 8081
 
+    ${this.c("dim", "# Build and deploy as .war file")}
+    xavva deploy --war
+
     ${this.c("dim", "# Run a class with debugging")}
     xavva debug com.example.MyClass
 
-    ${this.c("dim", "# Analyze dependencies for conflicts")}
-    xavva deps --verbose
+    ${this.c("dim", "# Use embedded Tomcat (auto-install)")}
+    xavva dev --yes
+    xavva dev --tomcat-version 9.0.115
 
-    ${this.c("dim", "# Update safe dependencies (non-breaking only)")}
+    ${this.c("dim", "# Analyze and update dependencies")}
+    xavva deps --verbose
     xavva deps --update-safe
 
-    ${this.c("dim", "# Security audit with auto-fix suggestions")}
+    ${this.c("dim", "# Security audit with auto-fix")}
     xavva audit --fix
 
+    ${this.c("dim", "# Manage embedded Tomcat")}
+    xavva tomcat list              # List available versions
+    xavva tomcat installed         # List installed versions
+    xavva tomcat install 9.0.115   # Install specific version
+    xavva tomcat use 9.0.115       # Switch to version for this project
+    xavva tomcat status
+    xavva tomcat uninstall 9.0.115
+
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
     

package/src/commands/ProfilesCommand.ts

@@ -20,7 +20,7 @@ export class ProfilesCommand implements Command {
         }
 
         Logger.log(`
-  ${Logger.C.cyan}Perfis detectados:${Logger.C.reset}`);
+  ${Logger.C.primary}Perfis detectados:${Logger.C.reset}`);
         profiles.forEach(p => {
             const active = config.project.profile === p ? ` ${Logger.C.green}(Ativo)${Logger.C.reset}` : "";
             Logger.log(`  ${Logger.C.bold}➜${Logger.C.reset} ${p}${active}`);

package/src/commands/RunCommand.ts

@@ -54,7 +54,7 @@ export class RunCommand implements Command {
 
         if (isDebug) {
             Logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
-            Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
+            Logger.log(`${Logger.C.primary}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
             Logger.newline();
         } else {
             Logger.warn(`🚀 Executando ${className}...`);

package/src/commands/TomcatCommand.ts

@@ -0,0 +1,209 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
+import { Logger } from "../utils/ui";
+import path from "path";
+import fs from "fs";
+
+export class TomcatCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        // A ação vem como positional após "tomcat" (ex: xavva tomcat list)
+        const tomcatIndex = positionals?.indexOf("tomcat") ?? -1;
+        const action = positionals && tomcatIndex >= 0 && positionals[tomcatIndex + 1] 
+            ? positionals[tomcatIndex + 1] 
+            : "status";
+        
+        // Argumentos extras após a ação (ex: xavva tomcat install 9.0.115)
+        const extraArgs = positionals && tomcatIndex >= 0 ? positionals.slice(tomcatIndex + 2) : [];
+        
+        switch (action) {
+            case "install":
+                await this.handleInstall(config, args, extraArgs);
+                break;
+            case "list":
+                this.handleList();
+                break;
+            case "installed":
+                this.handleInstalled();
+                break;
+            case "use":
+                await this.handleUse(config, args, extraArgs);
+                break;
+            case "uninstall":
+                await this.handleUninstall(config, args, extraArgs);
+                break;
+            case "status":
+                await this.handleStatus(config);
+                break;
+            default:
+                Logger.error(`Ação desconhecida: ${action}`);
+                Logger.info("Ações disponíveis", "install, list, installed, use, uninstall, status");
+        }
+    }
+
+    private async handleInstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
+        
+        // Detectar webapp path
+        const webappPath = config.project.buildTool === "maven"
+            ? path.join(process.cwd(), "src", "main", "webapp")
+            : path.join(process.cwd(), "src", "main", "webapp");
+
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath
+        });
+
+        if (service.checkInstallation()) {
+            Logger.info("Tomcat", `Versão ${version} já está instalada`);
+            const info = service.getInfo();
+            Logger.config("Local", info.home);
+            return;
+        }
+
+        const installed = await service.install();
+        if (installed) {
+            Logger.success(`Tomcat ${version} instalado com sucesso!`);
+        } else {
+            Logger.error("Falha na instalação");
+        }
+    }
+
+    private handleList(): void {
+        Logger.section("Versões Disponíveis para Download");
+        const versions = EmbeddedTomcatService.getAvailableVersions();
+        
+        for (const version of versions) {
+            Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} ${version}`);
+        }
+        
+        Logger.newline();
+        Logger.info("Versão padrão", "10.1.52");
+        Logger.newline();
+        Logger.info("Dica", "Use 'xavva tomcat installed' para ver versões já instaladas");
+    }
+
+    private handleInstalled(): void {
+        const installed = EmbeddedTomcatService.listInstalledVersions();
+        
+        Logger.section("Versões Instaladas");
+        
+        if (installed.length === 0) {
+            Logger.warn("Nenhuma versão instalada");
+            Logger.info("Dica", "Use 'xavva tomcat install <version>' para instalar");
+            return;
+        }
+        
+        for (const version of installed) {
+            Logger.log(`  ${Logger.C.success}✓${Logger.C.reset} ${version}`);
+        }
+        
+        Logger.newline();
+        Logger.info("Para usar uma versão", "xavva tomcat use <version>");
+    }
+
+    private async handleUse(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        const version = extraArgs[0] || args?.["tomcat-version"];
+        
+        if (!version) {
+            Logger.error("Versão não especificada");
+            Logger.info("Uso", "xavva tomcat use <version>");
+            Logger.info("Exemplo", "xavva tomcat use 9.0.115");
+            Logger.newline();
+            Logger.info("Versões instaladas", "");
+            this.handleInstalled();
+            return;
+        }
+        
+        // Verifica se a versão está instalada
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath: "."
+        });
+        
+        if (!service.checkInstallation()) {
+            Logger.warn(`Tomcat ${version} não está instalado`);
+            Logger.newline();
+            Logger.info("Opções", "");
+            Logger.log(`  ${Logger.C.primary}1.${Logger.C.reset} Instalar agora: xavva tomcat install ${version}`);
+            Logger.log(`  ${Logger.C.primary}2.${Logger.C.reset} Ver instaladas: xavva tomcat installed`);
+            return;
+        }
+        
+        // Salva a versão no xavva.json do projeto
+        await this.saveTomcatVersion(version);
+        
+        Logger.success(`Tomcat ${version} configurado para este projeto!`);
+        Logger.newline();
+        Logger.info("Próximos comandos", "");
+        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva dev    # Iniciar desenvolvimento`);
+        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva deploy # Fazer deploy`);
+    }
+
+    private async saveTomcatVersion(version: string): Promise<void> {
+        const xavvaJsonPath = path.join(process.cwd(), "xavva.json");
+        let config: any = {};
+        
+        if (fs.existsSync(xavvaJsonPath)) {
+            try {
+                config = JSON.parse(fs.readFileSync(xavvaJsonPath, "utf-8"));
+            } catch (e) {
+                // Arquivo existe mas é inválido, começa do zero
+            }
+        }
+        
+        if (!config.tomcat) config.tomcat = {};
+        config.tomcat.version = version;
+        config.tomcat.embedded = true;
+        
+        fs.writeFileSync(xavvaJsonPath, JSON.stringify(config, null, 2));
+    }
+
+    private async handleUninstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
+        
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath: "."
+        });
+
+        if (!service.checkInstallation()) {
+            Logger.warn(`Tomcat ${version} não está instalado`);
+            return;
+        }
+
+        Logger.step(`Removendo Tomcat ${version}...`);
+        await service.uninstall();
+        Logger.success("Removido com sucesso!");
+    }
+
+    private async handleStatus(config: AppConfig): Promise<void> {
+        Logger.section("Status do Tomcat");
+        
+        if (config.tomcat.embedded) {
+            Logger.config("Modo", "Embutido");
+            Logger.config("Versão", config.tomcat.version || "10.1.52");
+            Logger.config("Porta", String(config.tomcat.port));
+            Logger.config("Home", config.tomcat.path);
+        } else {
+            Logger.config("Modo", "Externo");
+            Logger.config("CATALINA_HOME", config.tomcat.path);
+            Logger.config("Porta", String(config.tomcat.port));
+        }
+        
+        // Verificar se está rodando
+        const netstat = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${config.tomcat.port}`]);
+        const output = await new Response(netstat.stdout).text();
+        
+        if (output.trim()) {
+            Logger.config("Status", `${Logger.C.success}Rodando${Logger.C.reset}`);
+        } else {
+            Logger.config("Status", `${Logger.C.warning}Parado${Logger.C.reset}`);
+        }
+    }
+}

package/src/index.ts

@@ -12,6 +12,7 @@ import { DocsCommand } from "./commands/DocsCommand";
 import { AuditCommand } from "./commands/AuditCommand";
 import { ProfilesCommand } from "./commands/ProfilesCommand";
 import { DepsCommand } from "./commands/DepsCommand";
+import { TomcatCommand } from "./commands/TomcatCommand";
 
 import { ProjectService } from "./services/ProjectService";
 import { TomcatService } from "./services/TomcatService";
@@ -36,7 +37,7 @@ async function main() {
 		await processManager.shutdown(0);
 	}
 
-	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles", "deps"];
+	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles", "deps", "tomcat"];
 	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
 	if (!values.help && !values.tui) {
@@ -44,6 +45,9 @@ async function main() {
 		if (config.project.encoding) {
 			Logger.config("Encoding", config.project.encoding);
 		}
+		if (config.tomcat.embedded) {
+			Logger.config("Tomcat", `Embutido ${config.tomcat.version}`);
+		}
 	}
 
 	if (values.help) {
@@ -80,6 +84,7 @@ async function main() {
 	registry.register("audit", new AuditCommand(auditService));
 	registry.register("profiles", new ProfilesCommand(projectService));
 	registry.register("deps", new DepsCommand());
+	registry.register("tomcat", new TomcatCommand());
 	registry.register("deploy", deployCmd);
 	registry.register("dev", deployCmd);
 
@@ -100,7 +105,7 @@ async function main() {
 		if (commandName === "debug") values.debug = true;
 		if (commandName === "run") values.debug = false;
 		
-		await registry.execute(commandName, config, values);
+		await registry.execute(commandName, config, values, positionals);
 	}
 }
 

package/src/services/BuildService.ts

@@ -30,7 +30,10 @@ export class BuildService {
 			this.cache.clearCache();
 		}
 
-		if (!incremental && !this.projectConfig.skipBuild) {
+		// Cache só é usado se --cache for passado ou em modo incremental
+		const useCache = this.projectConfig.cache || incremental;
+		
+		if (useCache && !incremental && !this.projectConfig.skipBuild) {
 			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool, this.projectService)) {
 				Logger.success("Build cache hit! Skipping full build.");
 				return;
@@ -43,8 +46,8 @@ export class BuildService {
 		if (this.projectConfig.buildTool === 'maven') {
 			command.push(process.platform === "win32" ? "mvn.cmd" : "mvn");
 
-			// Smart Offline: Se o pom.xml não mudou e é incremental ou rebuild forçado (mas cache existe), usa -o
-			if (!this.cache.shouldRebuild('maven', this.projectService)) {
+			// Smart Offline: só usa -o se cache estiver habilitado e pom não mudou
+			if (useCache && !this.cache.shouldRebuild('maven', this.projectService)) {
 				command.push("-o");
 			}
 
@@ -52,7 +55,12 @@ export class BuildService {
 				command.push("compile");
 			} else {
 				if (this.projectConfig.clean) command.push("clean");
-				command.push("compile", "war:exploded");
+				// Use 'package' para gerar .war ou 'war:exploded' para pasta
+				if (this.projectConfig.war) {
+					command.push("package");
+				} else {
+					command.push("compile", "war:exploded");
+				}
 				command.push("-T", "1C");
 			}
 			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");

package/src/services/DependencyAnalyzerService.ts

@@ -417,6 +417,14 @@ export class DependencyAnalyzerService {
 
 	private async checkSingleUpdate(dep: Dependency): Promise<DependencyUpdate | null> {
 		try {
+			// Primeiro verifica se a versão atual existe no Maven Central
+			// Se não existir, é uma dependência local - não sugerir atualização
+			const currentExists = await this.checkVersionExists(dep.groupId, dep.artifactId, dep.version);
+			if (!currentExists) {
+				Logger.debug(`Dependência local detectada (não no Maven Central): ${dep.groupId}:${dep.artifactId}:${dep.version}`);
+				return null;
+			}
+			
 			const latest = await this.fetchLatestVersion(dep.groupId, dep.artifactId);
 			if (latest && this.isNewer(latest, dep.version)) {
 				return {
@@ -433,6 +441,18 @@ export class DependencyAnalyzerService {
 		return null;
 	}
 
+	private async checkVersionExists(groupId: string, artifactId: string, version: string): Promise<boolean> {
+		try {
+			const url = `https://search.maven.org/solrsearch/select?q=g:"${groupId}"+AND+a:"${artifactId}"+AND+v:"${version}"&rows=1&wt=json`;
+			const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+			const data = await response.json();
+			return data.response?.numFound > 0;
+		} catch (e) {
+			// Se não conseguir verificar, assume que existe para não bloquear
+			return true;
+		}
+	}
+
 	private async fetchLatestVersion(groupId: string, artifactId: string): Promise<string | null> {
 		// Usar Maven Central API
 		try {
@@ -505,13 +525,17 @@ export class DependencyAnalyzerService {
 			const currentVersion = update.currentVersion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 			
 			// Regex para encontrar <version> dentro do bloco da dependência
+			// Captura: grupo 1 = tudo antes da versão incluindo <version>
+			//          grupo 2 = a versão atual
+			//          grupo 3 = </version> e resto
 			const depPattern = new RegExp(
-				`(<dependency>\\s*<groupId>${groupId}</groupId>\\s*<artifactId>${artifactId}</artifactId>(?:\\s*<version>)${currentVersion}(</version>))`,
+				`(<dependency>\\s*<groupId>${groupId}</groupId>\\s*<artifactId>${artifactId}</artifactId>\\s*<version>)(${currentVersion})(</version>)`,
 				'g'
 			);
 			
 			if (depPattern.test(content)) {
-				content = content.replace(depPattern, `$1${update.latestVersion}$2`);
+				// Substitui apenas o grupo 2 (a versão), mantendo as tags
+				content = content.replace(depPattern, `$1${update.latestVersion}$3`);
 				result.updated++;
 				modified = true;
 			} else {

package/src/services/EmbeddedTomcatService.ts

@@ -0,0 +1,436 @@
+import { Logger } from "../utils/ui";
+import {
+	existsSync,
+	mkdirSync,
+	createWriteStream,
+	writeFileSync,
+	readdirSync,
+	promises as fsPromises,
+} from "fs";
+import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+
+export interface EmbeddedTomcatOptions {
+	version?: string;
+	port?: number;
+	webappPath: string;
+	contextPath?: string;
+}
+
+interface DownloadProgress {
+	downloaded: number;
+	total: number;
+	percent: number;
+}
+
+export class EmbeddedTomcatService {
+	private readonly baseDir: string;
+	private readonly version: string;
+	private port: number;
+	private webappPath: string;
+	private contextPath: string;
+	private tomcatHome: string;
+	private downloadUrl: string;
+	private isInstalled: boolean = false;
+
+	// Versões estáveis do Tomcat (atualizadas: 2026-03-04)
+	private static readonly VERSIONS: Record<
+		string,
+		{ url: string; sha512: string }
+	> = {
+			"10.1.52": {
+				url: "https://dlcdn.apache.org/tomcat/tomcat-10/v10.1.52/bin/apache-tomcat-10.1.52-windows-x64.zip",
+				sha512: "",
+			},
+			"9.0.115": {
+				url: "https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.115/bin/apache-tomcat-9.0.115-windows-x64.zip",
+				sha512: "",
+			},
+			"11.0.18": {
+				url: "https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.18/bin/apache-tomcat-11.0.18-windows-x64.zip",
+				sha512: "",
+			},
+		};
+
+	constructor(options: EmbeddedTomcatOptions) {
+		this.version = options.version || "10.1.52";
+		this.port = options.port || 8080;
+		this.webappPath = path.resolve(options.webappPath);
+		this.contextPath = options.contextPath || "/";
+		this.baseDir = path.join(os.homedir(), ".xavva", "tomcat");
+		this.tomcatHome = path.join(this.baseDir, this.version);
+
+		// Se a versão não está na lista, usa URL padrão
+		const versionInfo = EmbeddedTomcatService.VERSIONS[this.version];
+		if (versionInfo) {
+			this.downloadUrl = versionInfo.url;
+		} else {
+			// Tenta inferir URL baseado no padrão Apache
+			const majorVersion = this.version.split(".")[0];
+			this.downloadUrl = `https://archive.apache.org/dist/tomcat/tomcat-${majorVersion}/v${this.version}/bin/apache-tomcat-${this.version}-windows-x64.zip`;
+		}
+	}
+
+	/**
+	 * Verifica se o Tomcat já está instalado
+	 */
+	checkInstallation(): boolean {
+		const catalinaBat = path.join(this.tomcatHome, "bin", "catalina.bat");
+		this.isInstalled = existsSync(catalinaBat);
+		return this.isInstalled;
+	}
+
+	/**
+	 * Retorna o caminho do Tomcat (instalado ou para instalar)
+	 */
+	getTomcatHome(): string {
+		return this.tomcatHome;
+	}
+
+	/**
+	 * Lista todas as versões instaladas
+	 */
+	static listInstalledVersions(): string[] {
+		const baseDir = path.join(os.homedir(), ".xavva", "tomcat");
+		if (!existsSync(baseDir)) return [];
+
+		const versions: string[] = [];
+		const entries = readdirSync(baseDir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				const catalinaBat = path.join(
+					baseDir,
+					entry.name,
+					"bin",
+					"catalina.bat",
+				);
+				if (existsSync(catalinaBat)) {
+					versions.push(entry.name);
+				}
+			}
+		}
+
+		return versions.sort();
+	}
+
+	/**
+	 * Baixa e instala o Tomcat
+	 */
+	async install(): Promise<boolean> {
+		if (this.checkInstallation()) {
+			Logger.info("Tomcat", `Versão ${this.version} já instalada`);
+			return true;
+		}
+
+		Logger.section("Instalando Tomcat Embutido");
+		Logger.info("Versão", this.version);
+		Logger.info("Destino", this.tomcatHome);
+
+		// Cria diretório base
+		if (!existsSync(this.baseDir)) {
+			mkdirSync(this.baseDir, { recursive: true });
+		}
+
+		const zipPath = path.join(
+			this.baseDir,
+			`apache-tomcat-${this.version}.zip`,
+		);
+
+		try {
+			// Download
+			await this.downloadFile(this.downloadUrl, zipPath);
+
+			// Extração
+			await this.extractZip(zipPath, this.baseDir);
+
+			// Renomeia diretório extraído para versão padronizada
+			const extractedDir = path.join(
+				this.baseDir,
+				`apache-tomcat-${this.version}`,
+			);
+			if (existsSync(extractedDir) && extractedDir !== this.tomcatHome) {
+				await fsPromises.rename(extractedDir, this.tomcatHome);
+			}
+
+			// Limpa arquivo zip
+			await fsPromises.unlink(zipPath).catch(() => { });
+
+			// Configura server.xml
+			await this.configureServerXml();
+
+			// Configura context.xml para hot-reload
+			await this.configureContextXml();
+
+			this.isInstalled = true;
+			Logger.success(`Tomcat ${this.version} instalado com sucesso!`);
+			return true;
+		} catch (error) {
+			Logger.error(`Falha ao instalar Tomcat: ${error}`);
+			// Limpa arquivos parciais
+			if (existsSync(this.tomcatHome)) {
+				await fsPromises.rm(this.tomcatHome, { recursive: true, force: true });
+			}
+			return false;
+		}
+	}
+
+	/**
+	 * Configura server.xml com porta personalizada
+	 */
+	private async configureServerXml(): Promise<void> {
+		const serverXmlPath = path.join(this.tomcatHome, "conf", "server.xml");
+
+		if (!existsSync(serverXmlPath)) {
+			throw new Error("server.xml não encontrado após extração");
+		}
+
+		let content = await fsPromises.readFile(serverXmlPath, "utf-8");
+
+		// Atualiza porta HTTP
+		content = content.replace(
+			/<Connector port="8080"/,
+			`<Connector port="${this.port}"`,
+		);
+
+		// Atualiza porta de shutdown
+		const shutdownPort = this.port + 1000;
+		content = content.replace(
+			/<Server port="8005"/,
+			`<Server port="${shutdownPort}"`,
+		);
+
+		// Atualiza porta AJP (se existir)
+		content = content.replace(
+			/<Connector port="8009"/,
+			`<Connector port="${this.port + 1001}"`,
+		);
+
+		// Desabilita manager e host-manager em embedded (opcional)
+		// Remove context do manager para segurança
+		content = content.replace(
+			/<Context docBase="manager"[^>]*\/>/g,
+			'<!-- <Context docBase="manager" ... /> -->',
+		);
+
+		await fsPromises.writeFile(serverXmlPath, content, "utf-8");
+		Logger.debug(`server.xml configurado na porta ${this.port}`);
+	}
+
+	/**
+	 * Configura context.xml para hot-reload
+	 */
+	private async configureContextXml(): Promise<void> {
+		const contextXmlPath = path.join(this.tomcatHome, "conf", "context.xml");
+
+		if (!existsSync(contextXmlPath)) return;
+
+		let content = await fsPromises.readFile(contextXmlPath, "utf-8");
+
+		// Adiciona atributos para hot-reload se não existirem
+		if (!content.includes("reloadable")) {
+			content = content.replace(
+				/<Context>/,
+				'<Context reloadable="true" autoDeploy="true" deployOnStartup="true">',
+			);
+		}
+
+		await fsPromises.writeFile(contextXmlPath, content, "utf-8");
+	}
+
+	/**
+	 * Cria contexto para a aplicação
+	 */
+	async createAppContext(): Promise<void> {
+		const webappsDir = path.join(this.tomcatHome, "webapps");
+
+		// Limpa webapps padrão
+		const defaultApps = ["docs", "examples", "host-manager", "manager", "ROOT"];
+		for (const app of defaultApps) {
+			const appPath = path.join(webappsDir, app);
+			if (existsSync(appPath)) {
+				await fsPromises.rm(appPath, { recursive: true, force: true });
+			}
+		}
+
+		// Cria diretório para a aplicação
+		const appName =
+			this.contextPath === "/" ? "ROOT" : this.contextPath.replace(/^\//, "");
+		const appDir = path.join(webappsDir, appName);
+
+		if (existsSync(appDir)) {
+			await fsPromises.rm(appDir, { recursive: true, force: true });
+		}
+
+		// Se webappPath é um diretório, cria link/simula deploy
+		if (existsSync(this.webappPath)) {
+			// Em Windows, vamos copiar inicialmente (symlink requer privilégios)
+			// Ou criar um context XML apontando para o diretório
+			await this.createContextXml(appName);
+		}
+	}
+
+	/**
+	 * Cria arquivo context XML para apontar para diretório externo
+	 */
+	private async createContextXml(appName: string): Promise<void> {
+		const confDir = path.join(this.tomcatHome, "conf", "Catalina", "localhost");
+
+		if (!existsSync(confDir)) {
+			mkdirSync(confDir, { recursive: true });
+		}
+
+		const contextFile = path.join(confDir, `${appName}.xml`);
+		const content = `<?xml version="1.0" encoding="UTF-8"?>
+<Context 
+    docBase="${this.webappPath.replace(/\\/g, "/")}"
+    reloadable="true"
+    crossContext="true"
+    antiResourceLocking="false"
+    antiJARLocking="false">
+</Context>`;
+
+		writeFileSync(contextFile, content);
+		Logger.debug(`Context criado: ${contextFile}`);
+	}
+
+	/**
+	 * Verifica se porta está disponível
+	 */
+	async isPortAvailable(): Promise<boolean> {
+		return new Promise((resolve) => {
+			const netstat = spawn("cmd", [
+				"/c",
+				`netstat -ano | findstr :${this.port}`,
+			]);
+			let output = "";
+
+			netstat.stdout?.on("data", (data) => {
+				output += data.toString();
+			});
+
+			netstat.on("close", () => {
+				resolve(output.trim().length === 0);
+			});
+
+			netstat.on("error", () => {
+				resolve(true); // Assume disponível se não conseguir verificar
+			});
+		});
+	}
+
+	/**
+	 * Encontra próxima porta disponível
+	 */
+	async findAvailablePort(startPort: number = 8080): Promise<number> {
+		let port = startPort;
+		while (!(await this.isPortAvailable())) {
+			port++;
+			if (port > 65535) {
+				throw new Error("Nenhuma porta disponível encontrada");
+			}
+		}
+		this.port = port;
+		return port;
+	}
+
+	/**
+	 * Retorna variáveis de ambiente para o Tomcat
+	 */
+	getEnvironment(): Record<string, string> {
+		return {
+			CATALINA_HOME: this.tomcatHome,
+			CATALINA_BASE: this.tomcatHome,
+			CATALINA_OPTS: process.env.CATALINA_OPTS || "",
+		};
+	}
+
+	/**
+	 * Lista versões disponíveis
+	 */
+	static getAvailableVersions(): string[] {
+		return Object.keys(EmbeddedTomcatService.VERSIONS);
+	}
+
+	/**
+	 * Download com progresso
+	 */
+	private async downloadFile(url: string, destPath: string): Promise<void> {
+		const spinner = Logger.spinner(`Baixando Tomcat ${this.version}...`);
+
+		try {
+			const response = await fetch(url);
+
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			}
+
+			const totalSize = parseInt(response.headers.get("content-length") || "0");
+			const buffer = await response.arrayBuffer();
+
+			writeFileSync(destPath, Buffer.from(buffer));
+
+			spinner(true);
+
+			const sizeMB = (buffer.byteLength / 1024 / 1024).toFixed(1);
+			Logger.info("Download", `${sizeMB} MB baixados`);
+		} catch (error) {
+			spinner(false);
+			throw error;
+		}
+	}
+
+	/**
+	 * Extrai arquivo ZIP usando PowerShell
+	 */
+	private async extractZip(zipPath: string, destDir: string): Promise<void> {
+		const spinner = Logger.spinner("Extraindo arquivos...");
+
+		return new Promise((resolve, reject) => {
+			const ps = spawn("powershell", [
+				"-command",
+				`Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`,
+			]);
+
+			ps.on("close", (code) => {
+				if (code === 0) {
+					spinner(true);
+					resolve();
+				} else {
+					spinner(false);
+					reject(new Error(`Falha ao extrair (código ${code})`));
+				}
+			});
+
+			ps.on("error", (err) => {
+				spinner(false);
+				reject(err);
+			});
+		});
+	}
+
+	/**
+	 * Remove instalação
+	 */
+	async uninstall(): Promise<void> {
+		if (existsSync(this.tomcatHome)) {
+			await fsPromises.rm(this.tomcatHome, { recursive: true, force: true });
+			Logger.info("Tomcat", `Versão ${this.version} removida`);
+		}
+	}
+
+	/**
+	 * Retorna informações da instalação
+	 */
+	getInfo(): Record<string, string> {
+		return {
+			version: this.version,
+			home: this.tomcatHome,
+			port: String(this.port),
+			installed: this.isInstalled ? "sim" : "não",
+			webapp: this.webappPath,
+			context: this.contextPath,
+		};
+	}
+}

package/src/services/LogAnalyzer.ts

@@ -98,7 +98,7 @@ export class LogAnalyzer {
             return `${Logger.C.magenta}👀 ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg.replace(/Class '.*?'/, (m) => Logger.C.bold + m + Logger.C.reset)}`;
         }
 
-        let color = Logger.C.cyan;
+        let color = Logger.C.primary;
         let symbol = "●";
         if (level === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
         else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }

package/src/services/ProjectService.ts

@@ -28,7 +28,12 @@ export class ProjectService {
         const artifacts = this.searchArtifacts(buildDir).sort((a, b) => b.time - a.time);
 
         if (artifacts.length === 0) {
-            throw new Error(`Nenhum artefato (.war ou pasta exploded) encontrado em ${buildDir}!`);
+            // Debug: listar o que existe no diretório target
+            let debugInfo = `\nDiretório ${buildDir} existe: ${existsSync(buildDir)}`;
+            if (existsSync(buildDir)) {
+                debugInfo += `\nConteúdo: ${readdirSync(buildDir).join(', ')}`;
+            }
+            throw new Error(`Nenhum artefato (.war ou pasta exploded) encontrado em ${buildDir}!${debugInfo}`);
         }
 
         const artifact = artifacts[0];

package/src/types/config.ts

@@ -3,6 +3,8 @@ export interface TomcatConfig {
     port: number;
     webapps: string;
     grep?: string;
+    embedded?: boolean;
+    version?: string;
 }
 
 export interface ProjectConfig {
@@ -20,6 +22,8 @@ export interface ProjectConfig {
     grep?: string;
     tui: boolean;
     encoding?: string;
+    war?: boolean;
+    cache?: boolean;
 }
 
 export interface AppConfig {
@@ -50,6 +54,13 @@ export interface CLIArguments {
     tui?: boolean;
     output?: string;
     strict?: boolean;
+    "tomcat-version"?: string;
+    "tomcat-action"?: string;
+    "update-safe"?: boolean;
+    "updateSafe"?: boolean;
+    yes?: boolean;
+    war?: boolean;
+    cache?: boolean;
 }
 
 export interface CommandContext {

package/src/utils/config.ts

@@ -3,6 +3,8 @@ import path from "path";
 import fs from "fs";
 import { DEFAULT_TOMCAT_PORT, DEFAULT_DEBUG_PORT } from "./constants";
 import type { AppConfig, CLIArguments, CommandContext } from "../types/config";
+import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
+import { Logger } from "./ui";
 
 export class ConfigManager {
     static async load(): Promise<CommandContext> {
@@ -32,6 +34,10 @@ export class ConfigManager {
                 tui: { type: "boolean" },
                 output: { type: "string", short: "o" },
                 strict: { type: "boolean" },
+                "tomcat-version": { type: "string" },
+                yes: { type: "boolean", short: "y" },
+                war: { type: "boolean", short: "W" },
+                cache: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
@@ -52,8 +58,9 @@ export class ConfigManager {
 
         const isDev = positionals.includes("dev");
         const isRun = positionals.includes("run") || positionals.includes("debug");
+        const isStart = positionals.includes("start") || positionals.includes("deploy") || isDev;
         
-        const envTomcatPath = process.env.TOMCAT_HOME || process.env.CATALINA_HOME || "C:\\apache-tomcat";
+        const envTomcatPath = process.env.TOMCAT_HOME || process.env.CATALINA_HOME;
         const detectedTool = this.detectBuildTool();
 
         let runClass = "";
@@ -64,12 +71,79 @@ export class ConfigManager {
             runClass = positionals[idx + 1] || "";
         }
 
+        // Detectar webapp path baseado no build tool
+        const webappPath = detectedTool === "maven" 
+            ? path.join(process.cwd(), "src", "main", "webapp")
+            : path.join(process.cwd(), "src", "main", "webapp");
+
+        // Verificar se usar Tomcat embutido
+        let tomcatPath = String(cliValues.path || xavvaJson.path || envTomcatPath || "");
+        let useEmbedded = false;
+        // Versão pode vir de: CLI flag > xavva.json tomcat.version > xavva.json version (legado) > padrão
+        const xavvaTomcatVersion = (xavvaJson as any).tomcat?.version;
+        let embeddedVersion = String(cliValues["tomcat-version"] || xavvaTomcatVersion || xavvaJson.version || "10.1.52");
+
+        // Se não há Tomcat configurado ou não existe no path, usar embutido
+        if (!tomcatPath || (!fs.existsSync(path.join(tomcatPath, "bin", "catalina.bat")) && isStart)) {
+            useEmbedded = true;
+            const embeddedService = new EmbeddedTomcatService({
+                version: embeddedVersion,
+                port: parseInt(String(cliValues.port || xavvaJson.port || String(DEFAULT_TOMCAT_PORT))),
+                webappPath: webappPath
+            });
+            
+            // Instala se necessário
+            if (!embeddedService.checkInstallation()) {
+                Logger.newline();
+                Logger.warn("Tomcat não encontrado!");
+                Logger.info("Versão solicitada", embeddedVersion);
+                Logger.newline();
+                Logger.log(`${Logger.C.primary}?${Logger.C.reset} Deseja instalar o Tomcat ${embeddedVersion} automaticamente?`);
+                Logger.log(`${Logger.C.dim}  O download é de ~16MB e será salvo em:~/.xavva/tomcat/${embeddedVersion}${Logger.C.reset}`);
+                Logger.newline();
+                
+                // Garante que não há output pendente antes da pergunta
+                await new Promise(resolve => setTimeout(resolve, 50));
+                process.stdout.write('\r\x1b[K'); // Limpa linha atual
+                
+                const autoYes = !!cliValues.yes;
+                const shouldInstall = autoYes || await this.askYesNo("Instalar");
+                
+                if (!shouldInstall) {
+                    Logger.newline();
+                    Logger.info("Opções disponíveis", "");
+                    Logger.log(`  ${Logger.C.primary}1.${Logger.C.reset} Defina TOMCAT_HOME ou CATALINA_HOME`);
+                    Logger.log(`  ${Logger.C.primary}2.${Logger.C.reset} Use --path para especificar o Tomcat`);
+                    Logger.log(`  ${Logger.C.primary}3.${Logger.C.reset} Use --tomcat-version para outra versão`);
+                    Logger.newline();
+                    process.exit(0);
+                }
+                
+                Logger.newline();
+                const installed = await embeddedService.install();
+                if (!installed) {
+                    Logger.error("Falha ao instalar Tomcat embutido.");
+                    Logger.info("Dica", "Instale o Tomcat manualmente ou defina TOMCAT_HOME");
+                    process.exit(1);
+                }
+            } else {
+                Logger.info("Tomcat", `Usando versão embutida ${embeddedVersion}`);
+            }
+            
+            // Configura contexto da aplicação
+            await embeddedService.createAppContext();
+            
+            tomcatPath = embeddedService.getTomcatHome();
+        }
+
         const config: AppConfig = {
             tomcat: {
-                path: String(cliValues.path || xavvaJson.path || envTomcatPath),
+                path: tomcatPath,
                 port: parseInt(String(cliValues.port || xavvaJson.port || String(DEFAULT_TOMCAT_PORT))),
                 webapps: "webapps",
                 grep: cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : "",
+                embedded: useEmbedded,
+                version: embeddedVersion,
             },
             project: {
                 appName: cliValues.name || xavvaJson.name ? String(cliValues.name || xavvaJson.name) : "",
@@ -86,6 +160,8 @@ export class ConfigManager {
                 grep: runClass || (cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : ""),
                 tui: !!(cliValues.tui ?? xavvaJson.tui),
                 encoding: cliValues.encoding || xavvaJson.encoding || "",
+                war: !!(cliValues.war ?? xavvaJson.war),
+                cache: !!(cliValues.cache ?? xavvaJson.cache),
             }
         };
 
@@ -106,6 +182,50 @@ export class ConfigManager {
         return "maven";
     }
 
+    private static async askYesNo(question: string): Promise<boolean> {
+        // Pequeno delay para garantir que o output anterior foi processado
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        // Limpa qualquer coisa pendente no stdout
+        process.stdout.write('\x1b[0m');
+        
+        return new Promise((resolve) => {
+            const chunks: Buffer[] = [];
+            
+            const cleanup = () => {
+                process.stdin.removeListener('data', onData);
+                process.stdin.removeListener('end', onEnd);
+                process.stdin.pause();
+            };
+            
+            const onData = (data: Buffer) => {
+                chunks.push(data);
+                const str = Buffer.concat(chunks).toString();
+                
+                // Procura por enter no input
+                if (str.includes('\n') || str.includes('\r')) {
+                    cleanup();
+                    const answer = str.replace(/\r?\n/g, '').trim().toLowerCase();
+                    process.stdout.write('\n');
+                    resolve(answer === '' || answer === 'y' || answer === 'yes');
+                }
+            };
+            
+            const onEnd = () => {
+                cleanup();
+                const answer = Buffer.concat(chunks).toString().trim().toLowerCase();
+                resolve(answer === '' || answer === 'y' || answer === 'yes');
+            };
+            
+            // Mostra a pergunta
+            process.stdout.write(`${question} [Y/n]: `);
+            
+            process.stdin.resume();
+            process.stdin.on('data', onData);
+            process.stdin.on('end', onEnd);
+        });
+    }
+
     private static ensureGitIgnore() {
         const gitignorePath = path.join(process.cwd(), ".gitignore");