create-byan-agent 2.0.1 → 2.1.1

package/install/src/observability/dashboard/dashboard.js

@@ -0,0 +1,191 @@
+/**
+ * Dashboard for BYAN v2.0
+ * Provides formatted console output for system status, metrics, and logs
+ * 
+ * @module observability/dashboard/dashboard
+ * @version 2.0.0-HYPER-MVP
+ */
+
+/**
+ * Print dashboard to console with formatted output
+ * 
+ * @param {Object} data - Dashboard data
+ * @param {Object} [data.metrics={}] - Metrics from MetricsCollector
+ * @param {Array} [data.logs=[]] - Recent logs from StructuredLogger
+ * @param {Array} [data.workers=[]] - Active workers
+ * @param {Object} [data.status={}] - System status
+ * @returns {string} Formatted dashboard output
+ * 
+ * @example
+ * const output = printDashboard({
+ *   metrics: metricsCollector.getMetrics(),
+ *   logs: logger.getLogs().slice(-5),
+ *   workers: pool.getActiveWorkers(),
+ *   status: { uptime: 3600, version: '2.0.0' }
+ * });
+ * console.log(output);
+ */
+function printDashboard(data = {}) {
+  // Handle null data
+  if (!data) {
+    data = {};
+  }
+  const { metrics = {}, logs = [], workers = [], status = {} } = data;
+
+  const lines = [];
+
+  // Header
+  lines.push('╔═══════════════════════════════════════════════════════════╗');
+  lines.push('║           BYAN v2.0 Dashboard                             ║');
+  lines.push('╚═══════════════════════════════════════════════════════════╝');
+  lines.push('');
+
+  // Status Section
+  lines.push('┌─ Status ──────────────────────────────────────────────────┐');
+  if (Object.keys(status).length > 0) {
+    Object.entries(status).forEach(([key, value]) => {
+      lines.push(`│ ${_padRight(key, 15)}: ${value}`);
+    });
+  } else {
+    lines.push('│ No status information available');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  // Metrics Section
+  lines.push('┌─ Metrics ─────────────────────────────────────────────────┐');
+  const metricsArray = Object.entries(metrics);
+  if (metricsArray.length > 0) {
+    metricsArray.slice(0, 10).forEach(([key, metric]) => {
+      const displayKey = key.length > 30 ? key.substring(0, 27) + '...' : key;
+      const displayValue = _formatMetricValue(metric.value);
+      lines.push(`│ ${_padRight(displayKey, 30)}: ${displayValue}`);
+    });
+    if (metricsArray.length > 10) {
+      lines.push(`│ ... and ${metricsArray.length - 10} more metrics`);
+    }
+  } else {
+    lines.push('│ No metrics available');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  // Recent Logs Section
+  lines.push('┌─ Recent Logs ─────────────────────────────────────────────┐');
+  if (logs.length > 0) {
+    logs.slice(-5).forEach((log) => {
+      const level = _padRight(`[${log.level.toUpperCase()}]`, 8);
+      const message = log.message.length > 40 ? log.message.substring(0, 37) + '...' : log.message;
+      lines.push(`│ ${level} ${message}`);
+    });
+  } else {
+    lines.push('│ No recent logs');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  // Workers Section
+  lines.push('┌─ Workers ─────────────────────────────────────────────────┐');
+  if (workers.length > 0) {
+    workers.forEach((worker) => {
+      const id = _padRight(`Worker ${worker.id}`, 15);
+      const status = worker.status || 'unknown';
+      lines.push(`│ ${id}: ${status}`);
+    });
+  } else {
+    lines.push('│ No active workers');
+  }
+  lines.push('└───────────────────────────────────────────────────────────┘');
+
+  return lines.join('\n');
+}
+
+/**
+ * Pad string to right with spaces
+ * 
+ * @private
+ * @param {string} str - String to pad
+ * @param {number} length - Target length
+ * @returns {string} Padded string
+ */
+function _padRight(str, length) {
+  const s = String(str);
+  return s.length >= length ? s : s + ' '.repeat(length - s.length);
+}
+
+/**
+ * Format metric value for display
+ * 
+ * @private
+ * @param {number} value - Metric value
+ * @returns {string} Formatted value
+ */
+function _formatMetricValue(value) {
+  if (typeof value !== 'number') {
+    return String(value);
+  }
+
+  // Format large numbers with separators
+  if (value >= 1000) {
+    return value.toLocaleString();
+  }
+
+  // Format decimals
+  if (value % 1 !== 0) {
+    return value.toFixed(2);
+  }
+
+  return String(value);
+}
+
+/**
+ * Generate summary dashboard
+ * 
+ * @param {Object} data - Dashboard data
+ * @returns {string} Summary output
+ * 
+ * @example
+ * const summary = generateSummary({
+ *   metrics: metricsCollector.getStats(),
+ *   logs: logger.getStats()
+ * });
+ */
+function generateSummary(data = {}) {
+  // Handle null data
+  if (!data) {
+    data = {};
+  }
+  const { metrics = {}, logs = {} } = data;
+
+  const lines = [];
+
+  lines.push('═══ BYAN v2.0 Summary ═══');
+  lines.push('');
+
+  if (metrics.total !== undefined) {
+    lines.push(`Metrics: ${metrics.total} total`);
+    if (metrics.byType) {
+      Object.entries(metrics.byType).forEach(([type, count]) => {
+        lines.push(`  - ${type}: ${count}`);
+      });
+    }
+  }
+
+  lines.push('');
+
+  if (logs.debug !== undefined || logs.info !== undefined) {
+    const totalLogs = (logs.debug || 0) + (logs.info || 0) + (logs.warn || 0) + (logs.error || 0);
+    lines.push(`Logs: ${totalLogs} total`);
+    lines.push(`  - debug: ${logs.debug || 0}`);
+    lines.push(`  - info: ${logs.info || 0}`);
+    lines.push(`  - warn: ${logs.warn || 0}`);
+    lines.push(`  - error: ${logs.error || 0}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  printDashboard,
+  generateSummary,
+};

package/install/src/observability/logger/structured-logger.js

@@ -0,0 +1,254 @@
+/**
+ * Structured Logger for BYAN v2.0
+ * Provides structured logging with JSON format, log levels, and metadata
+ * 
+ * @module observability/logger/structured-logger
+ * @version 2.0.0-HYPER-MVP
+ */
+
+/**
+ * Log levels supported by the logger
+ */
+const LOG_LEVELS = {
+  DEBUG: 'debug',
+  INFO: 'info',
+  WARN: 'warn',
+  ERROR: 'error',
+};
+
+/**
+ * Numeric priorities for log levels
+ */
+const LOG_PRIORITIES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+/**
+ * Structured Logger - Provides JSON-formatted logging with metadata
+ * 
+ * @class StructuredLogger
+ * @example
+ * const logger = new StructuredLogger();
+ * logger.info('User logged in', { userId: '123', ip: '192.168.1.1' });
+ */
+class StructuredLogger {
+  constructor(options = {}) {
+    this.level = options.level || LOG_LEVELS.INFO;
+    this.logs = []; // In-memory storage for tests
+    this.enableConsole = options.enableConsole !== false;
+  }
+
+  /**
+   * Set the minimum log level
+   * 
+   * @param {string} level - Log level (debug, info, warn, error)
+   * @returns {void}
+   * 
+   * @example
+   * logger.setLevel('debug'); // Show all logs
+   * logger.setLevel('error'); // Show only errors
+   */
+  setLevel(level) {
+    if (!LOG_PRIORITIES.hasOwnProperty(level)) {
+      throw new Error(
+        `Invalid log level: ${level}. Must be one of: debug, info, warn, error`
+      );
+    }
+    this.level = level;
+  }
+
+  /**
+   * Log debug message
+   * 
+   * @param {string} message - Log message
+   * @param {Object} [meta={}] - Additional metadata
+   * @returns {void}
+   * 
+   * @example
+   * logger.debug('Cache hit', { key: 'user:123', ttl: 3600 });
+   */
+  debug(message, meta = {}) {
+    this._log(LOG_LEVELS.DEBUG, message, meta);
+  }
+
+  /**
+   * Log info message
+   * 
+   * @param {string} message - Log message
+   * @param {Object} [meta={}] - Additional metadata
+   * @returns {void}
+   * 
+   * @example
+   * logger.info('Task started', { taskId: '123', agent: 'dev' });
+   */
+  info(message, meta = {}) {
+    this._log(LOG_LEVELS.INFO, message, meta);
+  }
+
+  /**
+   * Log warning message
+   * 
+   * @param {string} message - Log message
+   * @param {Object} [meta={}] - Additional metadata
+   * @returns {void}
+   * 
+   * @example
+   * logger.warn('Rate limit approaching', { limit: 1000, used: 950 });
+   */
+  warn(message, meta = {}) {
+    this._log(LOG_LEVELS.WARN, message, meta);
+  }
+
+  /**
+   * Log error message
+   * 
+   * @param {string} message - Log message
+   * @param {Object} [meta={}] - Additional metadata
+   * @returns {void}
+   * 
+   * @example
+   * logger.error('Task failed', { taskId: '123', error: 'Timeout' });
+   */
+  error(message, meta = {}) {
+    this._log(LOG_LEVELS.ERROR, message, meta);
+  }
+
+  /**
+   * Internal log method
+   * 
+   * @private
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {Object} meta - Metadata
+   * @returns {void}
+   */
+  _log(level, message, meta) {
+    // Check if this log should be recorded based on level
+    if (LOG_PRIORITIES[level] < LOG_PRIORITIES[this.level]) {
+      return;
+    }
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      meta: { ...meta },
+    };
+
+    // Store in memory
+    this.logs.push(logEntry);
+
+    // Output to console if enabled
+    if (this.enableConsole) {
+      this._outputToConsole(logEntry);
+    }
+  }
+
+  /**
+   * Output log entry to console
+   * 
+   * @private
+   * @param {Object} logEntry - Log entry
+   * @returns {void}
+   */
+  _outputToConsole(logEntry) {
+    const output = JSON.stringify(logEntry);
+    
+    switch (logEntry.level) {
+      case LOG_LEVELS.DEBUG:
+        console.debug(output);
+        break;
+      case LOG_LEVELS.INFO:
+        console.info(output);
+        break;
+      case LOG_LEVELS.WARN:
+        console.warn(output);
+        break;
+      case LOG_LEVELS.ERROR:
+        console.error(output);
+        break;
+      default:
+        console.log(output);
+    }
+  }
+
+  /**
+   * Get all logs
+   * 
+   * @returns {Array<Object>} Array of log entries
+   * 
+   * @example
+   * const logs = logger.getLogs();
+   * logs.forEach(log => {
+   *   console.log(`[${log.level}] ${log.message}`);
+   * });
+   */
+  getLogs() {
+    return [...this.logs];
+  }
+
+  /**
+   * Get logs filtered by level
+   * 
+   * @param {string} level - Log level to filter by
+   * @returns {Array<Object>} Filtered log entries
+   * 
+   * @example
+   * const errors = logger.getLogsByLevel('error');
+   */
+  getLogsByLevel(level) {
+    return this.logs.filter((log) => log.level === level);
+  }
+
+  /**
+   * Clear all logs
+   * 
+   * @returns {void}
+   * 
+   * @example
+   * logger.clear(); // Remove all logs from memory
+   */
+  clear() {
+    this.logs = [];
+  }
+
+  /**
+   * Get log count
+   * 
+   * @returns {number} Number of logs
+   */
+  count() {
+    return this.logs.length;
+  }
+
+  /**
+   * Get log count by level
+   * 
+   * @returns {Object} Count of logs per level
+   * 
+   * @example
+   * const stats = logger.getStats();
+   * // { debug: 10, info: 25, warn: 3, error: 1 }
+   */
+  getStats() {
+    const stats = {
+      debug: 0,
+      info: 0,
+      warn: 0,
+      error: 0,
+    };
+
+    this.logs.forEach((log) => {
+      if (stats.hasOwnProperty(log.level)) {
+        stats[log.level]++;
+      }
+    });
+
+    return stats;
+  }
+}
+
+module.exports = { StructuredLogger, LOG_LEVELS };