@archznn/xavva 1.7.0 → 1.8.1

package/README.md

@@ -1,41 +1,111 @@
-# XAVVA 🚀 (Windows Only) `v1.7.0`
+# XAVVA 🚀 (Windows Only) `v1.8.1`
 
 Xavva é uma CLI de alto desempenho construída com **Bun** para automatizar o ciclo de desenvolvimento de aplicações Java (Maven/Gradle) rodando no Apache Tomcat. Ela foi desenhada especificamente para desenvolvedores que buscam a velocidade de ambientes modernos (como Node.js/Vite) dentro do ecossistema Java Enterprise.
 
-## 🛠️ Funcionalidades de Elite
+---
+
+## 🛠️ Por que Xavva?
+
+Desenvolver para Java/Tomcat tradicionalmente envolve ciclos lentos de `clean install`, `war deploy` e restarts de servidor. O Xavva quebra esse paradigma ao introduzir um fluxo de **Hot-Reload incremental**, onde apenas o que mudou é enviado ao servidor.
+
+### ⚡ Funcionalidades de Elite
 
-- **⚡ Ultra-Fast Hot Swap**: Compilação incremental e injeção direta de arquivos `.class` e recursos (JSP, HTML, CSS, JS) no Tomcat em execução sem necessidade de restart.
-- **📦 Multi-Module Support**: Detecção recursiva de diretórios de classes em projetos complexos, garantindo que o Hot-Reload funcione entre diferentes módulos.
-- **🛠️ Modo Dev Inteligente**: O comando `xavva dev` ativa hot-reload, logs limpos, debugger (JPDA) e monitoramento de memória em um único fluxo.
-- **🌐 Live Reload Automático**: Atualiza automaticamente as abas do Chrome ou Edge após o deploy ou sincronização de arquivos, mantendo o foco no código.
-- **🔍 API Documentation (Swagger-like)**: O comando `xavva docs` mapeia estaticamente sua API, exibindo endpoints, métodos HTTP e parâmetros diretamente no terminal.
-- **📊 Real-time Log Filtering**: Filtra ruídos excessivos do Tomcat/Jersey/SLF4J, destacando erros Java com dicas de solução.
-- **📈 JVM & Memory Monitor**: Exibe o consumo de RAM do processo do Tomcat em tempo real.
-- **🩺 Doctor Mode**: Diagnostica o ambiente e corrige automaticamente problemas de **Encoding (UTF-8 BOM)**.
-- **🛡️ JAR Audit**: Analisa todas as dependências (`.jar`) da sua aplicação em busca de vulnerabilidades (CVEs).
+- **Ultra-Fast Hot Swap**: Compilação incremental e injeção direta de arquivos `.class` e recursos (JSP, HTML, CSS, JS) no Tomcat em execução sem restart.
+- **Gradle & Maven Native**: Suporte robusto para ambos os ecossistemas, incluindo extração automática de classpath para execução de classes standalone (`run`/`debug`).
+- **DCEVM Integration**: O Xavva pode baixar e configurar automaticamente uma JDK com DCEVM (JetBrains Runtime), permitindo mudanças estruturais em classes (novos métodos/campos) em tempo real.
+- **API Documentation (Swagger-like)**: Mapeamento estático de endpoints, métodos HTTP e parâmetros diretamente no terminal via `xavva docs`.
+- **Live Reload Automático**: Sincronização inteligente que atualiza o browser (Chrome/Edge) após mudanças em JSPs ou recursos estáticos.
+- **Segurança & Robustez**: Auditoria de dependências (`.jar`) e execução protegida contra *Command Injection* no PowerShell.
+- **Pathing JAR (Windows)**: Contorna limites de caracteres do Windows em classpaths gigantes através de geração dinâmica de Manifestos compatíveis com a especificação Java.
+- **Auto-Healing**: Diagnóstico e reparo automático de problemas comuns de ambiente, como encoding UTF-8 com BOM.
 
-## 🚀 Instalação e Uso
+---
+
+## 🚀 Começo Rápido
 
-```bash
-# Instalação global
+### Pré-requisitos
+- **Windows** (Otimizado para PowerShell Core e Windows PowerShell)
+- **Bun** instalado (`powershell -c "irm bun.sh/install.ps1 | iex"`)
+- **Tomcat** configurado via variável de ambiente `TOMCAT_HOME` ou `CATALINA_HOME`.
+
+### Instalação
+```powershell
+# Instalação global via NPM
 npm install -g @archznn/xavva
 
-# Ou rodar sem instalar via npx
+# Ou use diretamente via npx
 npx @archznn/xavva dev
 ```
 
-## ⚙️ Zero Config & Auto-Detection
+---
 
-O Xavva identifica automaticamente se seu projeto usa **Maven** (`pom.xml`) ou **Gradle** (`build.gradle`) e localiza o Tomcat através das variáveis `TOMCAT_HOME` ou `CATALINA_HOME`.
+## 📖 Referência de Comandos
 
-### Comandos Principais
+O Xavva utiliza uma arquitetura modular de comandos e serviços, garantindo alta performance e extensibilidade.
 
-```bash
-xavva dev          # Modo desenvolvimento completo com Hot-Reload
-xavva docs         # Documentação estática de endpoints
-xavva audit        # Auditoria de segurança de dependências
-xavva doctor --fix # Diagnóstico e reparo de ambiente
-```
+### 1. Modo Desenvolvimento (`xavva dev`)
+O comando principal para o dia a dia. Ativa o monitoramento de arquivos e o Hot-Reload.
+  - **O que faz**: Compila Java, sincroniza recursos, limpa logs, inicia o Tomcat e monitora mudanças.
+- **Flags úteis**: 
+  - `--no-build`: Pula o build inicial.
+  - `--watch`: Ativa o modo de observação de arquivos (padrão em `dev`).
+  - `--port 8081`: Define uma porta específica para o Tomcat.
+  - `--dp 9000`: Altera a porta do Debugger (JPDA) (padrão 5005).
+
+### 2. Execução de Classes (`xavva run` / `xavva debug`)
+Executa classes Java standalone (`public static void main`) com resolução automática de dependências Maven ou Gradle.
+- **Inteligência de Classpath**: Gera automaticamente um `classpath.jar` temporário (Pathing JAR) para evitar o erro de "Command line too long" no Windows.
+- **Busca por Grep**: Se você fornecer apenas parte do nome da classe, o Xavva a encontrará recursivamente no projeto.
+
+### 3. Documentação de API (`xavva docs`)
+Gera uma documentação instantânea dos seus controladores Jersey/Spring no terminal.
+- Mostra a URL completa, método HTTP e parâmetros (Path, Query, Body).
+
+### 4. Diagnóstico e Reparo (`xavva doctor`)
+Verifica se o seu ambiente está saudável.
+- **`xavva doctor --fix`**:
+  - Instala o **JetBrains Runtime (DCEVM)** se necessário.
+  - Remove automaticamente o **BOM (Byte Order Mark)** de arquivos Java que causam erros de compilação.
+  - Configura o `JAVA_HOME` do sistema.
+
+### 5. Auditoria de Segurança (`xavva audit`)
+Analisa a pasta `WEB-INF/lib` em busca de JARs vulneráveis via integração com **OSV.dev**. Essencial para manter a integridade do projeto antes de deploys em produção.
+
+### 6. Logs em Tempo Real (`xavva logs`)
+Exibe os logs do Tomcat filtrando ruídos excessivos e destacando StackTraces importantes. Use `--grep "NomeDaClasse"` para focar em logs específicos.
+
+---
+
+## 🏗️ Arquitetura do Sistema
+
+O Xavva foi refatorado para uma arquitetura de **Injeção de Dependências** e **Serviços Centralizados**:
+
+- **CommandRegistry**: Gerenciamento modular de comandos via Command Pattern.
+- **ProjectService**: Inteligência centralizada para descoberta de diretórios de build, artefatos e classpaths Java.
+- **AuditService**: Segurança aprimorada com execução isolada e protegida no PowerShell.
+- **TomcatService**: Gerenciamento do ciclo de vida do servidor com suporte a hotswap dinâmico.
+
+---
+
+## ⚙️ Configuração (Zero Config)
+
+O Xavva funciona sem arquivos de configuração externos, baseando-se no ambiente:
+
+| Variável | Descrição |
+|----------|-----------|
+| `TOMCAT_HOME` | Caminho raiz do seu Apache Tomcat. |
+| `JAVA_HOME` | JDK utilizada para compilação e execução. |
+
+**Dica**: O Xavva cria automaticamente uma pasta `.xavva` no seu projeto para cache e artefatos temporários, e a adiciona ao seu `.gitignore`.
+
+---
+
+## 🧩 Sincronização de Recursos
+
+Ao editar um arquivo, o Xavva decide a melhor estratégia:
+- **`.java`**: Compila apenas a classe e injeta o bytecode via `fastSync`.
+- **`.jsp` / `.html` / `.css`**: Sincroniza o arquivo diretamente na pasta de deploy do Tomcat.
+- **`pom.xml` / `build.gradle`**: Identifica mudanças estruturais e sugere um rebuild completo com invalidação de cache inteligente.
 
 ---
-*Desenvolvido para transformar a experiência de desenvolvimento Java Legacy em algo ágil e produtivo.*
+*Desenvolvido para transformar o legado em produtivo. 🚀*

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "1.7.0",
+	"version": "1.8.1",
 	"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/AuditCommand.ts

@@ -1,15 +1,17 @@
 import path from "path";
 import fs from "fs";
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import { AuditService, type JarAuditResult } from "../services/AuditService";
 import { Logger } from "../utils/ui";
 
 export class AuditCommand implements Command {
-    async execute(config: AppConfig): Promise<void> {
+    constructor(private auditService: AuditService) {}
+
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
         Logger.section("Vulnerability & JAR Audit");
 
-        let appName = config.project.appName;
+        let appName = args?.name || config.project.appName;
         
         if (!appName) {
             appName = this.inferFromArtifacts();
@@ -38,10 +40,8 @@ export class AuditCommand implements Command {
             return;
         }
 
-        const auditService = new AuditService(config.tomcat);
-        
         try {
-            const results = await auditService.runAudit(appName);
+            const results = await this.auditService.runAudit(appName);
             const vulnerable = results.filter(r => r.vulnerabilities.length > 0);
 
             if (vulnerable.length === 0) {

package/src/commands/BuildCommand.ts

@@ -4,15 +4,15 @@ import { BuildService } from "../services/BuildService";
 import { Logger } from "../utils/ui";
 
 export class BuildCommand implements Command {
+    constructor(private buildService: BuildService) {}
+
     async execute(config: AppConfig): Promise<void> {
-        const builder = new BuildService(config.project, config.tomcat);
-        
         Logger.section("Build Only");
         Logger.info("Tool", config.project.buildTool.toUpperCase());
         if (config.project.profile) Logger.info("Profile", config.project.profile);
         
         try {
-            await builder.runBuild();
+            await this.buildService.runBuild();
             Logger.success("Build completed successfully!");
         } catch (error: any) {
             Logger.error(error.message);

package/src/commands/Command.ts

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

package/src/commands/CommandRegistry.ts

@@ -0,0 +1,36 @@
+import type { AppConfig, CLIArguments } from "../types/config";
+import type { Command } from "./Command";
+import { Logger } from "../utils/ui";
+import { HelpCommand } from "./HelpCommand";
+
+export class CommandRegistry {
+    private commands = new Map<string, Command>();
+
+    register(name: string, command: Command) {
+        this.commands.set(name, command);
+    }
+
+    has(name: string): boolean {
+        return this.commands.has(name);
+    }
+
+    get(name: string): Command | undefined {
+        return this.commands.get(name);
+    }
+
+    async execute(name: string, config: AppConfig, args: CLIArguments) {
+        const command = this.commands.get(name);
+        if (!command) {
+            Logger.error(`Comando desconhecido: ${name}`);
+            await new HelpCommand().execute(config);
+            process.exit(1);
+        }
+
+        try {
+            await command.execute(config, args);
+        } catch (error: any) {
+            Logger.error(`Erro ao executar comando '${name}': ${error.message}`);
+            process.exit(1);
+        }
+    }
+}

package/src/commands/DeployCommand.ts

@@ -1,68 +1,24 @@
 import path from "path";
 import fs from "fs";
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import { BuildService } from "../services/BuildService";
 import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 import { EndpointService } from "../services/EndpointService";
+import { BrowserService } from "../services/BrowserService";
 
 export class DeployCommand implements Command {
-    constructor(private tomcat?: TomcatService, private builder?: BuildService) {}
+    constructor(private tomcat: TomcatService, private builder: BuildService) {}
 
-    private async reloadBrowser(url: string) {
-        if (process.platform !== 'win32') return;
-        
-        await new Promise(r => setTimeout(r, 800));
-
-        const psCommand = `
-            $shell = New-Object -ComObject WScript.Shell
-            $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
-            if ($process) {
-                $shell.AppActivate($process.Id)
-                Sleep -m 100
-                $shell.SendKeys("{F5}")
-            }
-        `;
-        Bun.spawn(["powershell", "-command", psCommand]);
-    }
-
-    async execute(config: AppConfig, incremental = false, isWatching = false): Promise<void> {
-        const tomcat = this.tomcat || new TomcatService(config.tomcat);
-        const builder = this.builder || new BuildService(config.project, config.tomcat);
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const incremental = args?.watch && args?.incremental;
+        const isWatching = !!args?.watch;
+        const tomcat = this.tomcat;
+        const builder = this.builder;
 
         if (!incremental) {
-            Logger.config("Runtime", config.project.buildTool.toUpperCase());
-            Logger.config("Watch Mode", isWatching ? "ON" : "OFF");
-            Logger.config("Debug", config.project.debug ? "ON (Port 5005)" : "OFF");
-
-            let javaBin = "java";
-            if (process.env.JAVA_HOME) {
-                const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
-                if (fs.existsSync(homeBin)) javaBin = homeBin;
-            }
-            
-            const javaVer = Bun.spawnSync([javaBin, "-version"]);
-            const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
-            const hasDcevm = output.includes("dcevm") || 
-                             output.includes("jetbrains") || 
-                             output.includes("trava") || 
-                             output.includes("jbr");
-            
-            if (!hasDcevm && isWatching) {
-                Logger.config("Hot Reload", "Standard (No structural changes)");
-            } else if (hasDcevm) {
-                Logger.config("Hot Reload", "Advanced (DCEVM Active)");
-            }
-
-            const srcPath = path.join(process.cwd(), "src");
-            if (fs.existsSync(srcPath)) {
-                const contextPath = (config.project.appName || "").replace(".war", "");
-                const endpoints = EndpointService.scan(srcPath, contextPath);
-                if (endpoints.length > 0) {
-                    Logger.config("Endpoints", endpoints.length);
-                }
-            }
+            this.logConfiguration(config, isWatching);
         } else {
             Logger.watcher("Change detected", "change");
         }
@@ -72,19 +28,28 @@ export class DeployCommand implements Command {
 
             if (!incremental) {
                 await tomcat.killConflict();
-            }
+                await tomcat.clearWebapps();
 
-            if (!config.project.skipBuild) {
-                if (incremental) Logger.watcher("Incremental compilation", "start");
-                await builder.runBuild(incremental);
-                if (!incremental) Logger.build("Full project build");
+                if (!config.project.skipBuild) {
+                    Logger.watcher("Building project", "start");
+                    await builder.runBuild(incremental);
+                }
+                
+                if (!config.project.skipBuild) {
+                    Logger.build("Full project build and environment ready");
+                }
+            } else {
+                if (!config.project.skipBuild) {
+                    Logger.watcher("Incremental compilation", "start");
+                    await builder.runBuild(incremental);
+                }
             }
 
             if (incremental) {
-                const actualAppFolder = await builder.syncClasses(true); 
+                const actualAppFolder = await builder.syncClasses(); 
                 const actualContextPath = contextPath || actualAppFolder || "";
                 const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
-                await this.reloadBrowser(actualAppUrl);
+                await BrowserService.reload(actualAppUrl);
                 Logger.watcher("Redeploy completed", "success");
                 return;
             }
@@ -96,62 +61,41 @@ export class DeployCommand implements Command {
             const finalContextPath = contextPath || artifactInfo.finalName.replace(".war", "");
             const appWebappPath = path.join(config.tomcat.path, "webapps", finalContextPath);
 
-            if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
-
-            try {
-                Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
-                Logger.build("Artifacts deployed");
-            } catch (e: any) {
-                const extractCmd = `powershell -command "Expand-Archive -Path '${artifactInfo.path}' -DestinationPath '${appWebappPath}' -Force"`;
-                Bun.spawnSync(["powershell", "-command", extractCmd]);
-                Logger.build("Artifacts deployed (legacy mode)");
+            if (artifactInfo.isDirectory) {
+                await builder.syncClasses(artifactInfo.path);
+                Logger.build("Exploded directory synced");
+            } else {
+                if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
+
+                const artifactStat = fs.statSync(artifactInfo.path);
+                const webappStat = fs.existsSync(appWebappPath) ? fs.statSync(appWebappPath) : null;
+
+                if (!webappStat || artifactStat.mtimeMs > webappStat.mtimeMs) {
+                    try {
+                        Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
+                        Logger.build("Artifacts deployed");
+                    } catch (e) {
+                        const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
+                        Bun.spawnSync(["powershell", "-command", extractCmd], {
+                            env: {
+                                ...process.env,
+                                ARTIFACT_PATH: artifactInfo.path,
+                                DEST_PATH: appWebappPath
+                            }
+                        });
+                        Logger.build("Artifacts deployed (legacy mode)");
+                    }
+                } else {
+                    Logger.build("Webapp already up to date, skipping extraction");
+                }
             }
 
-            const webInfClassesDir = path.join(appWebappPath, "WEB-INF", "classes");
-            if (!fs.existsSync(webInfClassesDir)) fs.mkdirSync(webInfClassesDir, { recursive: true });
-            
-            const xavvaProps = path.join(process.cwd(), ".xavva", "hotswap-agent.properties");
-            if (fs.existsSync(xavvaProps)) {
-                fs.copyFileSync(xavvaProps, path.join(webInfClassesDir, "hotswap-agent.properties"));
-            }
+            this.injectHotswapProperties(appWebappPath);
 
             const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
             
             tomcat.onReady = async () => {
-                try {
-                    await new Promise(r => setTimeout(r, 1500));
-                    const response = await fetch(finalAppUrl);
-                    if (response.status < 500) {
-                        const memory = await tomcat.getMemoryUsage();
-                        Logger.health(finalAppUrl, "success");
-                        Logger.health(`Status ${response.status}`, "success");
-                        Logger.health(`Memory ${memory}`, "success");
-
-                        if (!config.project.quiet) {
-                            const endpoints = EndpointService.scan(path.join(process.cwd(), "src"), finalContextPath);
-                            if (endpoints.length > 0) {
-                                Logger.newline();
-                                Logger.log(`${Logger.C.cyan}◈ ENDPOINT MAP:${Logger.C.reset}`);
-                                endpoints.forEach(e => Logger.log(`${Logger.C.dim}➜ ${Logger.C.reset}http://localhost:${config.tomcat.port}${e.fullPath}`));
-                            }
-                        }
-                        
-                        if (incremental) {
-                            await this.reloadBrowser(finalAppUrl);
-                        } else {
-                            if (process.platform === 'win32') {
-                                Bun.spawn(["cmd", "/c", "start", finalAppUrl]);
-                            } else {
-                                const start = process.platform === 'darwin' ? 'open' : 'xdg-open';
-                                Bun.spawn([start, finalAppUrl]);
-                            }
-                        }
-                    } else {
-                        Logger.health(`App returned status ${response.status}`, "warn");
-                    }
-                } catch (e) {
-                    Logger.health(`Could not connect to ${finalAppUrl}`, "error");
-                }
+                await this.handleServerReady(config, finalAppUrl, finalContextPath, tomcat, incremental);
             };
 
             tomcat.start(config, isWatching);
@@ -161,9 +105,98 @@ export class DeployCommand implements Command {
         }
     }
 
+    private logConfiguration(config: AppConfig, isWatching: boolean) {
+        Logger.config("Runtime", config.project.buildTool.toUpperCase());
+        Logger.config("Watch Mode", isWatching ? "ON" : "OFF");
+        Logger.config("Debug", config.project.debug ? `ON (Port ${config.project.debugPort})` : "OFF");
+
+        let javaBin = "java";
+        if (process.env.JAVA_HOME) {
+            const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
+            if (fs.existsSync(homeBin)) javaBin = homeBin;
+        }
+        
+        const javaVer = Bun.spawnSync([javaBin, "-version"]);
+        const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
+        const hasDcevm = ["dcevm", "jetbrains", "trava", "jbr"].some(v => output.includes(v));
+        
+        if (!hasDcevm && isWatching) {
+            Logger.config("Hot Reload", "Standard (No structural changes)");
+        } else if (hasDcevm) {
+            Logger.config("Hot Reload", "Advanced (DCEVM Active)");
+        }
+
+        const srcPath = path.join(process.cwd(), "src");
+        if (fs.existsSync(srcPath)) {
+            const contextPath = (config.project.appName || "").replace(".war", "");
+            const endpoints = EndpointService.scan(srcPath, contextPath);
+            if (endpoints.length > 0) {
+                Logger.config("Endpoints", endpoints.length);
+            }
+        }
+    }
+
+    private injectHotswapProperties(appWebappPath: string) {
+        const webInfClassesDir = path.join(appWebappPath, "WEB-INF", "classes");
+        if (!fs.existsSync(webInfClassesDir)) fs.mkdirSync(webInfClassesDir, { recursive: true });
+        
+        const xavvaProps = path.join(process.cwd(), ".xavva", "hotswap-agent.properties");
+        if (fs.existsSync(xavvaProps)) {
+            fs.copyFileSync(xavvaProps, path.join(webInfClassesDir, "hotswap-agent.properties"));
+        }
+    }
+
+    private async handleServerReady(config: AppConfig, url: string, context: string, tomcat: TomcatService, incremental: boolean) {
+        try {
+            await new Promise(r => setTimeout(r, 1500));
+            const response = await fetch(url);
+            if (response.status < 500) {
+                const memory = await tomcat.getMemoryUsage();
+                Logger.health(url, "success");
+                Logger.health(`Status ${response.status}`, "success");
+                Logger.health(`Memory ${memory}`, "success");
+
+                if (!config.project.quiet) {
+                    this.showEndpointMap(config.tomcat.port, context);
+                }
+                
+                if (incremental) {
+                    await BrowserService.reload(url);
+                } else {
+                    BrowserService.open(url);
+                }
+            } else {
+                Logger.health(`App returned status ${response.status}`, "warn");
+            }
+        } catch (e) {
+            Logger.health(`Could not connect to ${url}`, "error");
+        }
+    }
+
+    private showEndpointMap(port: number, context: string) {
+        const endpoints = EndpointService.scan(path.join(process.cwd(), "src"), context);
+        if (endpoints.length > 0) {
+            Logger.newline();
+            Logger.log(`${Logger.C.cyan}◈ ENDPOINT MAP:${Logger.C.reset}`);
+            
+            const apis = endpoints.filter(e => e.className !== "JSP");
+            const jsps = endpoints.filter(e => e.className === "JSP");
+
+            if (apis.length > 0) {
+                const uniqueApiUrls = [...new Set(apis.map(e => `http://localhost:${port}${e.fullPath}`))];
+                uniqueApiUrls.forEach(url => Logger.log(`${Logger.C.dim}➜ ${Logger.C.reset}${url}`));
+            }
+
+            if (jsps.length > 0) {
+                Logger.log(`${Logger.C.dim}--- JSPs ---${Logger.C.reset}`);
+                const uniqueJspUrls = [...new Set(jsps.map(e => `http://localhost:${port}${e.fullPath}`))];
+                uniqueJspUrls.forEach(url => Logger.log(`${Logger.C.dim}📄 ${Logger.C.reset}${url}`));
+            }
+        }
+    }
+
     async syncResource(config: AppConfig, filename: string): Promise<void> {
         const contextPath = (config.project.appName || "").replace(".war", "");
-        
         const webappsPath = path.join(config.tomcat.path, "webapps");
         let appFolder = contextPath;
         
@@ -174,10 +207,7 @@ export class DeployCommand implements Command {
         }
 
         const explodedPath = path.join(webappsPath, appFolder);
-        
-        if (!appFolder || !fs.existsSync(explodedPath)) {
-            return;
-        }
+        if (!appFolder || !fs.existsSync(explodedPath)) return;
 
         const parts = filename.split(/[/\\]/);
         const webappIndex = parts.indexOf("webapp");
@@ -196,7 +226,7 @@ export class DeployCommand implements Command {
                 if (!config.project.quiet) Logger.success(`Synced ${path.basename(filename)} directly to Tomcat!`);
                 
                 const appUrl = `http://localhost:${config.tomcat.port}/${appFolder}`;
-                await this.reloadBrowser(appUrl);
+                await BrowserService.reload(appUrl);
             } catch (e) {
                 Logger.error(`Failed to sync resource: ${filename}`);
             }