@archznn/xavva 2.7.0 → 2.8.0

package/src/index.ts

@@ -23,7 +23,8 @@ async function main() {
     const commandNames = [
         "deploy", "build", "start", "dev", "doctor", "run", 
         "debug", "logs", "docs", "audit", "profiles", 
-        "deps", "tomcat", "encoding"
+        "deps", "tomcat", "encoding", "init", "config", 
+        "history", "redo", "health", "completion", "help"
     ];
     const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
@@ -96,15 +97,52 @@ async function main() {
         registry.register("encoding", commands.encoding);
         registry.register("deploy", commands.deploy);
         registry.register("dev", commands.dev);
+        registry.register("init", commands.init);
+        registry.register("config", commands.config);
+        registry.register("history", commands.history);
+        registry.register("redo", commands.redo);
+        registry.register("health", commands.health);
+        registry.register("completion", commands.completion);
 
         // Configura flags específicas
         if (commandName === "debug") values.debug = true;
         if (commandName === "run") values.debug = false;
 
+        // Registra comando no histórico antes da execução
+        const startTime = Date.now();
+        let success = true;
+
         try {
             await registry.execute(commandName, config, values as CLIArguments, positionals);
         } catch (error) {
+            success = false;
             await ErrorHandler.getInstance().handle(error, { phase: "command-execution", command: commandName });
+        } finally {
+            // Salva no histórico
+            const duration = (Date.now() - startTime) / 1000;
+            const filteredPositionals = positionals.filter(p => p !== commandName && !commandNames.includes(p));
+            services.historyService.add({
+                command: commandName,
+                args: [...filteredPositionals, ...Object.entries(values)
+                    .filter(([, v]) => v !== undefined && typeof v !== "object")
+                    .flatMap(([k, v]) => [`--${k}`, String(v)])],
+                success,
+                duration
+            }).catch(() => { /* ignore history errors */ });
+
+            // Envia notificação para comandos longos
+            if (duration > 5 && commandName !== "logs" && commandName !== "history") {
+                const { NotificationService } = await import("./services/NotificationService");
+                if (success) {
+                    if (commandName === "build" || commandName === "deploy") {
+                        NotificationService.buildSuccess(duration);
+                    } else if (commandName === "start") {
+                        NotificationService.deployComplete(config.project.appName);
+                    }
+                } else {
+                    NotificationService.buildFailed(`Comando ${commandName} falhou`);
+                }
+            }
         }
     }
 }

package/src/services/EmbeddedTomcatService.ts

@@ -1,4 +1,5 @@
 import { Logger } from "../utils/ui";
+import { ProgressBar, ThemedSpinner } from "../utils/ProgressBar";
 import { VERSIONS, getAvailableTomcatVersions, isSupportedTomcatVersion } from "../config/versions";
 import {
 	existsSync,
@@ -347,27 +348,69 @@ export class EmbeddedTomcatService {
 	 * Download com progresso
 	 */
 	private async downloadFile(url: string, destPath: string): Promise<void> {
-		const spinner = Logger.spinner(`Baixando Tomcat ${this.version}...`);
+		const response = await fetch(url);
 
-		try {
-			const response = await fetch(url);
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		}
+
+		const totalSize = parseInt(response.headers.get("content-length") || "0");
+		
+		// Se temos content-length, usar progress bar
+		if (totalSize > 0) {
+			const progress = new ProgressBar({
+				title: `Baixando Tomcat ${this.version}`,
+				total: totalSize,
+				width: 25
+			});
 
-			if (!response.ok) {
-				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			const reader = response.body?.getReader();
+			if (!reader) {
+				throw new Error("Response body não disponível");
 			}
 
-			const totalSize = parseInt(response.headers.get("content-length") || "0");
-			const buffer = await response.arrayBuffer();
+			const chunks: Uint8Array[] = [];
+			let received = 0;
 
-			writeFileSync(destPath, Buffer.from(buffer));
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				
+				chunks.push(value);
+				received += value.length;
+				progress.update(received);
+			}
 
-			spinner(true);
+			progress.complete();
 
-			const sizeMB = (buffer.byteLength / 1024 / 1024).toFixed(1);
+			// Concatena chunks e salva
+			const allChunks = new Uint8Array(received);
+			let position = 0;
+			for (const chunk of chunks) {
+				allChunks.set(chunk, position);
+				position += chunk.length;
+			}
+
+			await fsPromises.writeFile(destPath, allChunks);
+			
+			const sizeMB = (received / 1024 / 1024).toFixed(1);
 			Logger.info("Download", `${sizeMB} MB baixados`);
-		} catch (error) {
-			spinner(false);
-			throw error;
+		} else {
+			// Sem content-length, usar spinner temático
+			const spinner = new ThemedSpinner();
+			const stop = spinner.start(`Baixando Tomcat ${this.version}`, "dots", "download");
+
+			try {
+				const buffer = await response.arrayBuffer();
+				await fsPromises.writeFile(destPath, Buffer.from(buffer));
+				stop(true);
+				
+				const sizeMB = (buffer.byteLength / 1024 / 1024).toFixed(1);
+				Logger.info("Download", `${sizeMB} MB baixados`);
+			} catch (error) {
+				stop(false);
+				throw error;
+			}
 		}
 	}
 
@@ -375,13 +418,14 @@ export class EmbeddedTomcatService {
 	 * Extrai arquivo de arquivos (ZIP ou tar.gz)
 	 */
 	private async extractZip(zipPath: string, destDir: string): Promise<void> {
-		const spinner = Logger.spinner("Extraindo arquivos...");
+		const spinner = new ThemedSpinner();
+		const stop = spinner.start("Extraindo arquivos", "pulse", "build");
 
 		return new Promise((resolve, reject) => {
 			const cmd = getExtractCommand(zipPath, destDir);
 			
 			if (!cmd) {
-				spinner(false);
+				stop(false);
 				reject(new Error(`Formato de arquivo não suportado: ${path.extname(zipPath)}`));
 				return;
 			}
@@ -390,16 +434,16 @@ export class EmbeddedTomcatService {
 
 			extractProcess.on("close", (code) => {
 				if (code === 0) {
-					spinner(true);
+					stop(true);
 					resolve();
 				} else {
-					spinner(false);
+					stop(false);
 					reject(new Error(`Falha ao extrair (código ${code})`));
 				}
 			});
 
 			extractProcess.on("error", (err) => {
-				spinner(false);
+				stop(false);
 				reject(err);
 			});
 		});

package/src/services/HistoryService.ts

@@ -0,0 +1,73 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface HistoryEntry {
+    command: string;
+    args: string[];
+    timestamp: string;
+    success: boolean;
+    duration?: number;
+}
+
+const HISTORY_FILE = join(homedir(), ".xavva", "history.json");
+const MAX_HISTORY_SIZE = 100;
+
+export class HistoryService {
+    private async ensureDir(): Promise<void> {
+        const dir = join(homedir(), ".xavva");
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+    }
+
+    private async load(): Promise<HistoryEntry[]> {
+        try {
+            await this.ensureDir();
+            const data = await readFile(HISTORY_FILE, "utf-8");
+            return JSON.parse(data);
+        } catch {
+            return [];
+        }
+    }
+
+    private async save(entries: HistoryEntry[]): Promise<void> {
+        await this.ensureDir();
+        // Keep only last MAX_HISTORY_SIZE entries
+        const trimmed = entries.slice(-MAX_HISTORY_SIZE);
+        await writeFile(HISTORY_FILE, JSON.stringify(trimmed, null, 2));
+    }
+
+    async add(entry: Omit<HistoryEntry, "timestamp">): Promise<void> {
+        const entries = await this.load();
+        entries.push({
+            ...entry,
+            timestamp: new Date().toISOString()
+        });
+        await this.save(entries);
+    }
+
+    async getRecent(limit: number = 10): Promise<HistoryEntry[]> {
+        const entries = await this.load();
+        return entries.slice(-limit).reverse();
+    }
+
+    async getLast(): Promise<HistoryEntry | null> {
+        const entries = await this.load();
+        return entries.length > 0 ? entries[entries.length - 1] : null;
+    }
+
+    async clear(): Promise<void> {
+        await this.save([]);
+    }
+
+    async getStats(): Promise<{ total: number; successful: number; failed: number }> {
+        const entries = await this.load();
+        return {
+            total: entries.length,
+            successful: entries.filter(e => e.success).length,
+            failed: entries.filter(e => !e.success).length
+        };
+    }
+}

package/src/services/NotificationService.ts

@@ -0,0 +1,145 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+
+const execAsync = promisify(exec);
+
+export interface NotificationOptions {
+    title: string;
+    message: string;
+    type?: "info" | "success" | "warning" | "error";
+    sound?: boolean;
+}
+
+export class NotificationService {
+    private static enabled = true;
+
+    static disable(): void {
+        this.enabled = false;
+    }
+
+    static enable(): void {
+        this.enabled = true;
+    }
+
+    static async notify(options: NotificationOptions): Promise<void> {
+        if (!this.enabled) return;
+
+        const { title, message, type = "info", sound = false } = options;
+
+        try {
+            if (platform() === "win32") {
+                await this.notifyWindows(title, message, type, sound);
+            } else if (platform() === "darwin") {
+                await this.notifyMacOS(title, message, type, sound);
+            } else {
+                await this.notifyLinux(title, message, type, sound);
+            }
+        } catch {
+            // Silently fail - notifications are not critical
+        }
+    }
+
+    private static async notifyWindows(
+        title: string, 
+        message: string, 
+        type: string, 
+        sound: boolean
+    ): Promise<void> {
+        // Use PowerShell notification
+        const iconMap: Record<string, string> = {
+            info: "Information",
+            success: "Information",
+            warning: "Warning",
+            error: "Error"
+        };
+
+        const psScript = `
+            Add-Type -AssemblyName System.Windows.Forms
+            $notify = New-Object System.Windows.Forms.NotifyIcon
+            $notify.Icon = [System.Drawing.SystemIcons]::${iconMap[type]}
+            $notify.BalloonTipTitle = "${title.replace(/"/g, '""')}"
+            $notify.BalloonTipText = "${message.replace(/"/g, '""')}"
+            $notify.BalloonTipIcon = "${iconMap[type]}"
+            $notify.Visible = $true
+            $notify.ShowBalloonTip(5000)
+        `;
+
+        await execAsync(`powershell -Command "${psScript}"`);
+    }
+
+    private static async notifyMacOS(
+        title: string, 
+        message: string, 
+        _type: string, 
+        sound: boolean
+    ): Promise<void> {
+        const soundFlag = sound ? '"\\"\\""' : "";
+        await execAsync(`osascript -e 'display notification "${message.replace(/"/g, '\\"')}" with title "${title.replace(/"/g, '\\"')}"${soundFlag}'`);
+    }
+
+    private static async notifyLinux(
+        title: string, 
+        message: string, 
+        type: string, 
+        _sound: boolean
+    ): Promise<void> {
+        const urgencyMap: Record<string, string> = {
+            info: "normal",
+            success: "normal",
+            warning: "normal",
+            error: "critical"
+        };
+
+        const iconMap: Record<string, string> = {
+            info: "dialog-information",
+            success: "dialog-information",
+            warning: "dialog-warning",
+            error: "dialog-error"
+        };
+
+        try {
+            await execAsync(`notify-send -u ${urgencyMap[type]} -i ${iconMap[type]} "${title}" "${message}"`);
+        } catch {
+            // Fallback: try zenity
+            try {
+                await execAsync(`zenity --info --title="${title}" --text="${message}" --timeout=5`);
+            } catch {
+                // No notification available
+            }
+        }
+    }
+
+    // Convenience methods
+    static buildSuccess(duration: number): Promise<void> {
+        return this.notify({
+            title: "Xavva - Build Completo",
+            message: `Build finalizado com sucesso em ${duration.toFixed(1)}s`,
+            type: "success"
+        });
+    }
+
+    static buildFailed(error: string): Promise<void> {
+        return this.notify({
+            title: "Xavva - Build Falhou",
+            message: error.slice(0, 100),
+            type: "error"
+        });
+    }
+
+    static deployComplete(appName: string): Promise<void> {
+        return this.notify({
+            title: "Xavva - Deploy Completo",
+            message: `${appName} implantado com sucesso`,
+            type: "success"
+        });
+    }
+
+    static watchReady(): Promise<void> {
+        return this.notify({
+            title: "Xavva - Watch Mode",
+            message: "Monitorando alterações nos arquivos...",
+            type: "info"
+        });
+    }
+}

package/src/services/TomcatService.ts

@@ -2,6 +2,7 @@ import type { TomcatConfig, AppConfig } from "../types";
 import { getHotswapAgentUrl, VERSIONS } from "../config/versions";
 import { NetworkError } from "../errors/XavvaError";
 import { Logger } from "../utils/ui";
+import { ProgressBar, ThemedSpinner } from "../utils/ProgressBar";
 import type { Subprocess } from "bun";
 import { ProjectService } from "./ProjectService";
 import { existsSync, mkdirSync, writeFileSync, statSync, promises as fs } from "fs";
@@ -146,47 +147,75 @@ export class TomcatService {
 		try {
 			if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
 			
-			Logger.step("Downloading HotswapAgent v2.0.3 (Global)...");
-			const url = "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-2.0.3/hotswap-agent-2.0.3.jar";
-			
-			Logger.debug(`URL: ${url}`);
-			Logger.debug(`Destino: ${agentPath}`);
-			
-			const response = await fetch(url, {
-				redirect: "follow",
-			});
+			const url = getHotswapAgentUrl();
+			const response = await fetch(url, { redirect: "follow" });
 			
 			if (!response.ok) {
 				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 			}
 			
-			const contentLength = response.headers.get("content-length");
-			Logger.debug(`Content-Length: ${contentLength || "unknown"}`);
+			const totalSize = parseInt(response.headers.get("content-length") || "0");
 			
-			const buffer = await response.arrayBuffer();
-			Logger.debug(`Downloaded: ${buffer.byteLength} bytes`);
-			
-			if (buffer.byteLength < 1000) {
-				throw new Error(`Arquivo muito pequeno (${buffer.byteLength} bytes)`);
+			if (totalSize > 0) {
+				// Usar progress bar
+				const progress = new ProgressBar({
+					title: `Baixando HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION}`,
+					total: totalSize,
+					width: 25
+				});
+
+				const reader = response.body?.getReader();
+				if (!reader) throw new Error("Response body não disponível");
+
+				const chunks: Uint8Array[] = [];
+				let received = 0;
+
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					
+					chunks.push(value);
+					received += value.length;
+					progress.update(received);
+				}
+
+				progress.complete();
+
+				// Concatena e salva
+				const allChunks = new Uint8Array(received);
+				let position = 0;
+				for (const chunk of chunks) {
+					allChunks.set(chunk, position);
+					position += chunk.length;
+				}
+
+				await fs.writeFile(agentPath, allChunks);
+			} else {
+				// Sem content-length, usar spinner
+				const spinner = new ThemedSpinner();
+				const stop = spinner.start(`Baixando HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION}`, "dots", "download");
+				
+				const buffer = await response.arrayBuffer();
+				writeFileSync(agentPath, Buffer.from(buffer));
+				
+				stop(true);
 			}
 			
-			writeFileSync(agentPath, Buffer.from(buffer));
-			
 			// Verifica se foi escrito corretamente
 			const stats = statSync(agentPath);
-			Logger.debug(`Escrito: ${stats.size} bytes`);
+			if (stats.size < 1000) {
+				throw new Error(`Arquivo muito pequeno (${stats.size} bytes)`);
+			}
 			
-			Logger.success(`HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION} installed globally!`);
+			Logger.success(`HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION} instalado!`);
 			return agentPath;
 		} catch (e: any) {
-			throw new NetworkError(url, e);
-			Logger.warn("Usando hot swap padrão da JVM.");
+			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
 			
 			// Limpa arquivo parcial se existir
 			if (existsSync(agentPath)) {
 				try {
 					await fs.unlink(agentPath);
-					Logger.debug("Arquivo parcial removido");
 				} catch {}
 			}
 			

package/src/types/args.ts

@@ -109,6 +109,21 @@ export interface EncodingCommandArgs extends BaseArgs, EncodingArgs {
     // Herda de EncodingArgs
 }
 
+// ===== Args dos Novos Comandos UX =====
+export interface ConfigArgs extends BaseArgs {
+    interactive?: boolean;
+    i?: boolean;
+}
+
+export interface HistoryArgs extends BaseArgs {
+    clear?: boolean;
+    limit?: string;
+}
+
+export interface CompletionArgs extends BaseArgs {
+    shell?: string;
+}
+
 // ===== CLIArguments Legado (para compatibilidade) =====
 // Será gradualmente removido
 export interface CLIArguments extends