@archznn/xavva 3.1.3 → 3.2.0

package/src/services/tomcat/types.ts

@@ -0,0 +1,120 @@
+/**
+ * Tipos compartilhados para serviços Tomcat
+ */
+
+/** Configuração de proxy */
+export interface TomcatProxyConfig {
+    http?: string;
+    https?: string;
+    noProxy?: string[];
+}
+
+/** Informações de mirror */
+export interface TomcatMirror {
+    name: string;
+    url: string;
+    region: string;
+    priority: number;
+}
+
+/** Configuração de download */
+export interface TomcatDownloadConfig {
+    /** Versão do Tomcat */
+    version: string;
+    /** Mirror preferido (ou 'auto' para seleção automática) */
+    mirror?: string | "auto";
+    /** Timeout em segundos */
+    timeout?: number;
+    /** Número de retries */
+    retries?: number;
+    /** Habilitar resume */
+    resume?: boolean;
+    /** Modo silencioso */
+    silent?: boolean;
+    /** Configuração de proxy */
+    proxy?: TomcatProxyConfig;
+    /** Cache de downloads */
+    cache?: {
+        enabled: boolean;
+        dir: string;
+    };
+}
+
+/** Resultado de instalação */
+export interface TomcatInstallResult {
+    success: boolean;
+    version: string;
+    home: string;
+    downloaded: boolean;
+    cached: boolean;
+    resumed: boolean;
+    attempts: number;
+    duration: number;
+    speed: number;
+    size: number;
+    checksum?: {
+        expected: string;
+        actual: string;
+        valid: boolean;
+    };
+    error?: string;
+}
+
+/** Informações de versão instalada */
+export interface InstalledVersion {
+    version: string;
+    home: string;
+    size: number;
+    installedAt: Date;
+    lastUsed?: Date;
+}
+
+/** Resultado de backup */
+export interface BackupResult {
+    success: boolean;
+    backupPath: string;
+    size: number;
+    timestamp: Date;
+}
+
+/** Resultado de restore */
+export interface RestoreResult {
+    success: boolean;
+    fromVersion: string;
+    toVersion: string;
+    backupPath: string;
+}
+
+/** Compatibilidade de versão */
+export interface CompatibilityResult {
+    compatible: boolean;
+    tomcatVersion: string;
+    servletVersion: string;
+    jspVersion: string;
+    warnings: string[];
+    errors: string[];
+}
+
+/** Estado do cache */
+export interface CacheState {
+    enabled: boolean;
+    dir: string;
+    size: number;
+    files: CacheFile[];
+}
+
+/** Arquivo em cache */
+export interface CacheFile {
+    name: string;
+    size: number;
+    modified: Date;
+    checksum: string;
+}
+
+/** Configuração de backup */
+export interface BackupConfig {
+    enabled: boolean;
+    dir: string;
+    maxBackups: number;
+    autoBackup: boolean;
+}

package/src/types/args.ts

@@ -125,6 +125,65 @@ export interface CompletionArgs extends BaseArgs {
     shell?: string;
 }
 
+// ===== Args do Novo Comando Clean =====
+export interface CleanArgs extends BaseArgs {
+    all?: boolean;
+    cache?: boolean;
+    build?: boolean;
+    logs?: boolean;
+    tomcat?: boolean;
+}
+
+// ===== Args do Comando Test =====
+export interface TestArgs extends BaseArgs {
+    watch?: boolean;
+    coverage?: boolean;
+    "fail-fast"?: boolean;
+    parallel?: boolean;
+    // Positional: filter
+}
+
+// ===== Args do Comando DB =====
+export interface DbArgs extends BaseArgs {
+    force?: boolean;
+    // Positional: action (status, migrate, reset, seed)
+}
+
+// ===== Args do Comando HTTP =====
+export interface HttpArgs extends BaseArgs {
+    "base-url"?: string;
+    body?: string;
+    file?: string;
+    header?: string[];
+    "content-type"?: string;
+    accept?: string;
+    param?: string[];
+    timeout?: string;
+    // Positional: method, path
+}
+
+// ===== Args do Comando Docker =====
+export interface DockerArgs extends BaseArgs {
+    tag?: string;
+    "java-version"?: string;
+    detached?: boolean;
+    registry?: string;
+    namespace?: string;
+    // Positional: action (init, build, up, down, run, status)
+}
+
+// ===== Args do Comando Changelog =====
+export interface ChangelogArgs extends BaseArgs {
+    output?: string;
+    from?: string;
+    to?: string;
+}
+
+// ===== Args do Novo Comando IDE =====
+export interface IdeArgs extends BaseArgs {
+    ide?: "vscode" | "idea" | "eclipse";
+}
+
 // ===== CLIArguments Legado (para compatibilidade) =====
 // Será gradualmente removido
 export interface CLIArguments extends 
@@ -134,7 +193,15 @@ export interface CLIArguments extends
     DebugArgs, 
     AnalysisArgs, 
     EncodingArgs {
-    // Campos adicionais para compatibilidade
+    // Propriedades de CleanArgs
+    all?: boolean;
+    cache?: boolean;
+    build?: boolean;
+    logs?: boolean;
+    tomcat?: boolean;
+    // Propriedades extras
+    i?: boolean;
+    o?: string;
     [key: string]: unknown;
 }
 

package/src/types/configSchema.ts

@@ -0,0 +1,174 @@
+/**
+ * Schemas de validação Zod para configurações do XAVVA CLI
+ * Garante type safety e validação em runtime
+ */
+
+import { z } from "zod";
+
+// ============================================
+// SCHEMAS BASE
+// ============================================
+
+export const TomcatConfigSchema = z.object({
+    path: z.string().min(1, "Tomcat path é obrigatório"),
+    port: z.number().int().min(1).max(65535).default(8080),
+    webapps: z.string().default("webapps"),
+    grep: z.string().default(""),
+    embedded: z.boolean().default(false),
+    version: z.string().regex(/^\d+\.\d+\.\d+$/, "Versão deve seguir formato semver").default("10.1.52"),
+});
+
+export const ProjectConfigSchema = z.object({
+    appName: z.string().default(""),
+    buildTool: z.enum(["maven", "gradle"]).default("maven"),
+    profile: z.string().default(""),
+    skipBuild: z.boolean().default(false),
+    skipScan: z.boolean().default(true),
+    clean: z.boolean().default(false),
+    cleanLogs: z.boolean().default(true),
+    quiet: z.boolean().default(true),
+    verbose: z.boolean().default(false),
+    debug: z.boolean().default(false),
+    debugPort: z.number().int().min(1).max(65535).default(5005),
+    grep: z.string().default(""),
+    tui: z.boolean().default(false),
+    encoding: z.string().default(""),
+    war: z.boolean().default(false),
+    cache: z.boolean().default(false),
+    environment: z.string().default(""),
+    environments: z.record(z.any()).optional(),
+});
+
+export const AppConfigSchema = z.object({
+    tomcat: TomcatConfigSchema,
+    project: ProjectConfigSchema,
+});
+
+// ============================================
+// SCHEMAS DE CLI ARGS
+// ============================================
+
+export const BaseArgsSchema = z.object({
+    help: z.boolean().optional(),
+    version: z.boolean().optional(),
+    verbose: z.boolean().optional(),
+    quiet: z.boolean().optional(),
+    "debug-level": z.enum(["silent", "error", "warn", "info", "verbose", "trace", "silly"]).optional(),
+});
+
+export const ProjectArgsSchema = z.object({
+    tool: z.enum(["maven", "gradle"]).optional(),
+    name: z.string().optional(),
+    profile: z.string().optional(),
+    encoding: z.string().optional(),
+    "no-build": z.boolean().optional(),
+    clean: z.boolean().optional(),
+    war: z.boolean().optional(),
+    cache: z.boolean().optional(),
+});
+
+export const TomcatArgsSchema = z.object({
+    path: z.string().optional(),
+    port: z.string().optional(),
+    "tomcat-version": z.string().optional(),
+    yes: z.boolean().optional(),
+});
+
+export const DebugArgsSchema = z.object({
+    debug: z.boolean().optional(),
+    watch: z.boolean().optional(),
+    tui: z.boolean().optional(),
+    dp: z.string().optional(),
+});
+
+// ============================================
+// TIPOS INFERIDOS
+// ============================================
+
+export type ValidatedTomcatConfig = z.infer<typeof TomcatConfigSchema>;
+export type ValidatedProjectConfig = z.infer<typeof ProjectConfigSchema>;
+export type ValidatedAppConfig = z.infer<typeof AppConfigSchema>;
+
+// ============================================
+// FUNÇÕES DE VALIDAÇÃO
+// ============================================
+
+/**
+ * Valida configuração completa do aplicativo
+ */
+export function validateAppConfig(config: unknown): ValidatedAppConfig {
+    if (!config || typeof config !== 'object') {
+        throw new Error("Configuração deve ser um objeto");
+    }
+    
+    const result = AppConfigSchema.safeParse(config);
+    
+    if (!result.success) {
+        const issues = result.error?.issues || result.error?.errors || [];
+        const formattedErrors = issues.map((e: any) => 
+            `${e.path?.join('.') || 'root'}: ${e.message}`
+        ).join('\n');
+        
+        throw new Error(`Configuração inválida:\n${formattedErrors || result.error?.message || 'Erro desconhecido'}`);
+    }
+    
+    return result.data;
+}
+
+/**
+ * Valida config parcial (para merges)
+ */
+export function validatePartialConfig(config: unknown): Partial<ValidatedAppConfig> {
+    const result = AppConfigSchema.partial().safeParse(config);
+    
+    if (!result.success) {
+        const formattedErrors = result.error.errors.map(e => 
+            `${e.path.join('.')}: ${e.message}`
+        ).join('\n');
+        
+        throw new Error(`Configuração parcial inválida:\n${formattedErrors}`);
+    }
+    
+    return result.data;
+}
+
+/**
+ * Valida porta (helper)
+ */
+export function validatePort(port: string | number): number {
+    const num = typeof port === 'string' ? parseInt(port, 10) : port;
+    
+    if (isNaN(num) || num < 1 || num > 65535) {
+        throw new Error(`Porta inválida: ${port}. Deve ser entre 1 e 65535.`);
+    }
+    
+    return num;
+}
+
+/**
+ * Valida versão do Tomcat
+ */
+export function validateTomcatVersion(version: string): string {
+    const semverRegex = /^\d+\.\d+\.\d+$/;
+    
+    if (!semverRegex.test(version)) {
+        throw new Error(`Versão do Tomcat inválida: ${version}. Formato esperado: x.x.x (ex: 10.1.52)`);
+    }
+    
+    return version;
+}
+
+/**
+ * Merge seguro de configurações
+ */
+export function mergeConfigs(
+    base: Partial<ValidatedAppConfig>,
+    override: Partial<ValidatedAppConfig>
+): ValidatedAppConfig {
+    const merged = {
+        tomcat: { ...base.tomcat, ...override.tomcat },
+        project: { ...base.project, ...override.project },
+    };
+    
+    return validateAppConfig(merged);
+}

package/src/utils/ChangelogGenerator.ts

@@ -20,17 +20,17 @@ interface Version {
 
 export class ChangelogGenerator {
     private static readonly TYPES: Record<string, { title: string; emoji: string }> = {
-        feat: { title: "Features", emoji: "✨" },
-        fix: { title: "Bug Fixes", emoji: "🐛" },
-        docs: { title: "Documentation", emoji: "📚" },
-        style: { title: "Styles", emoji: "💎" },
-        refactor: { title: "Code Refactoring", emoji: "♻️" },
-        perf: { title: "Performance", emoji: "⚡" },
-        test: { title: "Tests", emoji: "🧪" },
-        build: { title: "Build System", emoji: "🏗️" },
-        ci: { title: "CI/CD", emoji: "🔄" },
-        chore: { title: "Chores", emoji: "🔧" },
-        revert: { title: "Reverts", emoji: "⏪" },
+        feat: { title: "Features", emoji: "+" },
+        fix: { title: "Bug Fixes", emoji: "!" },
+        docs: { title: "Documentation", emoji: "D" },
+        style: { title: "Styles", emoji: "S" },
+        refactor: { title: "Code Refactoring", emoji: "R" },
+        perf: { title: "Performance", emoji: "P" },
+        test: { title: "Tests", emoji: "T" },
+        build: { title: "Build System", emoji: "B" },
+        ci: { title: "CI/CD", emoji: "C" },
+        chore: { title: "Chores", emoji: "*" },
+        revert: { title: "Reverts", emoji: "-" },
     };
 
     static generate(): string {

package/src/utils/LoggerLevel.ts

@@ -1,4 +1,10 @@
-import { Logger } from "./ui";
+/**
+ * LoggerLevel - Adaptador para o novo sistema de logging
+ * 
+ * @deprecated Use o Logger de src/logging/ diretamente
+ */
+
+import { Logger } from "../logging";
 
 export type LogLevel = "silent" | "error" | "warn" | "info" | "verbose" | "trace" | "silly";
 
@@ -8,20 +14,28 @@ interface LogLevelConfig {
     prefix: string;
 }
 
+/**
+ * @deprecated Use Logger de src/logging/
+ * 
+ * LoggerLevel - Adaptador que delega para o novo sistema de logging
+ */
 export class LoggerLevel {
     private static currentLevel: LogLevel = "info";
+    private static logger = Logger.getInstance();
+    
     private static readonly levels: Record<LogLevel, LogLevelConfig> = {
         silent: { value: 0, color: "", prefix: "" },
-        error: { value: 1, color: Logger.C.error, prefix: "ERR" },
-        warn: { value: 2, color: Logger.C.warning, prefix: "WRN" },
-        info: { value: 3, color: Logger.C.info, prefix: "INF" },
-        verbose: { value: 4, color: Logger.C.primary, prefix: "VRB" },
-        trace: { value: 5, color: Logger.C.gray, prefix: "TRC" },
-        silly: { value: 6, color: Logger.C.darkGray, prefix: "SLY" },
+        error: { value: 1, color: Logger.getInstance()['config'].colors ? "\x1b[31m" : "", prefix: "ERR" },
+        warn: { value: 2, color: Logger.getInstance()['config'].colors ? "\x1b[33m" : "", prefix: "WRN" },
+        info: { value: 3, color: Logger.getInstance()['config'].colors ? "\x1b[34m" : "", prefix: "INF" },
+        verbose: { value: 4, color: Logger.getInstance()['config'].colors ? "\x1b[36m" : "", prefix: "VRB" },
+        trace: { value: 5, color: Logger.getInstance()['config'].colors ? "\x1b[90m" : "", prefix: "TRC" },
+        silly: { value: 6, color: Logger.getInstance()['config'].colors ? "\x1b[38;5;240m" : "", prefix: "SLY" },
     };
 
     static setLevel(level: LogLevel): void {
         this.currentLevel = level;
+        this.logger.setLevel(level);
     }
 
     static getLevel(): LogLevel {
@@ -35,17 +49,27 @@ export class LoggerLevel {
     private static log(level: LogLevel, message: string, ...args: unknown[]): void {
         if (!this.shouldLog(level)) return;
         
-        const config = this.levels[level];
         const formatted = args.length > 0 
             ? this.formatMessage(message, args)
             : message;
         
-        if (level === "error") {
-            Logger.error(formatted);
-        } else if (level === "warn") {
-            Logger.warn(formatted);
-        } else {
-            console.log(`${Logger.C.gray}│${Logger.C.reset}  ${config.color}[${config.prefix}]${Logger.C.reset} ${formatted}`);
+        switch (level) {
+            case "error":
+                this.logger.error(formatted);
+                break;
+            case "warn":
+                this.logger.warn(formatted);
+                break;
+            case "info":
+                this.logger.info(formatted);
+                break;
+            case "verbose":
+                this.logger.debug(formatted);
+                break;
+            case "trace":
+            case "silly":
+                this.logger.trace(formatted);
+                break;
         }
     }
 
@@ -87,13 +111,13 @@ export class LoggerLevel {
     // Utility methods for specific debug scenarios
     static debugCommand(command: string, args: string[]): void {
         if (this.shouldLog("verbose")) {
-            this.verbose("Executing: %1 %2", command, args.join(" "));
+            this.verbose("Executando: %1 %2", command, args.join(" "));
         }
     }
 
     static debugSpawn(cmd: string, options: Record<string, unknown>): void {
         if (this.shouldLog("trace")) {
-            this.trace("Spawn: %1 with options: %2", cmd, options);
+            this.trace("Spawn: %1 com opções: %2", cmd, options);
         }
     }
 
@@ -106,7 +130,7 @@ export class LoggerLevel {
 
     static debugFile(operation: string, path: string, details?: unknown): void {
         if (this.shouldLog("trace")) {
-            this.trace("File %1: %2 %3", operation, path, details || "");
+            this.trace("Arquivo %1: %2 %3", operation, path, details || "");
         }
     }
 
@@ -118,7 +142,7 @@ export class LoggerLevel {
 
     static debugPerformance(operation: string, durationMs: number): void {
         if (this.shouldLog("verbose")) {
-            this.verbose("Performance: %1 took %2ms", operation, durationMs);
+            this.verbose("Performance: %1 levou %2ms", operation, durationMs);
         }
     }
 
@@ -128,11 +152,11 @@ export class LoggerLevel {
         }
         
         const start = performance.now();
-        this.verbose("Timing started: %1", label);
+        this.verbose("Timing iniciado: %1", label);
         
         return () => {
             const duration = Math.round(performance.now() - start);
-            this.verbose("Timing ended: %1 took %2ms", label, duration);
+            this.verbose("Timing finalizado: %1 levou %2ms", label, duration);
         };
     }
 }