@archznn/xavva 3.1.2 → 3.2.0

package/src/logging/OperationLogger.ts

@@ -0,0 +1,296 @@
+/**
+ * OperationLogger - Logger especializado para operações complexas com múltiplas etapas
+ * 
+ * Uso:
+ * const op = new OperationLogger('deploy');
+ * op.start('Iniciando deploy');
+ * 
+ * const buildStep = op.step('build', 'Compilando projeto...');
+ * await buildService.build();
+ * buildStep.success('Build concluído em 3.2s');
+ * 
+ * op.complete('Deploy finalizado com sucesso');
+ */
+
+import type { OperationStep } from './types';
+import { Logger } from './Logger';
+import { Colors, Icons } from './colors';
+import { LAYOUT } from './constants';
+
+export class OperationStepLogger {
+  private operation: OperationLogger;
+  private step: OperationStep;
+
+  constructor(operation: OperationLogger, step: OperationStep) {
+    this.operation = operation;
+    this.step = step;
+  }
+
+  /**
+   * Marca o passo como em execução
+   */
+  start(message?: string): void {
+    this.step.status = 'running';
+    this.step.startTime = new Date();
+    if (message) {
+      this.step.message = message;
+    }
+    this.operation.logStep(this.step);
+  }
+
+  /**
+   * Atualiza mensagem do passo
+   */
+  update(message: string): void {
+    this.step.message = message;
+    this.operation.logStep(this.step);
+  }
+
+  /**
+   * Marca o passo como concluído com sucesso
+   */
+  success(message?: string): void {
+    this.step.status = 'success';
+    this.step.endTime = new Date();
+    if (message) {
+      this.step.message = message;
+    }
+    this.operation.logStep(this.step);
+  }
+
+  /**
+   * Marca o passo como falho
+   */
+  fail(error: Error | string): void {
+    this.step.status = 'failed';
+    this.step.endTime = new Date();
+    this.step.error = error instanceof Error ? error : new Error(error);
+    this.step.message = error instanceof Error ? error.message : error;
+    this.operation.logStep(this.step);
+  }
+
+  /**
+   * Obtém dados do passo
+   */
+  getData(): OperationStep {
+    return { ...this.step };
+  }
+}
+
+export class OperationLogger {
+  private name: string;
+  private steps: OperationStep[] = [];
+  private startTime: Date | null = null;
+  private endTime: Date | null = null;
+  private status: 'pending' | 'running' | 'success' | 'failed' = 'pending';
+  private traceId: string;
+  private logger: Logger;
+
+  constructor(name: string, logger?: Logger) {
+    this.name = name;
+    this.logger = logger || Logger.getInstance();
+    this.traceId = this.logger.generateTraceId() || '';
+  }
+
+  /**
+   * Inicia a operação
+   */
+  start(message?: string): void {
+    this.startTime = new Date();
+    this.status = 'running';
+    
+    const icon = Icons.arrow;
+    const color = Colors.primary;
+    const bold = Colors.bold;
+    const reset = Colors.reset;
+    
+    // Usa log direto sem ícone duplicado
+    this.logger.log('info', `${color}${icon}${reset} ${bold}${this.name}${reset}${message ? ': ' + message : ''}`);
+  }
+
+  /**
+   * Cria um novo passo na operação
+   */
+  step(id: string, message?: string): OperationStepLogger {
+    const stepData: OperationStep = {
+      id,
+      name: id,
+      status: 'pending',
+      message,
+    };
+    
+    this.steps.push(stepData);
+    const stepLogger = new OperationStepLogger(this, stepData);
+    stepLogger.start(message);
+    return stepLogger;
+  }
+
+  /**
+   * Loga um passo
+   */
+  logStep(step: OperationStep): void {
+    const indent = ' '.repeat(LAYOUT.indentSize * 2);
+    
+    let icon: string;
+    let color: string;
+    
+    switch (step.status) {
+      case 'running':
+        icon = Icons.spinner;
+        color = Colors.primary;
+        break;
+      case 'success':
+        icon = Icons.success;
+        color = Colors.success;
+        break;
+      case 'failed':
+        icon = Icons.error;
+        color = Colors.error;
+        break;
+      default:
+        icon = Icons.pending;
+        color = Colors.gray;
+    }
+    
+    const reset = Colors.reset;
+    const dim = Colors.dim;
+    
+    let message = step.message || step.name;
+    
+    // Adiciona tempo se concluído
+    if ((step.status === 'success' || step.status === 'failed') && step.startTime && step.endTime) {
+      const duration = ((step.endTime.getTime() - step.startTime.getTime()) / 1000).toFixed(1);
+      message += ` ${dim}(${duration}s)${reset}`;
+    }
+    
+    // Usa log direto sem ícone duplicado do logger.info()
+    this.logger.log('info', `${indent}${color}${icon}${reset} ${message}`);
+  }
+
+  /**
+   * Completa a operação com sucesso
+   */
+  complete(message?: string): void {
+    this.endTime = new Date();
+    this.status = 'success';
+    
+    const icon = Icons.success;
+    const color = Colors.success;
+    const bold = Colors.bold;
+    const reset = Colors.reset;
+    const dim = Colors.dim;
+    
+    let finalMessage = message || `${this.name} concluído`;
+    
+    // Adiciona tempo total
+    if (this.startTime) {
+      const duration = ((this.endTime.getTime() - this.startTime.getTime()) / 1000).toFixed(1);
+      finalMessage += ` ${dim}(${duration}s)${reset}`;
+    }
+    
+    // Usa log direto sem ícone duplicado
+    this.logger.log('info', `${color}${icon}${reset} ${bold}${finalMessage}${reset}`);
+  }
+
+  /**
+   * Falha na operação
+   */
+  fail(message?: string, error?: Error): void {
+    this.endTime = new Date();
+    this.status = 'failed';
+    
+    const icon = Icons.error;
+    const color = Colors.error;
+    const bold = Colors.bold;
+    const reset = Colors.reset;
+    const dim = Colors.dim;
+    
+    let finalMessage = message || `${this.name} falhou`;
+    
+    // Adiciona tempo total
+    if (this.startTime) {
+      const duration = ((this.endTime.getTime() - this.startTime.getTime()) / 1000).toFixed(1);
+      finalMessage += ` ${dim}(${duration}s)${reset}`;
+    }
+    
+    // Usa log direto para erro
+    this.logger.log('error', `${color}${icon}${reset} ${bold}${finalMessage}${reset}`);
+    
+    // Loga detalhes do erro
+    if (error) {
+      this.logger.group('Detalhes do erro');
+      this.logger.error(error.message);
+      if (error.stack) {
+        const lines = error.stack.split('\n').slice(1, 5);
+        for (const line of lines) {
+          this.logger.debug(line.trim());
+        }
+      }
+      this.logger.groupEnd();
+    }
+    
+    // Loga passos que falharam
+    const failedSteps = this.steps.filter(s => s.status === 'failed');
+    if (failedSteps.length > 0) {
+      this.logger.group('Passos com falha');
+      for (const step of failedSteps) {
+        this.logger.error(`${step.name}: ${step.error?.message || 'Falha desconhecida'}`);
+      }
+      this.logger.groupEnd();
+    }
+  }
+
+  /**
+   * Obtém estatísticas da operação
+   */
+  getStats(): {
+    name: string;
+    status: string;
+    duration: number;
+    steps: { total: number; success: number; failed: number; pending: number };
+  } {
+    const duration = this.startTime && this.endTime
+      ? (this.endTime.getTime() - this.startTime.getTime()) / 1000
+      : 0;
+    
+    return {
+      name: this.name,
+      status: this.status,
+      duration,
+      steps: {
+        total: this.steps.length,
+        success: this.steps.filter(s => s.status === 'success').length,
+        failed: this.steps.filter(s => s.status === 'failed').length,
+        pending: this.steps.filter(s => s.status === 'pending').length,
+      },
+    };
+  }
+
+  /**
+   * Verifica se a operação teve sucesso
+   */
+  isSuccess(): boolean {
+    return this.status === 'success';
+  }
+
+  /**
+   * Verifica se a operação falhou
+   */
+  isFailed(): boolean {
+    return this.status === 'failed';
+  }
+
+  /**
+   * Obtém trace ID da operação
+   */
+  getTraceId(): string {
+    return this.traceId;
+  }
+}
+
+/**
+ * Cria uma nova operação (função helper)
+ */
+export function createOperation(name: string, logger?: Logger): OperationLogger {
+  return new OperationLogger(name, logger);
+}

package/src/logging/ProgressLogger.ts

@@ -0,0 +1,187 @@
+/**
+ * ProgressLogger - Logger especializado para operações com progresso
+ * 
+ * Uso:
+ * const progress = new ProgressLogger('Download', { total: 100, unit: 'MB' });
+ * progress.update(50);
+ * progress.complete();
+ * 
+ * Ou:
+ * const progress = new ProgressLogger('Processando', { total: files.length, unit: 'arquivos' });
+ * for (let i = 0; i < files.length; i++) {
+ *   await process(files[i]);
+ *   progress.increment();
+ * }
+ * progress.complete();
+ */
+
+import { Logger } from './Logger';
+import { Colors } from './colors';
+
+export interface ProgressOptions {
+  total: number;
+  unit?: string;
+  width?: number;
+  showPercentage?: boolean;
+  showEta?: boolean;
+  showCount?: boolean;
+}
+
+export class ProgressLogger {
+  private name: string;
+  private options: Required<ProgressOptions>;
+  private current = 0;
+  private startTime: number;
+  private logger: Logger;
+  private lastUpdate = 0;
+  private updateInterval = 100; // ms - limita updates para não flickerar
+
+  constructor(name: string, options: ProgressOptions, logger?: Logger) {
+    this.name = name;
+    this.logger = logger || Logger.getInstance();
+    this.startTime = Date.now();
+    
+    this.options = {
+      total: options.total,
+      unit: options.unit || '',
+      width: options.width || 30,
+      showPercentage: options.showPercentage !== false,
+      showEta: options.showEta !== false,
+      showCount: options.showCount !== false,
+    };
+  }
+
+  /**
+   * Atualiza o progresso para um valor específico
+   */
+  update(value: number): void {
+    const now = Date.now();
+    if (now - this.lastUpdate < this.updateInterval && value < this.options.total) {
+      return; // Rate limiting de updates visuais
+    }
+    
+    this.current = Math.min(value, this.options.total);
+    this.lastUpdate = now;
+    this.render();
+  }
+
+  /**
+   * Incrementa o progresso
+   */
+  increment(amount = 1): void {
+    this.update(this.current + amount);
+  }
+
+  /**
+   * Marca como completo
+   */
+  complete(message?: string): void {
+    this.current = this.options.total;
+    this.render();
+    
+    // Limpa a linha atual
+    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    
+    const duration = ((Date.now() - this.startTime) / 1000).toFixed(1);
+    const finalMessage = message || `${this.name} concluído`;
+    
+    this.logger.success(`${finalMessage} (${duration}s)`);
+  }
+
+  /**
+   * Falha no progresso
+   */
+  fail(message?: string): void {
+    // Limpa a linha atual
+    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    
+    const finalMessage = message || `${this.name} falhou`;
+    this.logger.error(finalMessage);
+  }
+
+  /**
+   * Renderiza a barra de progresso
+   */
+  private render(): void {
+    const { total, width, showPercentage, showEta, showCount, unit } = this.options;
+    const ratio = this.current / total;
+    const filled = Math.floor(ratio * width);
+    const empty = width - filled;
+    
+    // Caracteres da barra
+    const barFilled = '█'.repeat(filled);
+    const barEmpty = '░'.repeat(empty);
+    
+    const primaryColor = Colors.primary;
+    const dimColor = Colors.dim;
+    const whiteColor = Colors.white;
+    const reset = Colors.reset;
+    
+    let line = '\r  ';
+    
+    // Nome da operação
+    line += `${primaryColor}▸${reset} ${dimColor}${this.name}${reset} `;
+    
+    // Barra
+    line += `${primaryColor}[${barFilled}${barEmpty}]${reset}`;
+    
+    // Porcentagem
+    if (showPercentage) {
+      const percentage = Math.floor(ratio * 100);
+      line += ` ${whiteColor}${percentage}%${reset}`;
+    }
+    
+    // Contagem
+    if (showCount) {
+      line += ` ${dimColor}(${this.current}/${total}${unit ? ' ' + unit : ''})${reset}`;
+    }
+    
+    // ETA
+    if (showEta && this.current > 0 && this.current < total) {
+      const elapsed = Date.now() - this.startTime;
+      const rate = this.current / elapsed;
+      const remaining = (total - this.current) / rate;
+      const eta = Math.ceil(remaining / 1000);
+      
+      line += ` ${dimColor}(faltam ~${eta}s)${reset}`;
+    }
+    
+    // Limpa o resto da linha e escreve
+    process.stdout.write(line + '\x1b[K');
+  }
+
+  /**
+   * Obtém porcentagem atual
+   */
+  getPercentage(): number {
+    return Math.floor((this.current / this.options.total) * 100);
+  }
+
+  /**
+   * Obtém valor atual
+   */
+  getCurrent(): number {
+    return this.current;
+  }
+
+  /**
+   * Obtém total
+   */
+  getTotal(): number {
+    return this.options.total;
+  }
+
+  /**
+   * Verifica se está completo
+   */
+  isComplete(): boolean {
+    return this.current >= this.options.total;
+  }
+}
+
+/**
+ * Cria um progress logger (função helper)
+ */
+export function createProgress(name: string, options: ProgressOptions, logger?: Logger): ProgressLogger {
+  return new ProgressLogger(name, options, logger);
+}

package/src/logging/TableLogger.ts

@@ -0,0 +1,246 @@
+/**
+ * TableLogger - Logger especializado para exibição de dados tabulares
+ * 
+ * Uso:
+ * const table = new TableLogger(['Nome', 'Versão', 'Status']);
+ * table.add(['Spring', '5.3.0', '✓']);
+ * table.add(['Hibernate', '6.0.0', '⚠']);
+ * table.print();
+ * 
+ * Ou com opções de alinhamento:
+ * const table = new TableLogger([
+ *   { header: 'ID', align: 'center', width: 10 },
+ *   { header: 'Nome', align: 'left' },
+ *   { header: 'Valor', align: 'right', width: 15 }
+ * ]);
+ */
+
+import type { TableColumn, TableRow } from './types';
+import { Logger } from './Logger';
+import { Colors, stripAnsi, visualWidth, padText } from './colors';
+
+export interface TableOptions {
+  headerStyle?: boolean;
+  border?: boolean;
+  compact?: boolean;
+}
+
+export class TableLogger {
+  private columns: TableColumn[];
+  private rows: TableRow[] = [];
+  private options: Required<TableOptions>;
+  private logger: Logger;
+
+  constructor(
+    columns: (string | TableColumn)[],
+    options: TableOptions = {},
+    logger?: Logger
+  ) {
+    this.logger = logger || Logger.getInstance();
+    
+    // Normaliza colunas
+    this.columns = columns.map(col => {
+      if (typeof col === 'string') {
+        return { header: col, align: 'left' };
+      }
+      return { align: 'left', ...col };
+    });
+    
+    this.options = {
+      headerStyle: true,
+      border: false,
+      compact: false,
+      ...options,
+    };
+  }
+
+  /**
+   * Adiciona uma linha à tabela
+   */
+  add(cells: (string | number)[], styles?: string[]): this {
+    this.rows.push({
+      cells: cells.map(c => String(c)),
+      styles,
+    });
+    return this;
+  }
+
+  /**
+   * Adiciona múltiplas linhas
+   */
+  addMany(rows: (string | number)[][]): this {
+    for (const row of rows) {
+      this.add(row);
+    }
+    return this;
+  }
+
+  /**
+   * Limpa todas as linhas
+   */
+  clear(): this {
+    this.rows = [];
+    return this;
+  }
+
+  /**
+   * Define larguras das colunas baseado no conteúdo
+   */
+  private calculateWidths(): number[] {
+    const widths: number[] = [];
+    
+    for (let i = 0; i < this.columns.length; i++) {
+      const col = this.columns[i];
+      
+      // Se já tem largura definida, usa ela
+      if (col.width) {
+        widths[i] = col.width;
+        continue;
+      }
+      
+      // Calcula largura máxima baseada no header e conteúdo
+      let maxWidth = visualWidth(col.header);
+      
+      for (const row of this.rows) {
+        const cell = row.cells[i] || '';
+        maxWidth = Math.max(maxWidth, visualWidth(cell));
+      }
+      
+      // Adiciona padding
+      widths[i] = maxWidth + 2;
+    }
+    
+    return widths;
+  }
+
+  /**
+   * Renderiza a tabela
+   */
+  render(): string {
+    if (this.rows.length === 0 && this.options.compact) {
+      return '';
+    }
+    
+    const widths = this.calculateWidths();
+    const lines: string[] = [];
+    
+    // Linha de borda superior
+    if (this.options.border) {
+      let border = '  ┌';
+      for (let i = 0; i < widths.length; i++) {
+        border += '─'.repeat(widths[i] + 2);
+        if (i < widths.length - 1) border += '┬';
+      }
+      border += '┐';
+      lines.push(Colors.darkGray + border + Colors.reset);
+    }
+    
+    // Header
+    const headerCells = this.columns.map((col, i) => {
+      const width = widths[i];
+      const padded = padText(col.header, width, col.align);
+      return this.options.headerStyle 
+        ? `${Colors.bold}${padded}${Colors.reset}`
+        : padded;
+    });
+    
+    const headerLine = this.options.border
+      ? `  │ ${headerCells.join(' │ ')} │`
+      : '  ' + headerCells.join('');
+    lines.push(headerLine);
+    
+    // Linha separadora
+    if (this.options.border) {
+      let sep = '  ├';
+      for (let i = 0; i < widths.length; i++) {
+        sep += '─'.repeat(widths[i] + 2);
+        if (i < widths.length - 1) sep += '┼';
+      }
+      sep += '┤';
+      lines.push(Colors.darkGray + sep + Colors.reset);
+    } else if (!this.options.compact) {
+      let sep = '  ';
+      for (let i = 0; i < widths.length; i++) {
+        sep += '─'.repeat(widths[i]);
+      }
+      lines.push(Colors.darkGray + sep + Colors.reset);
+    }
+    
+    // Linhas de dados
+    for (const row of this.rows) {
+      const cells = row.cells.map((cell, i) => {
+        const width = widths[i];
+        const col = this.columns[i];
+        const style = row.styles?.[i] || '';
+        const reset = style ? Colors.reset : '';
+        return style + padText(cell, width, col.align) + reset;
+      });
+      
+      const line = this.options.border
+        ? `  │ ${cells.join(' │ ')} │`
+        : '  ' + cells.join('');
+      lines.push(line);
+    }
+    
+    // Linha de borda inferior
+    if (this.options.border) {
+      let border = '  └';
+      for (let i = 0; i < widths.length; i++) {
+        border += '─'.repeat(widths[i] + 2);
+        if (i < widths.length - 1) border += '┴';
+      }
+      border += '┘';
+      lines.push(Colors.darkGray + border + Colors.reset);
+    }
+    
+    return lines.join('\n');
+  }
+
+  /**
+   * Imprime a tabela
+   */
+  print(): void {
+    const output = this.render();
+    if (output) {
+      this.logger.info(output);
+    }
+  }
+
+  /**
+   * Obtém número de linhas
+   */
+  getRowCount(): number {
+    return this.rows.length;
+  }
+
+  /**
+   * Obtém número de colunas
+   */
+  getColumnCount(): number {
+    return this.columns.length;
+  }
+}
+
+/**
+ * Cria uma tabela (função helper)
+ */
+export function createTable(
+  columns: (string | TableColumn)[],
+  options?: TableOptions,
+  logger?: Logger
+): TableLogger {
+  return new TableLogger(columns, options, logger);
+}
+
+/**
+ * Imprime uma tabela simples rapidamente
+ */
+export function printTable(
+  headers: string[],
+  rows: (string | number)[][],
+  logger?: Logger
+): void {
+  const table = new TableLogger(headers, {}, logger);
+  table.addMany(rows);
+  table.print();
+}