@stackmemoryai/stackmemory 0.3.17 → 0.3.18

package/scripts/testing/src/core/errors/index.js

@@ -0,0 +1,291 @@
+/**
+ * Custom error classes for StackMemory
+ * Provides a hierarchy of error types for better error handling and debugging
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // Database errors (1000-1999)
+    ErrorCode["DB_CONNECTION_FAILED"] = "DB_001";
+    ErrorCode["DB_QUERY_FAILED"] = "DB_002";
+    ErrorCode["DB_TRANSACTION_FAILED"] = "DB_003";
+    ErrorCode["DB_MIGRATION_FAILED"] = "DB_004";
+    ErrorCode["DB_CONSTRAINT_VIOLATION"] = "DB_005";
+    ErrorCode["DB_SCHEMA_ERROR"] = "DB_006";
+    ErrorCode["DB_INSERT_FAILED"] = "DB_007";
+    ErrorCode["DB_UPDATE_FAILED"] = "DB_008";
+    ErrorCode["DB_DELETE_FAILED"] = "DB_009";
+    // Frame errors (2000-2999)
+    ErrorCode["FRAME_NOT_FOUND"] = "FRAME_001";
+    ErrorCode["FRAME_INVALID_STATE"] = "FRAME_002";
+    ErrorCode["FRAME_PARENT_NOT_FOUND"] = "FRAME_003";
+    ErrorCode["FRAME_CYCLE_DETECTED"] = "FRAME_004";
+    ErrorCode["FRAME_ALREADY_CLOSED"] = "FRAME_005";
+    ErrorCode["FRAME_INIT_FAILED"] = "FRAME_006";
+    ErrorCode["FRAME_INVALID_INPUT"] = "FRAME_007";
+    ErrorCode["FRAME_STACK_OVERFLOW"] = "FRAME_008";
+    // Task errors (3000-3999)
+    ErrorCode["TASK_NOT_FOUND"] = "TASK_001";
+    ErrorCode["TASK_INVALID_STATE"] = "TASK_002";
+    ErrorCode["TASK_DEPENDENCY_CONFLICT"] = "TASK_003";
+    ErrorCode["TASK_CIRCULAR_DEPENDENCY"] = "TASK_004";
+    // Integration errors (4000-4999)
+    ErrorCode["LINEAR_AUTH_FAILED"] = "LINEAR_001";
+    ErrorCode["LINEAR_API_ERROR"] = "LINEAR_002";
+    ErrorCode["LINEAR_SYNC_FAILED"] = "LINEAR_003";
+    ErrorCode["LINEAR_WEBHOOK_FAILED"] = "LINEAR_004";
+    // MCP errors (5000-5999)
+    ErrorCode["MCP_TOOL_NOT_FOUND"] = "MCP_001";
+    ErrorCode["MCP_INVALID_PARAMS"] = "MCP_002";
+    ErrorCode["MCP_EXECUTION_FAILED"] = "MCP_003";
+    ErrorCode["MCP_RATE_LIMITED"] = "MCP_004";
+    // Project errors (6000-6999)
+    ErrorCode["PROJECT_NOT_FOUND"] = "PROJECT_001";
+    ErrorCode["PROJECT_INVALID_PATH"] = "PROJECT_002";
+    ErrorCode["PROJECT_GIT_ERROR"] = "PROJECT_003";
+    // Validation errors (7000-7999)
+    ErrorCode["VALIDATION_FAILED"] = "VAL_001";
+    ErrorCode["INVALID_INPUT"] = "VAL_002";
+    ErrorCode["MISSING_REQUIRED_FIELD"] = "VAL_003";
+    ErrorCode["TYPE_MISMATCH"] = "VAL_004";
+    // System errors (8000-8999)
+    ErrorCode["INITIALIZATION_ERROR"] = "SYS_001";
+    ErrorCode["NOT_FOUND"] = "SYS_002";
+    ErrorCode["INTERNAL_ERROR"] = "SYS_003";
+    ErrorCode["CONFIGURATION_ERROR"] = "SYS_004";
+    ErrorCode["PERMISSION_DENIED"] = "SYS_005";
+    ErrorCode["RESOURCE_EXHAUSTED"] = "SYS_006";
+    ErrorCode["SERVICE_UNAVAILABLE"] = "SYS_007";
+    ErrorCode["SYSTEM_INIT_FAILED"] = "SYS_008";
+    // Collaboration errors (9000-9999)
+    ErrorCode["STACK_CONTEXT_NOT_FOUND"] = "COLLAB_001";
+    ErrorCode["HANDOFF_REQUEST_EXPIRED"] = "COLLAB_002";
+    ErrorCode["MERGE_CONFLICT_UNRESOLVABLE"] = "COLLAB_003";
+    ErrorCode["PERMISSION_VIOLATION"] = "COLLAB_004";
+    ErrorCode["OPERATION_FAILED"] = "COLLAB_005";
+    ErrorCode["OPERATION_EXPIRED"] = "COLLAB_006";
+    ErrorCode["INVALID_STATE"] = "COLLAB_007";
+    ErrorCode["RESOURCE_NOT_FOUND"] = "COLLAB_008";
+    ErrorCode["HANDOFF_ALREADY_EXISTS"] = "COLLAB_009";
+    ErrorCode["MERGE_SESSION_INVALID"] = "COLLAB_010";
+    ErrorCode["STACK_SWITCH_FAILED"] = "COLLAB_011";
+    ErrorCode["APPROVAL_TIMEOUT"] = "COLLAB_012";
+    ErrorCode["CONFLICT_RESOLUTION_FAILED"] = "COLLAB_013";
+    ErrorCode["TEAM_ACCESS_DENIED"] = "COLLAB_014";
+    ErrorCode["STACK_LIMIT_EXCEEDED"] = "COLLAB_015";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Base error class for all StackMemory errors
+ */
+export class StackMemoryError extends Error {
+    constructor(options) {
+        super(options.message);
+        this.name = this.constructor.name;
+        this.code = options.code;
+        this.context = options.context;
+        this.cause = options.cause;
+        this.isRetryable = options.isRetryable ?? false;
+        this.httpStatus = options.httpStatus ?? 500;
+        this.timestamp = new Date();
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            context: this.context,
+            isRetryable: this.isRetryable,
+            httpStatus: this.httpStatus,
+            timestamp: this.timestamp.toISOString(),
+            stack: this.stack,
+            cause: this.cause?.message,
+        };
+    }
+}
+/**
+ * Database-related errors
+ */
+export class DatabaseError extends StackMemoryError {
+    constructor(message, code = ErrorCode.DB_QUERY_FAILED, context, cause) {
+        super({
+            code,
+            message,
+            context,
+            cause,
+            isRetryable: code === ErrorCode.DB_CONNECTION_FAILED,
+            httpStatus: 503,
+        });
+    }
+}
+/**
+ * Frame-related errors
+ */
+export class FrameError extends StackMemoryError {
+    constructor(message, code = ErrorCode.FRAME_INVALID_STATE, context) {
+        super({
+            code,
+            message,
+            context,
+            isRetryable: false,
+            httpStatus: 400,
+        });
+    }
+}
+/**
+ * Task-related errors
+ */
+export class TaskError extends StackMemoryError {
+    constructor(message, code = ErrorCode.TASK_INVALID_STATE, context) {
+        super({
+            code,
+            message,
+            context,
+            isRetryable: false,
+            httpStatus: 400,
+        });
+    }
+}
+/**
+ * Integration errors (Linear, etc.)
+ */
+export class IntegrationError extends StackMemoryError {
+    constructor(message, code = ErrorCode.LINEAR_API_ERROR, context, cause) {
+        super({
+            code,
+            message,
+            context,
+            cause,
+            isRetryable: true,
+            httpStatus: 502,
+        });
+    }
+}
+/**
+ * MCP-related errors
+ */
+export class MCPError extends StackMemoryError {
+    constructor(message, code = ErrorCode.MCP_EXECUTION_FAILED, context) {
+        super({
+            code,
+            message,
+            context,
+            isRetryable: code === ErrorCode.MCP_RATE_LIMITED,
+            httpStatus: code === ErrorCode.MCP_RATE_LIMITED ? 429 : 400,
+        });
+    }
+}
+/**
+ * Validation errors
+ */
+export class ValidationError extends StackMemoryError {
+    constructor(message, code = ErrorCode.VALIDATION_FAILED, context) {
+        super({
+            code,
+            message,
+            context,
+            isRetryable: false,
+            httpStatus: 400,
+        });
+    }
+}
+/**
+ * Project-related errors
+ */
+export class ProjectError extends StackMemoryError {
+    constructor(message, code = ErrorCode.PROJECT_NOT_FOUND, context) {
+        super({
+            code,
+            message,
+            context,
+            isRetryable: false,
+            httpStatus: 404,
+        });
+    }
+}
+/**
+ * System/Internal errors
+ */
+export class SystemError extends StackMemoryError {
+    constructor(message, code = ErrorCode.INTERNAL_ERROR, context, cause) {
+        super({
+            code,
+            message,
+            context,
+            cause,
+            isRetryable: code === ErrorCode.SERVICE_UNAVAILABLE,
+            httpStatus: 500,
+        });
+    }
+}
+/**
+ * Helper function to determine if an error is retryable
+ */
+export function isRetryableError(error) {
+    if (error instanceof StackMemoryError) {
+        return error.isRetryable;
+    }
+    // Check for common retryable error patterns
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        return (message.includes('econnrefused') ||
+            message.includes('timeout') ||
+            message.includes('enotfound') ||
+            message.includes('socket hang up'));
+    }
+    return false;
+}
+/**
+ * Helper function to safely extract error message
+ */
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object' && 'message' in error) {
+        return String(error.message);
+    }
+    return 'An unknown error occurred';
+}
+/**
+ * Helper function to wrap unknown errors in StackMemoryError
+ */
+export function wrapError(error, defaultMessage, code = ErrorCode.INTERNAL_ERROR, context) {
+    if (error instanceof StackMemoryError) {
+        return error;
+    }
+    const cause = error instanceof Error ? error : undefined;
+    const message = error instanceof Error ? error.message : defaultMessage;
+    return new SystemError(message, code, context, cause);
+}
+/**
+ * Type guard to check if error is a StackMemoryError
+ */
+export function isStackMemoryError(error) {
+    return error instanceof StackMemoryError;
+}
+/**
+ * Create context-aware error handler
+ */
+export function createErrorHandler(defaultContext) {
+    return (error, additionalContext) => {
+        const context = { ...defaultContext, ...additionalContext };
+        if (error instanceof StackMemoryError) {
+            // Create a new error with merged context since context is readonly
+            return new StackMemoryError({
+                code: error.code,
+                message: error.message,
+                context: { ...error.context, ...context },
+                cause: error.cause,
+                isRetryable: error.isRetryable,
+                httpStatus: error.httpStatus,
+            });
+        }
+        return wrapError(error, getErrorMessage(error), ErrorCode.INTERNAL_ERROR, context);
+    };
+}

package/scripts/testing/src/core/errors/recovery.js

@@ -0,0 +1,268 @@
+/**
+ * Error recovery utilities for StackMemory
+ * Provides retry logic, circuit breakers, and fallback mechanisms
+ */
+import { logger } from '../monitoring/logger.js';
+import { isRetryableError, getErrorMessage, } from './index.js';
+export var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "closed";
+    CircuitState["OPEN"] = "open";
+    CircuitState["HALF_OPEN"] = "half_open";
+})(CircuitState || (CircuitState = {}));
+/**
+ * Exponential backoff with jitter
+ */
+export function calculateBackoff(attempt, initialDelay, maxDelay, factor) {
+    const exponentialDelay = Math.min(initialDelay * Math.pow(factor, attempt - 1), maxDelay);
+    // Add jitter (0-25% of delay)
+    const jitter = exponentialDelay * Math.random() * 0.25;
+    return Math.floor(exponentialDelay + jitter);
+}
+/**
+ * Retry with exponential backoff
+ */
+export async function retry(fn, options = {}) {
+    const { maxAttempts = 3, initialDelay = 1000, maxDelay = 30000, backoffFactor = 2, timeout, onRetry, } = options;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            // Add timeout if specified
+            if (timeout) {
+                return await Promise.race([
+                    fn(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${timeout}ms`)), timeout)),
+                ]);
+            }
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry if not retryable or last attempt
+            if (!isRetryableError(error) || attempt === maxAttempts) {
+                throw error;
+            }
+            const delay = calculateBackoff(attempt, initialDelay, maxDelay, backoffFactor);
+            logger.warn(`Retry attempt ${attempt}/${maxAttempts} after ${delay}ms`, {
+                error: getErrorMessage(error),
+                attempt,
+                delay,
+            });
+            if (onRetry) {
+                onRetry(attempt, error);
+            }
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
+/**
+ * Circuit breaker implementation
+ */
+export class CircuitBreaker {
+    constructor(name, options = {}) {
+        this.name = name;
+        this.state = CircuitState.CLOSED;
+        this.failures = 0;
+        this.successCount = 0;
+        this.options = {
+            failureThreshold: options.failureThreshold ?? 5,
+            resetTimeout: options.resetTimeout ?? 60000,
+            halfOpenRequests: options.halfOpenRequests ?? 3,
+        };
+    }
+    async execute(fn) {
+        // Check if circuit should transition from OPEN to HALF_OPEN
+        if (this.state === CircuitState.OPEN) {
+            const timeSinceLastFailure = this.lastFailTime
+                ? Date.now() - this.lastFailTime.getTime()
+                : 0;
+            if (timeSinceLastFailure >= this.options.resetTimeout) {
+                this.state = CircuitState.HALF_OPEN;
+                this.successCount = 0;
+                logger.info(`Circuit breaker ${this.name} entering half-open state`);
+            }
+            else {
+                throw new Error(`Circuit breaker ${this.name} is OPEN. Retry after ${this.options.resetTimeout - timeSinceLastFailure}ms`);
+            }
+        }
+        try {
+            const result = await fn();
+            // Handle success
+            if (this.state === CircuitState.HALF_OPEN) {
+                this.successCount++;
+                if (this.successCount >= this.options.halfOpenRequests) {
+                    this.state = CircuitState.CLOSED;
+                    this.failures = 0;
+                    logger.info(`Circuit breaker ${this.name} is now CLOSED`);
+                }
+            }
+            else {
+                this.failures = 0;
+            }
+            return result;
+        }
+        catch (error) {
+            this.handleFailure(error);
+            throw error;
+        }
+    }
+    handleFailure(error) {
+        this.failures++;
+        this.lastFailTime = new Date();
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.state = CircuitState.OPEN;
+            logger.error(`Circuit breaker ${this.name} reopened due to failure in half-open state`);
+        }
+        else if (this.state === CircuitState.CLOSED &&
+            this.failures >= this.options.failureThreshold) {
+            this.state = CircuitState.OPEN;
+            logger.error(`Circuit breaker ${this.name} opened after ${this.failures} failures`);
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    reset() {
+        this.state = CircuitState.CLOSED;
+        this.failures = 0;
+        this.successCount = 0;
+        this.lastFailTime = undefined;
+        logger.info(`Circuit breaker ${this.name} manually reset`);
+    }
+}
+/**
+ * Fallback with multiple strategies
+ */
+export async function withFallback(primary, fallbacks, context) {
+    const errors = [];
+    // Try primary
+    try {
+        return await primary();
+    }
+    catch (error) {
+        errors.push(error);
+        logger.warn('Primary operation failed, trying fallbacks', {
+            error: getErrorMessage(error),
+            context,
+        });
+    }
+    // Try fallbacks in order
+    for (let i = 0; i < fallbacks.length; i++) {
+        try {
+            const result = await fallbacks[i]();
+            logger.info(`Fallback ${i + 1} succeeded`, { context });
+            return result;
+        }
+        catch (error) {
+            errors.push(error);
+            if (i < fallbacks.length - 1) {
+                logger.warn(`Fallback ${i + 1} failed, trying next`, {
+                    error: getErrorMessage(error),
+                    context,
+                });
+            }
+        }
+    }
+    // All attempts failed
+    throw new Error(`All attempts failed. Errors: ${errors.map(getErrorMessage).join(', ')}`);
+}
+/**
+ * Bulkhead pattern - limit concurrent operations
+ */
+export class Bulkhead {
+    constructor(name, maxConcurrent) {
+        this.name = name;
+        this.maxConcurrent = maxConcurrent;
+        this.running = 0;
+        this.queue = [];
+    }
+    async execute(fn) {
+        if (this.running >= this.maxConcurrent) {
+            await new Promise((resolve) => {
+                this.queue.push(resolve);
+            });
+        }
+        this.running++;
+        try {
+            return await fn();
+        }
+        finally {
+            this.running--;
+            const next = this.queue.shift();
+            if (next) {
+                next();
+            }
+        }
+    }
+    getStats() {
+        return {
+            running: this.running,
+            queued: this.queue.length,
+            maxConcurrent: this.maxConcurrent,
+        };
+    }
+}
+/**
+ * Timeout wrapper with proper cleanup
+ */
+export async function withTimeout(fn, timeoutMs, timeoutMessage) {
+    return Promise.race([
+        fn(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(timeoutMessage ?? `Operation timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+/**
+ * Graceful degradation helper
+ */
+export async function gracefulDegrade(fn, defaultValue, logContext) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        logger.warn('Operation failed, using default value', {
+            error: getErrorMessage(error),
+            ...logContext,
+        });
+        return defaultValue;
+    }
+}
+/**
+ * Create a resilient operation with multiple recovery strategies
+ */
+export function createResilientOperation(name, options = {}) {
+    const circuitBreaker = options.circuitBreaker
+        ? new CircuitBreaker(name, options.circuitBreaker)
+        : null;
+    const bulkhead = options.bulkhead
+        ? new Bulkhead(name, options.bulkhead)
+        : null;
+    return async (fn) => {
+        let currentFn = fn;
+        // Wrap with bulkhead if configured
+        if (bulkhead) {
+            const wrapped = currentFn;
+            currentFn = () => bulkhead.execute(wrapped);
+        }
+        // Wrap with timeout if configured
+        if (options.timeout) {
+            const wrapped = currentFn;
+            currentFn = () => withTimeout(wrapped, options.timeout);
+        }
+        // Wrap with retry if configured
+        if (options.retry) {
+            const wrapped = currentFn;
+            currentFn = () => retry(wrapped, options.retry);
+        }
+        // Wrap with circuit breaker if configured
+        if (circuitBreaker) {
+            const wrapped = currentFn;
+            currentFn = () => circuitBreaker.execute(wrapped);
+        }
+        // Execute with fallback if configured
+        if (options.fallback) {
+            return withFallback(currentFn, [options.fallback]);
+        }
+        return currentFn();
+    };
+}

package/scripts/testing/src/core/monitoring/logger.js

@@ -0,0 +1,145 @@
+/**
+ * Structured logging utility for StackMemory CLI
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    constructor() {
+        this.logLevel = LogLevel.INFO;
+        this.fileLoggingDisabledNotified = false;
+        // Set log level from environment
+        const envLevel = process.env.STACKMEMORY_LOG_LEVEL?.toUpperCase();
+        switch (envLevel) {
+            case 'ERROR':
+                this.logLevel = LogLevel.ERROR;
+                break;
+            case 'WARN':
+                this.logLevel = LogLevel.WARN;
+                break;
+            case 'DEBUG':
+                this.logLevel = LogLevel.DEBUG;
+                break;
+            default:
+                this.logLevel = LogLevel.INFO;
+        }
+        // Set up log file if in debug mode or if specified
+        if (this.logLevel === LogLevel.DEBUG || process.env.STACKMEMORY_LOG_FILE) {
+            this.logFile =
+                process.env.STACKMEMORY_LOG_FILE ||
+                    path.join(process.env.HOME || '.', '.stackmemory', 'logs', 'cli.log');
+            this.ensureLogDirectory();
+        }
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    ensureLogDirectory() {
+        if (!this.logFile)
+            return;
+        const logDir = path.dirname(this.logFile);
+        try {
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+        }
+        catch (err) {
+            // Disable file logging if we cannot create the directory (e.g., ENOSPC)
+            this.logFile = undefined;
+            if (!this.fileLoggingDisabledNotified) {
+                this.fileLoggingDisabledNotified = true;
+                // Emit a single warning to console so we don't spam output
+                const msg = '[Logger] File logging disabled (failed to create log directory). Falling back to console only.';
+                // Use console directly to avoid recursion
+                // eslint-disable-next-line no-console
+                console.warn(msg);
+            }
+        }
+    }
+    writeLog(entry) {
+        const logLine = JSON.stringify(entry) + '\n';
+        // Always write to file if configured
+        if (this.logFile) {
+            try {
+                fs.appendFileSync(this.logFile, logLine);
+            }
+            catch (err) {
+                // Disable file logging on error (e.g., ENOSPC) to avoid repeated failures
+                this.logFile = undefined;
+                if (!this.fileLoggingDisabledNotified) {
+                    this.fileLoggingDisabledNotified = true;
+                    const msg = '[Logger] File logging disabled (write failed). Falling back to console only.';
+                    // eslint-disable-next-line no-console
+                    console.warn(msg);
+                }
+            }
+        }
+        // Console output based on level
+        if (entry.level <= this.logLevel) {
+            const levelNames = ['ERROR', 'WARN', 'INFO', 'DEBUG'];
+            const levelName = levelNames[entry.level] || 'UNKNOWN';
+            const consoleMessage = `[${entry.timestamp}] ${levelName}: ${entry.message}`;
+            if (entry.level === LogLevel.ERROR) {
+                console.error(consoleMessage);
+                if (entry.error) {
+                    console.error(entry.error.stack);
+                }
+            }
+            else if (entry.level === LogLevel.WARN) {
+                console.warn(consoleMessage);
+            }
+            else {
+                console.log(consoleMessage);
+            }
+        }
+    }
+    error(message, errorOrContext, context) {
+        const isError = errorOrContext instanceof Error;
+        this.writeLog({
+            timestamp: new Date().toISOString(),
+            level: LogLevel.ERROR,
+            message,
+            context: isError ? context : errorOrContext,
+            error: isError ? errorOrContext : undefined,
+        });
+    }
+    warn(message, errorOrContext) {
+        const isError = errorOrContext instanceof Error;
+        this.writeLog({
+            timestamp: new Date().toISOString(),
+            level: LogLevel.WARN,
+            message,
+            context: isError
+                ? undefined
+                : errorOrContext,
+            error: isError ? errorOrContext : undefined,
+        });
+    }
+    info(message, context) {
+        this.writeLog({
+            timestamp: new Date().toISOString(),
+            level: LogLevel.INFO,
+            message,
+            context,
+        });
+    }
+    debug(message, context) {
+        this.writeLog({
+            timestamp: new Date().toISOString(),
+            level: LogLevel.DEBUG,
+            message,
+            context,
+        });
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();