packfs-core/dist/esm/core/logger.js

Semantic filesystem operations for LLM agent frameworks with natural language understanding. See LLM_AGENT_GUIDE.md for copy-paste examples.

import * as fs from 'fs';
import * as path from 'path';
export var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
    LogLevel[LogLevel["INFO"] = 1] = "INFO";
    LogLevel[LogLevel["WARN"] = 2] = "WARN";
    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
    LogLevel[LogLevel["NONE"] = 4] = "NONE";
})(LogLevel || (LogLevel = {}));
export class ConsoleTransport {
    formatLevel(level) {
        switch (level) {
            case LogLevel.DEBUG: return 'DEBUG';
            case LogLevel.INFO: return 'INFO';
            case LogLevel.WARN: return 'WARN';
            case LogLevel.ERROR: return 'ERROR';
            default: return 'UNKNOWN';
        }
    }
    log(entry) {
        const timestamp = entry.timestamp.toISOString();
        const level = this.formatLevel(entry.level);
        const message = `[${timestamp}] [${level}] [${entry.category}] ${entry.message}`;
        if (entry.data) {
            console.log(message, entry.data);
        }
        else {
            console.log(message);
        }
    }
}
export class FileTransport {
    constructor(filePath, append = true) {
        this.filePath = filePath;
        this.append = append;
        this.stream = null;
        this.initializeStream();
    }
    initializeStream() {
        this.ensureDirectory();
        this.stream = fs.createWriteStream(this.filePath, {
            flags: this.append ? 'a' : 'w',
            encoding: 'utf8'
        });
    }
    ensureDirectory() {
        const dir = path.dirname(this.filePath);
        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }
    }
    formatLevel(level) {
        switch (level) {
            case LogLevel.DEBUG: return 'DEBUG';
            case LogLevel.INFO: return 'INFO';
            case LogLevel.WARN: return 'WARN';
            case LogLevel.ERROR: return 'ERROR';
            default: return 'UNKNOWN';
        }
    }
    log(entry) {
        if (!this.stream)
            return;
        const timestamp = entry.timestamp.toISOString();
        const level = this.formatLevel(entry.level);
        const message = `[${timestamp}] [${level}] [${entry.category}] ${entry.message}`;
        if (entry.data) {
            this.stream.write(`${message} ${JSON.stringify(entry.data)}\n`);
        }
        else {
            this.stream.write(`${message}\n`);
        }
    }
    close() {
        if (this.stream) {
            this.stream.end();
            this.stream = null;
        }
    }
}
export class Logger {
    constructor() {
        this.config = {
            level: LogLevel.INFO,
            transports: [new ConsoleTransport()]
        };
    }
    static getInstance() {
        if (!Logger.instance) {
            Logger.instance = new Logger();
        }
        return Logger.instance;
    }
    configure(config) {
        if (config.level !== undefined) {
            this.config.level = config.level;
        }
        if (config.transports !== undefined) {
            this.config.transports = config.transports;
        }
    }
    shouldLog(level) {
        return level >= this.config.level;
    }
    log(level, category, message, data) {
        if (!this.shouldLog(level))
            return;
        const entry = {
            timestamp: new Date(),
            level,
            category,
            message,
            data
        };
        for (const transport of this.config.transports) {
            try {
                const result = transport.log(entry);
                if (result instanceof Promise) {
                    result.catch(err => console.error('Logging transport error:', err));
                }
            }
            catch (err) {
                console.error('Logging transport error:', err);
            }
        }
    }
    debug(category, message, data) {
        this.log(LogLevel.DEBUG, category, message, data);
    }
    info(category, message, data) {
        this.log(LogLevel.INFO, category, message, data);
    }
    warn(category, message, data) {
        this.log(LogLevel.WARN, category, message, data);
    }
    error(category, message, data) {
        this.log(LogLevel.ERROR, category, message, data);
    }
    createChildLogger(category) {
        return new CategoryLogger(this, category);
    }
}
Logger.instance = null;
export class CategoryLogger {
    constructor(logger, category) {
        this.logger = logger;
        this.category = category;
    }
    debug(message, data) {
        this.logger.debug(this.category, message, data);
    }
    info(message, data) {
        this.logger.info(this.category, message, data);
    }
    warn(message, data) {
        this.logger.warn(this.category, message, data);
    }
    error(message, data) {
        this.logger.error(this.category, message, data);
    }
}
export class MemoryTransport {
    constructor(maxSize = 1000) {
        this.logs = [];
        this.maxSize = maxSize;
    }
    log(entry) {
        this.logs.push(entry);
        if (this.logs.length > this.maxSize) {
            this.logs.shift();
        }
    }
    getLogs() {
        return [...this.logs];
    }
    clear() {
        this.logs = [];
    }
}
export class CustomTransport {
    constructor(logFunction) {
        this.logFunction = logFunction;
    }
    log(entry) {
        return this.logFunction(entry);
    }
}
//# sourceMappingURL=logger.js.map