@seekora-ai/search-sdk 0.2.7 → 0.2.12

package/dist/src/logger.d.ts

@@ -1,61 +0,0 @@
-/**
- * Seekora SDK Logger
- *
- * Provides structured logging with configurable levels:
- * - VERBOSE: Detailed debugging information
- * - INFO: General informational messages (default)
- * - WARN: Warning messages
- * - ERROR: Error messages
- * - SILENT: No logging
- *
- * Configurable via SEEKORA_LOG_LEVEL environment variable
- */
-export type LogLevel = 'verbose' | 'info' | 'warn' | 'error' | 'silent';
-export interface LoggerConfig {
-    level?: LogLevel;
-    enableConsole?: boolean;
-    enableFile?: boolean;
-    filePath?: string;
-    format?: 'json' | 'text';
-    enableTimestamp?: boolean;
-    prefix?: string;
-    enablePrefix?: boolean;
-}
-/**
- * Get log level from environment variable or default
- */
-export declare function getLogLevelFromEnv(): LogLevel;
-/**
- * Logger implementation with configurable levels and formatting
- */
-export declare class Logger {
-    private level;
-    private levelValue;
-    private enableConsole;
-    private enableFile;
-    private filePath?;
-    private format;
-    private enableTimestamp;
-    private prefix;
-    private enablePrefix;
-    constructor(config?: LoggerConfig);
-    private shouldLog;
-    private formatMessage;
-    private write;
-    verbose(message: string, meta?: any): void;
-    info(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    error(message: string, meta?: any): void;
-    debug(message: string, meta?: any): void;
-    fatal(message: string, meta?: any): void;
-    setLevel(level: LogLevel): void;
-    getLevel(): LogLevel;
-}
-/**
- * Create a logger instance
- */
-export declare function createLogger(config?: LoggerConfig): Logger;
-/**
- * Default logger instance
- */
-export declare const defaultLogger: Logger;

package/dist/src/logger.js

@@ -1,172 +0,0 @@
-"use strict";
-/**
- * Seekora SDK Logger
- *
- * Provides structured logging with configurable levels:
- * - VERBOSE: Detailed debugging information
- * - INFO: General informational messages (default)
- * - WARN: Warning messages
- * - ERROR: Error messages
- * - SILENT: No logging
- *
- * Configurable via SEEKORA_LOG_LEVEL environment variable
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultLogger = exports.Logger = void 0;
-exports.getLogLevelFromEnv = getLogLevelFromEnv;
-exports.createLogger = createLogger;
-const LOG_LEVELS = {
-    verbose: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    silent: 4,
-};
-/**
- * Get log level from environment variable or default
- */
-function getLogLevelFromEnv() {
-    let envLevel;
-    // Try to get from process.env (Node.js) or window (browser)
-    if (typeof process !== 'undefined' && process.env) {
-        envLevel = process.env.SEEKORA_LOG_LEVEL?.toLowerCase();
-    }
-    else if (typeof window !== 'undefined' && window.SEEKORA_LOG_LEVEL) {
-        envLevel = String(window.SEEKORA_LOG_LEVEL).toLowerCase();
-    }
-    // Support both old and new level names
-    const levelMap = {
-        'verbose': 'verbose',
-        'info': 'info',
-        'warn': 'warn',
-        'warning': 'warn',
-        'error': 'error',
-        'silent': 'silent',
-        // Legacy support
-        'debug': 'verbose',
-        'fatal': 'error',
-    };
-    if (envLevel && levelMap[envLevel]) {
-        return levelMap[envLevel];
-    }
-    // Default: INFO in production, VERBOSE in debug mode
-    const nodeEnv = typeof process !== 'undefined' && process.env
-        ? process.env.NODE_ENV
-        : undefined;
-    const debug = typeof process !== 'undefined' && process.env
-        ? process.env.DEBUG
-        : undefined;
-    if (nodeEnv === 'development' || debug) {
-        return 'verbose';
-    }
-    return 'info';
-}
-/**
- * Logger implementation with configurable levels and formatting
- */
-class Logger {
-    constructor(config = {}) {
-        this.level = config.level || getLogLevelFromEnv();
-        this.levelValue = LOG_LEVELS[this.level];
-        this.enableConsole = config.enableConsole !== false;
-        this.enableFile = config.enableFile || false;
-        this.filePath = config.filePath;
-        this.format = config.format || 'text';
-        this.enableTimestamp = config.enableTimestamp !== false;
-        this.prefix = config.prefix || '[Seekora SDK]';
-        this.enablePrefix = config.enablePrefix !== false;
-    }
-    shouldLog(level) {
-        if (this.level === 'silent') {
-            return false;
-        }
-        return LOG_LEVELS[level] >= this.levelValue;
-    }
-    formatMessage(level, message, meta) {
-        const parts = [];
-        // Add timestamp if enabled
-        if (this.enableTimestamp) {
-            const timestamp = new Date().toISOString();
-            parts.push(`[${timestamp}]`);
-        }
-        // Add prefix if enabled
-        if (this.enablePrefix && this.prefix) {
-            parts.push(this.prefix);
-        }
-        // Add log level
-        parts.push(`[${level.toUpperCase()}]`);
-        // Add message
-        parts.push(message);
-        // Add metadata if present
-        if (meta && Object.keys(meta).length > 0) {
-            if (this.format === 'json') {
-                return JSON.stringify({
-                    timestamp: this.enableTimestamp ? new Date().toISOString() : undefined,
-                    level,
-                    message,
-                    ...meta,
-                });
-            }
-            else {
-                parts.push(JSON.stringify(meta, null, 2));
-            }
-        }
-        return parts.join(' ');
-    }
-    write(level, message, meta) {
-        if (!this.shouldLog(level)) {
-            return;
-        }
-        const formatted = this.formatMessage(level, message, meta);
-        if (this.enableConsole) {
-            const consoleMethod = level === 'error'
-                ? console.error
-                : level === 'warn'
-                    ? console.warn
-                    : console.log;
-            consoleMethod(formatted);
-        }
-        if (this.enableFile && this.filePath) {
-            // File logging would require fs module
-            // In production, you might want to use winston or similar
-            // For now, we'll just log to console
-        }
-    }
-    verbose(message, meta) {
-        this.write('verbose', message, meta);
-    }
-    info(message, meta) {
-        this.write('info', message, meta);
-    }
-    warn(message, meta) {
-        this.write('warn', message, meta);
-    }
-    error(message, meta) {
-        this.write('error', message, meta);
-    }
-    // Legacy support methods
-    debug(message, meta) {
-        this.verbose(message, meta);
-    }
-    fatal(message, meta) {
-        this.error(message, meta);
-    }
-    setLevel(level) {
-        this.level = level;
-        this.levelValue = LOG_LEVELS[level];
-    }
-    getLevel() {
-        return this.level;
-    }
-}
-exports.Logger = Logger;
-/**
- * Create a logger instance
- */
-function createLogger(config) {
-    return new Logger(config);
-}
-/**
- * Default logger instance
- */
-exports.defaultLogger = createLogger();

package/dist/src/utils.d.ts

@@ -1,20 +0,0 @@
-/**
- * Utility functions for the Seekora SDK
- */
-/**
- * Generate a UUID v4
- * Uses crypto.randomUUID() if available, otherwise falls back to manual generation
- */
-export declare function generateUUID(): string;
-/**
- * Get or create anonymous ID from storage
- * In browser: uses localStorage
- * In Node.js: uses a simple in-memory store (consider file-based storage for production)
- */
-export declare function getOrCreateAnonId(): string;
-/**
- * Get or create session ID
- * In browser: uses sessionStorage
- * In Node.js: uses a simple in-memory store (session ends when process ends)
- */
-export declare function getOrCreateSessionId(): string;

package/dist/src/utils.js

@@ -1,73 +0,0 @@
-"use strict";
-/**
- * Utility functions for the Seekora SDK
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUUID = generateUUID;
-exports.getOrCreateAnonId = getOrCreateAnonId;
-exports.getOrCreateSessionId = getOrCreateSessionId;
-// Browser environment types are handled via typeof checks and type assertions
-/**
- * Generate a UUID v4
- * Uses crypto.randomUUID() if available, otherwise falls back to manual generation
- */
-function generateUUID() {
-    // Use native crypto.randomUUID() if available (Node.js 14.17+, modern browsers)
-    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
-        return crypto.randomUUID();
-    }
-    // Fallback for older environments
-    // Simplified UUID v4 generation
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-}
-/**
- * Get or create anonymous ID from storage
- * In browser: uses localStorage
- * In Node.js: uses a simple in-memory store (consider file-based storage for production)
- */
-function getOrCreateAnonId() {
-    // Check for browser environment
-    if (typeof window !== 'undefined' && window?.localStorage) {
-        const key = 'seekora_anon_id';
-        const storage = window.localStorage;
-        let anonId = storage.getItem(key);
-        if (!anonId) {
-            anonId = generateUUID();
-            storage.setItem(key, anonId);
-        }
-        return anonId;
-    }
-    // Node.js environment - use in-memory storage
-    // For production Node.js apps, consider using a file-based storage
-    if (!global.__seekora_anon_id) {
-        global.__seekora_anon_id = generateUUID();
-    }
-    return global.__seekora_anon_id;
-}
-/**
- * Get or create session ID
- * In browser: uses sessionStorage
- * In Node.js: uses a simple in-memory store (session ends when process ends)
- */
-function getOrCreateSessionId() {
-    // Check for browser environment
-    if (typeof window !== 'undefined' && window?.sessionStorage) {
-        const key = 'seekora_session_id';
-        const storage = window.sessionStorage;
-        let sessionId = storage.getItem(key);
-        if (!sessionId) {
-            sessionId = generateUUID();
-            storage.setItem(key, sessionId);
-        }
-        return sessionId;
-    }
-    // Node.js environment - use in-memory storage
-    if (!global.__seekora_session_id) {
-        global.__seekora_session_id = generateUUID();
-    }
-    return global.__seekora_session_id;
-}