@crimsonsunset/jsg-logger 1.0.8

package/index.js

@@ -0,0 +1,413 @@
+/**
+ * CACP Portable Logger System
+ * Main entry point for the smart adaptive logging system
+ */
+
+import pino from 'pino';
+import {configManager} from './config/config-manager.js';
+import {COMPONENT_SCHEME} from './config/component-schemes.js';
+import defaultConfig from './config/default-config.json';
+import {getEnvironment, isBrowser, isCLI} from './utils/environment-detector.js';
+import {createBrowserFormatter} from './formatters/browser-formatter.js';
+import {createCLIFormatter} from './formatters/cli-formatter.js';
+import {createServerFormatter, getServerConfig} from './formatters/server-formatter.js';
+import {LogStore} from './stores/log-store.js';
+
+/**
+ * Main Logger Class
+ * Manages logger instances and provides the public API
+ */
+class CACPLogger {
+    constructor() {
+        this.loggers = {};
+        this.logStore = new LogStore();
+        this.environment = getEnvironment();
+        this.initialized = false;
+    }
+
+    /**
+     * Initialize the logger system
+     * @param {Object} options - Initialization options
+     * @returns {Promise<Object>} Logger instance with all components
+     */
+    async init(options = {}) {
+        try {
+            // Load configuration
+            if (options.configPath || options.config) {
+                await configManager.loadConfig(options.configPath || options.config);
+            }
+
+            // Create loggers for all available components
+            const components = configManager.getAvailableComponents();
+
+            components.forEach(componentName => {
+                this.loggers[componentName] = this.createLogger(componentName);
+            });
+
+            // Create legacy compatibility aliases
+            this.createAliases();
+
+            // Add utility methods
+            this.addUtilityMethods();
+
+            this.initialized = true;
+
+            // Log initialization success
+            if (this.loggers.cacp) {
+                this.loggers.cacp.info('CACP Logger initialized', {
+                    environment: this.environment,
+                    components: components.length,
+                    projectName: configManager.getProjectName(),
+                    configPaths: configManager.loadedPaths,
+                    fileOverrides: Object.keys(configManager.config.fileOverrides || {}).length
+                });
+            }
+
+            return this.getLoggerExports();
+        } catch (error) {
+            console.error('CACP Logger initialization failed:', error);
+            // Return minimal fallback logger
+            return this.createFallbackLogger();
+        }
+    }
+
+    /**
+     * Initialize synchronously with default configuration
+     * @returns {Object} Logger instance with all components
+     */
+    initSync() {
+        try {
+            // Create loggers for all available components using default config
+            const components = configManager.getAvailableComponents();
+
+            components.forEach(componentName => {
+                this.loggers[componentName] = this.createLogger(componentName);
+            });
+
+            // Create legacy compatibility aliases
+            this.createAliases();
+
+            // Add utility methods
+            this.addUtilityMethods();
+
+            this.initialized = true;
+
+            // Log initialization success
+            if (this.loggers.cacp) {
+                this.loggers.cacp.info('CACP Logger initialized (sync)', {
+                    environment: this.environment,
+                    components: components.length,
+                    projectName: configManager.getProjectName(),
+                    fileOverrides: Object.keys(configManager.config.fileOverrides || {}).length,
+                    timestampMode: configManager.getTimestampMode()
+                });
+            }
+
+            return this.getLoggerExports();
+        } catch (error) {
+            console.error('CACP Logger sync initialization failed:', error);
+            // Return minimal fallback logger
+            return this.createFallbackLogger();
+        }
+    }
+
+    /**
+     * Create a logger for a specific component
+     * @param {string} componentName - Component identifier
+     * @returns {Object} Pino logger instance
+     */
+    createLogger(componentName) {
+        const component = configManager.getComponentConfig(componentName);
+
+        let stream;
+        let config = {
+            name: componentName,
+            level: configManager.getEffectiveLevel(componentName) // Use smart level resolution
+        };
+
+        if (isBrowser()) {
+            // Browser environment - bypass Pino, use direct console formatting
+            return this.createDirectBrowserLogger(componentName);
+        } else if (isCLI()) {
+            // CLI environment - use pino-colada or pino-pretty
+            stream = createCLIFormatter();
+            config.prettyPrint = true;
+        } else {
+            // Server/production environment - structured JSON
+            stream = createServerFormatter();
+            config = {...config, ...getServerConfig()};
+        }
+
+        const logger = stream ? pino(config, stream) : pino(config);
+
+        // Add component emoji to logger for easy identification
+        logger._componentEmoji = component.emoji;
+        logger._componentName = component.name;
+        logger._effectiveLevel = configManager.getEffectiveLevel(componentName);
+
+        return logger;
+    }
+
+    /**
+     * Create legacy compatibility aliases
+     * @private
+     */
+    createAliases() {
+        // Legacy compatibility for existing codebase
+        this.loggers.siteDetector = this.loggers['site-detector'];
+        this.loggers.priorityManager = this.loggers['priority-manager'];
+    }
+
+    /**
+     * Add utility methods to the logger exports
+     * @private
+     */
+    addUtilityMethods() {
+        // Create logger on demand
+        this.createLogger = (componentName) => {
+            if (!this.loggers[componentName]) {
+                this.loggers[componentName] = this.createLogger(componentName);
+            }
+            return this.loggers[componentName];
+        };
+    }
+
+    /**
+     * Get the object to export with all loggers and utilities
+     * @returns {Object} Complete logger exports
+     */
+    getLoggerExports() {
+        return {
+            // All component loggers
+            ...this.loggers,
+
+            // Utility methods
+            createLogger: (componentName) => {
+                if (!this.loggers[componentName]) {
+                    this.loggers[componentName] = this.createLogger(componentName);
+                }
+                return this.loggers[componentName];
+            },
+
+            // Configuration and debugging
+            config: {
+                environment: this.environment,
+                components: COMPONENT_SCHEME,
+                summary: configManager.getSummary()
+            },
+
+            // Expose config manager for runtime configuration
+            configManager: configManager,
+
+            // Log store for popup/debugging
+            logStore: this.logStore,
+
+            // Enhanced runtime controls with all new features
+            controls: {
+                // Level controls
+                setLevel: (component, level) => {
+                    if (this.loggers[component]) {
+                        this.loggers[component].level = level;
+                        this.loggers[component]._effectiveLevel = level;
+                    }
+                },
+                getLevel: (component) => {
+                    return this.loggers[component]?._effectiveLevel;
+                },
+
+                // Component controls
+                listComponents: () => Object.keys(this.loggers),
+                enableDebugMode: () => {
+                    Object.keys(this.loggers).forEach(component => {
+                        this.controls.setLevel(component, 'debug');
+                    });
+                },
+                enableTraceMode: () => {
+                    Object.keys(this.loggers).forEach(component => {
+                        this.controls.setLevel(component, 'trace');
+                    });
+                },
+
+                // File override controls
+                addFileOverride: (filePath, overrideConfig) => {
+                    configManager.addFileOverride(filePath, overrideConfig);
+                    // Refresh affected loggers
+                    this.refreshLoggers();
+                },
+                removeFileOverride: (filePath) => {
+                    if (configManager.config.fileOverrides) {
+                        delete configManager.config.fileOverrides[filePath];
+                        this.refreshLoggers();
+                    }
+                },
+                listFileOverrides: () => {
+                    return Object.keys(configManager.config.fileOverrides || {});
+                },
+
+                // Timestamp controls
+                setTimestampMode: (mode) => {
+                    configManager.config.timestampMode = mode;
+                },
+                getTimestampMode: () => {
+                    return configManager.getTimestampMode();
+                },
+                getTimestampModes: () => {
+                    return ['absolute', 'readable', 'relative', 'disable'];
+                },
+
+                // Display controls
+                setDisplayOption: (option, enabled) => {
+                    if (!configManager.config.display) {
+                        configManager.config.display = {};
+                    }
+                    configManager.config.display[option] = enabled;
+                },
+                getDisplayConfig: () => {
+                    return configManager.getDisplayConfig();
+                },
+                toggleDisplayOption: (option) => {
+                    const current = configManager.getDisplayConfig();
+                    this.controls.setDisplayOption(option, !current[option]);
+                },
+
+                // Statistics and debugging
+                getStats: () => this.logStore.getStats(),
+                getConfigSummary: () => configManager.getSummary(),
+
+                // Advanced configuration
+                setComponentLevel: (component, level) => {
+                    if (!configManager.config.components[component]) {
+                        configManager.config.components[component] = {};
+                    }
+                    configManager.config.components[component].level = level;
+                    this.refreshLoggers();
+                },
+                getComponentLevel: (component) => {
+                    return configManager.config.components?.[component]?.level;
+                },
+
+                // System controls
+                refresh: () => this.refreshLoggers(),
+                reset: () => {
+                    configManager.config = {...defaultConfig};
+                    this.refreshLoggers();
+                }
+            }
+        };
+    }
+
+    /**
+     * Create a direct browser logger that bypasses Pino for full control
+     * @param {string} componentName - Component identifier
+     * @returns {Object} Logger-like object with standard methods
+     * @private
+     */
+    createDirectBrowserLogger(componentName) {
+        const formatter = createBrowserFormatter(componentName, this.logStore);
+        const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+        const levelMap = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60 };
+        
+        const logger = {};
+        
+        levels.forEach(level => {
+            logger[level] = (first, ...args) => {
+                const logLevel = levelMap[level];
+                
+                // Check if level should be logged
+                const effectiveLevel = configManager.getEffectiveLevel(componentName);
+                const minLevel = levelMap[effectiveLevel] || 30;
+                if (logLevel < minLevel) return;
+                
+                // Create log data object
+                let logData = {
+                    level: logLevel,
+                    time: Date.now(),
+                    name: componentName,
+                    v: 1
+                };
+                
+                // Handle different argument patterns
+                if (typeof first === 'string') {
+                    logData.msg = first;
+                    // Add additional args as context
+                    if (args.length === 1 && typeof args[0] === 'object') {
+                        Object.assign(logData, args[0]);
+                    } else if (args.length > 0) {
+                        logData.args = args;
+                    }
+                } else if (typeof first === 'object') {
+                    Object.assign(logData, first);
+                    if (args.length > 0 && typeof args[0] === 'string') {
+                        logData.msg = args[0];
+                    }
+                }
+                
+                // Use our beautiful formatter
+                formatter.write(JSON.stringify(logData));
+            };
+        });
+        
+        // Add Pino-compatible properties
+        logger._componentEmoji = configManager.getComponentConfig(componentName).emoji;
+        logger._componentName = componentName;
+        logger._effectiveLevel = configManager.getEffectiveLevel(componentName);
+        logger.level = configManager.getEffectiveLevel(componentName);
+        
+        return logger;
+    }
+
+    /**
+     * Refresh all loggers with updated configuration
+     * @private
+     */
+    refreshLoggers() {
+        Object.keys(this.loggers).forEach(componentName => {
+            this.loggers[componentName] = this.createLogger(componentName);
+        });
+    }
+
+    /**
+     * Create fallback logger for error scenarios
+     * @private
+     */
+    createFallbackLogger() {
+        const fallback = {
+            info: console.log,
+            debug: console.log,
+            trace: console.log,
+            warn: console.warn,
+            error: console.error,
+            fatal: console.error
+        };
+
+        return {
+            cacp: fallback,
+            createLogger: () => fallback,
+            config: {environment: 'fallback'},
+            logStore: {getRecent: () => [], clear: () => {}},
+            controls: {
+                setLevel: () => {},
+                getLevel: () => 'info',
+                listComponents: () => [],
+                enableDebugMode: () => {},
+                getStats: () => ({total: 0})
+            }
+        };
+    }
+}
+
+// Create singleton instance
+const logger = new CACPLogger();
+
+// Initialize synchronously with default config for immediate use
+// (Chrome extensions and other environments that don't support top-level await)
+const enhancedLoggers = logger.initSync();
+
+// Make runtime controls available globally in browser for debugging
+if (isBrowser() && typeof window !== 'undefined') {
+    window.CACP_Logger = enhancedLoggers.controls;
+}
+
+// Export both the initialized loggers and the init function for advanced usage
+export default enhancedLoggers;
+export {logger as CACPLogger};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@crimsonsunset/jsg-logger",
+  "version": "1.0.8",
+  "type": "module",
+  "description": "JSG Logger - Multi-environment logger with smart detection, file-level overrides, and beautiful console formatting",
+  "main": "index.js",
+  "keywords": [
+    "logging",
+    "pino",
+    "browser",
+    "cli",
+    "server",
+    "chrome-extension",
+    "adaptive",
+    "jsg-logger",
+    "environment-detection",
+    "file-overrides"
+  ],
+  "author": "Joe Sangiorgio <jsangio1@gmail.com>",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crimsonsunset/jsg-logger.git"
+  },
+  "bugs": {
+    "url": "https://github.com/crimsonsunset/jsg-logger/issues"
+  },
+  "homepage": "https://github.com/crimsonsunset/jsg-logger#readme",
+  "dependencies": {
+    "pino": "^9.7.0"
+  },
+  "devDependencies": {
+    "pino-colada": "^2.2.2"
+  },
+  "peerDependencies": {
+    "pino-colada": "^2.2.2"
+  },
+  "files": [
+    "index.js",
+    "config/",
+    "formatters/",
+    "stores/",
+    "utils/",
+    "examples/",
+    "docs/",
+    "README.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./config": "./config/config-manager.js",
+    "./config/manager": "./config/config-manager.js",
+    "./config/schemes": "./config/component-schemes.js",
+    "./config/default": "./config/default-config.json",
+    "./formatters/browser": "./formatters/browser-formatter.js",
+    "./formatters/cli": "./formatters/cli-formatter.js",
+    "./formatters/server": "./formatters/server-formatter.js",
+    "./stores": "./stores/log-store.js",
+    "./stores/log-store": "./stores/log-store.js",
+    "./utils": "./utils/environment-detector.js",
+    "./utils/environment": "./utils/environment-detector.js",
+    "./examples/*": "./examples/*"
+  },
+  "scripts": {
+    "release:patch": "npm version patch && npm publish --access public",
+    "release:minor": "npm version minor && npm publish --access public",
+    "release:major": "npm version major && npm publish --access public",
+    "release": "npm run release:patch",
+    "publish:public": "npm publish --access public",
+    "check": "npm run test && echo 'Package ready for publishing'"
+  }
+}

package/stores/log-store.js

@@ -0,0 +1,148 @@
+/**
+ * Log Store for In-Memory Log Management
+ * Particularly useful for Chrome extension popup debugging
+ */
+
+export class LogStore {
+  constructor(maxLogs = 100) {
+    this.logs = [];
+    this.maxLogs = maxLogs;
+    this.subscribers = [];
+  }
+
+  /**
+   * Add a log entry to the store
+   * @param {Object} logData - Structured log data
+   */
+  add(logData) {
+    const logEntry = {
+      ...logData,
+      id: Date.now() + Math.random(),
+      timestamp: logData.time || Date.now()
+    };
+
+    this.logs.unshift(logEntry);
+    
+    // Maintain max size
+    if (this.logs.length > this.maxLogs) {
+      this.logs.pop();
+    }
+
+    // Notify subscribers
+    this.subscribers.forEach(callback => {
+      try {
+        callback(logEntry, this.logs);
+      } catch (error) {
+        console.error('LogStore subscriber error:', error);
+      }
+    });
+  }
+
+  /**
+   * Get recent log entries
+   * @param {number} count - Number of logs to return
+   * @returns {Array} Recent log entries
+   */
+  getRecent(count = 20) {
+    return this.logs.slice(0, count);
+  }
+
+  /**
+   * Get logs filtered by component
+   * @param {string} component - Component name to filter by
+   * @param {number} count - Max number of logs to return
+   * @returns {Array} Filtered log entries
+   */
+  getByComponent(component, count = 20) {
+    return this.logs
+      .filter(log => log.name === component)
+      .slice(0, count);
+  }
+
+  /**
+   * Get logs filtered by level
+   * @param {number} level - Minimum log level (10=trace, 60=fatal)
+   * @param {number} count - Max number of logs to return
+   * @returns {Array} Filtered log entries
+   */
+  getByLevel(level, count = 20) {
+    return this.logs
+      .filter(log => log.level >= level)
+      .slice(0, count);
+  }
+
+  /**
+   * Clear all stored logs
+   */
+  clear() {
+    this.logs = [];
+    this.subscribers.forEach(callback => {
+      try {
+        callback(null, []);
+      } catch (error) {
+        console.error('LogStore subscriber error:', error);
+      }
+    });
+  }
+
+  /**
+   * Subscribe to log updates
+   * @param {Function} callback - Called when new logs are added
+   * @returns {Function} Unsubscribe function
+   */
+  subscribe(callback) {
+    this.subscribers.push(callback);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.subscribers.indexOf(callback);
+      if (index > -1) {
+        this.subscribers.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Get summary statistics
+   * @returns {Object} Log statistics
+   */
+  getStats() {
+    const stats = {
+      total: this.logs.length,
+      byLevel: {},
+      byComponent: {},
+      timeRange: null
+    };
+
+    if (this.logs.length > 0) {
+      stats.timeRange = {
+        start: this.logs[this.logs.length - 1].timestamp,
+        end: this.logs[0].timestamp
+      };
+
+      this.logs.forEach(log => {
+        // Level stats
+        const levelName = this.getLevelName(log.level);
+        stats.byLevel[levelName] = (stats.byLevel[levelName] || 0) + 1;
+
+        // Component stats  
+        const component = log.name || 'unknown';
+        stats.byComponent[component] = (stats.byComponent[component] || 0) + 1;
+      });
+    }
+
+    return stats;
+  }
+
+  /**
+   * Helper to get level name from level number
+   * @private
+   */
+  getLevelName(level) {
+    const levelMap = {
+      10: 'trace', 20: 'debug', 30: 'info',
+      40: 'warn', 50: 'error', 60: 'fatal'
+    };
+    return levelMap[level] || 'unknown';
+  }
+}

package/utils/environment-detector.js

@@ -0,0 +1,38 @@
+/**
+ * Environment Detection Utilities
+ * Smart detection of browser, CLI, and server environments
+ */
+
+/**
+ * Check if running in browser environment
+ * @returns {boolean}
+ */
+export const isBrowser = () => {
+  return typeof window !== 'undefined' && typeof document !== 'undefined';
+};
+
+/**
+ * Check if running in CLI/terminal environment
+ * @returns {boolean}
+ */
+export const isCLI = () => {
+  return typeof process !== 'undefined' && process.stdout && process.stdout.isTTY;
+};
+
+/**
+ * Check if running in server/production environment
+ * @returns {boolean}
+ */
+export const isServer = () => {
+  return !isBrowser() && !isCLI();
+};
+
+/**
+ * Get current environment type
+ * @returns {'browser'|'cli'|'server'}
+ */
+export const getEnvironment = () => {
+  if (isBrowser()) return 'browser';
+  if (isCLI()) return 'cli';
+  return 'server';
+};