@archznn/xavva 1.6.5 → 1.7.0

package/src/commands/DoctorCommand.ts

@@ -5,85 +5,248 @@ import fs from "fs";
 import path from "path";
 
 export class DoctorCommand implements Command {
-    async execute(config: AppConfig, values: any = {}): Promise<void> {
-        Logger.section("Xavva Doctor - Ambiente");
+	async execute(config: AppConfig, values: any = {}): Promise<void> {
+		Logger.section("Xavva Doctor - Ambiente");
 
-        this.check("JAVA_HOME", !!process.env.JAVA_HOME, process.env.JAVA_HOME || "Não definido");
-        
-        const tomcatOk = fs.existsSync(config.tomcat.path);
-        this.check("Tomcat Path", tomcatOk, config.tomcat.path);
-        
-        if (tomcatOk) {
-            const binOk = fs.existsSync(path.join(config.tomcat.path, "bin", "catalina.bat"));
-            this.check("Tomcat Bin", binOk, binOk ? "OK" : "catalina.bat não encontrado");
-        }
+		this.check(
+			"JAVA_HOME",
+			!!process.env.JAVA_HOME,
+			process.env.JAVA_HOME || "Não definido",
+		);
 
-        const mvnOk = this.checkBinary("mvn");
-        this.check("Maven", mvnOk, mvnOk ? "Disponível" : "Não encontrado no PATH");
+		const jvmInfo = this.checkJVM();
+		this.check(
+			"JVM Type",
+			jvmInfo.dcevm,
+			jvmInfo.name +
+			(jvmInfo.dcevm ? " (Advanced Hot Reload OK)" : " (Standard)"),
+		);
 
-        const gradleOk = this.checkBinary("gradle") || this.checkBinary("gradlew");
-        this.check("Gradle", gradleOk, gradleOk ? "Disponível" : "Não encontrado no PATH");
+		if (!jvmInfo.dcevm) {
+			Logger.log(
+				`    ${Logger.C.yellow}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
+			);
+			if (values.fix) {
+				await this.installDCEVM();
+			} else {
+				Logger.log(
+					`    ${Logger.C.cyan}Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.${Logger.C.reset}`,
+				);
+			}
+		}
 
-        const gitOk = this.checkBinary("git");
-        this.check("Git", gitOk, gitOk ? "Disponível" : "Não encontrado no PATH");
+		const tomcatOk = fs.existsSync(config.tomcat.path);
+		this.check("Tomcat Path", tomcatOk, config.tomcat.path);
 
-        Logger.section("Xavva Doctor - Integridade de Arquivos");
-        await this.checkBOM(values.fix);
+		if (tomcatOk) {
+			const binOk = fs.existsSync(
+				path.join(config.tomcat.path, "bin", "catalina.bat"),
+			);
+			this.check(
+				"Tomcat Bin",
+				binOk,
+				binOk ? "OK" : "catalina.bat não encontrado",
+			);
+		}
 
-        console.log("");
-    }
+		const mvnOk = this.checkBinary("mvn");
+		this.check("Maven", mvnOk, mvnOk ? "Disponível" : "Não encontrado no PATH");
 
-    private async checkBOM(fix: boolean) {
-        const srcPath = path.join(process.cwd(), "src");
-        if (!fs.existsSync(srcPath)) return;
-
-        const filesWithBOM: string[] = [];
-        const scan = (dir: string) => {
-            const list = fs.readdirSync(dir, { withFileTypes: true });
-            for (const item of list) {
-                const res = path.resolve(dir, item.name);
-                if (item.isDirectory()) {
-                    scan(res);
-                } else if (item.name.endsWith(".java")) {
-                    const buffer = fs.readFileSync(res);
-                    if (buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
-                        filesWithBOM.push(res);
-                    }
-                }
-            }
-        };
-
-        scan(srcPath);
-
-        if (filesWithBOM.length > 0) {
-            this.check("Encoding BOM", false, `${filesWithBOM.length} arquivos com BOM (UTF-8 com assinatura)`);
-            if (fix) {
-                for (const file of filesWithBOM) {
-                    const buffer = fs.readFileSync(file);
-                    const cleanBuffer = buffer.subarray(3);
-                    fs.writeFileSync(file, cleanBuffer);
-                    console.log(`    \x1b[32m✔\x1b[0m Corrigido: ${path.basename(file)}`);
-                }
-                Logger.success("BOM removido de todos os arquivos!");
-            } else {
-                Logger.warn("Use 'xavva doctor --fix' para remover o BOM automaticamente.");
-            }
-        } else {
-            this.check("Encoding BOM", true, "Nenhum arquivo com BOM detectado.");
-        }
-    }
+		const gradleOk = this.checkBinary("gradle") || this.checkBinary("gradlew");
+		this.check(
+			"Gradle",
+			gradleOk,
+			gradleOk ? "Disponível" : "Não encontrado no PATH",
+		);
 
-    private check(label: string, ok: boolean, detail: string) {
-        const icon = ok ? "\x1b[32m✔\x1b[0m" : "\x1b[31m✘\x1b[0m";
-        console.log(`  ${icon} ${label.padEnd(15)} ${detail}`);
-    }
+		const gitOk = this.checkBinary("git");
+		this.check("Git", gitOk, gitOk ? "Disponível" : "Não encontrado no PATH");
+
+		Logger.section("Xavva Doctor - Integridade de Arquivos");
+		await this.checkBOM(values.fix);
+
+		console.log("");
+	}
+
+	private async checkBOM(fix: boolean) {
+		const srcPath = path.join(process.cwd(), "src");
+		if (!fs.existsSync(srcPath)) return;
+
+		const filesWithBOM: string[] = [];
+		const scan = (dir: string) => {
+			const list = fs.readdirSync(dir, { withFileTypes: true });
+			for (const item of list) {
+				const res = path.resolve(dir, item.name);
+				if (item.isDirectory()) {
+					scan(res);
+				} else if (item.name.endsWith(".java")) {
+					const buffer = fs.readFileSync(res);
+					if (buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+						filesWithBOM.push(res);
+					}
+				}
+			}
+		};
 
-    private checkBinary(name: string): boolean {
+		scan(srcPath);
+
+		if (filesWithBOM.length > 0) {
+			this.check(
+				"Encoding BOM",
+				false,
+				`${filesWithBOM.length} arquivos com BOM (UTF-8 com assinatura)`,
+			);
+			if (fix) {
+				for (const file of filesWithBOM) {
+					const buffer = fs.readFileSync(file);
+					const cleanBuffer = buffer.subarray(3);
+					fs.writeFileSync(file, cleanBuffer);
+					console.log(
+						`    \x1b[32m✔\x1b[0m Corrigido: ${path.basename(file)}`,
+					);
+				}
+				Logger.success("BOM removido de todos os arquivos!");
+			} else {
+				Logger.warn(
+					"Use 'xavva doctor --fix' para remover o BOM automaticamente.",
+				);
+			}
+		} else {
+			this.check("Encoding BOM", true, "Nenhum arquivo com BOM detectado.");
+		}
+	}
+
+	private check(label: string, ok: boolean, detail: string) {
+		const icon = ok ? "\x1b[32m✔\x1b[0m" : "\x1b[31m✘\x1b[0m";
+		console.log(`  ${icon} ${label.padEnd(15)} ${detail}`);
+	}
+
+	private checkBinary(name: string): boolean {
+		try {
+			const proc = Bun.spawnSync([
+				process.platform === "win32" ? "where" : "which",
+				name,
+			]);
+			return proc.exitCode === 0;
+		} catch {
+			return false;
+		}
+	}
+
+    private checkJVM(): { name: string, dcevm: boolean } {
         try {
-            const proc = Bun.spawnSync([process.platform === 'win32' ? "where" : "which", name]);
-            return proc.exitCode === 0;
+            // Tentar primeiro o binário do JAVA_HOME para evitar cache do Path
+            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 proc = Bun.spawnSync([javaBin, "-version"]);
+            const output = (proc.stderr.toString() + proc.stdout.toString()).toLowerCase();
+            const isDcevm = output.includes("dcevm") || 
+                            output.includes("jetbrains") || 
+                            output.includes("trava") || 
+                            output.includes("jbr");
+            
+            const versionMatch = output.match(/version "(.*?)"/);
+            return {
+                name: versionMatch ? `Java ${versionMatch[1]}` : "Java Desconhecido",
+                dcevm: isDcevm
+            };
         } catch {
-            return false;
+            return { name: "Não encontrada", dcevm: false };
         }
     }
+
+    private async installDCEVM() {
+        Logger.section("Instalação do JetBrains Runtime (JBR 21)");
+        Logger.log("Baixando JDK moderna com DCEVM nativo (JBR 21 SDK)...");
+        
+        // URL para o JetBrains Runtime 21 SDK Windows x64
+        const url = "https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-21.0.6-windows-x64-b895.97.tar.gz";
+        const installDir = path.join(require("os").homedir(), ".xavva", "jdk-dcevm");
+        
+        // Limpar instalação anterior se existir
+        if (fs.existsSync(installDir)) {
+            try {
+                fs.rmSync(installDir, { recursive: true, force: true });
+            } catch (e) {}
+        }
+        fs.mkdirSync(installDir, { recursive: true });
+
+        try {
+            const response = await fetch(url);
+            if (!response.ok) throw new Error("Erro ao baixar JBR (verifique sua conexão)");
+            const buffer = await response.arrayBuffer();
+            const tarPath = path.join(installDir, "jbr.tar.gz");
+            fs.writeFileSync(tarPath, Buffer.from(buffer));
+            
+            Logger.success("Download concluído. Extraindo binários...");
+            
+            // Usar PowerShell para extrair .tar.gz (nativo no Windows 10/11)
+            const extractCmd = `powershell -command "tar -xzf '${tarPath}' -C '${installDir}'"`;
+            Bun.spawnSync(["powershell", "-command", extractCmd]);
+            
+            fs.rmSync(tarPath);
+
+            // Busca recursiva para encontrar onde está o bin/java.exe
+            const findJdkRoot = (dir: string): string | null => {
+                if (fs.existsSync(path.join(dir, "bin", "java.exe"))) return dir;
+                const subdirs = fs.readdirSync(dir, { withFileTypes: true })
+                    .filter(d => d.isDirectory())
+                    .map(d => path.join(dir, d.name));
+                for (const subdir of subdirs) {
+                    const found = findJdkRoot(subdir);
+                    if (found) return found;
+                }
+                return null;
+            };
+
+            const jdkPath = findJdkRoot(installDir) || installDir;
+			            
+			                                    Logger.process("Configurando variáveis de ambiente do SISTEMA...");
+			                        
+			                                                const setEnvCmd = `
+			                                                    $jdk = '${jdkPath}';
+			                                                    $bin = '${path.join(jdkPath, "bin")}';
+			                                                    try {
+			                                                        [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
+			                                                        $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
+			                                                        $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
+			                                                        $normalizedBin = $bin.TrimEnd('\\').ToLower();
+			                                                        
+			                                                        $exists = $false;
+			                                                        foreach ($p in $paths) {
+			                                                            if ($p.TrimEnd('\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
+			                                                        }
+			                                    
+			                                                        if (-not $exists) {
+			                                                            $newPath = "$bin;" + $pathVar;
+			                                                            [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
+			                                                        }
+			                                                        Write-Output "OK";
+			                                                    } catch {
+			                                                        Write-Error $_.Exception.Message;
+			                                                    }
+			                                                `.replace(/\n/g, ' ');
+			                                    			                                    const result = Bun.spawnSync(["powershell", "-command", setEnvCmd]);
+			                                    const output = result.stdout.toString() + result.stderr.toString();
+			                        
+			                                    if (output.includes("ACCESS_DENIED")) {
+			                                        Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
+			                                        Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
+			                                        Logger.info("JAVA_HOME manual", jdkPath);
+			                                    } else {
+			                                        Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
+			                                        Logger.info("JAVA_HOME", jdkPath);
+			                                    }
+			                        
+			                                    Logger.newline();
+			                                    Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
+			                                } catch (e: any) {
+			                        
+			            			Logger.error(`Falha na instalação: ${e.message}`);
+		}
+	}
 }

package/src/commands/RunCommand.ts

@@ -49,7 +49,8 @@ export class RunCommand implements Command {
 
         if (this.debug) {
             Logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
-            Logger.log(`${"\x1b[36m"}Dica:${"\x1b[0m"} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.\n`);
+            Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
+            Logger.newline();
         } else {
             Logger.warn(`🚀 Executando ${className}...`);
         }
@@ -140,7 +141,7 @@ export class RunCommand implements Command {
         });
 
         return new Promise((resolve) => {
-            readline.question(`\n  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
+            readline.question(`  Escolha a classe (1-${uniqueClasses.length}) ou [C]ancelar: `, (answer: string) => {
                 readline.close();
                 const idx = parseInt(answer) - 1;
                 if (!isNaN(idx) && uniqueClasses[idx]) {
@@ -175,7 +176,7 @@ export class RunCommand implements Command {
             });
 
             return new Promise((resolve) => {
-                readline.question(`\n  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
+                readline.question(`  Escolha a classe (1-${Math.min(history.length, 5)}) ou [C]ancelar: `, (answer: string) => {
                     readline.close();
                     if (!answer.trim()) {
                         resolve(history[0]);

package/src/commands/StartCommand.ts

@@ -15,7 +15,7 @@ export class StartCommand implements Command {
             Logger.step("Checking ports");
             await tomcat.killConflict();
             Logger.step("Starting Tomcat");
-            tomcat.start(config.project.cleanLogs, config.project.debug, config.project.skipScan, config.project.quiet);
+            tomcat.start(config, false);
             
             await new Promise(() => {}); 
         } catch (error: any) {

package/src/index.ts

@@ -20,7 +20,7 @@ async function main() {
 	const { config, positionals, values } = await ConfigManager.load();
 
 	if (values.version) {
-		console.log(`v${pkg.version}`);
+		Logger.log(`v${pkg.version}`);
 		process.exit(0);
 	}
 
@@ -66,7 +66,7 @@ async function main() {
 			await handleDeploy(config, values);
 			break;
 		default:
-			console.error(`Comando desconhecido: ${commandName}`);
+			Logger.error(`Comando desconhecido: ${commandName}`);
 			new HelpCommand().execute(config);
 			process.exit(1);
 	}
@@ -93,9 +93,15 @@ async function handleDeploy(config: any, values: any) {
 		await run(false);
 
 		let debounceTimer: Timer;
+		const coolingFiles = new Set<string>();
+
 		watch(process.cwd(), { recursive: true }, async (event, filename) => {
 			if (!filename) return;
 
+			if (coolingFiles.has(filename)) return;
+			coolingFiles.add(filename);
+			setTimeout(() => coolingFiles.delete(filename), 500);
+
 			const isJava = filename.endsWith(".java") || filename === "pom.xml" || filename === "build.gradle";
 			const isResource = filename.endsWith(".jsp") || filename.endsWith(".html") || 
 							   filename.endsWith(".css") || filename.endsWith(".js") || 
@@ -116,21 +122,34 @@ async function handleDeploy(config: any, values: any) {
 				if (isJsp) {
 					const parts = filename.split(/[/\\]/);
 					const webappIndex = parts.indexOf("webapp");
-					if (webappIndex !== -1) {
-						const relPath = parts.slice(webappIndex + 1).join("/");
+					const webContentIndex = parts.indexOf("WebContent");
+					const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+
+					if (rootIndex !== -1) {
+						const relPath = parts.slice(rootIndex + 1).join("/");
 						isPrivate = relPath.startsWith("WEB-INF") || relPath.startsWith("META-INF");
-						const contextPath = (config.project.appName || "").replace(".war", "");
+						
+						let contextPath = (config.project.appName || "").replace(".war", "");
+						if (!contextPath) {
+							const webappsPath = require("path").join(config.tomcat.path, "webapps");
+							if (require("fs").existsSync(webappsPath)) {
+								const folders = require("fs").readdirSync(webappsPath, { withFileTypes: true })
+									.filter((dirent: any) => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs"].includes(dirent.name));
+								if (folders.length === 1) contextPath = folders[0].name;
+							}
+						}
+
 						jspUrl = `http://localhost:${config.tomcat.port}${contextPath ? "/" + contextPath : ""}/${relPath}`;
 					}
 				}
 
 				if (isJsp && isPrivate) {
-					console.log(`\n  ${"\x1b[33m"}🔒${"\x1b[0m"} JSP Privado alterado (WEB-INF): ${filename}`);
-					console.log(`     ${"\x1b[90m"}Nota: Este arquivo não é acessível via URL direta.${"\x1b[0m"}`);
+					Logger.watcher(`JSP Private (WEB-INF): ${filename}`, 'change');
+					Logger.dim(`Nota: Este arquivo não é acessível via URL direta.`);
 				} else if (isJsp && jspUrl) {
-					console.log(`\n  ${"\x1b[32m"}📄${"\x1b[0m"} JSP Atualizado: ${"\x1b[4m"}${jspUrl}${"\x1b[0m"}`);
+					Logger.watcher(`JSP Updated: ${jspUrl}`, 'success');
 				} else {
-					console.log(`\n  ${"\x1b[35m"}⚡${"\x1b[0m"} Recurso alterado: ${filename}`);
+					Logger.watcher(`Resource altered: ${filename}`, 'change');
 				}
 
 				await deployCmd.syncResource(config, filename);
@@ -139,7 +158,7 @@ async function handleDeploy(config: any, values: any) {
 
 			if (!isJava) return;
 
-			console.log(`\n  ${"\x1b[33m"}👀${"\x1b[0m"} Alteração detectada em: ${filename}`);
+			Logger.watcher(filename, 'watch');
 			clearTimeout(debounceTimer);
 			
 			debounceTimer = setTimeout(() => {

package/src/services/AuditService.ts

@@ -34,7 +34,6 @@ export class AuditService {
 
         const stopSpinner = Logger.spinner(`Auditando ${jars.length} dependências`);
 
-        // Process in chunks to avoid overwhelming the API
         const chunkSize = 10;
         for (let i = 0; i < jars.length; i += chunkSize) {
             const chunk = jars.slice(i, i + chunkSize);
@@ -52,7 +51,6 @@ export class AuditService {
         const info = await this.extractJarInfo(jarPath);
         
         if (!info.artifactId || !info.version) {
-            // Fallback to filename parsing if pom.properties is missing
             const match = jarName.match(/(.+)-([\d\.]+.*)\.jar/);
             if (match) {
                 info.artifactId = info.artifactId || match[1];
@@ -70,8 +68,6 @@ export class AuditService {
     }
 
     private async extractJarInfo(jarPath: string): Promise<{ groupId?: string, artifactId?: string, version?: string }> {
-        // We use PowerShell to quickly peek inside the JAR for pom.properties
-        // This is faster than extracting the whole JAR
         const normalizedPath = jarPath.split(path.sep).join("/");
         const psCommand = `
             Add-Type -AssemblyName System.IO.Compression.FileSystem
@@ -137,7 +133,6 @@ export class AuditService {
     private extractSeverity(vuln: any): string {
         if (vuln.database_specific?.severity) return vuln.database_specific.severity;
         if (vuln.advisories?.[0]?.url?.includes("github.com/advisories")) {
-            // Try to infer from details if common keywords exist
             const d = (vuln.details || "").toLowerCase();
             if (d.includes("critical")) return "CRITICAL";
             if (d.includes("high")) return "HIGH";

package/src/services/BuildService.ts

@@ -51,7 +51,7 @@ export class BuildService {
 		if (proc.exitCode !== 0) {
             if (!this.projectConfig.verbose) {
                 const err = await new Response(proc.stderr).text();
-                console.log(err);
+                Logger.log(err);
             }
             Logger.error(`${this.projectConfig.buildTool.toUpperCase()} build failed!`);
             throw new Error("Falha no build do Java!");
@@ -79,7 +79,7 @@ export class BuildService {
 					errorCount++;
 					if (errorCount > maxErrors && !this.projectConfig.verbose) {
 						if (errorCount === maxErrors + 1) {
-							console.log(`\n  ${"\x1b[31m"}... e mais erros ocultos. Use -V para ver todos.${"\x1b[0m"}`);
+							Logger.warn("... e mais erros ocultos. Use -V para ver todos.");
 						}
 						continue;
 					}
@@ -92,7 +92,7 @@ export class BuildService {
 				}
 
 				const summarized = Logger.summarize(cleanLine);
-				if (summarized) console.log(summarized);
+				if (summarized) Logger.log(summarized);
 			}
 		}
 	}
@@ -105,7 +105,7 @@ export class BuildService {
 
 		if (!appFolder && fs.existsSync(webappsPath)) {
 			const folders = fs.readdirSync(webappsPath, { withFileTypes: true })
-				.filter((dirent: any) => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs"].includes(dirent.name));
+				.filter((dirent: any) => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs", "examples"].includes(dirent.name));
 			
 			if (folders.length === 1) {
 				appFolder = folders[0].name;
@@ -124,7 +124,6 @@ export class BuildService {
 		if (!fs.existsSync(sourceDir)) return null;
 		
 		if (!appFolder || !fs.existsSync(destDir)) {
-			Logger.warn("Pasta descompactada no Tomcat não encontrada. Hot Swap impossível.");
 			return null;
 		}
 
@@ -145,11 +144,10 @@ export class BuildService {
 		};
 
 		copyDir(sourceDir, destDir);
-		Logger.success("Classes swapped in running Tomcat");
 		return appFolder;
 	}
 
-	async deployToWebapps(): Promise<string> {
+	async deployToWebapps(): Promise<{ path: string, finalName: string }> {
 		const destDir = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
 		
 		Logger.step("Searching for generated artifacts");
@@ -187,12 +185,10 @@ export class BuildService {
 			Logger.info("Artifact", warFile.name);
 			if (this.projectConfig.appName) Logger.info("Deploy as", finalName);
 		} else {
-			const displayName = this.projectConfig.appName ? `${this.projectConfig.appName}` : warFile.name.replace(".war", "");
-			process.stdout.write(`  ${"\x1b[90m"}➜${"\x1b[0m"} Deploying ${"\x1b[1m"}${displayName}${"\x1b[0m"}...\n`);
+			Logger.process(`Deploying ${this.projectConfig.appName ? this.projectConfig.appName : warFile.name.replace(".war", "")}...`);
 		}
 		
-		copyFileSync(warFile.path, path.join(destDir, finalName));
 		this.inferredAppName = finalName.replace(".war", "");
-		return finalName;
+		return { path: warFile.path, finalName };
 	}
 }

package/src/services/EndpointService.ts

@@ -33,11 +33,9 @@ export class EndpointService {
         const endpoints: ApiEndpoint[] = [];
         const className = fileName.replace(".java", "");
 
-        // Find class-level mapping
         const classPathMatch = content.match(/@(Path|RequestMapping)\s*\(\s*["'](.*?)["']\s*\)/);
         const basePath = classPathMatch ? this.normalizePath(classPathMatch[2]) : "";
 
-        // Common mapping annotations
         const methodRegex = /@(GET|POST|PUT|DELETE|PATCH|Path|RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)\s*(\(\s*["'](.*?)["']\s*\))?\s*([\s\S]*?)\s+([a-zA-Z0-9_]+)\s*\(([\s\S]*?)\)/g;
         
         let match;
@@ -98,7 +96,6 @@ export class EndpointService {
         for (const p of individualParams) {
             const trimmed = p.trim();
             
-            // Check for annotations
             const pathParam = trimmed.match(/@PathParam\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);
             const pathVariable = trimmed.match(/@PathVariable\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);
             const queryParam = trimmed.match(/@QueryParam\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);