@archznn/xavva 1.7.0 → 1.8.1

package/src/services/BuildCacheService.ts

@@ -0,0 +1,83 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+export interface CacheData {
+    lastConfigHash: string;
+    lastBuildTime: number;
+}
+
+export class BuildCacheService {
+    private cacheDir: string;
+    private cacheFile: string;
+
+    constructor() {
+        this.cacheDir = path.join(process.cwd(), ".xavva");
+        this.cacheFile = path.join(this.cacheDir, "build-cache.json");
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+
+    getHash(filePath: string): string {
+        if (!fs.existsSync(filePath)) return "";
+        const content = fs.readFileSync(filePath);
+        return crypto.createHash("md5").update(content).digest("hex");
+    }
+
+    getConfigHash(tool: "maven" | "gradle"): string {
+        const file = tool === "maven" ? "pom.xml" : "build.gradle";
+        const configPath = path.join(process.cwd(), file);
+        let hash = this.getHash(configPath);
+
+        // Se for gradle, também checar build.gradle.kts e settings
+        if (tool === "gradle") {
+            const kts = path.join(process.cwd(), "build.gradle.kts");
+            const settings = path.join(process.cwd(), "settings.gradle");
+            if (fs.existsSync(kts)) hash += this.getHash(kts);
+            if (fs.existsSync(settings)) hash += this.getHash(settings);
+        }
+
+        return crypto.createHash("md5").update(hash).digest("hex");
+    }
+
+    shouldRebuild(tool: "maven" | "gradle", projectService?: any): boolean {
+        if (!fs.existsSync(this.cacheFile)) return true;
+
+        try {
+            const currentHash = this.getConfigHash(tool);
+            const cache: CacheData = JSON.parse(fs.readFileSync(this.cacheFile, "utf-8"));
+            
+            // Se o pom/gradle mudou, precisa de rebuild completo
+            if (currentHash !== cache.lastConfigHash) return true;
+
+            // Verificar se o artefato (.war) ainda existe fisicamente
+            if (projectService) {
+                try {
+                    const artifact = projectService.getArtifact();
+                    if (!fs.existsSync(artifact.path)) return true;
+                } catch (e) {
+                    return true;
+                }
+            }
+
+            return false;
+        } catch (e) {
+            return true;
+        }
+    }
+
+    saveCache(tool: "maven" | "gradle") {
+        const data: CacheData = {
+            lastConfigHash: this.getConfigHash(tool),
+            lastBuildTime: Date.now()
+        };
+        fs.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2));
+    }
+
+    clearCache() {
+        if (fs.existsSync(this.cacheFile)) {
+            fs.unlinkSync(this.cacheFile);
+        }
+    }
+}

package/src/services/BuildService.ts

@@ -1,47 +1,78 @@
-import { readdirSync, copyFileSync, existsSync, statSync, mkdirSync } from "fs";
+import { readdirSync, existsSync, statSync, mkdirSync, promises as fs } from "fs";
 import path from "path";
 import type { ProjectConfig, TomcatConfig } from "../types/config";
 import { Logger } from "../utils/ui";
+import { BuildCacheService } from "./BuildCacheService";
+import { ProjectService } from "./ProjectService";
 
 export class BuildService {
-	private inferredAppName: string | null = null;
-
-	constructor(private projectConfig: ProjectConfig, private tomcatConfig: TomcatConfig) { }
+	constructor(
+		private projectConfig: ProjectConfig, 
+		private tomcatConfig: TomcatConfig,
+		private projectService: ProjectService,
+		private cache: BuildCacheService
+	) { }
 
 	async runBuild(incremental = false) {
+		if (this.projectConfig.clean) {
+			this.cache.clearCache();
+		}
+
+		if (!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;
+			}
+		}
+
 		const command = [];
+		const env = { ...process.env };
 		
 		if (this.projectConfig.buildTool === 'maven') {
 			command.push("mvn");
+
+			if (!this.cache.shouldRebuild('maven', this.projectService)) {
+				command.push("-o");
+			}
+
 			if (incremental) {
 				command.push("compile");
 			} else {
-				command.push("clean", "package");
+				if (this.projectConfig.clean) command.push("clean");
+				command.push("compile", "war:exploded");
+				command.push("-T", "1C");
 			}
-			command.push("-DskipTests");
+			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");
 			if (this.projectConfig.profile) command.push(`-P${this.projectConfig.profile}`);
+
+			env.MAVEN_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
 		} else {
 			command.push("gradle");
 			if (incremental) {
 				command.push("classes");
 			} else {
-				command.push("clean", "build");
+				if (this.projectConfig.clean) command.push("clean");
+				command.push("war");
+				command.push("--parallel", "--build-cache");
 			}
-			command.push("-x", "test");
+			command.push("-x", "test", "-x", "javadoc");
 			if (this.projectConfig.profile) command.push(`-Pprofile=${this.projectConfig.profile}`);
+
+			env.GRADLE_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
 		}
 
 		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
 
 		const proc = Bun.spawn(command, { 
 			stdout: "pipe",
-			stderr: "pipe"
+			stderr: "pipe",
+			env: env as any
 		});
 
 		if (this.projectConfig.verbose) {
 			await Promise.all([
-				this.processBuildLogs(proc.stdout, false),
-				this.processBuildLogs(proc.stderr, false)
+				this.processBuildLogs(proc.stdout as ReadableStream, false),
+				this.processBuildLogs(proc.stderr as ReadableStream, false)
 			]);
 		}
 
@@ -56,6 +87,10 @@ export class BuildService {
             Logger.error(`${this.projectConfig.buildTool.toUpperCase()} build failed!`);
             throw new Error("Falha no build do Java!");
         }
+
+		if (!incremental) {
+			this.cache.saveCache(this.projectConfig.buildTool);
+		}
 	}
 
 	private async processBuildLogs(stream: ReadableStream, quiet: boolean) {
@@ -97,98 +132,86 @@ export class BuildService {
 		}
 	}
 
-	async syncClasses(): Promise<string | null> {
-		const fs = require("fs");
-		let appFolder = this.projectConfig.appName || this.inferredAppName || "";
-
+	async syncClasses(customSrc?: string): Promise<string | null> {
+		const appFolder = this.projectService.getInferredAppName();
 		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", "examples"].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");
+		const sourceDir = customSrc || this.projectService.getClassesDir();
+		const destDir = customSrc ? path.join(webappsPath, appFolder) : path.join(webappsPath, appFolder, "WEB-INF", "classes");
 
-		if (!fs.existsSync(sourceDir)) return null;
-		
-		if (!appFolder || !fs.existsSync(destDir)) {
-			return null;
+		if (!existsSync(sourceDir)) return null;
+		if (!appFolder || !existsSync(destDir)) {
+			if (customSrc && appFolder) {
+				mkdirSync(destDir, { recursive: true });
+			} else {
+				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 fastSync = async (src: string, dest: string) => {
+			if (!existsSync(dest)) await fs.mkdir(dest, { recursive: true });
+			const list = await fs.readdir(src, { withFileTypes: true });
+			
+			const tasks = list.map(async (item) => {
 				const s = path.join(src, item.name);
 				const d = path.join(dest, item.name);
+				
 				if (item.isDirectory()) {
-					copyDir(s, d);
+					await fastSync(s, d);
 				} else {
-					if (!fs.existsSync(d) || fs.statSync(s).mtimeMs > fs.statSync(d).mtimeMs) {
-						fs.copyFileSync(s, d);
+					const sStat = await fs.stat(s);
+					let shouldCopy = false;
+
+					if (!existsSync(d)) {
+						shouldCopy = true;
+					} else {
+						const dStat = await fs.stat(d);
+						if (sStat.mtimeMs > dStat.mtimeMs || dStat.size === 0) {
+							shouldCopy = true;
+						}
+					}
+
+					if (shouldCopy) {
+						let retries = 3;
+						while (retries > 0) {
+							try {
+								await fs.copyFile(s, d);
+								const finalStat = await fs.stat(d);
+								if (item.name.endsWith(".jar") && finalStat.size === 0 && sStat.size > 0) {
+									throw new Error("Zero byte copy detected");
+								}
+								await fs.utimes(d, sStat.atime, sStat.mtime);
+								break;
+							} catch (e) {
+								retries--;
+								if (retries === 0) {
+									Logger.warn(`Failed to copy ${item.name} after retries.`);
+								} else {
+									await new Promise(r => setTimeout(r, 100));
+								}
+							}
+						}
 					}
 				}
-			}
+			});
+
+			await Promise.all(tasks);
 		};
 
-		copyDir(sourceDir, destDir);
+		await fastSync(sourceDir, destDir);
 		return appFolder;
 	}
 
-	async deployToWebapps(): Promise<{ path: string, finalName: string }> {
-		const destDir = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
-		
+	async deployToWebapps(): Promise<{ path: string, finalName: string, isDirectory: boolean }> {
 		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;
+		const artifact = this.projectService.getArtifact();
 
 		if (!this.projectConfig.quiet) {
-			Logger.info("Artifact", warFile.name);
-			if (this.projectConfig.appName) Logger.info("Deploy as", finalName);
-		} else {
-			Logger.process(`Deploying ${this.projectConfig.appName ? this.projectConfig.appName : warFile.name.replace(".war", "")}...`);
+			Logger.info(artifact.isDirectory ? "Exploded Dir" : "Artifact", path.basename(artifact.path));
+			if (this.projectConfig.appName) Logger.info("Deploy as", artifact.name);
 		}
 		
-		this.inferredAppName = finalName.replace(".war", "");
-		return { path: warFile.path, finalName };
+		return { path: artifact.path, finalName: artifact.name, isDirectory: artifact.isDirectory };
 	}
 }

package/src/services/EndpointService.ts

@@ -18,6 +18,23 @@ export class EndpointService {
                     const content = readFileSync(res, 'utf8');
                     const fileEndpoints = this.parseJavaFile(content, item.name, contextPath);
                     endpoints.push(...fileEndpoints);
+                } else if (item.name.endsWith('.jsp')) {
+                    const parts = res.split(/[/\\]/);
+                    const webappIndex = parts.indexOf("webapp");
+                    const webContentIndex = parts.indexOf("WebContent");
+                    const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+                    
+                    if (rootIndex !== -1) {
+                        const relPath = "/" + parts.slice(rootIndex + 1).join("/");
+                        endpoints.push({
+                            method: "GET",
+                            path: relPath,
+                            fullPath: this.combinePaths(contextPath, relPath),
+                            className: "JSP",
+                            methodName: item.name,
+                            parameters: []
+                        });
+                    }
                 }
             }
         };

package/src/services/ProjectService.ts

@@ -0,0 +1,126 @@
+import { existsSync, readdirSync, statSync } from "fs";
+import path from "path";
+import type { ProjectConfig } from "../types/config";
+
+export class ProjectService {
+    constructor(private config: ProjectConfig) {}
+
+    getBuildOutputDir(): string {
+        return path.join(process.cwd(), this.config.buildTool === "maven" ? "target" : "build");
+    }
+
+    getClassesDir(): string {
+        return this.config.buildTool === "maven" 
+            ? path.join(process.cwd(), "target", "classes")
+            : path.join(process.cwd(), "build", "classes", "java", "main");
+    }
+
+    getSourceDirs(): string[] {
+        return [
+            path.join(process.cwd(), "src", "main", "java"),
+            path.join(process.cwd(), "src", "main", "resources"),
+            path.join(process.cwd(), "src", "main", "webapp")
+        ].filter(d => existsSync(d));
+    }
+
+    getArtifact(): { path: string; name: string; isDirectory: boolean } {
+        const buildDir = this.getBuildOutputDir();
+        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}!`);
+        }
+
+        const artifact = artifacts[0];
+        return {
+            path: artifact.path,
+            name: this.config.appName ? `${this.config.appName}.war` : artifact.name,
+            isDirectory: artifact.isDirectory
+        };
+    }
+
+    private searchArtifacts(dir: string): { path: string; name: string; time: number; isDirectory: boolean }[] {
+        let results: { path: string; name: string; time: number; isDirectory: boolean }[] = [];
+        if (!existsSync(dir)) return results;
+
+        const list = readdirSync(dir, { withFileTypes: true });
+        for (const item of list) {
+            const fullPath = path.resolve(dir, item.name);
+            
+            if (item.isDirectory()) {
+                // Se for Maven e tiver WEB-INF, é um exploded war
+                if (this.config.buildTool === 'maven' && existsSync(path.join(fullPath, "WEB-INF"))) {
+                    results.push({ 
+                        path: fullPath, 
+                        name: `${item.name}.war`, 
+                        time: statSync(fullPath).mtime.getTime(),
+                        isDirectory: true 
+                    });
+                } else if (item.name.endsWith('.war')) { // Algumas ferramentas podem gerar pastas .war
+                     results.push({ 
+                        path: fullPath, 
+                        name: item.name, 
+                        time: statSync(fullPath).mtime.getTime(),
+                        isDirectory: true 
+                    });
+                } else if (['libs', 'distributions'].includes(item.name)) { // Gradle common dirs
+                    results = results.concat(this.searchArtifacts(fullPath));
+                }
+            } else if (item.name.endsWith('.war')) {
+                results.push({ 
+                    path: fullPath, 
+                    name: item.name, 
+                    time: statSync(fullPath).mtime.getTime(),
+                    isDirectory: false 
+                });
+            }
+        }
+        return results;
+    }
+
+    getInferredAppName(): string {
+        if (this.config.appName) return this.config.appName;
+        try {
+            const artifact = this.getArtifact();
+            return artifact.name.replace(".war", "");
+        } catch (e) {
+            return "ROOT";
+        }
+    }
+
+    findAllClassPaths(): string[] {
+        const results: string[] = [];
+        const root = process.cwd();
+
+        const scan = (dir: string) => {
+            try {
+                const files = readdirSync(dir, { withFileTypes: true });
+                for (const file of files) {
+                    if (!file.isDirectory()) continue;
+                    
+                    const name = file.name;
+                    if (name.startsWith('.') || ['node_modules', 'out', 'bin', 'src', 'webapps', '.xavva'].includes(name)) continue;
+
+                    const fullPath = path.join(dir, name);
+                    
+                    const isMavenClasses = this.config.buildTool === 'maven' && name === 'classes' && dir.endsWith('target');
+                    const isGradleClasses = this.config.buildTool === 'gradle' && name === 'main' && dir.endsWith(path.join('classes', 'java'));
+                    
+                    if (isMavenClasses || isGradleClasses) {
+                        results.push(fullPath.replace(/\\/g, "/"));
+                    } else {
+                        scan(fullPath);
+                    }
+                }
+            } catch (e) {}
+        };
+
+        scan(root);
+        
+        if (results.length === 0) {
+            results.push(this.getClassesDir().replace(/\\/g, "/"));
+        }
+
+        return results;
+    }
+}