@archznn/xavva 3.1.2 → 3.2.0

package/src/logging/colors.ts

@@ -0,0 +1,167 @@
+/**
+ * Cores e estilos ANSI para o sistema de logging
+ * Paleta suave e moderna
+ */
+
+export const Colors = {
+  // Reset
+  reset: '\x1b[0m',
+  
+  // Estilos
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  
+  // Cores principais
+  primary: '\x1b[36m',       // Cyan
+  primaryBright: '\x1b[96m', // Bright Cyan
+  secondary: '\x1b[35m',     // Magenta
+  
+  // Estados
+  success: '\x1b[32m',       // Green
+  successBright: '\x1b[92m', // Bright Green
+  warning: '\x1b[33m',       // Yellow
+  error: '\x1b[31m',         // Red
+  info: '\x1b[34m',          // Blue
+  
+  // Neutros
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  darkGray: '\x1b[38;5;240m',
+  lightGray: '\x1b[38;5;250m',
+  
+  // Backgrounds
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+} as const;
+
+export type ColorKey = keyof typeof Colors;
+
+/**
+ * Aplica cor ao texto
+ */
+export function colorize(text: string, color: ColorKey): string {
+  return `${Colors[color]}${text}${Colors.reset}`;
+}
+
+/**
+ * Remove códigos ANSI do texto
+ */
+export function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[\d+m/g, '');
+}
+
+/**
+ * Calcula largura visual do texto (ignorando ANSI)
+ */
+export function visualWidth(text: string): number {
+  return stripAnsi(text).length;
+}
+
+/**
+ * Preenche string até o tamanho especificado, considerando ANSI codes
+ */
+export function padText(text: string, width: number, align: 'left' | 'right' | 'center' = 'left'): string {
+  const plain = stripAnsi(text);
+  const diff = width - plain.length;
+  
+  if (diff <= 0) return text;
+  
+  const padding = ' '.repeat(diff);
+  
+  switch (align) {
+    case 'right':
+      return padding + text;
+    case 'center':
+      const left = Math.floor(diff / 2);
+      const right = diff - left;
+      return ' '.repeat(left) + text + ' '.repeat(right);
+    default:
+      return text + padding;
+  }
+}
+
+/**
+ * Trunca texto mantendo códigos ANSI
+ */
+export function truncateText(text: string, maxLength: number, suffix = '...'): string {
+  const plain = stripAnsi(text);
+  if (plain.length <= maxLength) return text;
+  
+  // Extrai todos os códigos ANSI para reconstruir
+  const ansiCodes: string[] = [];
+  let match;
+  const ansiRegex = /\x1b\[\d+m/g;
+  while ((match = ansiRegex.exec(text)) !== null) {
+    ansiCodes.push(match[0]);
+  }
+  
+  // Trunca o texto plano
+  const truncatedPlain = plain.slice(0, maxLength - suffix.length) + suffix;
+  
+  // Reaplica os códigos ANSI (simplificado - apenas os que aparecem antes do corte)
+  return truncatedPlain; // Versão simplificada sem ANSI
+}
+
+/**
+ * Ícones semânticos para diferentes tipos de log
+ * Usando caracteres ASCII/Unicode amplamente suportados
+ */
+export const Icons = {
+  success: '✓',
+  error: '✗',
+  warning: '!',
+  info: 'i',
+  arrow: '->',
+  bullet: '*',
+  diamond: '>',
+  circle: 'o',
+  hotswap: '~',
+  spinner: '|',
+  pending: 'o',
+  running: '>',
+  ready: '✓',
+  sync: '<>',
+  build: '[b]',
+  deploy: '[d]',
+  server: '[s]',
+  database: '[db]',
+  search: '[?]',
+  time: '[t]',
+  file: '[f]',
+  folder: '[dir]',
+  link: '->',
+  star: '*',
+  check: '✓',
+  cross: '✗',
+  question: '?',
+  exclamation: '!',
+} as const;
+
+export type IconKey = keyof typeof Icons;
+
+/**
+ * Obtém ícone com cor aplicada
+ */
+export function getIcon(name: IconKey, color?: ColorKey): string {
+  const icon = Icons[name] || Icons.info;
+  if (color) {
+    return colorize(icon, color);
+  }
+  return icon;
+}
+
+/**
+ * Verifica se o terminal suporta cores
+ */
+export function supportsColor(): boolean {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return process.stdout.isTTY === true;
+}

package/src/logging/constants.ts

@@ -0,0 +1,176 @@
+/**
+ * Constantes do sistema de logging
+ */
+
+import type { LoggerConfig } from './types';
+
+// Configurações padrão
+export const DEFAULT_CONFIG: LoggerConfig = {
+  level: 'info',
+  mode: 'pretty',
+  timestamps: false,
+  colors: true,
+  icons: true,
+  fileLogging: false,
+  logDir: '.xavva/logs',
+  maxLogFiles: 7,
+  rateLimitWindowMs: 10000, // 10 segundos
+  maxDuplicateLogs: 5,
+};
+
+// Níveis de log com valores numéricos para comparação
+export const LOG_LEVELS = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  success: 3,
+  debug: 4,
+  trace: 5,
+  silly: 6,
+} as const;
+
+// Cores associadas a cada nível de log
+export const LEVEL_COLORS = {
+  error: 'error' as const,
+  warn: 'warning' as const,
+  info: 'info' as const,
+  success: 'success' as const,
+  debug: 'gray' as const,
+  trace: 'darkGray' as const,
+  silly: 'darkGray' as const,
+  silent: 'reset' as const,
+};
+
+// Ícones associados a cada nível de log
+export const LEVEL_ICONS = {
+  error: 'error',
+  warn: 'warning',
+  info: 'info',
+  success: 'success',
+  debug: 'bullet',
+  trace: 'circle',
+  silly: 'circle',
+  silent: '',
+} as const;
+
+// Configurações de layout
+export const LAYOUT = {
+  // Larguras de colunas para alinhamento
+  columns: {
+    timestamp: 12,
+    level: 8,
+    name: 12,
+    status: 10,
+    info: 30,
+  },
+  
+  // Caracteres de borda
+  borders: {
+    horizontal: '─',
+    vertical: '│',
+    topLeft: '┌',
+    topRight: '┐',
+    bottomLeft: '└',
+    bottomRight: '┘',
+    leftT: '├',
+    rightT: '┤',
+    cross: '┼',
+  },
+  
+  // Identação
+  indentSize: 2,
+  maxIndent: 10,
+  
+  // Truncamento
+  maxMessageLength: 500,
+  maxLineLength: 120,
+};
+
+// Padrões de noise para filtragem
+export const NOISE_PATTERNS = {
+  // Maven/Gradle noise
+  build: [
+    /^\[INFO\]\s+Scanning for projects/,
+    /^\[INFO\]\s+Building /,
+    /^\[INFO\]\s+---\s+.*\s+---$/,
+    /^\[INFO\]\s+T+E+\s*$/,
+    /^\[INFO\]\s+BUILD\s+SUCCESS/i,
+    /^\[INFO\]\s+Total time:/,
+    /^\[INFO\]\s+Finished at:/,
+    /^\[INFO\]\s+Final Memory:/,
+  ],
+  
+  // Tomcat noise
+  tomcat: [
+    /^Using CATALINA_/,
+    /^Using JRE_HOME/,
+    /^Using CLASSPATH/,
+    /^Using CATALINA_OPTS/,
+    /^NOTE: Picked up JDK_JAVA_OPTIONS/,
+    /^HOTSWAP AGENT:.*Plugin.*initialized in ClassLoader/,
+    /^HOTSWAP AGENT:.*Registering directory/,
+    /^HOTSWAP AGENT:.*WARNING.*TreeWatcherNIO.*Unable to watch/,
+    /^HOTSWAP AGENT:.*INFO.*TreeWatcherNIO/,
+    /^HOTSWAP AGENT:.*INFO.*PluginRegistry.*Discovered plugins/,
+    /^HOTSWAP AGENT:.*INFO.*HotswapAgent.*Loading Hotswap agent/,
+    /^HOTSWAP AGENT:.*INFO.*TomcatPlugin.*Tomcat plugin initialized/,
+    /^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*VersionLoggerListener/,
+    /^\d{2}-[A-Za-z]+-\d{4}\s+\d{2}:\d{2}:\d{2}\.\d+\s+(INFORMAÇÕES|INFO)\s+\[main\].*AprLifecycleListener/,
+  ],
+  
+  // System noise
+  system: [
+    'Using CATALINA_',
+    'Using JRE_HOME',
+    'Using CLASSPATH',
+    'Scanning for projects...',
+    'Building ',
+    '--- ',
+    '+++ ',
+    'SLF4J: ',
+    'Discovered plugins:',
+    'enhanced with plugin initialization',
+    'Hotswap ready',
+    'autoHotswap.delay',
+    'watchResources=false',
+    'TreeWatcherNIO',
+    'HOTSWAP AGENT',
+    'org.hotswap.agent',
+    'org.glassfish.jersey',
+    'org.apache.catalina',
+    'org.apache.jasper',
+  ],
+};
+
+// Padrões essenciais que sempre devem ser mostrados
+export const ESSENTIAL_PATTERNS = [
+  'SEVERE',
+  'ERROR',
+  'Exception',
+  'Caused by',
+  'Server startup in',
+  'HOTSWAP AGENT:.*RELOAD',
+  'BUILD FAILURE',
+  'Compilation failure',
+];
+
+// Spinner frames - usando ASCII para melhor compatibilidade com Windows
+export const SPINNER_FRAMES = {
+  default: ['|', '/', '-', '\\'],
+  dots: ['.', '..', '...', '....', '.....', '....', '...', '..'],
+  line: ['-', '\\', '|', '/'],
+  arrow: ['>', '->', '-->', '--->', '---->', '--->', '-->', '->'],
+  pulse: ['#', '##', '###', '####', '#####', '####', '###', '##'],
+};
+
+// Intervalo do spinner em ms
+export const SPINNER_INTERVAL = 80;
+
+// Configurações de arquivo de log
+export const FILE_LOG = {
+  extension: '.log',
+  dateFormat: 'YYYY-MM-DD',
+  maxSize: 10 * 1024 * 1024, // 10MB
+  maxFiles: 7,
+};

package/src/logging/formatters.ts

@@ -0,0 +1,337 @@
+/**
+ * Formatadores de saída para diferentes modos de log
+ */
+
+import type { LogEntry, LogOutputMode, LoggerConfig } from './types';
+import { Colors, stripAnsi, visualWidth, padText } from './colors';
+import { LEVEL_COLORS, LAYOUT } from './constants';
+
+/**
+ * Formata timestamp
+ */
+function formatTimestamp(date: Date, config: LoggerConfig): string {
+  if (!config.timestamps) return '';
+  
+  const now = new Date();
+  const hours = date.getHours().toString().padStart(2, '0');
+  const minutes = date.getMinutes().toString().padStart(2, '0');
+  const seconds = date.getSeconds().toString().padStart(2, '0');
+  
+  // Se for o mesmo dia, mostra apenas hora
+  if (now.toDateString() === date.toDateString()) {
+    return `${Colors.gray}${hours}:${minutes}:${seconds}${Colors.reset} `;
+  }
+  
+  // Caso contrário, mostra data completa
+  const day = date.getDate().toString().padStart(2, '0');
+  const month = (date.getMonth() + 1).toString().padStart(2, '0');
+  return `${Colors.gray}${day}/${month} ${hours}:${minutes}:${seconds}${Colors.reset} `;
+}
+
+/**
+ * Formata nível de log
+ */
+function formatLevel(level: string, config: LoggerConfig): string {
+  if (!config.colors) {
+    return `[${level.toUpperCase()}] `;
+  }
+  
+  const colorKey = LEVEL_COLORS[level as keyof typeof LEVEL_COLORS] || 'reset';
+  const color = Colors[colorKey];
+  const padded = level.toUpperCase().padStart(5);
+  
+  return `${color}${padded}${Colors.reset} `;
+}
+
+/**
+ * Formata indentação
+ */
+function formatIndent(indent: number): string {
+  const size = Math.min(indent, LAYOUT.maxIndent) * LAYOUT.indentSize;
+  return ' '.repeat(size);
+}
+
+/**
+ * Formata metadados
+ */
+function formatMetadata(metadata: Record<string, unknown> | undefined, indent: number): string {
+  if (!metadata || Object.keys(metadata).length === 0) return '';
+  
+  const prefix = '\n' + formatIndent(indent + 1);
+  const lines: string[] = [];
+  
+  for (const [key, value] of Object.entries(metadata)) {
+    let formattedValue: string;
+    
+    if (value === null) {
+      formattedValue = 'null';
+    } else if (value === undefined) {
+      formattedValue = 'undefined';
+    } else if (typeof value === 'object') {
+      try {
+        formattedValue = JSON.stringify(value);
+      } catch {
+        formattedValue = '[Object]';
+      }
+    } else if (typeof value === 'string' && value.length > 100) {
+      formattedValue = value.slice(0, 97) + '...';
+    } else {
+      formattedValue = String(value);
+    }
+    
+    const keyStr = `${Colors.dim}${key}:${Colors.reset}`;
+    const valueStr = `${Colors.white}${formattedValue}${Colors.reset}`;
+    lines.push(`${prefix}${keyStr} ${valueStr}`);
+  }
+  
+  return lines.join('');
+}
+
+/**
+ * Formata trace ID
+ */
+function formatTraceId(traceId: string | undefined): string {
+  if (!traceId) return '';
+  return `${Colors.darkGray}[${traceId}]${Colors.reset} `;
+}
+
+/**
+ * Formata mensagem completa no modo pretty
+ */
+export function formatPretty(entry: LogEntry, config: LoggerConfig): string {
+  const parts: string[] = [];
+  
+  // Timestamp
+  parts.push(formatTimestamp(entry.timestamp, config));
+  
+  // Trace ID (só mostra em modo debug/trace ou quando explicitamente configurado)
+  if (config.level === 'debug' || config.level === 'trace' || config.level === 'silly') {
+    parts.push(formatTraceId(entry.context?.traceId));
+  }
+  
+  // Indentação
+  parts.push(formatIndent(entry.context?.indent || 0));
+  
+  // Nível (apenas para debug/trace, outros têm ícones)
+  if (['debug', 'trace', 'silly'].includes(entry.level)) {
+    parts.push(formatLevel(entry.level, config));
+  }
+  
+  // Mensagem
+  parts.push(entry.message);
+  
+  // Metadados
+  if (entry.metadata) {
+    parts.push(formatMetadata(entry.metadata, entry.context?.indent || 0));
+  }
+  
+  return parts.join('');
+}
+
+/**
+ * Formata mensagem no modo minimal
+ */
+export function formatMinimal(entry: LogEntry, config: LoggerConfig): string {
+  // No modo minimal, ignora debug/trace/silly
+  if (['debug', 'trace', 'silly'].includes(entry.level)) {
+    return '';
+  }
+  
+  const parts: string[] = [];
+  
+  // Timestamp opcional
+  if (config.timestamps) {
+    const hours = entry.timestamp.getHours().toString().padStart(2, '0');
+    const minutes = entry.timestamp.getMinutes().toString().padStart(2, '0');
+    parts.push(`${hours}:${minutes} `);
+  }
+  
+  // Ícone baseado no nível
+  let icon = '';
+  switch (entry.level) {
+    case 'error':
+      icon = '✗';
+      break;
+    case 'warn':
+      icon = '!';
+      break;
+    case 'success':
+      icon = '✓';
+      break;
+    case 'info':
+      icon = '→';
+      break;
+  }
+  
+  if (icon) {
+    parts.push(`${icon} `);
+  }
+  
+  // Mensagem (sem cores)
+  parts.push(stripAnsi(entry.message));
+  
+  return parts.join('');
+}
+
+/**
+ * Formata mensagem no modo JSON
+ */
+export function formatJson(entry: LogEntry): string {
+  const obj = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    message: stripAnsi(entry.message),
+    ...entry.context,
+    metadata: entry.metadata,
+  };
+  
+  return JSON.stringify(obj);
+}
+
+/**
+ * Formata mensagem de acordo com o modo configurado
+ */
+export function formatEntry(entry: LogEntry, config: LoggerConfig): string {
+  switch (config.mode) {
+    case 'json':
+      return formatJson(entry);
+    case 'minimal':
+      return formatMinimal(entry, config);
+    case 'silent':
+      return '';
+    case 'pretty':
+    default:
+      return formatPretty(entry, config);
+  }
+}
+
+/**
+ * Formata linha de status (nome, status, info)
+ */
+export function formatStatusLine(
+  name: string,
+  status: 'pending' | 'running' | 'success' | 'error' | 'warning',
+  info?: string,
+  config?: LoggerConfig
+): string {
+  const colors = config?.colors !== false;
+  
+  const statusConfig = {
+    pending: { icon: '○', color: Colors.gray, text: 'pendente' },
+    running: { icon: '●', color: Colors.primary, text: 'executando' },
+    success: { icon: '✓', color: Colors.success, text: 'concluído' },
+    error: { icon: '✗', color: Colors.error, text: 'erro' },
+    warning: { icon: '!', color: Colors.warning, text: 'aviso' },
+  };
+  
+  const s = statusConfig[status];
+  const indent = formatIndent(1);
+  
+  let line = indent;
+  
+  // Nome
+  line += padText(name, LAYOUT.columns.name);
+  
+  // Status
+  const statusText = colors 
+    ? `${s.color}${s.icon} ${s.text}${Colors.reset}`
+    : `${s.icon} ${s.text}`;
+  line += padText(statusText, LAYOUT.columns.status);
+  
+  // Info
+  if (info) {
+    line += colors ? `${Colors.dim}${info}${Colors.reset}` : info;
+  }
+  
+  return line;
+}
+
+/**
+ * Formata seção com título
+ */
+export function formatSection(title: string, config?: LoggerConfig): string {
+  const colors = config?.colors !== false;
+  const indent = formatIndent(1);
+  
+  let output = '\n';
+  output += indent;
+  output += colors ? `${Colors.bold}${title}${Colors.reset}` : title;
+  output += '\n';
+  output += indent;
+  output += colors 
+    ? `${Colors.darkGray}${LAYOUT.borders.horizontal.repeat(40)}${Colors.reset}`
+    : '-'.repeat(40);
+  
+  return output;
+}
+
+/**
+ * Formata configuração (chave: valor)
+ */
+export function formatConfig(key: string, value: string | number | boolean, config?: LoggerConfig): string {
+  const colors = config?.colors !== false;
+  const indent = formatIndent(1);
+  
+  const keyStr = padText(`${key}:`, 12);
+  let valueStr = String(value);
+  
+  if (colors) {
+    if (typeof value === 'boolean') {
+      valueStr = value 
+        ? `${Colors.success}sim${Colors.reset}` 
+        : `${Colors.gray}não${Colors.reset}`;
+    } else {
+      valueStr = `${Colors.white}${valueStr}${Colors.reset}`;
+    }
+  }
+  
+  return `${indent}${Colors.dim}${keyStr}${Colors.reset}${valueStr}`;
+}
+
+/**
+ * Formata URL
+ */
+export function formatUrl(label: string, url: string, config?: LoggerConfig): string {
+  const colors = config?.colors !== false;
+  const indent = formatIndent(1);
+  
+  if (colors) {
+    return `${indent}${Colors.success}→${Colors.reset} ${label}: ${Colors.primaryBright}${Colors.bold}${url}${Colors.reset}`;
+  }
+  return `${indent}→ ${label}: ${url}`;
+}
+
+/**
+ * Formata arquivo (nome, ação, caminho)
+ */
+export function formatFile(
+  name: string,
+  action: 'changed' | 'compiled' | 'synced' | 'error',
+  path?: string,
+  config?: LoggerConfig
+): string {
+  const colors = config?.colors !== false;
+  const indent = formatIndent(1);
+  
+  const actionConfig = {
+    changed: { icon: '○', color: Colors.gray },
+    compiled: { icon: '✓', color: Colors.success },
+    synced: { icon: '✓', color: Colors.success },
+    error: { icon: '✗', color: Colors.error },
+  };
+  
+  const a = actionConfig[action];
+  const displayName = name.length > 25 ? '...' + name.slice(-22) : name;
+  
+  let line = indent;
+  line += colors ? `${a.color}${a.icon}${Colors.reset}` : a.icon;
+  line += ' ';
+  line += colors ? `${Colors.dim}${displayName}${Colors.reset}` : displayName;
+  
+  if (path) {
+    line += ' ';
+    line += colors ? `${Colors.darkGray}${path}${Colors.reset}` : path;
+  }
+  
+  return line;
+}