@hamak/logging-impl 0.4.1

package/dist/es2015/utils/console-interceptor.js

@@ -0,0 +1,105 @@
+/**
+ * Console interceptor that routes console methods through the logging system
+ *
+ * By default, this is enabled. Set `interceptConsole: false` in LoggingPluginConfig to disable.
+ */
+export class ConsoleInterceptor {
+    constructor(logManager) {
+        this.logManager = logManager;
+        this.isIntercepting = false;
+        // Store original console methods
+        this.originalConsole = {
+            log: console.log.bind(console),
+            debug: console.debug.bind(console),
+            info: console.info.bind(console),
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+            trace: console.trace.bind(console),
+        };
+    }
+    /**
+     * Start intercepting console methods
+     */
+    intercept() {
+        if (this.isIntercepting) {
+            return;
+        }
+        const logger = this.logManager.createLogger({
+            plugin: 'console-interceptor',
+            module: 'global'
+        });
+        // Intercept console.log
+        console.log = (...args) => {
+            logger.info(this.formatMessage(args));
+        };
+        // Intercept console.debug
+        console.debug = (...args) => {
+            logger.debug(this.formatMessage(args));
+        };
+        // Intercept console.info
+        console.info = (...args) => {
+            logger.info(this.formatMessage(args));
+        };
+        // Intercept console.warn
+        console.warn = (...args) => {
+            logger.warn(this.formatMessage(args));
+        };
+        // Intercept console.error
+        console.error = (...args) => {
+            const message = this.formatMessage(args);
+            const error = args.find(arg => arg instanceof Error);
+            logger.error(message, error);
+        };
+        // Intercept console.trace
+        console.trace = (...args) => {
+            const message = this.formatMessage(args);
+            logger.debug(message, {
+                stack: new Error().stack,
+                tags: ['trace']
+            });
+        };
+        this.isIntercepting = true;
+    }
+    /**
+     * Stop intercepting and restore original console methods
+     */
+    restore() {
+        if (!this.isIntercepting) {
+            return;
+        }
+        console.log = this.originalConsole.log;
+        console.debug = this.originalConsole.debug;
+        console.info = this.originalConsole.info;
+        console.warn = this.originalConsole.warn;
+        console.error = this.originalConsole.error;
+        console.trace = this.originalConsole.trace;
+        this.isIntercepting = false;
+    }
+    /**
+     * Get original console for direct access
+     */
+    getOriginalConsole() {
+        return this.originalConsole;
+    }
+    /**
+     * Format console arguments into a single message
+     */
+    formatMessage(args) {
+        return args
+            .map(arg => {
+            if (typeof arg === 'string') {
+                return arg;
+            }
+            if (arg instanceof Error) {
+                return `${arg.name}: ${arg.message}`;
+            }
+            try {
+                return JSON.stringify(arg);
+            }
+            catch (_a) {
+                return String(arg);
+            }
+        })
+            .join(' ');
+    }
+}

package/dist/es2015/utils/event-emitter.js

@@ -0,0 +1,39 @@
+/**
+ * Simple event emitter for internal use
+ */
+export class EventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, handler) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(handler);
+    }
+    off(event, handler) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.listeners.delete(event);
+            }
+        }
+    }
+    emit(event, ...args) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(...args);
+                }
+                catch (error) {
+                    console.error(`[EventEmitter] Error in handler for '${event}':`, error);
+                }
+            });
+        }
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}

package/dist/es2015/utils/index.js

@@ -0,0 +1,2 @@
+export * from './event-emitter.js';
+export * from './console-interceptor.js';

package/dist/formatters/dev-formatter.d.ts

@@ -0,0 +1,20 @@
+import type { ILogFormatter, LogEntry, ConsoleTransportConfig } from '@hamak/logging-api';
+/**
+ * Development formatter with colors and emojis
+ *
+ * Provides rich, human-readable console output for development.
+ */
+export declare class DevFormatter implements ILogFormatter {
+    private config;
+    constructor(config?: ConsoleTransportConfig);
+    format(entry: LogEntry): string;
+    formatBatch(entries: LogEntry[]): string;
+    private formatTimestamp;
+    private formatLevel;
+    private getLevelEmoji;
+    private getLevelLabel;
+    private colorize;
+    private formatContext;
+    private formatMetadata;
+}
+//# sourceMappingURL=dev-formatter.d.ts.map

package/dist/formatters/dev-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-formatter.d.ts","sourceRoot":"","sources":["../../src/formatters/dev-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAqC,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE7H;;;;GAIG;AACH,qBAAa,YAAa,YAAW,aAAa;IACpC,OAAO,CAAC,MAAM;gBAAN,MAAM,GAAE,sBAA2B;IASvD,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IA+B/B,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM;IAIxC,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,cAAc;CAiCvB"}

package/dist/formatters/dev-formatter.js

@@ -0,0 +1,140 @@
+/**
+ * Development formatter with colors and emojis
+ *
+ * Provides rich, human-readable console output for development.
+ */
+export class DevFormatter {
+    constructor(config = {}) {
+        this.config = config;
+        this.config = {
+            colors: config.colors ?? true,
+            emojis: config.emojis ?? true,
+            timestamps: config.timestamps ?? true,
+            showContext: config.showContext ?? true,
+        };
+    }
+    format(entry) {
+        const parts = [];
+        // Timestamp
+        if (this.config.timestamps) {
+            parts.push(this.formatTimestamp(entry.timestamp));
+        }
+        // Level with emoji and color
+        parts.push(this.formatLevel(entry.level));
+        // Context (plugin/module/component)
+        if (this.config.showContext) {
+            const context = this.formatContext(entry.context);
+            if (context) {
+                parts.push(context);
+            }
+        }
+        // Message
+        parts.push(entry.message);
+        // Metadata
+        const metadata = this.formatMetadata(entry.metadata);
+        if (metadata) {
+            parts.push(metadata);
+        }
+        return parts.join(' ');
+    }
+    formatBatch(entries) {
+        return entries.map(e => this.format(e)).join('\n');
+    }
+    formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        const time = date.toISOString().split('T')[1].split('.')[0];
+        return this.config.colors ? `\x1b[90m${time}\x1b[0m` : time;
+    }
+    formatLevel(level) {
+        const emoji = this.config.emojis ? this.getLevelEmoji(level) : '';
+        const label = this.getLevelLabel(level);
+        const colored = this.config.colors ? this.colorize(label, level) : label;
+        return emoji ? `${emoji} ${colored}` : colored;
+    }
+    getLevelEmoji(level) {
+        switch (level) {
+            case 0: return '🔍'; // TRACE
+            case 1: return '🐛'; // DEBUG
+            case 2: return 'ℹ️ '; // INFO
+            case 3: return '⚠️ '; // WARN
+            case 4: return '❌'; // ERROR
+            case 5: return '💀'; // FATAL
+            default: return '';
+        }
+    }
+    getLevelLabel(level) {
+        switch (level) {
+            case 0: return 'TRACE';
+            case 1: return 'DEBUG';
+            case 2: return 'INFO ';
+            case 3: return 'WARN ';
+            case 4: return 'ERROR';
+            case 5: return 'FATAL';
+            default: return 'UNKNW';
+        }
+    }
+    colorize(text, level) {
+        const colors = {
+            0: '\x1b[90m', // TRACE - Gray
+            1: '\x1b[36m', // DEBUG - Cyan
+            2: '\x1b[32m', // INFO - Green
+            3: '\x1b[33m', // WARN - Yellow
+            4: '\x1b[31m', // ERROR - Red
+            5: '\x1b[35m', // FATAL - Magenta
+        };
+        const color = colors[level] || '\x1b[0m';
+        const reset = '\x1b[0m';
+        return `${color}${text}${reset}`;
+    }
+    formatContext(context) {
+        const parts = [];
+        if (context.plugin) {
+            parts.push(this.config.colors
+                ? `\x1b[35m[${context.plugin}]\x1b[0m`
+                : `[${context.plugin}]`);
+        }
+        if (context.module) {
+            parts.push(this.config.colors
+                ? `\x1b[34m{${context.module}}\x1b[0m`
+                : `{${context.module}}`);
+        }
+        if (context.component) {
+            parts.push(this.config.colors
+                ? `\x1b[36m<${context.component}>\x1b[0m`
+                : `<${context.component}>`);
+        }
+        if (context.operation) {
+            parts.push(this.config.colors
+                ? `\x1b[90m(${context.operation})\x1b[0m`
+                : `(${context.operation})`);
+        }
+        return parts.join(' ');
+    }
+    formatMetadata(metadata) {
+        if (!metadata || Object.keys(metadata).length === 0) {
+            return '';
+        }
+        const { error, stack, tags, duration, ...rest } = metadata;
+        const parts = [];
+        // Duration
+        if (duration !== undefined) {
+            const color = this.config.colors ? '\x1b[33m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}⏱  ${duration}ms${reset}`);
+        }
+        // Tags
+        if (tags && tags.length > 0) {
+            const tagString = tags.map(t => `#${t}`).join(' ');
+            const color = this.config.colors ? '\x1b[90m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}${tagString}${reset}`);
+        }
+        // Other metadata
+        if (Object.keys(rest).length > 0) {
+            const color = this.config.colors ? '\x1b[90m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}${JSON.stringify(rest)}${reset}`);
+        }
+        return parts.length > 0 ? parts.join(' ') : '';
+    }
+}

package/dist/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dev-formatter.js';
+export * from './json-formatter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/formatters/index.js

@@ -0,0 +1,2 @@
+export * from './dev-formatter.js';
+export * from './json-formatter.js';

package/dist/formatters/json-formatter.d.ts

@@ -0,0 +1,24 @@
+import type { ILogFormatter, LogEntry } from '@hamak/logging-api';
+/**
+ * JSON formatter for structured logging
+ *
+ * Outputs logs as JSON for easy parsing by log aggregation tools.
+ */
+export declare class JsonFormatter implements ILogFormatter {
+    private config;
+    constructor(config?: JsonFormatterConfig);
+    format(entry: LogEntry): string;
+    formatBatch(entries: LogEntry[]): string;
+    private toObject;
+    private getLevelName;
+}
+/**
+ * Configuration for JSON formatter
+ */
+export interface JsonFormatterConfig {
+    /** Pretty print JSON (with indentation) */
+    pretty?: boolean;
+    /** Include stack traces for errors */
+    includeStack?: boolean;
+}
+//# sourceMappingURL=json-formatter.d.ts.map

package/dist/formatters/json-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-formatter.d.ts","sourceRoot":"","sources":["../../src/formatters/json-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAElE;;;;GAIG;AACH,qBAAa,aAAc,YAAW,aAAa;IACrC,OAAO,CAAC,MAAM;gBAAN,MAAM,GAAE,mBAAwB;IAQpD,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAO/B,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM;IAOxC,OAAO,CAAC,QAAQ;IAiChB,OAAO,CAAC,YAAY;CAWrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB"}

package/dist/formatters/json-formatter.js

@@ -0,0 +1,65 @@
+/**
+ * JSON formatter for structured logging
+ *
+ * Outputs logs as JSON for easy parsing by log aggregation tools.
+ */
+export class JsonFormatter {
+    constructor(config = {}) {
+        this.config = config;
+        this.config = {
+            pretty: config.pretty ?? false,
+            includeStack: config.includeStack ?? true,
+            ...config,
+        };
+    }
+    format(entry) {
+        const logObject = this.toObject(entry);
+        return this.config.pretty
+            ? JSON.stringify(logObject, null, 2)
+            : JSON.stringify(logObject);
+    }
+    formatBatch(entries) {
+        const logObjects = entries.map(e => this.toObject(e));
+        return this.config.pretty
+            ? JSON.stringify(logObjects, null, 2)
+            : JSON.stringify(logObjects);
+    }
+    toObject(entry) {
+        const obj = {
+            timestamp: entry.timestamp,
+            level: this.getLevelName(entry.level),
+            message: entry.message,
+        };
+        // Add context
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            obj.context = entry.context;
+        }
+        // Add metadata
+        if (entry.metadata) {
+            const { error, stack, ...rest } = entry.metadata;
+            if (Object.keys(rest).length > 0) {
+                obj.metadata = rest;
+            }
+            // Handle error separately
+            if (error) {
+                obj.error = {
+                    name: error.name,
+                    message: error.message,
+                    ...(this.config.includeStack && stack ? { stack } : {}),
+                };
+            }
+        }
+        return obj;
+    }
+    getLevelName(level) {
+        switch (level) {
+            case 0: return 'TRACE';
+            case 1: return 'DEBUG';
+            case 2: return 'INFO';
+            case 3: return 'WARN';
+            case 4: return 'ERROR';
+            case 5: return 'FATAL';
+            default: return 'UNKNOWN';
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @hamak/logging-impl
+ *
+ * Core implementation of the pluggable logging system.
+ * Provides LogManager, ContextLogger, transports, and formatters.
+ *
+ * @packageDocumentation
+ */
+export * from './core/index.js';
+export * from './transports/index.js';
+export * from './formatters/index.js';
+export * from './plugin/index.js';
+export * from './utils/index.js';
+export type { ILogger, ILogTransport, ILogFormatter, ILogManager, LogLevel, LogEntry, LogContext, LogMetadata, TransportConfig, LogManagerConfig, ConsoleTransportConfig, RemoteTransportConfig, } from '@hamak/logging-api';
+export { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN, } from '@hamak/logging-api';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,iBAAiB,CAAC;AAGhC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,kBAAkB,CAAC;AAGjC,YAAY,EACV,OAAO,EACP,aAAa,EACb,aAAa,EACb,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+/**
+ * @hamak/logging-impl
+ *
+ * Core implementation of the pluggable logging system.
+ * Provides LogManager, ContextLogger, transports, and formatters.
+ *
+ * @packageDocumentation
+ */
+// Export core implementations
+export * from './core/index.js';
+// Export transports
+export * from './transports/index.js';
+// Export formatters
+export * from './formatters/index.js';
+// Export plugin factory
+export * from './plugin/index.js';
+// Export utilities
+export * from './utils/index.js';
+export { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN, } from '@hamak/logging-api';

package/dist/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logging-plugin-factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/dist/plugin/index.js

@@ -0,0 +1 @@
+export * from './logging-plugin-factory.js';

package/dist/plugin/logging-plugin-factory.d.ts

@@ -0,0 +1,37 @@
+import type { PluginModule } from '@hamak/microkernel-spi';
+import type { LogManagerConfig } from '@hamak/logging-api';
+/**
+ * Configuration for the logging plugin
+ */
+export interface LoggingPluginConfig extends LogManagerConfig {
+    /** Use development formatter (rich console output) */
+    devFormatter?: boolean;
+    /** Remote transport configuration */
+    remoteTransport?: any;
+    /**
+     * Intercept console.log/warn/error and route through logging system
+     * @default true - Enabled by default, set to false to disable
+     */
+    interceptConsole?: boolean;
+}
+/**
+ * Create a logging plugin for the microkernel
+ *
+ * @example
+ * ```typescript
+ * import { createLoggingPlugin } from '@hamak/logging-impl';
+ *
+ * const loggingPlugin = createLoggingPlugin({
+ *   globalLevel: LogLevel.DEBUG,
+ *   pluginLevels: {
+ *     'my-plugin': LogLevel.TRACE
+ *   }
+ * });
+ *
+ * const host = createHost({
+ *   plugins: [loggingPlugin, myPlugin]
+ * });
+ * ```
+ */
+export declare function createLoggingPlugin(config?: LoggingPluginConfig): PluginModule;
+//# sourceMappingURL=logging-plugin-factory.d.ts.map

package/dist/plugin/logging-plugin-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-plugin-factory.d.ts","sourceRoot":"","sources":["../../src/plugin/logging-plugin-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,wBAAwB,CAAC;AAElF,OAAO,KAAK,EAAW,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAQpE;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,sDAAsD;IACtD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,qCAAqC;IACrC,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,mBAAwB,GAAG,YAAY,CAyGlF"}

package/dist/plugin/logging-plugin-factory.js

@@ -0,0 +1,112 @@
+import { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN } from '@hamak/logging-api';
+import { LogManager } from '../core/log-manager.js';
+import { ConsoleTransport } from '../transports/console-transport.js';
+import { DevFormatter } from '../formatters/dev-formatter.js';
+import { JsonFormatter } from '../formatters/json-formatter.js';
+import { ConsoleInterceptor } from '../utils/console-interceptor.js';
+/**
+ * Create a logging plugin for the microkernel
+ *
+ * @example
+ * ```typescript
+ * import { createLoggingPlugin } from '@hamak/logging-impl';
+ *
+ * const loggingPlugin = createLoggingPlugin({
+ *   globalLevel: LogLevel.DEBUG,
+ *   pluginLevels: {
+ *     'my-plugin': LogLevel.TRACE
+ *   }
+ * });
+ *
+ * const host = createHost({
+ *   plugins: [loggingPlugin, myPlugin]
+ * });
+ * ```
+ */
+export function createLoggingPlugin(config = {}) {
+    let logManager;
+    let rootLogger;
+    let consoleInterceptor;
+    // Determine environment
+    const isDevelopment = typeof process !== 'undefined'
+        ? process.env.NODE_ENV === 'development'
+        : true;
+    const defaultConfig = {
+        globalLevel: isDevelopment ? 1 : 2, // DEBUG in dev, INFO in prod
+        bufferSize: 1000,
+        flushInterval: 5000,
+        devFormatter: isDevelopment,
+        interceptConsole: true, // Enabled by default
+        pluginLevels: {},
+        moduleLevels: {},
+        ...config,
+    };
+    return {
+        async initialize(ctx) {
+            // Create log manager
+            logManager = new LogManager(defaultConfig);
+            rootLogger = logManager.createLogger({ plugin: 'logging', module: 'plugin' });
+            // Register console transport
+            const formatter = defaultConfig.devFormatter
+                ? new DevFormatter({
+                    colors: true,
+                    emojis: true,
+                    timestamps: true,
+                    showContext: true,
+                })
+                : new JsonFormatter({ pretty: isDevelopment });
+            logManager.registerTransport(new ConsoleTransport(formatter), {
+                id: 'console',
+                enabled: true,
+                minLevel: defaultConfig.globalLevel,
+            });
+            // Register services via DI
+            ctx.provide({ provide: LOG_MANAGER_TOKEN, useValue: logManager });
+            ctx.provide({ provide: LOG_CONFIG_TOKEN, useValue: defaultConfig });
+            // Provide logger factory
+            ctx.provide({
+                provide: LOGGER_TOKEN,
+                useFactory: (pluginName) => {
+                    return logManager.createLogger({ plugin: pluginName });
+                },
+                deps: [],
+            });
+            rootLogger.info('Logging plugin initialized', {
+                globalLevel: defaultConfig.globalLevel,
+                formatter: defaultConfig.devFormatter ? 'dev' : 'json',
+                tags: ['initialization'],
+            });
+        },
+        async activate(ctx) {
+            // Bridge microkernel events to logging
+            ctx.hooks.on('plugin:error', ({ plugin, error }) => {
+                const logger = logManager.createLogger({ plugin });
+                logger.error('Plugin error', error);
+            });
+            ctx.hooks.on('host:activated', () => {
+                rootLogger.info('Microkernel host activated', { tags: ['lifecycle'] });
+            });
+            // Intercept console methods if enabled
+            if (defaultConfig.interceptConsole) {
+                consoleInterceptor = new ConsoleInterceptor(logManager);
+                consoleInterceptor.intercept();
+                rootLogger.debug('Console interception enabled', { tags: ['console'] });
+            }
+            // Emit logging ready event
+            ctx.hooks.emit('logging:ready', { logManager });
+            rootLogger.info('Logging plugin activated', {
+                tags: ['lifecycle'],
+                interceptConsole: defaultConfig.interceptConsole,
+            });
+        },
+        async deactivate() {
+            rootLogger.info('Logging plugin deactivating', { tags: ['lifecycle'] });
+            // Restore original console methods
+            if (consoleInterceptor) {
+                consoleInterceptor.restore();
+                rootLogger.debug('Console interception disabled', { tags: ['console'] });
+            }
+            await logManager.destroy();
+        },
+    };
+}

package/dist/transports/console-transport.d.ts

@@ -0,0 +1,16 @@
+import type { ILogTransport, ILogFormatter, LogEntry } from '@hamak/logging-api';
+/**
+ * Console transport
+ *
+ * Outputs logs to the browser console or Node.js console.
+ * Supports formatting via pluggable formatters.
+ */
+export declare class ConsoleTransport implements ILogTransport {
+    private formatter;
+    readonly id = "console";
+    readonly name = "Console Transport";
+    constructor(formatter: ILogFormatter);
+    log(entry: LogEntry): void;
+    onError(error: Error): void;
+}
+//# sourceMappingURL=console-transport.d.ts.map

package/dist/transports/console-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-transport.d.ts","sourceRoot":"","sources":["../../src/transports/console-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEjF;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IAIxC,OAAO,CAAC,SAAS;IAH7B,QAAQ,CAAC,EAAE,aAAa;IACxB,QAAQ,CAAC,IAAI,uBAAuB;gBAEhB,SAAS,EAAE,aAAa;IAE5C,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IA8B1B,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAG5B"}