@hamak/logging 0.5.1

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

@@ -0,0 +1,112 @@
+import { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN } from '../../api/index';
+import { LogManager } from '../core/log-manager';
+import { ConsoleTransport } from '../transports/console-transport';
+import { DevFormatter } from '../formatters/dev-formatter';
+import { JsonFormatter } from '../formatters/json-formatter';
+import { ConsoleInterceptor } from '../utils/console-interceptor';
+/**
+ * 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/impl/transports/console-transport.d.ts

@@ -0,0 +1,16 @@
+import type { ILogTransport, ILogFormatter, LogEntry } from '../../api/index';
+/**
+ * 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/impl/transports/console-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-transport.d.ts","sourceRoot":"","sources":["../../../src/impl/transports/console-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE9E;;;;;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"}

package/dist/impl/transports/console-transport.js

@@ -0,0 +1,55 @@
+/**
+ * Console transport
+ *
+ * Outputs logs to the browser console or Node.js console.
+ * Supports formatting via pluggable formatters.
+ */
+export class ConsoleTransport {
+    constructor(formatter) {
+        Object.defineProperty(this, "formatter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: formatter
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'console'
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Console Transport'
+        });
+    }
+    log(entry) {
+        const formatted = this.formatter.format(entry);
+        switch (entry.level) {
+            case 0: // TRACE
+            case 1: // DEBUG
+                console.debug(formatted);
+                break;
+            case 2: // INFO
+                console.info(formatted);
+                break;
+            case 3: // WARN
+                console.warn(formatted);
+                break;
+            case 4: // ERROR
+            case 5: // FATAL
+                console.error(formatted);
+                if (entry.metadata?.error) {
+                    console.error(entry.metadata.error);
+                }
+                break;
+            default:
+                console.log(formatted);
+        }
+    }
+    onError(error) {
+        console.error('[ConsoleTransport] Error:', error);
+    }
+}

package/dist/impl/transports/index.d.ts

@@ -0,0 +1,2 @@
+export * from './console-transport';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/transports/index.d.ts.map

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

package/dist/impl/transports/index.js

@@ -0,0 +1 @@
+export * from './console-transport';

package/dist/impl/utils/console-interceptor.d.ts

@@ -0,0 +1,36 @@
+import type { ILogManager } from '../../api/index';
+/**
+ * Console interceptor that routes console methods through the logging system
+ *
+ * By default, this is enabled. Set `interceptConsole: false` in LoggingPluginConfig to disable.
+ */
+export declare class ConsoleInterceptor {
+    private logManager;
+    private originalConsole;
+    private isIntercepting;
+    constructor(logManager: ILogManager);
+    /**
+     * Start intercepting console methods
+     */
+    intercept(): void;
+    /**
+     * Stop intercepting and restore original console methods
+     */
+    restore(): void;
+    /**
+     * Get original console for direct access
+     */
+    getOriginalConsole(): {
+        log: typeof console.log;
+        debug: typeof console.debug;
+        info: typeof console.info;
+        warn: typeof console.warn;
+        error: typeof console.error;
+        trace: typeof console.trace;
+    };
+    /**
+     * Format console arguments into a single message
+     */
+    private formatMessage;
+}
+//# sourceMappingURL=console-interceptor.d.ts.map

package/dist/impl/utils/console-interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-interceptor.d.ts","sourceRoot":"","sources":["../../../src/impl/utils/console-interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,kBAAkB;IAYjB,OAAO,CAAC,UAAU;IAX9B,OAAO,CAAC,eAAe,CAOrB;IAEF,OAAO,CAAC,cAAc,CAAS;gBAEX,UAAU,EAAE,WAAW;IAY3C;;OAEG;IACH,SAAS,IAAI,IAAI;IAiDjB;;OAEG;IACH,OAAO,IAAI,IAAI;IAef;;OAEG;IACH,kBAAkB;aA/FX,OAAO,OAAO,CAAC,GAAG;eAChB,OAAO,OAAO,CAAC,KAAK;cACrB,OAAO,OAAO,CAAC,IAAI;cACnB,OAAO,OAAO,CAAC,IAAI;eAClB,OAAO,OAAO,CAAC,KAAK;eACpB,OAAO,OAAO,CAAC,KAAK;;IA8F7B;;OAEG;IACH,OAAO,CAAC,aAAa;CAiBtB"}

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

@@ -0,0 +1,121 @@
+/**
+ * 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) {
+        Object.defineProperty(this, "logManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logManager
+        });
+        Object.defineProperty(this, "originalConsole", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isIntercepting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 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 {
+                return String(arg);
+            }
+        })
+            .join(' ');
+    }
+}

package/dist/impl/utils/event-emitter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Simple event emitter for internal use
+ */
+export declare class EventEmitter {
+    private listeners;
+    on(event: string, handler: Function): void;
+    off(event: string, handler: Function): void;
+    emit(event: string, ...args: any[]): void;
+    clear(): void;
+}
+//# sourceMappingURL=event-emitter.d.ts.map

package/dist/impl/utils/event-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.d.ts","sourceRoot":"","sources":["../../../src/impl/utils/event-emitter.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAoC;IAErD,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,IAAI;IAO1C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,IAAI;IAU3C,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAazC,KAAK,IAAI,IAAI;CAGd"}

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

@@ -0,0 +1,44 @@
+/**
+ * Simple event emitter for internal use
+ */
+export class EventEmitter {
+    constructor() {
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 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/impl/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './event-emitter';
+export * from './console-interceptor';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}

package/dist/impl/utils/index.js

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

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @hamak/logging
+ *
+ * Complete logging system with API, SPI, and implementation.
+ *
+ * Usage:
+ * - `@hamak/logging/api` - Pure interfaces and tokens
+ * - `@hamak/logging/spi` - Extension points for custom transports/formatters
+ * - `@hamak/logging` - Full implementation
+ *
+ * @packageDocumentation
+ */
+export * from './impl/index';
+export type { ITransportProvider, TransportRegistration, IFormatterProvider, FormatterRegistration, } from './spi/index';
+//# 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;;;;;;;;;;;GAWG;AAGH,cAAc,cAAc,CAAC;AAG7B,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * @hamak/logging
+ *
+ * Complete logging system with API, SPI, and implementation.
+ *
+ * Usage:
+ * - `@hamak/logging/api` - Pure interfaces and tokens
+ * - `@hamak/logging/spi` - Extension points for custom transports/formatters
+ * - `@hamak/logging` - Full implementation
+ *
+ * @packageDocumentation
+ */
+// Export everything from impl (which re-exports api)
+export * from './impl/index';

package/dist/spi/formatter/formatter-provider.d.ts

@@ -0,0 +1,67 @@
+import type { ILogFormatter } from '../../api/index';
+/**
+ * Formatter Provider Interface
+ *
+ * Allows plugins to contribute custom log formatters.
+ * Formatters convert LogEntry objects into formatted output.
+ *
+ * @example
+ * ```typescript
+ * export class MyFormatterProvider implements IFormatterProvider {
+ *   readonly id = 'my-formatter';
+ *   readonly name = 'My Custom Formatter';
+ *
+ *   create(config?: MyFormatterConfig): ILogFormatter {
+ *     return new MyFormatter(config);
+ *   }
+ * }
+ * ```
+ */
+export interface IFormatterProvider {
+    /**
+     * Unique identifier for this formatter provider
+     */
+    readonly id: string;
+    /**
+     * Human-readable name
+     */
+    readonly name: string;
+    /**
+     * Description of the formatting style
+     */
+    readonly description?: string;
+    /**
+     * Create a formatter instance with the given configuration
+     *
+     * @param config Optional formatter-specific configuration
+     * @returns A configured formatter instance
+     */
+    create(config?: any): ILogFormatter;
+    /**
+     * Validate formatter-specific configuration
+     * Called before creating the formatter
+     *
+     * @param config Configuration to validate
+     * @returns true if valid, false otherwise
+     */
+    validateConfig?(config: any): boolean;
+    /**
+     * Get configuration schema for documentation/UI
+     *
+     * @returns JSON Schema or similar
+     */
+    getConfigSchema?(): any;
+}
+/**
+ * Formatter registration
+ * Used when plugins contribute formatters
+ */
+export interface FormatterRegistration {
+    /** The formatter provider */
+    provider: IFormatterProvider;
+    /** Formatter configuration */
+    config?: any;
+    /** Plugin that registered this formatter */
+    plugin?: string;
+}
+//# sourceMappingURL=formatter-provider.d.ts.map

package/dist/spi/formatter/formatter-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter-provider.d.ts","sourceRoot":"","sources":["../../../src/spi/formatter/formatter-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,aAAa,CAAC;IAEpC;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC;IAEtC;;;;OAIG;IACH,eAAe,CAAC,IAAI,GAAG,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,6BAA6B;IAC7B,QAAQ,EAAE,kBAAkB,CAAC;IAE7B,8BAA8B;IAC9B,MAAM,CAAC,EAAE,GAAG,CAAC;IAEb,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/spi/formatter/formatter-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/spi/formatter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './formatter-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/spi/formatter/index.d.ts.map

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

package/dist/spi/formatter/index.js

@@ -0,0 +1 @@
+export * from './formatter-provider';

package/dist/spi/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hamak/logging/spi
+ *
+ * Service Provider Interface for the logging system.
+ * Provides extension points for custom transports and formatters.
+ *
+ * @packageDocumentation
+ */
+export * from './transport/index';
+export * from './formatter/index';
+export type { ILogger, ILogTransport, ILogFormatter, ILogManager, LogLevel, LogEntry, LogContext, LogMetadata, TransportConfig, LogManagerConfig, } from '../api/index';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,mBAAmB,CAAC;AAGlC,cAAc,mBAAmB,CAAC;AAGlC,YAAY,EACV,OAAO,EACP,aAAa,EACb,aAAa,EACb,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,WAAW,EACX,eAAe,EACf,gBAAgB,GACjB,MAAM,cAAc,CAAC"}

package/dist/spi/index.js

@@ -0,0 +1,12 @@
+/**
+ * @hamak/logging/spi
+ *
+ * Service Provider Interface for the logging system.
+ * Provides extension points for custom transports and formatters.
+ *
+ * @packageDocumentation
+ */
+// Export transport provider interfaces
+export * from './transport/index';
+// Export formatter provider interfaces
+export * from './formatter/index';

package/dist/spi/transport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './transport-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/spi/transport/index.d.ts.map

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

package/dist/spi/transport/index.js

@@ -0,0 +1 @@
+export * from './transport-provider';