@archznn/xavva 1.7.0 → 1.8.0

package/src/services/WatcherService.ts

@@ -0,0 +1,78 @@
+import { watch } from "fs";
+import { Logger } from "../utils/ui";
+import { DeployCommand } from "../commands/DeployCommand";
+import type { AppConfig } from "../types/config";
+
+export class WatcherService {
+    private isDeploying = false;
+    private pendingFullBuild = false;
+    private coolingFiles = new Set<string>();
+    private debounceTimer?: Timer;
+
+    constructor(private config: AppConfig, private deployCmd: DeployCommand) {}
+
+    public async start() {
+        await this.run(false);
+
+        watch(process.cwd(), { recursive: true }, async (event, filename) => {
+            if (!filename) return;
+
+            if (this.coolingFiles.has(filename)) return;
+            this.coolingFiles.add(filename);
+            setTimeout(() => this.coolingFiles.delete(filename), 500);
+
+            if (this.isIgnored(filename)) return;
+
+            const isBuildConfig = filename === "pom.xml" || filename === "build.gradle" || filename === "build.gradle.kts";
+            const isJava = filename.endsWith(".java") || isBuildConfig;
+            const isResource = this.isResourceFile(filename);
+
+            if (isBuildConfig) {
+                Logger.watcher(`Build configuration changed: ${filename}`, 'warn');
+                const { BuildCacheService } = await import("./BuildCacheService");
+                new BuildCacheService().clearCache();
+                this.pendingFullBuild = true;
+            }
+
+            if (isResource && !isJava) {
+                await this.deployCmd.syncResource(this.config, filename);
+                return;
+            }
+
+            if (!isJava) return;
+
+            Logger.watcher(filename, 'watch');
+            clearTimeout(this.debounceTimer);
+            
+            this.debounceTimer = setTimeout(() => {
+                this.run(this.pendingFullBuild ? false : true);
+                this.pendingFullBuild = false;
+            }, 1000);
+        });
+    }
+
+    private async run(incremental = false) {
+        if (this.isDeploying) return;
+        this.isDeploying = true;
+        try {
+            await this.deployCmd.execute(this.config, { watch: true, incremental });
+        } catch (e) {
+            // Error handled by command
+        } finally {
+            this.isDeploying = false;
+        }
+    }
+
+    private isIgnored(filename: string): boolean {
+        return filename.includes("target") || 
+               filename.includes("build") || 
+               filename.includes("node_modules") || 
+               filename.split(/[/\\]/).some(part => part.startsWith("."));
+    }
+
+    private isResourceFile(filename: string): boolean {
+        return filename.endsWith(".jsp") || filename.endsWith(".html") || 
+               filename.endsWith(".css") || filename.endsWith(".js") || 
+               filename.endsWith(".xml") || filename.endsWith(".properties");
+    }
+}

package/src/types/config.ts

@@ -11,10 +11,12 @@ export interface ProjectConfig {
     profile: string;
     skipBuild: boolean;
     skipScan: boolean;
-    cleanLogs: boolean;
+    clean: boolean;
     quiet: boolean;
     verbose: boolean;
     debug: boolean;
+    debugPort: number;
+    cleanLogs: boolean;
     grep?: string;
 }
 
@@ -22,3 +24,30 @@ export interface AppConfig {
     tomcat: TomcatConfig;
     project: ProjectConfig;
 }
+
+export interface CLIArguments {
+    path?: string;
+    tool?: string;
+    name?: string;
+    port?: string;
+    "no-build"?: boolean;
+    scan?: boolean;
+    clean?: boolean;
+    quiet?: boolean;
+    help?: boolean;
+    version?: boolean;
+    debug?: boolean;
+    watch?: boolean;
+    profile?: string;
+    grep?: string;
+    verbose?: boolean;
+    dp?: string;
+    fix?: boolean;
+    incremental?: boolean;
+}
+
+export interface CommandContext {
+    config: AppConfig;
+    positionals: string[];
+    values: CLIArguments;
+}

package/src/utils/config.ts

@@ -1,10 +1,10 @@
 import { parseArgs } from "util";
 import path from "path";
 import fs from "fs";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments, CommandContext } from "../types/config";
 
 export class ConfigManager {
-    static async load(): Promise<{ config: AppConfig, positionals: string[], values: any }> {
+    static async load(): Promise<CommandContext> {
         const args = Bun.argv.slice(Bun.argv[0].endsWith("bun.exe") || Bun.argv[0].endsWith("bun") ? 2 : 1);
         
         const { values, positionals } = parseArgs({
@@ -25,12 +25,14 @@ export class ConfigManager {
                 profile: { type: "string", short: "P" },
                 grep: { type: "string", short: "G" },
                 verbose: { type: "boolean", short: "V" },
+                dp: { type: "string" },
                 fix: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
         });
 
+        const cliValues = values as CLIArguments;
         const isDev = positionals.includes("dev");
         const isRun = positionals.includes("run") || positionals.includes("debug");
         
@@ -47,30 +49,32 @@ export class ConfigManager {
 
         const config: AppConfig = {
             tomcat: {
-                path: String(values.path || envTomcatPath),
-                port: parseInt(String(values.port || "8080")),
+                path: String(cliValues.path || envTomcatPath),
+                port: parseInt(String(cliValues.port || "8080")),
                 webapps: "webapps",
-                grep: values.grep ? String(values.grep) : "",
+                grep: cliValues.grep ? String(cliValues.grep) : "",
             },
             project: {
-                appName: values.name ? String(values.name) : "",
-                buildTool: (values.tool as "maven" | "gradle") || detectedTool,
-                profile: String(values.profile || ""),
-                skipBuild: !!values["no-build"],
-                skipScan: values.scan !== undefined ? !values.scan : true,
-                cleanLogs: !!(values.clean || isDev),
-                quiet: !!(values.quiet || isDev),
-                verbose: !!values.verbose,
-                debug: !!(values.debug || isDev || isRun),
-                grep: runClass || (values.grep ? String(values.grep) : ""),
+                appName: cliValues.name ? String(cliValues.name) : "",
+                buildTool: (cliValues.tool as "maven" | "gradle") || detectedTool,
+                profile: String(cliValues.profile || ""),
+                skipBuild: !!cliValues["no-build"],
+                skipScan: cliValues.scan !== undefined ? !cliValues.scan : true,
+                clean: !!cliValues.clean,
+                cleanLogs: cliValues.verbose ? false : true,
+                quiet: cliValues.verbose ? false : true,
+                verbose: !!cliValues.verbose,
+                debug: !!(cliValues.debug || isDev || isRun),
+                debugPort: parseInt(String(cliValues.dp || "5005")),
+                grep: runClass || (cliValues.grep ? String(cliValues.grep) : ""),
             }
         };
 
-        if (isDev) values.watch = true;
+        if (isDev) cliValues.watch = true;
 
         this.ensureGitIgnore();
 
-        return { config, positionals, values };
+        return { config, positionals, values: cliValues };
     }
 
     private static detectBuildTool(): "maven" | "gradle" {

package/src/utils/ui.ts

@@ -54,21 +54,21 @@ export class Logger {
     static banner(command?: string) {
         console.clear();
         const git = this.getGitContext();
-        const name = (process.cwd().split(/[/\\]/).pop() || "JAVA").toUpperCase();
+        const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
+        const version = `v${pkg.version}`;
         
-        const width = 62;
-        const line = "─".repeat(width);
-        
-        this.write(`${this.C.gray}╭${line}╮`);
-        this.write(`${this.C.gray}│  ${this.C.bold}${this.C.blue}${name} CLI${this.C.reset}${" ".repeat(width - name.length - 6)} ${this.C.gray}│`);
+        const mode = command?.toUpperCase() || "DEPLOY";
+        const modeColor = mode === "DEV" ? this.C.green : this.C.blue;
+        const modeIcon = mode === "DEV" ? "⚡" : "🚀";
+
+        console.log("");
+        console.log(`  ${this.C.bold}${this.C.cyan}X A V V A${this.C.reset} ${this.C.dim}─${this.C.reset} ${this.C.bold}${this.C.white}${name}${this.C.reset}`);
         
-        const info = `Version: ${pkg.version}  |  Branch: ${git.branch}  |  ${git.hash}`;
-        this.write(`${this.C.gray}│  ${this.C.dim}${info}${" ".repeat(width - info.length - 2)}${this.C.gray}│`);
+        const gitInfo = git.branch ? `${this.C.magenta}🌿 ${git.branch}${this.C.reset} ${this.C.dim}•${this.C.reset} ${this.C.yellow}${git.hash}${this.C.reset}` : "";
+        console.log(`  ${this.C.dim}📦 ${version}${gitInfo ? `  ${this.C.dim}•${this.C.reset}  ${gitInfo}` : ""}${this.C.reset}`);
         
-        const modeLine = `Mode: ${command?.toUpperCase() || "DEPLOY"}`;
-        const status = command === 'dev' ? `${this.C.green}🟢` : `${this.C.blue}🔵`;
-        this.write(`${this.C.gray}│  ${this.C.yellow}${this.C.bold}${modeLine}${" ".repeat(width - modeLine.length - 5)}${status}   ${this.C.gray}│`);
-        this.write(`${this.C.gray}╰${line}╯${this.C.reset}`);
+        console.log(`  ${modeColor}${this.C.bold}⬢ ${modeIcon} ${mode} MODE${this.C.reset}`);
+        console.log(`  ${this.C.dim}─────────────────────────────────────────────────${this.C.reset}`);
     }
 
     static section(title: string) {
@@ -162,7 +162,9 @@ export class Logger {
             "org.apache.catalina.core.StandardContext.setPath", "milliseconds",
             "org.apache.catalina.startup.HostConfig.deployWAR", "org.apache.catalina.startup.HostConfig.deployDirectory",
             "Deployment of web application", "Deploying web application archive", "at org.apache",
-            "Registering directory"
+            "Registering directory", "initialized in ClassLoader", "Discovered plugins:",
+            "enhanced with plugin initialization", "registerJerseyContainer", "JasperLoader@",
+            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false"
         ];
         return noise.some(n => line.includes(n));
     }