@archznn/xavva 1.6.5

package/src/services/AuditService.ts

@@ -0,0 +1,148 @@
+import fs from "fs";
+import path from "path";
+import type { TomcatConfig } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export interface Vulnerability {
+    id: string;
+    summary: string;
+    details: string;
+    severity: string;
+    fixedIn?: string;
+}
+
+export interface JarAuditResult {
+    jarName: string;
+    groupId?: string;
+    artifactId?: string;
+    version?: string;
+    vulnerabilities: Vulnerability[];
+}
+
+export class AuditService {
+    constructor(private tomcatConfig: TomcatConfig) {}
+
+    async runAudit(appName: string): Promise<JarAuditResult[]> {
+        const libPath = path.join(this.tomcatConfig.path, "webapps", appName, "WEB-INF", "lib");
+        
+        if (!fs.existsSync(libPath)) {
+            throw new Error(`Pasta lib não encontrada em: ${libPath}. Faça o deploy da aplicação primeiro.`);
+        }
+
+        const jars = fs.readdirSync(libPath).filter(f => f.endsWith(".jar"));
+        const results: JarAuditResult[] = [];
+
+        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);
+            const chunkPromises = chunk.map(jar => this.auditJar(path.join(libPath, jar)));
+            const chunkResults = await Promise.all(chunkPromises);
+            results.push(...chunkResults);
+        }
+
+        stopSpinner();
+        return results;
+    }
+
+    private async auditJar(jarPath: string): Promise<JarAuditResult> {
+        const jarName = path.basename(jarPath);
+        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];
+                info.version = info.version || match[2];
+            }
+        }
+
+        const vulnerabilities = await this.checkVulnerabilities(info.groupId, info.artifactId, info.version);
+
+        return {
+            jarName,
+            ...info,
+            vulnerabilities
+        };
+    }
+
+    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
+            $zip = [System.IO.Compression.ZipFile]::OpenRead("${normalizedPath}")
+            $entry = $zip.Entries | Where-Object { $_.FullName -match "pom.properties$" } | Select-Object -First 1
+            if ($entry) {
+                $stream = $entry.Open()
+                $reader = New-Object System.IO.StreamReader($stream)
+                $content = $reader.ReadToEnd()
+                $reader.Close()
+                $stream.Close()
+                $content
+            }
+            $zip.Dispose()
+        `;
+
+        try {
+            const proc = Bun.spawn(["powershell", "-command", psCommand]);
+            const output = await new Response(proc.stdout).text();
+            
+            const groupId = output.match(/groupId=(.*)/)?.[1]?.trim();
+            const artifactId = output.match(/artifactId=(.*)/)?.[1]?.trim();
+            const version = output.match(/version=(.*)/)?.[1]?.trim();
+
+            return { groupId, artifactId, version };
+        } catch (e) {
+            return {};
+        }
+    }
+
+    private async checkVulnerabilities(groupId?: string, artifactId?: string, version?: string): Promise<Vulnerability[]> {
+        if (!artifactId || !version) return [];
+
+        const name = groupId ? `${groupId}:${artifactId}` : artifactId;
+        
+        try {
+            const response = await fetch("https://api.osv.dev/v1/query", {
+                method: "POST",
+                body: JSON.stringify({
+                    version: version,
+                    package: {
+                        name: name,
+                        ecosystem: "Maven"
+                    }
+                })
+            });
+
+            const data = await response.json();
+            if (!data.vulns) return [];
+
+            return data.vulns.map((v: any) => ({
+                id: v.id,
+                summary: v.summary || v.details?.substring(0, 100) + "...",
+                details: v.details,
+                severity: this.extractSeverity(v),
+                fixedIn: v.affected?.[0]?.ranges?.[0]?.events?.find((e: any) => e.fixed)?.fixed
+            }));
+        } catch (e) {
+            return [];
+        }
+    }
+
+    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";
+            if (d.includes("moderate") || d.includes("medium")) return "MEDIUM";
+        }
+        return "UNKNOWN";
+    }
+}

package/src/services/BuildService.ts

@@ -0,0 +1,198 @@
+import { readdirSync, copyFileSync, existsSync, statSync, mkdirSync } from "fs";
+import path from "path";
+import type { ProjectConfig, TomcatConfig } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export class BuildService {
+	private inferredAppName: string | null = null;
+
+	constructor(private projectConfig: ProjectConfig, private tomcatConfig: TomcatConfig) { }
+
+	async runBuild(incremental = false) {
+		const command = [];
+		
+		if (this.projectConfig.buildTool === 'maven') {
+			command.push("mvn");
+			if (incremental) {
+				command.push("compile");
+			} else {
+				command.push("clean", "package");
+			}
+			command.push("-DskipTests");
+			if (this.projectConfig.profile) command.push(`-P${this.projectConfig.profile}`);
+		} else {
+			command.push("gradle");
+			if (incremental) {
+				command.push("classes");
+			} else {
+				command.push("clean", "build");
+			}
+			command.push("-x", "test");
+			if (this.projectConfig.profile) command.push(`-Pprofile=${this.projectConfig.profile}`);
+		}
+
+		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
+
+		const proc = Bun.spawn(command, { 
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+
+		if (this.projectConfig.verbose) {
+			await Promise.all([
+				this.processBuildLogs(proc.stdout, false),
+				this.processBuildLogs(proc.stderr, false)
+			]);
+		}
+
+		await proc.exited;
+		stopSpinner();
+
+		if (proc.exitCode !== 0) {
+            if (!this.projectConfig.verbose) {
+                const err = await new Response(proc.stderr).text();
+                console.log(err);
+            }
+            Logger.error(`${this.projectConfig.buildTool.toUpperCase()} build failed!`);
+            throw new Error("Falha no build do Java!");
+        }
+	}
+
+	private async processBuildLogs(stream: ReadableStream, quiet: boolean) {
+		const reader = stream.getReader();
+		const decoder = new TextDecoder();
+		let errorCount = 0;
+		const maxErrors = 15;
+
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+
+			const chunk = decoder.decode(value);
+			const lines = chunk.split(/[\r\n]+/);
+
+			for (const line of lines) {
+				const cleanLine = line.trim();
+				if (!cleanLine) continue;
+
+				if (cleanLine.includes("[ERROR]")) {
+					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"}`);
+						}
+						continue;
+					}
+				}
+
+				if (quiet) {
+					if (!Logger.isEssential(cleanLine)) continue;
+				} else if (Logger.isSystemNoise(cleanLine)) {
+					continue;
+				}
+
+				const summarized = Logger.summarize(cleanLine);
+				if (summarized) console.log(summarized);
+			}
+		}
+	}
+
+	async syncClasses(): Promise<string | null> {
+		const fs = require("fs");
+		let appFolder = this.projectConfig.appName || this.inferredAppName || "";
+
+		const webappsPath = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
+
+		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));
+			
+			if (folders.length === 1) {
+				appFolder = folders[0].name;
+			} else if (folders.length > 1) {
+				const sorted = folders.map((f: any) => ({
+					name: f.name,
+					time: fs.statSync(path.join(webappsPath, f.name)).mtimeMs
+				})).sort((a: any, b: any) => b.time - a.time);
+				appFolder = sorted[0].name;
+			}
+		}
+
+		const sourceDir = this.projectConfig.buildTool === 'maven' ? 'target/classes' : 'build/classes/java/main';
+		const destDir = path.join(webappsPath, appFolder, "WEB-INF", "classes");
+
+		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;
+		}
+
+		const copyDir = (src: string, dest: string) => {
+			if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+			const list = fs.readdirSync(src, { withFileTypes: true });
+			for (const item of list) {
+				const s = path.join(src, item.name);
+				const d = path.join(dest, item.name);
+				if (item.isDirectory()) {
+					copyDir(s, d);
+				} else {
+					if (!fs.existsSync(d) || fs.statSync(s).mtimeMs > fs.statSync(d).mtimeMs) {
+						fs.copyFileSync(s, d);
+					}
+				}
+			}
+		};
+
+		copyDir(sourceDir, destDir);
+		Logger.success("Classes swapped in running Tomcat");
+		return appFolder;
+	}
+
+	async deployToWebapps(): Promise<string> {
+		const destDir = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
+		
+		Logger.step("Searching for generated artifacts");
+		
+		const findWars = (dir: string): string[] => {
+			let results: string[] = [];
+			const list = readdirSync(dir, { withFileTypes: true });
+			for (const item of list) {
+				const res = path.resolve(dir, item.name);
+				if (item.isDirectory()) {
+					if (item.name === 'target' || item.name === 'build') {
+						results = results.concat(findWars(res));
+					} else if (!['node_modules', '.git', 'src', 'webapps', 'bin', 'conf', 'lib', 'logs', 'temp', 'work'].includes(item.name)) {
+						results = results.concat(findWars(res));
+					}
+				} else if (item.name.endsWith('.war')) {
+					results.push(res);
+				}
+			}
+			return results;
+		};
+
+		const allWars = findWars(process.cwd())
+			.map(f => ({ path: f, name: path.basename(f), time: statSync(f).mtime.getTime() }))
+			.sort((a, b) => b.time - a.time);
+
+		if (allWars.length === 0) {
+			throw new Error('Nenhum arquivo .war encontrado! Verifique se o build realmente gerou um artefato.');
+		}
+
+		const warFile = allWars[0];
+		const finalName = this.projectConfig.appName ? `${this.projectConfig.appName}.war` : warFile.name;
+
+		if (!this.projectConfig.quiet) {
+			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`);
+		}
+		
+		copyFileSync(warFile.path, path.join(destDir, finalName));
+		this.inferredAppName = finalName.replace(".war", "");
+		return finalName;
+	}
+}

package/src/services/EndpointService.ts

@@ -0,0 +1,124 @@
+import { readdirSync, readFileSync } from "fs";
+import path from "path";
+import type { ApiEndpoint, ApiParam } from "../types/endpoint";
+
+export class EndpointService {
+    static scan(srcPath: string, contextPath: string = ""): ApiEndpoint[] {
+        const endpoints: ApiEndpoint[] = [];
+        
+        const scanDir = (dir: string) => {
+            const list = readdirSync(dir, { withFileTypes: true });
+            for (const item of list) {
+                const res = path.resolve(dir, item.name);
+                if (item.isDirectory()) {
+                    if (!['node_modules', '.git', 'target', 'build'].includes(item.name)) {
+                        scanDir(res);
+                    }
+                } else if (item.name.endsWith('.java')) {
+                    const content = readFileSync(res, 'utf8');
+                    const fileEndpoints = this.parseJavaFile(content, item.name, contextPath);
+                    endpoints.push(...fileEndpoints);
+                }
+            }
+        };
+
+        try {
+            scanDir(srcPath);
+        } catch (e) {}
+
+        return endpoints.sort((a, b) => a.fullPath.localeCompare(b.fullPath));
+    }
+
+    private static parseJavaFile(content: string, fileName: string, contextPath: string): ApiEndpoint[] {
+        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;
+        while ((match = methodRegex.exec(content)) !== null) {
+            const annotation = match[1];
+            const pathArg = match[3] || "";
+            const methodName = match[5];
+            const paramsRaw = match[6];
+
+            const method = this.inferHttpMethod(annotation);
+            const methodPath = this.normalizePath(pathArg);
+            const fullPath = this.combinePaths(contextPath, basePath, methodPath);
+
+            const parameters = this.parseParameters(paramsRaw);
+
+            endpoints.push({
+                method,
+                path: methodPath,
+                fullPath,
+                className,
+                methodName,
+                parameters
+            });
+        }
+
+        return endpoints;
+    }
+
+    private static inferHttpMethod(annotation: string): ApiEndpoint["method"] {
+        if (annotation.includes("GET")) return "GET";
+        if (annotation.includes("POST")) return "POST";
+        if (annotation.includes("PUT")) return "PUT";
+        if (annotation.includes("DELETE")) return "DELETE";
+        if (annotation.includes("PATCH")) return "PATCH";
+        return "ALL";
+    }
+
+    private static normalizePath(p: string): string {
+        if (!p) return "";
+        let path = p.trim();
+        if (!path.startsWith("/")) path = "/" + path;
+        if (path.endsWith("/")) path = path.slice(0, -1);
+        return path;
+    }
+
+    private static combinePaths(...parts: string[]): string {
+        return parts
+            .map(p => this.normalizePath(p))
+            .filter(p => p && p !== "/")
+            .join("") || "/";
+    }
+
+    private static parseParameters(paramsRaw: string): ApiParam[] {
+        const params: ApiParam[] = [];
+        if (!paramsRaw.trim()) return params;
+
+        const individualParams = paramsRaw.split(",");
+        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+)/);
+            const requestParam = trimmed.match(/@RequestParam\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);
+            const headerParam = trimmed.match(/@HeaderParam\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);
+            const requestBody = trimmed.match(/@RequestBody\s*(\w+)\s+(\w+)/);
+
+            if (pathParam || pathVariable) {
+                const m = pathParam || pathVariable!;
+                params.push({ name: m[1], type: m[2], source: "PATH", required: true });
+            } else if (queryParam || requestParam) {
+                const m = queryParam || requestParam!;
+                params.push({ name: m[1], type: m[2], source: "QUERY", required: !trimmed.includes("required = false") });
+            } else if (headerParam) {
+                params.push({ name: headerParam[1], type: headerParam[2], source: "HEADER", required: true });
+            } else if (requestBody) {
+                params.push({ name: "body", type: requestBody[1], source: "BODY", required: true });
+            }
+        }
+
+        return params;
+    }
+}

package/src/services/TomcatService.ts

@@ -0,0 +1,164 @@
+import type { TomcatConfig } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export class TomcatService {
+	private activeConfig: TomcatConfig;
+	private currentProcess: any = null;
+	private stopStartupSpinner?: (success?: boolean) => void;
+	public onReady?: () => void;
+	private pid: number | null = null;
+
+	constructor(customConfig: TomcatConfig) {
+		this.activeConfig = customConfig;
+	}
+
+	async getMemoryUsage(): Promise<string> {
+		if (!this.pid) return "0 MB";
+		try {
+			const { stdout } = Bun.spawnSync(["powershell", "-command", `(Get-Process -Id ${this.pid}).WorkingSet64 / 1MB`]);
+			const mem = await new Response(stdout).text();
+			return `${Math.round(parseFloat(mem))} MB`;
+		} catch (e) {
+			return "N/A";
+		}
+	}
+
+	async killConflict() {
+		const { stdout } = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${this.activeConfig.port}`]);
+		const output = await new Response(stdout).text();
+
+		if (output) {
+			const lines = output.trim().split('\n');
+			const pid = lines[0].trim().split(/\s+/).pop();
+			Logger.step(`Freeing port ${this.activeConfig.port}`);
+			Bun.spawnSync(["taskkill", "/F", "/PID", pid]);
+		}
+	}
+
+	clearWebapps(appName?: string) {
+		const fs = require("fs");
+		const path = require("path");
+		const webappsPath = path.join(this.activeConfig.path, "webapps");
+		const workPath = path.join(this.activeConfig.path, "work");
+		const tempPath = path.join(this.activeConfig.path, "temp");
+
+		try {
+			[workPath, tempPath].forEach(p => {
+				if (fs.existsSync(p)) {
+					fs.rmSync(p, { recursive: true, force: true });
+					fs.mkdirSync(p);
+				}
+			});
+
+			const files = fs.readdirSync(webappsPath);
+			for (const file of files) {
+				const fullPath = path.join(webappsPath, file);
+				if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
+				
+				fs.rmSync(fullPath, { recursive: true, force: true });
+			}
+		} catch (e) {
+			Logger.warn("Não foi possível limpar totalmente a pasta webapps ou cache.");
+		}
+	}
+
+	stop() {
+		if (this.currentProcess) {
+			Logger.warn("Stopping active server...");
+			this.currentProcess.kill();
+			this.currentProcess = null;
+		}
+	}
+
+	start(cleanLogs: boolean = false, debug: boolean = false, skipScan: boolean = false, quiet: boolean = false) {
+		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
+		const args = debug ? ["jpda", "run"] : ["run"];
+		
+		const catalinaOpts = [process.env.CATALINA_OPTS || ""];
+		
+		if (skipScan) {
+			catalinaOpts.push(
+				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToSkip=*.jar",
+				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToScan=",
+				"-Dorg.apache.catalina.startup.ContextConfig.jarsToSkip=*.jar",
+				"-Dorg.apache.catalina.startup.TldConfig.jarsToSkip=*.jar",
+				"-Dorg.apache.tomcat.util.scan.StandardJarScanFilter.jarsToSkip=*.jar",
+				"-Dorg.apache.catalina.startup.ContextConfig.jarsToScan=" 
+			);
+		}
+
+		const env: any = { 
+			...process.env, 
+			CATALINA_HOME: this.activeConfig.path,
+			CATALINA_OPTS: catalinaOpts.join(" ").trim()
+		};
+
+		if (debug) {
+			Logger.warn("🐞 Java Debugger habilitado na porta 5005");
+			env.JPDA_ADDRESS = "5005";
+			env.JPDA_TRANSPORT = "dt_socket";
+		}
+
+		if (cleanLogs || quiet) {
+			this.stopStartupSpinner = Logger.spinner("Starting Tomcat server");
+		}
+
+		this.currentProcess = Bun.spawn([binPath, ...args], {
+			stdout: "pipe",
+			stderr: "pipe",
+			env: env
+		});
+
+		this.pid = this.currentProcess.pid;
+
+		this.processLogStream(this.currentProcess.stdout, cleanLogs, quiet);
+		this.processLogStream(this.currentProcess.stderr, cleanLogs, quiet);
+	}
+
+	private async processLogStream(stream: ReadableStream, clean: boolean, quiet: boolean) {
+		const reader = stream.getReader();
+		const decoder = new TextDecoder();
+
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+
+			const chunk = decoder.decode(value);
+			const lines = chunk.split(/[\r\n]+/);
+
+			for (const line of lines) {
+				const cleanLine = line.trim();
+				if (!cleanLine || cleanLine.startsWith("Listening for transport")) continue;
+
+				if (cleanLine.includes("Server startup in") || cleanLine.includes("SEVERE") || cleanLine.includes("Exception")) {
+					const isSuccess = cleanLine.includes("Server startup in");
+					if (this.stopStartupSpinner) {
+						this.stopStartupSpinner(isSuccess);
+						this.stopStartupSpinner = undefined;
+					}
+					if (isSuccess && this.onReady) {
+						this.onReady();
+					}
+				}
+
+				if (clean) {
+					if (quiet && !Logger.isEssential(cleanLine)) {
+						if (Logger.isSystemNoise(cleanLine)) continue;
+						if (cleanLine.includes("INFO")) continue;
+					} else if (Logger.isSystemNoise(cleanLine)) {
+						continue;
+					}
+
+					if (this.activeConfig.grep && !cleanLine.toLowerCase().includes(this.activeConfig.grep.toLowerCase())) {
+						if (!Logger.isEssential(cleanLine)) continue;
+					}
+					
+					const summarized = Logger.summarize(cleanLine);
+					console.log(summarized);
+				} else {
+					console.log(cleanLine);
+				}
+			}
+		}
+	}
+}

package/src/types/config.ts

@@ -0,0 +1,24 @@
+export interface TomcatConfig {
+    path: string;
+    port: number;
+    webapps: string;
+    grep?: string;
+}
+
+export interface ProjectConfig {
+    appName: string;
+    buildTool: "maven" | "gradle";
+    profile: string;
+    skipBuild: boolean;
+    skipScan: boolean;
+    cleanLogs: boolean;
+    quiet: boolean;
+    verbose: boolean;
+    debug: boolean;
+    grep?: string;
+}
+
+export interface AppConfig {
+    tomcat: TomcatConfig;
+    project: ProjectConfig;
+}

package/src/types/endpoint.ts

@@ -0,0 +1,15 @@
+export interface ApiParam {
+    name: string;
+    type: string;
+    source: "PATH" | "QUERY" | "BODY" | "HEADER" | "FORM";
+    required: boolean;
+}
+
+export interface ApiEndpoint {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "ALL";
+    path: string;
+    fullPath: string;
+    className: string;
+    methodName: string;
+    parameters: ApiParam[];
+}