@archznn/xavva 3.1.3 → 3.2.0

package/src/utils/ProgressBar.ts

@@ -1,4 +1,10 @@
-import { Logger } from "./ui";
+/**
+ * ProgressBar - Adaptador para o novo sistema de logging
+ * 
+ * @deprecated Use ProgressLogger de src/logging/
+ */
+
+import { Logger, ProgressLogger, Colors } from "../logging";
 
 export interface ProgressBarOptions {
     title: string;
@@ -6,13 +12,18 @@ export interface ProgressBarOptions {
     width?: number;
     showPercentage?: boolean;
     showEta?: boolean;
+    showSpeed?: boolean;
 }
 
+/**
+ * @deprecated Use ProgressLogger de src/logging/
+ */
 export class ProgressBar {
     private current = 0;
     private startTime: number;
     private options: Required<ProgressBarOptions>;
     private isComplete = false;
+    private logger: ProgressLogger;
 
     constructor(options: ProgressBarOptions) {
         this.options = {
@@ -22,12 +33,55 @@ export class ProgressBar {
             ...options
         };
         this.startTime = Date.now();
+        
+        // Cria um ProgressLogger interno
+        this.logger = new ProgressLogger(options.title, {
+            total: options.total,
+            width: this.options.width,
+            showPercentage: this.options.showPercentage,
+            showEta: this.options.showEta,
+        });
     }
 
-    update(current: number): void {
+    update(current: number, speed?: number, eta?: number): void {
         if (this.isComplete) return;
         this.current = Math.min(current, this.options.total);
-        this.render();
+        
+        // Atualiza o ProgressLogger interno com extras se disponíveis
+        if (speed !== undefined && eta !== undefined) {
+            // Cria string de extras
+            const extras: string[] = [];
+            if (this.options.showSpeed && speed > 0) {
+                extras.push(`${speed.toFixed(1)} MB/s`);
+            }
+            if (this.options.showEta && eta > 0) {
+                const etaSec = Math.ceil(eta);
+                if (etaSec < 60) {
+                    extras.push(`${etaSec}s restantes`);
+                } else {
+                    extras.push(`${Math.ceil(etaSec / 60)}min restantes`);
+                }
+            }
+            
+            // Renderiza com extras
+            this.renderWithExtras(extras);
+        } else {
+            this.logger.update(this.current);
+        }
+    }
+
+    private renderWithExtras(extras: string[]): void {
+        // Acessa o método privado via cast para atualizar com extras
+        const percentage = Math.floor((this.current / this.options.total) * 100);
+        const filled = Math.floor((this.current / this.options.total) * this.options.width);
+        const empty = this.options.width - filled;
+        
+        const bar = "█".repeat(filled) + "░".repeat(empty);
+        const extraStr = extras.length > 0 ? ` | ${extras.join(" | ")}` : "";
+        
+        process.stdout.clearLine?.(0);
+        process.stdout.cursorTo?.(0);
+        process.stdout.write(`  ${this.options.title}: [${bar}] ${percentage}%${extraStr}`);
     }
 
     increment(amount = 1): void {
@@ -38,54 +92,39 @@ export class ProgressBar {
         if (this.isComplete) return;
         this.current = this.options.total;
         this.isComplete = true;
-        this.render();
-        process.stdout.write("\n");
+        
+        // Limpa linha e mostra completo
+        process.stdout.clearLine?.(0);
+        process.stdout.cursorTo?.(0);
+        
+        this.logger.complete();
     }
 
     private render(): void {
-        const { title, total, width, showPercentage, showEta } = this.options;
-        const ratio = this.current / total;
-        const filled = Math.floor(ratio * width);
-        const empty = width - filled;
-
-        const bar = "█".repeat(filled) + "░".repeat(empty);
-        const percentage = Math.floor(ratio * 100);
-
-        let line = `${Logger.C.gray}│${Logger.C.reset}  ${Logger.C.primary}▸${Logger.C.reset} ${Logger.C.dim}${title}${Logger.C.reset} `;
-        line += `${Logger.C.primary}[${bar}]${Logger.C.reset}`;
-
-        if (showPercentage) {
-            line += ` ${Logger.C.white}${percentage}%${Logger.C.reset}`;
-        }
-
-        if (showEta && this.current > 0) {
-            const elapsed = Date.now() - this.startTime;
-            const eta = Math.ceil((elapsed / this.current) * (total - this.current) / 1000);
-            line += ` ${Logger.C.gray}(ETA: ${eta}s)${Logger.C.reset}`;
-        }
-
-        // Clear line and write new content
-        process.stdout.write(`\r${line}`);
+        // Delegado para o ProgressLogger
+        this.logger.update(this.current);
     }
 }
 
-// Spinner especializado para diferentes operações
+/**
+ * @deprecated Use ProgressLogger de src/logging/
+ */
 export class ThemedSpinner {
     private static frames = {
-        default: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-        dots: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"],
+        default: ["|", "/", "-", "\\"],
+        dots: [".", "..", "...", "....", ".....", "....", "...", ".."],
         line: ["-", "\\", "|", "/"],
-        arrow: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
-        pulse: ["█", "▉", "▊", "▋", "▌", "▍", "▎", "▏"],
-        moon: ["🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"]
+        arrow: [">", "->", "-->", "--->", "---->", "--->", "-->", "->"],
+        pulse: ["#", "##", "###", "####", "#####", "####", "###", "##"],
+        moon: ["(", "(-", "(-(", "(-(-", "(-(-(", "(-(-", "(-(", "(-"]
     };
 
     private static colors = {
-        default: Logger.C.primary,
-        build: Logger.C.warning,
-        download: Logger.C.info,
-        deploy: Logger.C.success,
-        watch: Logger.C.secondary
+        default: Colors.primary,
+        build: Colors.warning,
+        download: Colors.info,
+        deploy: Colors.success,
+        watch: Colors.secondary
     };
 
     private timer?: Timer;
@@ -99,12 +138,12 @@ export class ThemedSpinner {
         const frames = ThemedSpinner.frames[theme];
         const colorCode = ThemedSpinner.colors[color];
 
-        process.stdout.write(`${Logger.C.gray}│${Logger.C.reset}  `);
+        process.stdout.write(`${Colors.gray}│${Colors.reset}  `);
         process.stdout.write("\x1B[?25l");
 
         this.timer = setInterval(() => {
             const frame = frames[this.frameIndex];
-            process.stdout.write(`\r${Logger.C.gray}│${Logger.C.reset}  ${colorCode}${frame}${Logger.C.reset} ${Logger.C.dim}${message}${Logger.C.reset}`);
+            process.stdout.write(`\r${Colors.gray}│${Colors.reset}  ${colorCode}${frame}${Colors.reset} ${Colors.dim}${message}${Colors.reset}`);
             this.frameIndex = (this.frameIndex + 1) % frames.length;
         }, 80);
 
@@ -114,14 +153,16 @@ export class ThemedSpinner {
                     clearInterval(this.timer);
                 }
                 process.stdout.write("\x1B[?25h");
-                const icon = success ? `${Logger.C.success}✓${Logger.C.reset}` : `${Logger.C.error}✗${Logger.C.reset}`;
-                console.log(`\r${Logger.C.gray}│${Logger.C.reset}  ${icon} ${message}`);
+                const icon = success ? `${Colors.success}✓${Colors.reset}` : `${Colors.error}✗${Colors.reset}`;
+                console.log(`\r${Colors.gray}│${Colors.reset}  ${icon} ${message}`);
             }
         };
     }
 }
 
-// Função auxiliar para downloads com progresso
+/**
+ * @deprecated Use ProgressLogger de src/logging/
+ */
 export async function downloadWithProgress(
     url: string, 
     destination: string, 
@@ -129,7 +170,7 @@ export async function downloadWithProgress(
 ): Promise<void> {
     const response = await fetch(url);
     if (!response.ok) {
-        throw new Error(`Failed to download: ${response.statusText}`);
+        throw new Error(`Falha ao baixar: ${response.statusText}`);
     }
 
     const totalSize = parseInt(response.headers.get("content-length") || "0");
@@ -153,7 +194,7 @@ export async function downloadWithProgress(
 
     const reader = response.body?.getReader();
     if (!reader) {
-        throw new Error("No response body");
+        throw new Error("Sem response body");
     }
 
     const chunks: Uint8Array[] = [];

package/src/utils/argsParser.ts

@@ -0,0 +1,260 @@
+/**
+ * Parser de argumentos CLI com tipagem forte
+ * Wrapper tipado ao redor de parseArgs do Bun
+ */
+
+import { parseArgs } from "util";
+import type { 
+    BaseArgs, 
+    DeployArgs, 
+    BuildArgs, 
+    StartArgs, 
+    RunArgs,
+    LogsArgs,
+    AuditArgs,
+    DepsArgs,
+    DocsArgs,
+    ProfilesArgs,
+    DoctorArgs,
+    TomcatCommandArgs,
+    EncodingCommandArgs,
+    ConfigArgs,
+    HistoryArgs,
+    CompletionArgs,
+    CleanArgs,
+    TestArgs,
+    DbArgs,
+    HttpArgs,
+    DockerArgs,
+    ChangelogArgs,
+    IdeArgs,
+    CLIArguments 
+} from "../types/args";
+
+// Map de opções para parseArgs
+const PARSE_OPTIONS = {
+    // Base
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+    verbose: { type: "boolean", short: "V" },
+    quiet: { type: "boolean", short: "q" },
+    "debug-level": { type: "string" },
+
+    // Project
+    tool: { type: "string", short: "t" },
+    name: { type: "string", short: "n" },
+    profile: { type: "string", short: "P" },
+    encoding: { type: "string", short: "e" },
+    "no-build": { type: "boolean", short: "s" },
+    clean: { type: "boolean", short: "c" },
+    war: { type: "boolean", short: "W" },
+    cache: { type: "boolean" },
+
+    // Tomcat
+    path: { type: "string", short: "p" },
+    port: { type: "string" },
+    "tomcat-version": { type: "string" },
+    yes: { type: "boolean", short: "y" },
+
+    // Debug/Dev
+    debug: { type: "boolean", short: "d" },
+    watch: { type: "boolean", short: "w" },
+    tui: { type: "boolean" },
+    dp: { type: "string" },
+    incremental: { type: "boolean" },
+
+    // Analysis
+    grep: { type: "string", short: "G" },
+    scan: { type: "boolean" },
+    fix: { type: "boolean" },
+    output: { type: "string", short: "o" },
+    strict: { type: "boolean" },
+    "update-safe": { type: "boolean" },
+
+    // Encoding
+    from: { type: "string" },
+    to: { type: "string" },
+    backup: { type: "boolean" },
+    "dry-run": { type: "boolean" },
+    force: { type: "boolean" },
+    src: { type: "string" },
+
+    // Config/History
+    interactive: { type: "boolean", short: "i" },
+    clear: { type: "boolean" },
+    limit: { type: "string" },
+
+    // Completion
+    shell: { type: "string" },
+
+    // Clean
+    all: { type: "boolean" },
+    logs: { type: "boolean" },
+    build: { type: "boolean" },
+
+    // Test
+    coverage: { type: "boolean" },
+    "fail-fast": { type: "boolean" },
+    parallel: { type: "boolean" },
+
+    // HTTP
+    "base-url": { type: "string" },
+    body: { type: "string" },
+    file: { type: "string" },
+    header: { type: "string", multiple: true },
+    "content-type": { type: "string" },
+    accept: { type: "string" },
+    param: { type: "string", multiple: true },
+    timeout: { type: "string" },
+
+    // Docker
+    tag: { type: "string" },
+    "java-version": { type: "string" },
+    detached: { type: "boolean", short: "d" },
+    registry: { type: "string" },
+    namespace: { type: "string" },
+
+    // Multi-environment
+    env: { type: "string" },
+    environment: { type: "string" },
+
+    // Profile
+    profile: { type: "boolean" },
+
+    // IDE
+    ide: { type: "string" },
+} as const;
+
+export interface ParsedArgs<T = CLIArguments> {
+    values: T;
+    positionals: string[];
+}
+
+/**
+ * Parse argumentos genéricos
+ */
+export function parseCliArgs(argv: string[]): ParsedArgs {
+    return parseArgs({
+        args: argv,
+        options: PARSE_OPTIONS,
+        strict: false,
+        allowPositionals: true,
+    }) as ParsedArgs;
+}
+
+/**
+ * Parse argumentos específicos para comando deploy
+ */
+export function parseDeployArgs(argv: string[]): ParsedArgs<DeployArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as DeployArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando build
+ */
+export function parseBuildArgs(argv: string[]): ParsedArgs<BuildArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as BuildArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando start
+ */
+export function parseStartArgs(argv: string[]): ParsedArgs<StartArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as StartArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando run/debug
+ */
+export function parseRunArgs(argv: string[]): ParsedArgs<RunArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as RunArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando logs
+ */
+export function parseLogsArgs(argv: string[]): ParsedArgs<LogsArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as LogsArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando audit
+ */
+export function parseAuditArgs(argv: string[]): ParsedArgs<AuditArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as AuditArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando deps
+ */
+export function parseDepsArgs(argv: string[]): ParsedArgs<DepsArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as DepsArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando doctor
+ */
+export function parseDoctorArgs(argv: string[]): ParsedArgs<DoctorArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as DoctorArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando clean
+ */
+export function parseCleanArgs(argv: string[]): ParsedArgs<CleanArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as CleanArgs };
+}
+
+/**
+ * Parse argumentos específicos para comando encoding
+ */
+export function parseEncodingArgs(argv: string[]): ParsedArgs<EncodingCommandArgs> {
+    const parsed = parseCliArgs(argv);
+    return { ...parsed, values: parsed.values as EncodingCommandArgs };
+}
+
+/**
+ * Obtém o comando principal dos positionals
+ */
+export function detectCommand(positionals: string[]): string {
+    const commandNames = [
+        "deploy", "build", "start", "dev", "doctor", "run", 
+        "debug", "logs", "docs", "audit", "profiles", 
+        "deps", "tomcat", "encoding", "init", "config", 
+        "history", "redo", "health", "completion", "changelog",
+        "test", "db", "http", "docker", "help", "clean", "ide"
+    ];
+    
+    return positionals.find(p => commandNames.includes(p)) || "deploy";
+}
+
+/**
+ * Factory para parser baseado no comando
+ */
+export function createCommandParser(command: string) {
+    const parsers: Record<string, (argv: string[]) => ParsedArgs> = {
+        deploy: parseDeployArgs,
+        dev: parseDeployArgs,
+        build: parseBuildArgs,
+        start: parseStartArgs,
+        run: parseRunArgs,
+        debug: parseRunArgs,
+        logs: parseLogsArgs,
+        audit: parseAuditArgs,
+        deps: parseDepsArgs,
+        doctor: parseDoctorArgs,
+        clean: parseCleanArgs,
+        encoding: parseEncodingArgs,
+    };
+    
+    return parsers[command] || parseCliArgs;
+}