@archznn/xavva 3.1.3 → 3.2.0

package/src/commands/CleanCommand.ts

@@ -0,0 +1,242 @@
+/**
+ * Comando Clean - Limpa cache, builds e logs
+ * 
+ * Uso:
+ *   xavva clean           # limpa tudo
+ *   xavva clean --cache   # só cache
+ *   xavva clean --build   # só target/build
+ *   xavva clean --logs    # só logs do Tomcat
+ *   xavva clean --tomcat  # só work do Tomcat
+ */
+
+import { rm, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import os from "os";
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { Logger } from "../logging";
+import { PATHS } from "../config/versions";
+
+interface CleanOptions {
+    all: boolean;
+    cache: boolean;
+    build: boolean;
+    logs: boolean;
+    tomcat: boolean;
+}
+
+interface CleanResult {
+    cleaned: string[];
+    failed: Array<{ path: string; error: string }>;
+    bytesFreed: number;
+}
+
+export class CleanCommand implements Command {
+    private logger = Logger.getInstance();
+
+    async execute(config: AppConfig, args: CLIArguments): Promise<void> {
+        const options = this.parseOptions(args);
+        
+        this.logger.section("LIMPEZA");
+        
+        const result: CleanResult = {
+            cleaned: [],
+            failed: [],
+            bytesFreed: 0,
+        };
+
+        // Limpa cache
+        if (options.cache || options.all) {
+            await this.cleanCache(result);
+        }
+
+        // Limpa build
+        if (options.build || options.all) {
+            await this.cleanBuild(result, config);
+        }
+
+        // Limpa logs
+        if (options.logs || options.all) {
+            await this.cleanLogs(result, config);
+        }
+
+        // Limpa Tomcat work
+        if (options.tomcat || options.all) {
+            await this.cleanTomcatWork(result, config);
+        }
+
+        this.printSummary(result);
+    }
+
+    private parseOptions(args: CLIArguments): CleanOptions {
+        const hasSpecific = args.cache || args.build || args.logs || (args as any).tomcat;
+        
+        return {
+            all: !hasSpecific, // Se nenhum específico, limpa tudo
+            cache: !!(args.cache || !hasSpecific),
+            build: !!(args.build || !hasSpecific),
+            logs: !!(args.logs || !hasSpecific),
+            tomcat: !!((args as any).tomcat || !hasSpecific),
+        };
+    }
+
+    private async cleanCache(result: CleanResult): Promise<void> {
+        this.logger.step("Limpando cache...");
+        
+        const cacheDirs = [
+            path.join(os.homedir(), '.xavva', 'cache'),
+            path.join(os.homedir(), '.xavva', 'dependency-cache'),
+            path.join(os.homedir(), '.xavva', 'build-cache'),
+            path.join(process.cwd(), PATHS.XAVVA_DIR, 'cache'),
+        ];
+
+        for (const dir of cacheDirs) {
+            if (existsSync(dir)) {
+                try {
+                    const size = await this.getDirectorySize(dir);
+                    await rm(dir, { recursive: true, force: true });
+                    result.cleaned.push(`cache: ${path.basename(dir)}`);
+                    result.bytesFreed += size;
+                } catch (e) {
+                    result.failed.push({ path: dir, error: (e as Error).message });
+                }
+            }
+        }
+    }
+
+    private async cleanBuild(result: CleanResult, config: AppConfig): Promise<void> {
+        this.logger.step("Limpando diretórios de build...");
+        
+        const buildDirs = [
+            path.join(process.cwd(), PATHS.TARGET_DIR),
+            path.join(process.cwd(), PATHS.BUILD_DIR),
+        ];
+
+        for (const dir of buildDirs) {
+            if (existsSync(dir)) {
+                try {
+                    const size = await this.getDirectorySize(dir);
+                    await rm(dir, { recursive: true, force: true });
+                    result.cleaned.push(`build: ${path.basename(dir)}`);
+                    result.bytesFreed += size;
+                } catch (e) {
+                    result.failed.push({ path: dir, error: (e as Error).message });
+                }
+            }
+        }
+    }
+
+    private async cleanLogs(result: CleanResult, config: AppConfig): Promise<void> {
+        this.logger.step("Limpando logs...");
+        
+        const logDirs = [
+            path.join(config.tomcat.path, "logs"),
+            path.join(process.cwd(), PATHS.XAVVA_DIR, "logs"),
+        ];
+
+        for (const dir of logDirs) {
+            if (existsSync(dir)) {
+                try {
+                    const files = await readdir(dir);
+                    let dirSize = 0;
+                    
+                    for (const file of files) {
+                        if (file.endsWith('.log') || file.endsWith('.txt')) {
+                            const filePath = path.join(dir, file);
+                            const stats = await Bun.file(filePath).stat();
+                            dirSize += stats.size;
+                            await rm(filePath);
+                        }
+                    }
+                    
+                    result.cleaned.push(`logs: ${path.basename(dir)} (${files.length} arquivos)`);
+                    result.bytesFreed += dirSize;
+                } catch (e) {
+                    result.failed.push({ path: dir, error: (e as Error).message });
+                }
+            }
+        }
+    }
+
+    private async cleanTomcatWork(result: CleanResult, config: AppConfig): Promise<void> {
+        this.logger.step("Limpando work do Tomcat...");
+        
+        const workDirs = [
+            path.join(config.tomcat.path, "work"),
+            path.join(config.tomcat.path, "temp"),
+            path.join(config.tomcat.path, PATHS.WEBAPP_DIR),
+        ];
+
+        for (const dir of workDirs) {
+            if (existsSync(dir)) {
+                try {
+                    const size = await this.getDirectorySize(dir);
+                    await rm(dir, { recursive: true, force: true });
+                    result.cleaned.push(`tomcat: ${path.basename(dir)}`);
+                    result.bytesFreed += size;
+                } catch (e) {
+                    result.failed.push({ path: dir, error: (e as Error).message });
+                }
+            }
+        }
+    }
+
+    private async getDirectorySize(dir: string): Promise<number> {
+        let total = 0;
+        
+        try {
+            const files = await readdir(dir, { withFileTypes: true });
+            
+            for (const file of files) {
+                const filePath = path.join(dir, file.name);
+                
+                if (file.isDirectory()) {
+                    total += await this.getDirectorySize(filePath);
+                } else {
+                    const stats = await Bun.file(filePath).stat();
+                    total += stats.size;
+                }
+            }
+        } catch {
+            // Ignora erros
+        }
+        
+        return total;
+    }
+
+    private formatBytes(bytes: number): string {
+        if (bytes === 0) return "0 B";
+        
+        const units = ["B", "KB", "MB", "GB"];
+        const i = Math.floor(Math.log(bytes) / Math.log(1024));
+        
+        return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
+    }
+
+    private printSummary(result: CleanResult): void {
+        this.logger.newline();
+        this.logger.divider();
+        
+        if (result.cleaned.length > 0) {
+            this.logger.success(`${result.cleaned.length} item(ns) limpo(s)`);
+            for (const item of result.cleaned) {
+                this.logger.info(`  ✓ ${item}`);
+            }
+        }
+        
+        if (result.failed.length > 0) {
+            this.logger.warn(`${result.failed.length} falha(s)`);
+            for (const item of result.failed) {
+                this.logger.error(`  ✗ ${path.basename(item.path)}: ${item.error}`);
+            }
+        }
+        
+        this.logger.divider();
+        this.logger.info(`Espaço liberado: ${this.formatBytes(result.bytesFreed)}`);
+        
+        if (result.cleaned.length === 0 && result.failed.length === 0) {
+            this.logger.info("Nada para limpar - já está tudo organizado!");
+        }
+    }
+}

package/src/commands/CompletionCommand.ts

@@ -1,6 +1,6 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 
 export class CompletionCommand implements Command {
     private readonly commands = [
@@ -51,14 +51,14 @@ export class CompletionCommand implements Command {
                 Logger.section("Shell Completion");
                 Logger.info("Uso: xavva completion <shell>");
                 Logger.newline();
-                Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva completion bash${Logger.C.reset}  ${Logger.C.gray}# Bash${Logger.C.reset}`);
-                Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva completion zsh${Logger.C.reset}   ${Logger.C.gray}# Zsh${Logger.C.reset}`);
-                Logger.log(`${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva completion fish${Logger.C.reset}  ${Logger.C.gray}# Fish${Logger.C.reset}`);
+                Logger.log(`${C.gray}│${C.reset}  ${C.primary}xavva completion bash${C.reset}  ${C.gray}# Bash${C.reset}`);
+                Logger.log(`${C.gray}│${C.reset}  ${C.primary}xavva completion zsh${C.reset}   ${C.gray}# Zsh${C.reset}`);
+                Logger.log(`${C.gray}│${C.reset}  ${C.primary}xavva completion fish${C.reset}  ${C.gray}# Fish${C.reset}`);
                 Logger.endSection();
                 Logger.dim("Adicione ao seu shell:");
-                Logger.log(`  ${Logger.C.gray}# Bash: echo 'eval "$(xavva completion bash)"' >> ~/.bashrc${Logger.C.reset}`);
-                Logger.log(`  ${Logger.C.gray}# Zsh:  echo 'eval "$(xavva completion zsh)"' >> ~/.zshrc${Logger.C.reset}`);
-                Logger.log(`  ${Logger.C.gray}# Fish: xavva completion fish > ~/.config/fish/completions/xavva.fish${Logger.C.reset}`);
+                Logger.log(`  ${C.gray}# Bash: echo 'eval "$(xavva completion bash)"' >> ~/.bashrc${C.reset}`);
+                Logger.log(`  ${C.gray}# Zsh:  echo 'eval "$(xavva completion zsh)"' >> ~/.zshrc${C.reset}`);
+                Logger.log(`  ${C.gray}# Fish: xavva completion fish > ~/.config/fish/completions/xavva.fish${C.reset}`);
         }
     }
 

package/src/commands/DbCommand.ts

@@ -6,28 +6,30 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { DbService, type DbConfig } from "../services/DbService";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { ProcessManager } from "../utils/processManager";
 
 export class DbCommand implements Command {
+    private logger = Logger.getInstance();
+
     private showHelp(): void {
-        Logger.section("Database Command");
-        Logger.log(`${Logger.C.bold}Usage:${Logger.C.reset} xavva db <action> [options]`);
-        Logger.newline();
-        Logger.log(`${Logger.C.bold}Actions:${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.primary}status${Logger.C.reset}     Show migration status`);
-        Logger.log(`  ${Logger.C.primary}migrate${Logger.C.reset}    Run pending migrations`);
-        Logger.log(`  ${Logger.C.primary}reset${Logger.C.reset}      Reset database (⚠️ destructive)`);
-        Logger.log(`  ${Logger.C.primary}seed${Logger.C.reset}       Populate with test data`);
-        Logger.newline();
-        Logger.log(`${Logger.C.bold}Options:${Logger.C.reset}`);
-        Logger.log(`  --force           Confirm destructive operations`);
-        Logger.log(`  --env <name>      Use environment config`);
-        Logger.newline();
-        Logger.log(`${Logger.C.bold}Examples:${Logger.C.reset}`);
-        Logger.log(`  xavva db status`);
-        Logger.log(`  xavva db migrate`);
-        Logger.log(`  xavva db reset --force`);
+        this.logger.section("Database Command");
+        console.log(`Usage: xavva db <action> [options]`);
+        this.logger.newline();
+        console.log(`Actions:`);
+        console.log(`  status     Show migration status`);
+        console.log(`  migrate    Run pending migrations`);
+        console.log(`  reset      Reset database (! destructive)`);
+        console.log(`  seed       Populate with test data`);
+        this.logger.newline();
+        console.log(`Options:`);
+        console.log(`  --force           Confirm destructive operations`);
+        console.log(`  --env <name>      Use environment config`);
+        this.logger.newline();
+        console.log(`Examples:`);
+        console.log(`  xavva db status`);
+        console.log(`  xavva db migrate`);
+        console.log(`  xavva db reset --force`);
     }
 
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
@@ -52,7 +54,7 @@ export class DbCommand implements Command {
                 case "up":
                     const migrateResult = await service.migrate(dbConfig);
                     if (!migrateResult.success) {
-                        Logger.error(migrateResult.message);
+                        this.logger.error(migrateResult.message);
                         await processManager.shutdown(1);
                     }
                     break;
@@ -66,8 +68,8 @@ export class DbCommand implements Command {
                 case "clean":
                 case "drop":
                     if (!args?.force) {
-                        Logger.warn("This will DELETE all data in the database!");
-                        Logger.info("Use", "--force to confirm");
+                        this.logger.warn("This will DELETE all data in the database!");
+                        this.logger.info("Use --force to confirm");
                         await processManager.shutdown(1);
                         return;
                     }
@@ -82,7 +84,7 @@ export class DbCommand implements Command {
                 case "seed":
                     const seedResult = await service.seed(dbConfig, args?.src);
                     if (!seedResult.success) {
-                        Logger.error(seedResult.message);
+                        this.logger.error(seedResult.message);
                         await processManager.shutdown(1);
                     }
                     break;
@@ -92,12 +94,12 @@ export class DbCommand implements Command {
                     break;
 
                 default:
-                    Logger.error(`Unknown db action: ${action}`);
-                    Logger.info("Actions", "migrate, status, reset, seed, create");
+                    this.logger.error(`Unknown db action: ${action}`);
+                    this.logger.info("Actions: migrate, status, reset, seed, create");
                     await processManager.shutdown(1);
             }
         } catch (error) {
-            Logger.error(`Database command failed: ${(error as Error).message}`);
+            this.logger.error(`Database command failed: ${(error as Error).message}`);
             await processManager.shutdown(1);
         }
     }
@@ -130,8 +132,8 @@ export class DbCommand implements Command {
 
     private async createMigration(service: DbService, args?: CLIArguments): Promise<void> {
         const name = args?.name || "new_migration";
-        Logger.section("Create Migration");
-        Logger.info("Name", name);
+        this.logger.section("Create Migration");
+        this.logger.config("Name", name);
         
         // Detecta ferramenta
         const tool = await service.detectTool();
@@ -141,13 +143,13 @@ export class DbCommand implements Command {
             const filename = `V${timestamp}__${name}.sql`;
             const filepath = `src/main/resources/db/migration/${filename}`;
             
-            Logger.success(`Create file: ${filepath}`);
-            Logger.dim("-- Add your SQL here");
+            this.logger.success(`Create file: ${filepath}`);
+            console.log("-- Add your SQL here");
         } else if (tool === "liquibase") {
             const filename = `${name}.sql`;
-            Logger.success(`Add to changelog: db/changelog/${filename}`);
+            this.logger.success(`Add to changelog: db/changelog/${filename}`);
         } else {
-            Logger.warn("No migration tool detected");
+            this.logger.warn("No migration tool detected");
         }
     }
 }