@archznn/xavva 2.6.0 → 2.8.0

package/src/types/args.ts

@@ -0,0 +1,151 @@
+/**
+ * Argumentos de linha de comando tipados por contexto
+ * Substitui CLIArguments monolítico
+ */
+
+// ===== Args Base (comuns a todos os comandos) =====
+export interface BaseArgs {
+    help?: boolean;
+    version?: boolean;
+    verbose?: boolean;
+    quiet?: boolean;
+}
+
+// ===== Args de Configuração de Projeto =====
+export interface ProjectArgs {
+    tool?: string;
+    name?: string;
+    profile?: string;
+    encoding?: string;
+    "no-build"?: boolean;
+    clean?: boolean;
+    war?: boolean;
+    cache?: boolean;
+}
+
+// ===== Args de Configuração do Tomcat =====
+export interface TomcatArgs {
+    path?: string;
+    port?: string;
+    "tomcat-version"?: string;
+    yes?: boolean;
+}
+
+// ===== Args de Debug/Desenvolvimento =====
+export interface DebugArgs {
+    debug?: boolean;
+    watch?: boolean;
+    tui?: boolean;
+    dp?: string;
+}
+
+// ===== Args de Análise =====
+export interface AnalysisArgs {
+    grep?: string;
+    scan?: boolean;
+    fix?: boolean;
+    output?: string;
+    strict?: boolean;
+    "update-safe"?: boolean;
+}
+
+// ===== Args de Encoding =====
+export interface EncodingArgs {
+    from?: string;
+    to?: string;
+    backup?: boolean;
+    "dry-run"?: boolean;
+    force?: boolean;
+    src?: string;
+}
+
+// ===== Args Específicas de Comandos =====
+export interface DeployArgs extends BaseArgs, ProjectArgs, TomcatArgs, DebugArgs {
+    incremental?: boolean;
+    changedFiles?: string[];
+}
+
+export interface BuildArgs extends BaseArgs, ProjectArgs {
+    // Herda de ProjectArgs
+}
+
+export interface StartArgs extends BaseArgs, TomcatArgs, DebugArgs {
+    // Herda de TomcatArgs e DebugArgs
+}
+
+export interface RunArgs extends BaseArgs, DebugArgs {
+    // Positional: className
+}
+
+export interface LogsArgs extends BaseArgs {
+    grep?: string;
+}
+
+export interface AuditArgs extends BaseArgs, AnalysisArgs {
+    // Herda de AnalysisArgs
+}
+
+export interface DepsArgs extends BaseArgs, AnalysisArgs {
+    // Herda de AnalysisArgs
+}
+
+export interface DocsArgs extends BaseArgs {
+    output?: string;
+}
+
+export interface ProfilesArgs extends BaseArgs {
+    // Sem args específicas
+}
+
+export interface DoctorArgs extends BaseArgs {
+    fix?: boolean;
+}
+
+export interface TomcatCommandArgs extends BaseArgs, TomcatArgs {
+    "tomcat-action"?: string;
+}
+
+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 
+    BaseArgs, 
+    ProjectArgs, 
+    TomcatArgs, 
+    DebugArgs, 
+    AnalysisArgs, 
+    EncodingArgs {
+    // Campos adicionais para compatibilidade
+    [key: string]: unknown;
+}
+
+// ===== Type Guards =====
+export function isDeployArgs(args: CLIArguments): args is DeployArgs {
+    return "incremental" in args || "watch" in args;
+}
+
+export function isBuildArgs(args: CLIArguments): args is BuildArgs {
+    return "tool" in args || "clean" in args;
+}
+
+export function isEncodingArgs(args: CLIArguments): args is EncodingCommandArgs {
+    return "from" in args || "to" in args;
+}

package/src/types/config.ts

@@ -62,6 +62,12 @@ export interface CLIArguments {
     war?: boolean;
     cache?: boolean;
     changedFiles?: string[];
+    from?: string;
+    to?: string;
+    backup?: boolean;
+    "dry-run"?: boolean;
+    force?: boolean;
+    src?: string;
 }
 
 export interface CommandContext {

package/src/types/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel export para todos os tipos
+ */
+
+export * from "./config";
+export * from "./endpoint";
+export * from "./args";

package/src/utils/PathUtils.ts

@@ -0,0 +1,221 @@
+/**
+ * Utilitários para manipulação de paths
+ * Centraliza lógica comum de normalização e resolução de caminhos
+ */
+
+import path from "path";
+
+export class PathUtils {
+    /**
+     * Normaliza separadores de path para forward slash
+     */
+    static normalizeSeparators(filePath: string): string {
+        return filePath.replace(/\\/g, "/");
+    }
+
+    /**
+     * Converte caminho relativo para absoluto a partir do cwd
+     */
+    static resolveFromCwd(relativePath: string): string {
+        return path.resolve(process.cwd(), relativePath);
+    }
+
+    /**
+     * Obtém caminho relativo a partir do diretório raiz do projeto
+     */
+    static relativeToProject(absolutePath: string): string {
+        return path.relative(process.cwd(), absolutePath);
+    }
+
+    /**
+     * Verifica se caminho está dentro do diretório src/main/java (Maven) ou equivalente
+     */
+    static isSourceFile(filePath: string): boolean {
+        const normalized = this.normalizeSeparators(filePath);
+        return /src\/(main|test)\/(java|resources)/.test(normalized);
+    }
+
+    /**
+     * Extrai package de um arquivo Java baseado no caminho
+     */
+    static extractPackageFromPath(javaFilePath: string): string | null {
+        const normalized = this.normalizeSeparators(javaFilePath);
+        
+        // Procura por src/main/java ou src/test/java
+        const match = normalized.match(/src\/(?:main|test)\/java\/(.*)\/[^/]+\.java$/);
+        if (match) {
+            return match[1].replace(/\//g, ".");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Converte caminho de .java para .class
+     */
+    static javaToClassPath(javaPath: string): string {
+        return javaPath.replace(/\.java$/i, ".class");
+    }
+
+    /**
+     * Converte caminho relativo do source para caminho no diretório de classes
+     */
+    static sourceToClassesPath(
+        sourcePath: string, 
+        classesDir: string,
+        sourceRoots: string[] = ["src/main/java", "src/test/java", "src"]
+    ): string {
+        const normalized = this.normalizeSeparators(sourcePath);
+        
+        for (const root of sourceRoots) {
+            const normalizedRoot = this.normalizeSeparators(root);
+            const index = normalized.indexOf(normalizedRoot);
+            if (index !== -1) {
+                const relativePart = normalized.slice(index + normalizedRoot.length + 1);
+                const classFile = this.javaToClassPath(relativePart);
+                return path.join(classesDir, classFile);
+            }
+        }
+        
+        // Fallback: assume que é relativo ao classesDir
+        return path.join(classesDir, path.basename(this.javaToClassPath(sourcePath)));
+    }
+
+    /**
+     * Encontra o webapp root a partir de um caminho de recurso
+     */
+    static findWebappRoot(resourcePath: string): string | null {
+        const normalized = this.normalizeSeparators(resourcePath);
+        const parts = normalized.split("/");
+        
+        const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+        
+        if (rootIndex !== -1) {
+            return parts.slice(0, rootIndex + 1).join("/");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Obtém caminho relativo dentro do webapp
+     */
+    static getWebappRelativePath(resourcePath: string): string | null {
+        const normalized = this.normalizeSeparators(resourcePath);
+        const parts = normalized.split("/");
+        
+        const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+        
+        if (rootIndex !== -1 && rootIndex < parts.length - 1) {
+            return parts.slice(rootIndex + 1).join("/");
+        }
+        
+        return null;
+    }
+
+    /**
+     * Verifica se é arquivo de recurso web (JSP, HTML, etc)
+     */
+    static isWebResource(filePath: string): boolean {
+        return /\.(jsp|html|htm|css|js|xml|properties|json|png|jpg|jpeg|gif|svg|ico)$/i.test(filePath);
+    }
+
+    /**
+     * Verifica se é arquivo Java
+     */
+    static isJavaFile(filePath: string): boolean {
+        return /\.java$/i.test(filePath);
+    }
+
+    /**
+     * Verifica se é arquivo de build/configuração
+     */
+    static isBuildConfig(filePath: string): boolean {
+        return /(pom\.xml|build\.gradle|build\.gradle\.kts|settings\.gradle)$/i.test(filePath);
+    }
+
+    /**
+     * Combina múltiplos paths de forma segura
+     */
+    static combinePaths(...parts: string[]): string {
+        return path.join(...parts);
+    }
+
+    /**
+     * Obtém diretório do arquivo
+     */
+    static getDir(filePath: string): string {
+        return path.dirname(filePath);
+    }
+
+    /**
+     * Obtém nome do arquivo
+     */
+    static getFilename(filePath: string): string {
+        return path.basename(filePath);
+    }
+
+    /**
+     * Obtém extensão do arquivo
+     */
+    static getExtension(filePath: string): string {
+        return path.extname(filePath).toLowerCase();
+    }
+
+    /**
+     * Remove extensão do arquivo
+     */
+    static removeExtension(filePath: string): string {
+        const ext = path.extname(filePath);
+        return ext ? filePath.slice(0, -ext.length) : filePath;
+    }
+
+    /**
+     * Verifica se caminho está dentro de diretório ignorado
+     */
+    static isIgnoredPath(filePath: string, ignoredDirs: string[] = []): boolean {
+        const normalized = this.normalizeSeparators(filePath);
+        const defaultIgnored = ["target", "build", "node_modules", ".git", ".xavva"];
+        const allIgnored = [...defaultIgnored, ...ignoredDirs];
+        
+        return allIgnored.some(dir => {
+            // Match exato ou como diretório
+            const pattern = new RegExp(`(^|/)${dir}($|/)`);
+            return pattern.test(normalized);
+        });
+    }
+
+    /**
+     * Resolve caminho de contexto WAR
+     */
+    static resolveContextPath(appName: string): string {
+        return appName.replace(/\.war$/i, "");
+    }
+}
+
+// Exporta funções standalone para conveniência
+export const {
+    normalizeSeparators,
+    resolveFromCwd,
+    relativeToProject,
+    isSourceFile,
+    extractPackageFromPath,
+    javaToClassPath,
+    sourceToClassesPath,
+    findWebappRoot,
+    getWebappRelativePath,
+    isWebResource,
+    isJavaFile,
+    isBuildConfig,
+    combinePaths,
+    getDir,
+    getFilename,
+    getExtension,
+    removeExtension,
+    isIgnoredPath,
+    resolveContextPath,
+} = PathUtils;

package/src/utils/ProgressBar.ts

@@ -0,0 +1,182 @@
+import { Logger } from "./ui";
+
+export interface ProgressBarOptions {
+    title: string;
+    total: number;
+    width?: number;
+    showPercentage?: boolean;
+    showEta?: boolean;
+}
+
+export class ProgressBar {
+    private current = 0;
+    private startTime: number;
+    private options: Required<ProgressBarOptions>;
+    private isComplete = false;
+
+    constructor(options: ProgressBarOptions) {
+        this.options = {
+            width: 30,
+            showPercentage: true,
+            showEta: true,
+            ...options
+        };
+        this.startTime = Date.now();
+    }
+
+    update(current: number): void {
+        if (this.isComplete) return;
+        this.current = Math.min(current, this.options.total);
+        this.render();
+    }
+
+    increment(amount = 1): void {
+        this.update(this.current + amount);
+    }
+
+    complete(): void {
+        if (this.isComplete) return;
+        this.current = this.options.total;
+        this.isComplete = true;
+        this.render();
+        process.stdout.write("\n");
+    }
+
+    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}`);
+    }
+}
+
+// Spinner especializado para diferentes operações
+export class ThemedSpinner {
+    private static frames = {
+        default: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+        dots: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"],
+        line: ["-", "\\", "|", "/"],
+        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
+    };
+
+    private timer?: Timer;
+    private frameIndex = 0;
+
+    start(
+        message: string, 
+        theme: keyof typeof ThemedSpinner.frames = "default",
+        color: keyof typeof ThemedSpinner.colors = "default"
+    ): { stop: (success?: boolean) => void } {
+        const frames = ThemedSpinner.frames[theme];
+        const colorCode = ThemedSpinner.colors[color];
+
+        process.stdout.write(`${Logger.C.gray}│${Logger.C.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}`);
+            this.frameIndex = (this.frameIndex + 1) % frames.length;
+        }, 80);
+
+        return {
+            stop: (success = true) => {
+                if (this.timer) {
+                    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}`);
+            }
+        };
+    }
+}
+
+// Função auxiliar para downloads com progresso
+export async function downloadWithProgress(
+    url: string, 
+    destination: string, 
+    title: string
+): Promise<void> {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download: ${response.statusText}`);
+    }
+
+    const totalSize = parseInt(response.headers.get("content-length") || "0");
+    if (!totalSize) {
+        // Sem content-length, usar spinner simples
+        const spinner = new ThemedSpinner();
+        const stop = spinner.start(title, "dots", "download");
+
+        const data = await response.arrayBuffer();
+        await Bun.write(destination, data);
+
+        stop(true);
+        return;
+    }
+
+    const progress = new ProgressBar({
+        title,
+        total: totalSize,
+        width: 25
+    });
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error("No response body");
+    }
+
+    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 chunks e salva
+    const allChunks = new Uint8Array(received);
+    let position = 0;
+    for (const chunk of chunks) {
+        allChunks.set(chunk, position);
+        position += chunk.length;
+    }
+
+    await Bun.write(destination, allChunks);
+}

package/src/utils/config.ts

@@ -38,6 +38,12 @@ export class ConfigManager {
                 yes: { type: "boolean", short: "y" },
                 war: { type: "boolean", short: "W" },
                 cache: { type: "boolean" },
+                from: { type: "string" },
+                to: { type: "string" },
+                backup: { type: "boolean" },
+                "dry-run": { type: "boolean" },
+                force: { type: "boolean" },
+                src: { type: "string" },
             },
             strict: false,
             allowPositionals: true,