@vybestack/llxprt-code-core 0.1.12

package/dist/src/core/logger.js

@@ -0,0 +1,237 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { getProjectTempDir, ensureLlxprtDirExists } from '../utils/paths.js';
+const LOG_FILE_NAME = 'logs.json';
+export var MessageSenderType;
+(function (MessageSenderType) {
+    MessageSenderType["USER"] = "user";
+})(MessageSenderType || (MessageSenderType = {}));
+export class Logger {
+    llxprtDir;
+    logFilePath;
+    sessionId;
+    messageId = 0; // Instance-specific counter for the next messageId
+    initialized = false;
+    logs = []; // In-memory cache, ideally reflects the last known state of the file
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+    async _readLogFile() {
+        if (!this.logFilePath) {
+            throw new Error('Log file path not set during read attempt.');
+        }
+        try {
+            const fileContent = await fs.readFile(this.logFilePath, 'utf-8');
+            const parsedLogs = JSON.parse(fileContent);
+            if (!Array.isArray(parsedLogs)) {
+                console.debug(`Log file at ${this.logFilePath} is not a valid JSON array. Starting with empty logs.`);
+                await this._backupCorruptedLogFile('malformed_array');
+                return [];
+            }
+            return parsedLogs.filter((entry) => typeof entry.sessionId === 'string' &&
+                typeof entry.messageId === 'number' &&
+                typeof entry.timestamp === 'string' &&
+                typeof entry.type === 'string' &&
+                typeof entry.message === 'string');
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code === 'ENOENT') {
+                return [];
+            }
+            if (error instanceof SyntaxError) {
+                console.debug(`Invalid JSON in log file ${this.logFilePath}. Backing up and starting fresh.`, error);
+                await this._backupCorruptedLogFile('invalid_json');
+                return [];
+            }
+            console.debug(`Failed to read or parse log file ${this.logFilePath}:`, error);
+            throw error;
+        }
+    }
+    async _backupCorruptedLogFile(reason) {
+        if (!this.logFilePath)
+            return;
+        const backupPath = `${this.logFilePath}.${reason}.${Date.now()}.bak`;
+        try {
+            await fs.rename(this.logFilePath, backupPath);
+            console.debug(`Backed up corrupted log file to ${backupPath}`);
+        }
+        catch (_backupError) {
+            // If rename fails (e.g. file doesn't exist), no need to log an error here as the primary error (e.g. invalid JSON) is already handled.
+        }
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        ensureLlxprtDirExists();
+        this.llxprtDir = getProjectTempDir(process.cwd());
+        this.logFilePath = path.join(this.llxprtDir, LOG_FILE_NAME);
+        try {
+            await fs.mkdir(this.llxprtDir, { recursive: true });
+            let fileExisted = true;
+            try {
+                await fs.access(this.logFilePath);
+            }
+            catch (_e) {
+                fileExisted = false;
+            }
+            this.logs = await this._readLogFile();
+            if (!fileExisted && this.logs.length === 0) {
+                await fs.writeFile(this.logFilePath, '[]', 'utf-8');
+            }
+            const sessionLogs = this.logs.filter((entry) => entry.sessionId === this.sessionId);
+            this.messageId =
+                sessionLogs.length > 0
+                    ? Math.max(...sessionLogs.map((entry) => entry.messageId)) + 1
+                    : 0;
+            this.initialized = true;
+        }
+        catch (err) {
+            console.error('Failed to initialize logger:', err);
+            this.initialized = false;
+        }
+    }
+    async _updateLogFile(entryToAppend) {
+        if (!this.logFilePath) {
+            console.debug('Log file path not set. Cannot persist log entry.');
+            throw new Error('Log file path not set during update attempt.');
+        }
+        let currentLogsOnDisk;
+        try {
+            currentLogsOnDisk = await this._readLogFile();
+        }
+        catch (readError) {
+            console.debug('Critical error reading log file before append:', readError);
+            throw readError;
+        }
+        // Determine the correct messageId for the new entry based on current disk state for its session
+        const sessionLogsOnDisk = currentLogsOnDisk.filter((e) => e.sessionId === entryToAppend.sessionId);
+        const nextMessageIdForSession = sessionLogsOnDisk.length > 0
+            ? Math.max(...sessionLogsOnDisk.map((e) => e.messageId)) + 1
+            : 0;
+        // Update the messageId of the entry we are about to append
+        entryToAppend.messageId = nextMessageIdForSession;
+        // Check if this entry (same session, same *recalculated* messageId, same content) might already exist
+        // This is a stricter check for true duplicates if multiple instances try to log the exact same thing
+        // at the exact same calculated messageId slot.
+        const entryExists = currentLogsOnDisk.some((e) => e.sessionId === entryToAppend.sessionId &&
+            e.messageId === entryToAppend.messageId &&
+            e.timestamp === entryToAppend.timestamp && // Timestamps are good for distinguishing
+            e.message === entryToAppend.message);
+        if (entryExists) {
+            console.debug(`Duplicate log entry detected and skipped: session ${entryToAppend.sessionId}, messageId ${entryToAppend.messageId}`);
+            this.logs = currentLogsOnDisk; // Ensure in-memory is synced with disk
+            return null; // Indicate that no new entry was actually added
+        }
+        currentLogsOnDisk.push(entryToAppend);
+        try {
+            await fs.writeFile(this.logFilePath, JSON.stringify(currentLogsOnDisk, null, 2), 'utf-8');
+            this.logs = currentLogsOnDisk;
+            return entryToAppend; // Return the successfully appended entry
+        }
+        catch (error) {
+            console.debug('Error writing to log file:', error);
+            throw error;
+        }
+    }
+    async getPreviousUserMessages() {
+        if (!this.initialized)
+            return [];
+        return this.logs
+            .filter((entry) => entry.type === MessageSenderType.USER)
+            .sort((a, b) => {
+            const dateA = new Date(a.timestamp).getTime();
+            const dateB = new Date(b.timestamp).getTime();
+            return dateB - dateA;
+        })
+            .map((entry) => entry.message);
+    }
+    async logMessage(type, message) {
+        if (!this.initialized || this.sessionId === undefined) {
+            console.debug('Logger not initialized or session ID missing. Cannot log message.');
+            return;
+        }
+        // The messageId used here is the instance's idea of the next ID.
+        // _updateLogFile will verify and potentially recalculate based on the file's actual state.
+        const newEntryObject = {
+            sessionId: this.sessionId,
+            messageId: this.messageId, // This will be recalculated in _updateLogFile
+            type,
+            message,
+            timestamp: new Date().toISOString(),
+        };
+        try {
+            const writtenEntry = await this._updateLogFile(newEntryObject);
+            if (writtenEntry) {
+                // If an entry was actually written (not a duplicate skip),
+                // then this instance can increment its idea of the next messageId for this session.
+                this.messageId = writtenEntry.messageId + 1;
+            }
+        }
+        catch (_error) {
+            // Error already logged by _updateLogFile or _readLogFile
+        }
+    }
+    _checkpointPath(tag) {
+        if (!tag.length) {
+            throw new Error('No checkpoint tag specified.');
+        }
+        if (!this.llxprtDir) {
+            throw new Error('Checkpoint file path not set.');
+        }
+        return path.join(this.llxprtDir, `checkpoint-${tag}.json`);
+    }
+    async saveCheckpoint(conversation, tag, context) {
+        if (!this.initialized) {
+            console.error('Logger not initialized or checkpoint file path not set. Cannot save a checkpoint.');
+            return;
+        }
+        const path = this._checkpointPath(tag);
+        try {
+            const data = JSON.stringify({ history: conversation, context }, null, 2);
+            await fs.writeFile(path, data, 'utf-8');
+        }
+        catch (error) {
+            console.error('Error writing to checkpoint file:', error);
+        }
+    }
+    async loadCheckpoint(tag) {
+        if (!this.initialized) {
+            console.error('Logger not initialized or checkpoint file path not set. Cannot load checkpoint.');
+            return { history: [] };
+        }
+        const path = this._checkpointPath(tag);
+        try {
+            const fileContent = await fs.readFile(path, 'utf-8');
+            const parsedContent = JSON.parse(fileContent);
+            if (Array.isArray(parsedContent)) {
+                // Backwards compatibility for old format
+                return { history: parsedContent };
+            }
+            return parsedContent;
+        }
+        catch (error) {
+            console.error(`Failed to read or parse checkpoint file ${path}:`, error);
+            const nodeError = error;
+            if (nodeError.code === 'ENOENT') {
+                // File doesn't exist, which is fine. Return empty.
+                return { history: [] };
+            }
+            return { history: [] };
+        }
+    }
+    close() {
+        this.initialized = false;
+        this.logFilePath = undefined;
+        this.logs = [];
+        this.sessionId = undefined;
+        this.messageId = 0;
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/src/core/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../src/core/logger.ts"],"names":[],"mappings":"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"}

package/dist/src/core/logger.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/core/logger.test.js

@@ -0,0 +1,387 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach, afterAll, } from 'vitest';
+import { Logger, MessageSenderType } from './logger.js';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import os from 'node:os';
+const LLXPRT_DIR_NAME = '.llxprt';
+const TMP_DIR_NAME = 'tmp';
+const LOG_FILE_NAME = 'logs.json';
+const CHECKPOINT_FILE_NAME = 'checkpoint.json';
+const projectDir = process.cwd();
+const hash = crypto.createHash('sha256').update(projectDir).digest('hex');
+const TEST_LLXPRT_DIR = path.join(os.homedir(), LLXPRT_DIR_NAME, TMP_DIR_NAME, hash);
+const TEST_LOG_FILE_PATH = path.join(TEST_LLXPRT_DIR, LOG_FILE_NAME);
+const TEST_CHECKPOINT_FILE_PATH = path.join(TEST_LLXPRT_DIR, CHECKPOINT_FILE_NAME);
+async function cleanupLogAndCheckpointFiles() {
+    try {
+        await fs.rm(TEST_LLXPRT_DIR, { recursive: true, force: true });
+    }
+    catch (_error) {
+        // Ignore errors, as the directory may not exist, which is fine.
+    }
+}
+async function readLogFile() {
+    try {
+        const content = await fs.readFile(TEST_LOG_FILE_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+vi.mock('../utils/session.js', () => ({
+    sessionId: 'test-session-id',
+}));
+describe('Logger', () => {
+    let logger;
+    const testSessionId = 'test-session-id';
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'));
+        // Clean up before the test
+        await cleanupLogAndCheckpointFiles();
+        // Ensure the directory exists for the test
+        await fs.mkdir(TEST_LLXPRT_DIR, { recursive: true });
+        logger = new Logger(testSessionId);
+        await logger.initialize();
+    });
+    afterEach(async () => {
+        if (logger) {
+            logger.close();
+        }
+        // Clean up after the test
+        await cleanupLogAndCheckpointFiles();
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    afterAll(async () => {
+        // Final cleanup
+        await cleanupLogAndCheckpointFiles();
+    });
+    describe('initialize', () => {
+        it('should create .llxprt directory and an empty log file if none exist', async () => {
+            const dirExists = await fs
+                .access(TEST_LLXPRT_DIR)
+                .then(() => true)
+                .catch(() => false);
+            expect(dirExists).toBe(true);
+            const fileExists = await fs
+                .access(TEST_LOG_FILE_PATH)
+                .then(() => true)
+                .catch(() => false);
+            expect(fileExists).toBe(true);
+            const logContent = await readLogFile();
+            expect(logContent).toEqual([]);
+        });
+        it('should load existing logs and set correct messageId for the current session', async () => {
+            const currentSessionId = 'session-123';
+            const anotherSessionId = 'session-456';
+            const existingLogs = [
+                {
+                    sessionId: currentSessionId,
+                    messageId: 0,
+                    timestamp: new Date('2025-01-01T10:00:05.000Z').toISOString(),
+                    type: MessageSenderType.USER,
+                    message: 'Msg1',
+                },
+                {
+                    sessionId: anotherSessionId,
+                    messageId: 5,
+                    timestamp: new Date('2025-01-01T09:00:00.000Z').toISOString(),
+                    type: MessageSenderType.USER,
+                    message: 'OldMsg',
+                },
+                {
+                    sessionId: currentSessionId,
+                    messageId: 1,
+                    timestamp: new Date('2025-01-01T10:00:10.000Z').toISOString(),
+                    type: MessageSenderType.USER,
+                    message: 'Msg2',
+                },
+            ];
+            await fs.writeFile(TEST_LOG_FILE_PATH, JSON.stringify(existingLogs, null, 2));
+            const newLogger = new Logger(currentSessionId);
+            await newLogger.initialize();
+            expect(newLogger['messageId']).toBe(2);
+            expect(newLogger['logs']).toEqual(existingLogs);
+            newLogger.close();
+        });
+        it('should set messageId to 0 for a new session if log file exists but has no logs for current session', async () => {
+            const existingLogs = [
+                {
+                    sessionId: 'some-other-session',
+                    messageId: 5,
+                    timestamp: new Date().toISOString(),
+                    type: MessageSenderType.USER,
+                    message: 'OldMsg',
+                },
+            ];
+            await fs.writeFile(TEST_LOG_FILE_PATH, JSON.stringify(existingLogs, null, 2));
+            const newLogger = new Logger('a-new-session');
+            await newLogger.initialize();
+            expect(newLogger['messageId']).toBe(0);
+            newLogger.close();
+        });
+        it('should be idempotent', async () => {
+            await logger.logMessage(MessageSenderType.USER, 'test message');
+            const initialMessageId = logger['messageId'];
+            const initialLogCount = logger['logs'].length;
+            await logger.initialize(); // Second call should not change state
+            expect(logger['messageId']).toBe(initialMessageId);
+            expect(logger['logs'].length).toBe(initialLogCount);
+            const logsFromFile = await readLogFile();
+            expect(logsFromFile.length).toBe(1);
+        });
+        it('should handle invalid JSON in log file by backing it up and starting fresh', async () => {
+            await fs.writeFile(TEST_LOG_FILE_PATH, 'invalid json');
+            const consoleDebugSpy = vi
+                .spyOn(console, 'debug')
+                .mockImplementation(() => { });
+            const newLogger = new Logger(testSessionId);
+            await newLogger.initialize();
+            expect(consoleDebugSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid JSON in log file'), expect.any(SyntaxError));
+            const logContent = await readLogFile();
+            expect(logContent).toEqual([]);
+            const dirContents = await fs.readdir(TEST_LLXPRT_DIR);
+            expect(dirContents.some((f) => f.startsWith(LOG_FILE_NAME + '.invalid_json') && f.endsWith('.bak'))).toBe(true);
+            newLogger.close();
+        });
+        it('should handle non-array JSON in log file by backing it up and starting fresh', async () => {
+            await fs.writeFile(TEST_LOG_FILE_PATH, JSON.stringify({ not: 'an array' }));
+            const consoleDebugSpy = vi
+                .spyOn(console, 'debug')
+                .mockImplementation(() => { });
+            const newLogger = new Logger(testSessionId);
+            await newLogger.initialize();
+            expect(consoleDebugSpy).toHaveBeenCalledWith(`Log file at ${TEST_LOG_FILE_PATH} is not a valid JSON array. Starting with empty logs.`);
+            const logContent = await readLogFile();
+            expect(logContent).toEqual([]);
+            const dirContents = await fs.readdir(TEST_LLXPRT_DIR);
+            expect(dirContents.some((f) => f.startsWith(LOG_FILE_NAME + '.malformed_array') &&
+                f.endsWith('.bak'))).toBe(true);
+            newLogger.close();
+        });
+    });
+    describe('logMessage', () => {
+        it('should append a message to the log file and update in-memory logs', async () => {
+            await logger.logMessage(MessageSenderType.USER, 'Hello, world!');
+            const logsFromFile = await readLogFile();
+            expect(logsFromFile.length).toBe(1);
+            expect(logsFromFile[0]).toMatchObject({
+                sessionId: testSessionId,
+                messageId: 0,
+                type: MessageSenderType.USER,
+                message: 'Hello, world!',
+                timestamp: new Date('2025-01-01T12:00:00.000Z').toISOString(),
+            });
+            expect(logger['logs'].length).toBe(1);
+            expect(logger['logs'][0]).toEqual(logsFromFile[0]);
+            expect(logger['messageId']).toBe(1);
+        });
+        it('should correctly increment messageId for subsequent messages in the same session', async () => {
+            await logger.logMessage(MessageSenderType.USER, 'First');
+            vi.advanceTimersByTime(1000);
+            await logger.logMessage(MessageSenderType.USER, 'Second');
+            const logs = await readLogFile();
+            expect(logs.length).toBe(2);
+            expect(logs[0].messageId).toBe(0);
+            expect(logs[1].messageId).toBe(1);
+            expect(logs[1].timestamp).not.toBe(logs[0].timestamp);
+            expect(logger['messageId']).toBe(2);
+        });
+        it('should handle logger not initialized', async () => {
+            const uninitializedLogger = new Logger(testSessionId);
+            uninitializedLogger.close(); // Ensure it's treated as uninitialized
+            const consoleDebugSpy = vi
+                .spyOn(console, 'debug')
+                .mockImplementation(() => { });
+            await uninitializedLogger.logMessage(MessageSenderType.USER, 'test');
+            expect(consoleDebugSpy).toHaveBeenCalledWith('Logger not initialized or session ID missing. Cannot log message.');
+            expect((await readLogFile()).length).toBe(0);
+            uninitializedLogger.close();
+        });
+        it('should simulate concurrent writes from different logger instances to the same file', async () => {
+            const concurrentSessionId = 'concurrent-session';
+            const logger1 = new Logger(concurrentSessionId);
+            await logger1.initialize();
+            const logger2 = new Logger(concurrentSessionId);
+            await logger2.initialize();
+            expect(logger2['sessionId']).toEqual(logger1['sessionId']);
+            await logger1.logMessage(MessageSenderType.USER, 'L1M1');
+            vi.advanceTimersByTime(10);
+            await logger2.logMessage(MessageSenderType.USER, 'L2M1');
+            vi.advanceTimersByTime(10);
+            await logger1.logMessage(MessageSenderType.USER, 'L1M2');
+            vi.advanceTimersByTime(10);
+            await logger2.logMessage(MessageSenderType.USER, 'L2M2');
+            const logsFromFile = await readLogFile();
+            expect(logsFromFile.length).toBe(4);
+            const messageIdsInFile = logsFromFile
+                .map((log) => log.messageId)
+                .sort((a, b) => a - b);
+            expect(messageIdsInFile).toEqual([0, 1, 2, 3]);
+            const messagesInFile = logsFromFile
+                .sort((a, b) => a.messageId - b.messageId)
+                .map((l) => l.message);
+            expect(messagesInFile).toEqual(['L1M1', 'L2M1', 'L1M2', 'L2M2']);
+            // Check internal state (next messageId each logger would use for that session)
+            expect(logger1['messageId']).toBe(3);
+            expect(logger2['messageId']).toBe(4);
+            logger1.close();
+            logger2.close();
+        });
+        it('should not throw, not increment messageId, and log error if writing to file fails', async () => {
+            vi.spyOn(fs, 'writeFile').mockRejectedValueOnce(new Error('Disk full'));
+            const consoleDebugSpy = vi
+                .spyOn(console, 'debug')
+                .mockImplementation(() => { });
+            const initialMessageId = logger['messageId'];
+            const initialLogCount = logger['logs'].length;
+            await logger.logMessage(MessageSenderType.USER, 'test fail write');
+            expect(consoleDebugSpy).toHaveBeenCalledWith('Error writing to log file:', expect.any(Error));
+            expect(logger['messageId']).toBe(initialMessageId); // Not incremented
+            expect(logger['logs'].length).toBe(initialLogCount); // Log not added to in-memory cache
+        });
+    });
+    describe('getPreviousUserMessages', () => {
+        it('should retrieve all user messages from logs, sorted newest first', async () => {
+            const loggerSort = new Logger('session-1');
+            await loggerSort.initialize();
+            await loggerSort.logMessage(MessageSenderType.USER, 'S1M0_ts100000');
+            vi.advanceTimersByTime(1000);
+            await loggerSort.logMessage(MessageSenderType.USER, 'S1M1_ts101000');
+            vi.advanceTimersByTime(1000);
+            // Switch to a different session to log
+            const loggerSort2 = new Logger('session-2');
+            await loggerSort2.initialize();
+            await loggerSort2.logMessage(MessageSenderType.USER, 'S2M0_ts102000');
+            vi.advanceTimersByTime(1000);
+            await loggerSort2.logMessage('model', 'S2_Model_ts103000');
+            vi.advanceTimersByTime(1000);
+            await loggerSort2.logMessage(MessageSenderType.USER, 'S2M1_ts104000');
+            loggerSort.close();
+            loggerSort2.close();
+            const finalLogger = new Logger('final-session');
+            await finalLogger.initialize();
+            const messages = await finalLogger.getPreviousUserMessages();
+            expect(messages).toEqual([
+                'S2M1_ts104000',
+                'S2M0_ts102000',
+                'S1M1_ts101000',
+                'S1M0_ts100000',
+            ]);
+            finalLogger.close();
+        });
+        it('should return empty array if no user messages exist', async () => {
+            await logger.logMessage('system', 'System boot');
+            const messages = await logger.getPreviousUserMessages();
+            expect(messages).toEqual([]);
+        });
+        it('should return empty array if logger not initialized', async () => {
+            const uninitializedLogger = new Logger(testSessionId);
+            uninitializedLogger.close();
+            const messages = await uninitializedLogger.getPreviousUserMessages();
+            expect(messages).toEqual([]);
+            uninitializedLogger.close();
+        });
+    });
+    describe('saveCheckpoint', () => {
+        const conversation = [
+            { role: 'user', parts: [{ text: 'Hello' }] },
+            { role: 'model', parts: [{ text: 'Hi there' }] },
+        ];
+        it('should save a checkpoint to a tagged file when a tag is provided', async () => {
+            const tag = 'my-test-tag';
+            await logger.saveCheckpoint(conversation, tag);
+            const taggedFilePath = path.join(TEST_LLXPRT_DIR, `${CHECKPOINT_FILE_NAME.replace('.json', '')}-${tag}.json`);
+            const fileContent = await fs.readFile(taggedFilePath, 'utf-8');
+            expect(JSON.parse(fileContent)).toEqual({ history: conversation });
+        });
+        it('should not throw if logger is not initialized', async () => {
+            const uninitializedLogger = new Logger(testSessionId);
+            uninitializedLogger.close();
+            const consoleErrorSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            await expect(uninitializedLogger.saveCheckpoint(conversation, 'tag')).resolves.not.toThrow();
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Logger not initialized or checkpoint file path not set. Cannot save a checkpoint.');
+        });
+    });
+    describe('loadCheckpoint', () => {
+        const conversation = [
+            { role: 'user', parts: [{ text: 'Hello' }] },
+            { role: 'model', parts: [{ text: 'Hi there' }] },
+        ];
+        beforeEach(async () => {
+            await fs.writeFile(TEST_CHECKPOINT_FILE_PATH, JSON.stringify(conversation, null, 2));
+        });
+        it('should load from a tagged checkpoint file when a tag is provided', async () => {
+            const tag = 'my-load-tag';
+            const taggedConversation = [
+                ...conversation,
+                { role: 'user', parts: [{ text: 'Another message' }] },
+            ];
+            const taggedFilePath = path.join(TEST_LLXPRT_DIR, `${CHECKPOINT_FILE_NAME.replace('.json', '')}-${tag}.json`);
+            await fs.writeFile(taggedFilePath, JSON.stringify(taggedConversation, null, 2));
+            const loaded = await logger.loadCheckpoint(tag);
+            expect(loaded).toEqual({ history: taggedConversation });
+        });
+        it('should return an empty array if a tagged checkpoint file does not exist', async () => {
+            const loaded = await logger.loadCheckpoint('non-existent-tag');
+            expect(loaded).toEqual({ history: [] });
+        });
+        it('should return an empty array if the checkpoint file does not exist', async () => {
+            await fs.unlink(TEST_CHECKPOINT_FILE_PATH); // Ensure it's gone
+            const loaded = await logger.loadCheckpoint('missing');
+            expect(loaded).toEqual({ history: [] });
+        });
+        it('should return an empty array if the file contains invalid JSON', async () => {
+            await fs.writeFile(TEST_CHECKPOINT_FILE_PATH, 'invalid json');
+            const consoleErrorSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            const loadedCheckpoint = await logger.loadCheckpoint('missing');
+            expect(loadedCheckpoint).toEqual({ history: [] });
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to read or parse checkpoint file'), expect.any(Error));
+        });
+        it('should return an empty array if logger is not initialized', async () => {
+            const uninitializedLogger = new Logger(testSessionId);
+            uninitializedLogger.close();
+            const consoleErrorSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            const loadedCheckpoint = await uninitializedLogger.loadCheckpoint('tag');
+            expect(loadedCheckpoint).toEqual({ history: [] });
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Logger not initialized or checkpoint file path not set. Cannot load checkpoint.');
+        });
+    });
+    describe('close', () => {
+        it('should reset logger state', async () => {
+            await logger.logMessage(MessageSenderType.USER, 'A message');
+            logger.close();
+            const consoleDebugSpy = vi
+                .spyOn(console, 'debug')
+                .mockImplementation(() => { });
+            await logger.logMessage(MessageSenderType.USER, 'Another message');
+            expect(consoleDebugSpy).toHaveBeenCalledWith('Logger not initialized or session ID missing. Cannot log message.');
+            const messages = await logger.getPreviousUserMessages();
+            expect(messages).toEqual([]);
+            expect(logger['initialized']).toBe(false);
+            expect(logger['logFilePath']).toBeUndefined();
+            expect(logger['logs']).toEqual([]);
+            expect(logger['sessionId']).toBeUndefined();
+            expect(logger['messageId']).toBe(0);
+        });
+    });
+});
+//# sourceMappingURL=logger.test.js.map