@archznn/xavva 3.1.2 → 3.2.0

package/src/commands/DepsCommand.ts

@@ -3,182 +3,182 @@ import type { AppConfig, CLIArguments } from "../types/config";
 import type { DependencyAnalysisResult } from "../services/DependencyAnalyzerService";
 import { DependencyAnalyzerService } from "../services/DependencyAnalyzerService";
 import { AuditService } from "../services/AuditService";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import { ProcessManager } from "../utils/processManager";
 import fs from "fs";
+import path from "path";
 
 export class DepsCommand implements Command {
-	private config!: AppConfig;
-
-	async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
-		this.config = config;
-		const analyzer = new DependencyAnalyzerService(config.project);
-		analyzer.setVerbose(!!args?.verbose);
-
-		Logger.section("Análise de Dependências");
-		Logger.info("Ferramenta", config.project.buildTool.toUpperCase());
-		Logger.info("Diretório", process.cwd());
-		
-		const spinner = Logger.spinner("Analisando dependências...");
-		
-		try {
-			const result = await analyzer.analyze();
-			spinner();
-
-			// Se não encontrou dependências, mostrar ajuda
-			if (result.dependencies.length === 0) {
-				Logger.warn("Nenhuma dependência encontrada!");
-				Logger.info("Possíveis causas:", "");
-				Logger.log("  • Projeto não foi compilado ainda (execute: mvn compile)");
-				Logger.log("  • Maven não está no PATH");
-				Logger.log("  • Arquivo pom.xml/build.gradle não encontrado");
-				Logger.log("  • Erro de parsing no arquivo de configuração");
-				Logger.newline();
-				Logger.log(`${Logger.C.primary}Dica:${Logger.C.reset} Execute com --verbose para mais detalhes`);
-				return;
-			}
-
-			// Verificar vulnerabilidades se solicitado
-			if (args?.["scan"] !== false) {
-				Logger.step("Verificando vulnerabilidades");
-				// Integração com AuditService para check de vulnerabilidades
-				// nas dependências do projeto
-			}
-
-			// Exibir relatório
-			const report = analyzer.generateReport(result);
-			console.log(report);
-
-			// Ações adicionais baseadas em flags
-			if (args?.["update-safe"] || args?.["updateSafe"]) {
-				await this.performUpdateSafe(analyzer, result, config.project.buildTool);
-			}
-
-			if (args?.["fix"]) {
-				await this.suggestFixes(result, config.project.buildTool);
-			}
-
-			// Exportar resultado se solicitado
-			if (args?.["output"]) {
-				this.exportReport(result, args["output"] as string);
-			}
-
-			// Sair com erro se houver conflitos críticos
-			const hasErrors = result.conflicts.some(c => c.severity === "error");
-			if (hasErrors && args?.["strict"]) {
-				await ProcessManager.getInstance().shutdown(1);
-			}
-
-		} catch (error) {
-			spinner(false);
-			const message = error instanceof Error ? error.message : String(error);
-			Logger.error(`Falha na análise: ${message}`);
-			throw error;
-		}
-	}
-
-	private async suggestFixes(result: DependencyAnalysisResult, buildTool: string): Promise<void> {
-		if (result.conflicts.length === 0) {
-			Logger.success("Nenhum conflito para resolver!");
-			return;
-		}
-
-		Logger.newline();
-		Logger.section("Sugestões de Correção");
-
-		for (const conflict of result.conflicts) {
-			Logger.log(`\n${Logger.C.primary}${conflict.groupId}:${conflict.artifactId}${Logger.C.reset}`);
-			
-			if (buildTool === "maven") {
-				Logger.log("  Adicione ao pom.xml:");
-				Logger.log(`  ${Logger.C.dim}<dependencyManagement>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}  <dependencies>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}    <dependency>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}      <groupId>${conflict.groupId}</groupId>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}      <artifactId>${conflict.artifactId}</artifactId>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}      <version>${conflict.versions[conflict.versions.length - 1]}</version>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}    </dependency>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}  </dependencies>${Logger.C.reset}`);
-				Logger.log(`  ${Logger.C.dim}</dependencyManagement>${Logger.C.reset}`);
-			} else {
-				Logger.log("  Adicione ao build.gradle:");
-				Logger.log(`  ${Logger.C.dim}implementation("${conflict.groupId}:${conflict.artifactId}:${conflict.versions[conflict.versions.length - 1]}")${Logger.C.reset}`);
-			}
-		}
-	}
-
-	private async performUpdateSafe(
-		analyzer: DependencyAnalyzerService,
-		result: DependencyAnalysisResult,
-		buildTool: string
-	): Promise<void> {
-		const safeUpdates = result.updates.filter(u => !u.isMajor);
-		
-		if (safeUpdates.length === 0) {
-			Logger.info("", "Nenhuma atualização segura disponível");
-			return;
-		}
-
-		Logger.newline();
-		Logger.section("Atualizando Dependências (Safe Mode)");
-		Logger.info("Atualizações a aplicar", String(safeUpdates.length));
-
-		const spinner = Logger.spinner("Atualizando arquivos de configuração...");
-		
-		try {
-			const updateResult = await analyzer.updateSafe(safeUpdates);
-			spinner();
-
-			if (updateResult.updated > 0) {
-				Logger.success(`${updateResult.updated} dependências atualizadas`);
-				Logger.info("", `Backup criado: ${buildTool === "maven" ? "pom.xml.backup" : "build.gradle.backup"}`);
-				
-				// Listar o que foi atualizado
-				for (const update of safeUpdates.slice(0, 5)) {
-					Logger.log(`  ${Logger.C.success}↑${Logger.C.reset} ${update.groupId}:${update.artifactId} ${update.currentVersion} → ${Logger.C.success}${update.latestVersion}${Logger.C.reset}`);
-				}
-				if (safeUpdates.length > 5) {
-					Logger.log(`  ${Logger.C.dim}... e mais ${safeUpdates.length - 5}${Logger.C.reset}`);
-				}
-
-				Logger.newline();
-				Logger.log(`${Logger.C.warning}⚠️  Execute 'xavva build' para compilar e aplicar as mudanças${Logger.C.reset}`);
-				Logger.log(`${Logger.C.primary}💡 Dica:${Logger.C.reset} Execute 'xavva audit' para verificar vulnerabilidades nas novas versões`);
-			} else {
-				Logger.warn("Nenhuma dependência foi atualizada");
-			}
-
-			if (updateResult.skipped > 0) {
-				Logger.info("Dependências ignoradas", `${updateResult.skipped} (definidas via propriedades)`);
-			}
-
-			if (updateResult.errors.length > 0) {
-				for (const error of updateResult.errors) {
-					Logger.warn(error);
-				}
-			}
-		} catch (error) {
-			spinner(false);
-			const message = error instanceof Error ? error.message : String(error);
-			Logger.error(`Falha na atualização: ${message}`);
-		}
-	}
-
-	private exportReport(
-		result: DependencyAnalysisResult,
-		outputPath: string
-	): void {
-		const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), "utf-8"));
-		const data = {
-			timestamp: new Date().toISOString(),
-			tool: "xavva",
-			version: pkg.version,
-			result
-		};
-		
-		fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
-		Logger.success(`Relatório exportado para: ${outputPath}`);
-	}
+    private logger = Logger.getInstance();
+    private config!: AppConfig;
+
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        this.config = config;
+        const analyzer = new DependencyAnalyzerService(config.project);
+        analyzer.setVerbose(!!args?.verbose);
+
+        this.logger.section("Análise de Dependências");
+        this.logger.config("Ferramenta", config.project.buildTool.toUpperCase());
+        this.logger.config("Diretório", process.cwd());
+        
+        const spinner = this.logger.spinner("Analisando dependências...");
+        
+        try {
+            const result = await analyzer.analyze();
+            spinner.stop();
+
+            // Se não encontrou dependências, mostrar ajuda
+            if (result.dependencies.length === 0) {
+                this.logger.warn("Nenhuma dependência encontrada!");
+                this.logger.info("Possíveis causas:");
+                console.log("  • Projeto não foi compilado ainda (execute: mvn compile)");
+                console.log("  • Maven não está no PATH");
+                console.log("  • Arquivo pom.xml/build.gradle não encontrado");
+                console.log("  • Erro de parsing no arquivo de configuração");
+                this.logger.newline();
+                console.log(`Dica: Execute com --verbose para mais detalhes`);
+                return;
+            }
+
+            // Verificar vulnerabilidades se solicitado
+            if (args?.["scan"] !== false) {
+                this.logger.step("Verificando vulnerabilidades");
+                // Integração com AuditService para check de vulnerabilidades
+                // nas dependências do projeto
+            }
+
+            // Exibir relatório
+            const report = analyzer.generateReport(result);
+            console.log(report);
+
+            // Ações adicionais baseadas em flags
+            if (args?.["update-safe"] || args?.["updateSafe"]) {
+                await this.performUpdateSafe(analyzer, result, config.project.buildTool);
+            }
+
+            if (args?.["fix"]) {
+                await this.suggestFixes(result, config.project.buildTool);
+            }
+
+            // Exportar resultado se solicitado
+            if (args?.["output"]) {
+                this.exportReport(result, args["output"] as string);
+            }
+
+            // Sair com erro se houver conflitos críticos
+            const hasErrors = result.conflicts.some(c => c.severity === "error");
+            if (hasErrors && args?.["strict"]) {
+                await ProcessManager.getInstance().shutdown(1);
+            }
+
+        } catch (error) {
+            spinner.stop(false);
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Falha na análise: ${message}`);
+            throw error;
+        }
+    }
+
+    private async suggestFixes(result: DependencyAnalysisResult, buildTool: string): Promise<void> {
+        if (result.conflicts.length === 0) {
+            this.logger.success("Nenhum conflito para resolver!");
+            return;
+        }
+
+        this.logger.newline();
+        this.logger.section("Sugestões de Correção");
+
+        for (const conflict of result.conflicts) {
+            console.log(`\n${conflict.groupId}:${conflict.artifactId}`);
+            
+            if (buildTool === "maven") {
+                console.log("  Adicione ao pom.xml:");
+                console.log(`  <dependencyManagement>`);
+                console.log(`    <dependencies>`);
+                console.log(`      <dependency>`);
+                console.log(`        <groupId>${conflict.groupId}</groupId>`);
+                console.log(`        <artifactId>${conflict.artifactId}</artifactId>`);
+                console.log(`        <version>${conflict.versions[conflict.versions.length - 1]}</version>`);
+                console.log(`      </dependency>`);
+                console.log(`    </dependencies>`);
+                console.log(`  </dependencyManagement>`);
+            } else {
+                console.log("  Adicione ao build.gradle:");
+                console.log(`  implementation("${conflict.groupId}:${conflict.artifactId}:${conflict.versions[conflict.versions.length - 1]}")`);
+            }
+        }
+    }
+
+    private async performUpdateSafe(
+        analyzer: DependencyAnalyzerService,
+        result: DependencyAnalysisResult,
+        buildTool: string
+    ): Promise<void> {
+        const safeUpdates = result.updates.filter(u => !u.isMajor);
+        
+        if (safeUpdates.length === 0) {
+            this.logger.info("Nenhuma atualização segura disponível");
+            return;
+        }
+
+        this.logger.newline();
+        this.logger.section("Atualizando Dependências (Safe Mode)");
+        this.logger.config("Atualizações a aplicar", String(safeUpdates.length));
+
+        const spinner = this.logger.spinner("Atualizando arquivos de configuração...");
+        
+        try {
+            const updateResult = await analyzer.updateSafe(safeUpdates);
+            spinner.stop();
+
+            if (updateResult.updated > 0) {
+                this.logger.success(`${updateResult.updated} dependências atualizadas`);
+                this.logger.info(`Backup criado: ${buildTool === "maven" ? "pom.xml.backup" : "build.gradle.backup"}`);
+                
+                // Listar o que foi atualizado
+                for (const update of safeUpdates.slice(0, 5)) {
+                    console.log(`  ↑ ${update.groupId}:${update.artifactId} ${update.currentVersion} → ${update.latestVersion}`);
+                }
+                if (safeUpdates.length > 5) {
+                    console.log(`  ... e mais ${safeUpdates.length - 5}`);
+                }
+
+                this.logger.newline();
+                console.log(`! Execute 'xavva build' para compilar e aplicar as mudancas`);
+                console.log(`* Dica: Execute 'xavva audit' para verificar vulnerabilidades nas novas versoes`);
+            } else {
+                this.logger.warn("Nenhuma dependência foi atualizada");
+            }
+
+            if (updateResult.skipped > 0) {
+                this.logger.config("Dependências ignoradas", `${updateResult.skipped} (definidas via propriedades)`);
+            }
+
+            if (updateResult.errors.length > 0) {
+                for (const error of updateResult.errors) {
+                    this.logger.warn(error);
+                }
+            }
+        } catch (error) {
+            spinner.stop(false);
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Falha na atualização: ${message}`);
+        }
+    }
+
+    private exportReport(
+        result: DependencyAnalysisResult,
+        outputPath: string
+    ): void {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), "utf-8"));
+        const data = {
+            timestamp: new Date().toISOString(),
+            tool: "xavva",
+            version: pkg.version,
+            result
+        };
+        
+        fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+        this.logger.success(`Relatório exportado para: ${outputPath}`);
+    }
 }
-
-import path from "path";

package/src/commands/DockerCommand.ts

@@ -6,12 +6,43 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { DockerService, type DockerConfig } from "../services/DockerService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import { ProcessManager } from "../utils/processManager";
 
 export class DockerCommand implements Command {
+    private showHelp(): void {
+        Logger.section("Docker Command");
+        Logger.log(`${C.bold}Usage:${C.reset} xavva docker <action> [options]`);
+        Logger.newline();
+        Logger.log(`${C.bold}Actions:${C.reset}`);
+        Logger.log(`  ${C.primary}init${C.reset}       Generate Dockerfile & docker-compose.yml`);
+        Logger.log(`  ${C.primary}build${C.reset}      Build Docker image`);
+        Logger.log(`  ${C.primary}run${C.reset}        Run development container`);
+        Logger.log(`  ${C.primary}up${C.reset}         Start with docker-compose`);
+        Logger.log(`  ${C.primary}down${C.reset}       Stop containers`);
+        Logger.log(`  ${C.primary}status${C.reset}     Show container status`);
+        Logger.newline();
+        Logger.log(`${C.bold}Options:${C.reset}`);
+        Logger.log(`  --name <n>        Image name`);
+        Logger.log(`  --tag <t>         Image tag`);
+        Logger.log(`  --port <p>        Port mapping`);
+        Logger.log(`  -d, --detached    Run in background`);
+        Logger.newline();
+        Logger.log(`${C.bold}Examples:${C.reset}`);
+        Logger.log(`  xavva docker init`);
+        Logger.log(`  xavva docker build --tag myapp:1.0`);
+        Logger.log(`  xavva docker up -d`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
         const processManager = ProcessManager.getInstance();
+
+        // Mostra help se solicitado
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
+
         const action = positionals?.[1] || "status";
 
         const service = new DockerService();
@@ -109,9 +140,9 @@ export class DockerCommand implements Command {
 
         Logger.divider();
         Logger.info("Next steps", "");
-        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker build${Logger.C.reset}  ${Logger.C.gray}- Build image${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker up${Logger.C.reset}      ${Logger.C.gray}- Start containers${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}xavva docker run${Logger.C.reset}     ${Logger.C.gray}- Run dev mode${Logger.C.reset}`);
+        Logger.log(`  ${C.gray}│${C.reset}  ${C.primary}xavva docker build${C.reset}  ${C.gray}- Build image${C.reset}`);
+        Logger.log(`  ${C.gray}│${C.reset}  ${C.primary}xavva docker up${C.reset}      ${C.gray}- Start containers${C.reset}`);
+        Logger.log(`  ${C.gray}│${C.reset}  ${C.primary}xavva docker run${C.reset}     ${C.gray}- Run dev mode${C.reset}`);
         Logger.endSection();
     }