@xopcai/xopcbot 0.1.0

package/dist/session/store.js

@@ -0,0 +1,687 @@
+// Session store - manages session persistence, indexing, compaction, and sliding window
+import { readFile, writeFile, mkdir, unlink, readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { createLogger } from '../utils/logger.js';
+import { SessionStatus } from './types.js';
+import { SessionCompactor } from '../agent/memory/compaction.js';
+import { SlidingWindow } from '../agent/memory/window.js';
+const log = createLogger('SessionStore');
+const INDEX_VERSION = '1.0';
+const DEFAULT_LIMIT = 50;
+export class SessionStore {
+    baseDir;
+    sessionsDir;
+    archiveDir;
+    indexFile;
+    indexCache = null;
+    indexCacheTime = 0;
+    indexDirty = false;
+    window;
+    compactor;
+    constructor(workspace, windowConfig, compactionConfig) {
+        this.baseDir = workspace;
+        this.sessionsDir = join(workspace, '.sessions');
+        this.archiveDir = join(workspace, '.sessions', 'archive');
+        this.indexFile = join(workspace, '.sessions', 'index.json');
+        this.window = new SlidingWindow(windowConfig);
+        this.compactor = new SessionCompactor(compactionConfig);
+    }
+    // ========== Initialization ==========
+    async initialize() {
+        await mkdir(this.sessionsDir, { recursive: true });
+        await mkdir(this.archiveDir, { recursive: true });
+        if (!existsSync(this.indexFile)) {
+            await this.rebuildIndex();
+        }
+        else {
+            await this.loadIndex();
+        }
+        log.info('Session store initialized');
+    }
+    // ========== Index Management ==========
+    async loadIndex() {
+        try {
+            // Check if index file has been modified
+            const stats = await stat(this.indexFile);
+            const mtime = stats.mtime.getTime();
+            // If cache is valid and file hasn't changed, use cache
+            if (this.indexCache && mtime <= this.indexCacheTime) {
+                return this.indexCache;
+            }
+            // File has changed or cache is empty, reload
+            const data = await readFile(this.indexFile, 'utf-8');
+            this.indexCache = JSON.parse(data);
+            this.indexCacheTime = mtime;
+            return this.indexCache;
+        }
+        catch {
+            // Index corrupted or missing, rebuild
+            return this.rebuildIndex();
+        }
+    }
+    /**
+     * Force refresh the index cache from disk
+     */
+    async refreshIndex() {
+        this.indexCache = null;
+        this.indexCacheTime = 0;
+        await this.loadIndex();
+    }
+    async saveIndex() {
+        if (!this.indexCache)
+            return;
+        this.indexCache.lastUpdated = new Date().toISOString();
+        await writeFile(this.indexFile, JSON.stringify(this.indexCache, null, 2));
+        this.indexDirty = false;
+        // Update cache time after saving
+        try {
+            const stats = await stat(this.indexFile);
+            this.indexCacheTime = stats.mtime.getTime();
+        }
+        catch {
+            this.indexCacheTime = Date.now();
+        }
+    }
+    async rebuildIndex() {
+        log.info('Rebuilding session index...');
+        const sessions = [];
+        // Scan sessions directory
+        const files = await this.scanSessionFiles();
+        for (const file of files) {
+            if (file.endsWith('.json') && !file.endsWith('.meta.json')) {
+                const key = this.fileNameToKey(file.replace('.json', ''));
+                try {
+                    const metadata = await this.scanSessionFile(key);
+                    if (metadata) {
+                        sessions.push(metadata);
+                    }
+                }
+                catch (err) {
+                    log.warn({ key, err }, 'Failed to scan session file');
+                }
+            }
+        }
+        this.indexCache = {
+            version: INDEX_VERSION,
+            lastUpdated: new Date().toISOString(),
+            sessions,
+        };
+        await this.saveIndex();
+        // Update cache time after saving
+        try {
+            const stats = await stat(this.indexFile);
+            this.indexCacheTime = stats.mtime.getTime();
+        }
+        catch {
+            this.indexCacheTime = Date.now();
+        }
+        log.info({ count: sessions.length }, 'Session index rebuilt');
+        return this.indexCache;
+    }
+    async scanSessionFiles() {
+        try {
+            const files = await readdir(this.sessionsDir);
+            return files.filter((f) => f.endsWith('.json') && f !== 'index.json');
+        }
+        catch {
+            return [];
+        }
+    }
+    async scanSessionFile(key) {
+        const messages = await this.loadMessages(key);
+        if (messages.length === 0)
+            return null;
+        const safeKey = this.sanitizeKey(key);
+        const filePath = join(this.sessionsDir, `${safeKey}.json`);
+        const stats = await stat(filePath);
+        const { channel, chatId } = this.parseSessionKey(key);
+        return {
+            key,
+            status: SessionStatus.ACTIVE,
+            tags: [],
+            createdAt: stats.birthtime.toISOString(),
+            updatedAt: stats.mtime.toISOString(),
+            lastAccessedAt: stats.mtime.toISOString(),
+            messageCount: messages.length,
+            estimatedTokens: this.estimateTokens(messages),
+            compactedCount: 0,
+            sourceChannel: channel,
+            sourceChatId: chatId,
+        };
+    }
+    // ========== CRUD Operations ==========
+    async list(query = {}) {
+        const index = await this.loadIndex();
+        let sessions = [...index.sessions];
+        // Apply filters
+        if (query.status) {
+            const statuses = Array.isArray(query.status) ? query.status : [query.status];
+            sessions = sessions.filter((s) => statuses.includes(s.status));
+        }
+        if (query.channel) {
+            sessions = sessions.filter((s) => s.sourceChannel === query.channel);
+        }
+        if (query.tags && query.tags.length > 0) {
+            sessions = sessions.filter((s) => query.tags.some((tag) => s.tags.includes(tag)));
+        }
+        if (query.search) {
+            const searchLower = query.search.toLowerCase();
+            sessions = sessions.filter((s) => s.key.toLowerCase().includes(searchLower) ||
+                s.name?.toLowerCase().includes(searchLower) ||
+                s.tags.some((t) => t.toLowerCase().includes(searchLower)));
+        }
+        // Apply sorting
+        const sortBy = query.sortBy || 'updatedAt';
+        const sortOrder = query.sortOrder || 'desc';
+        sessions.sort((a, b) => {
+            const aVal = a[sortBy];
+            const bVal = b[sortBy];
+            const comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+            return sortOrder === 'asc' ? comparison : -comparison;
+        });
+        // Apply pagination
+        const total = sessions.length;
+        const limit = query.limit || DEFAULT_LIMIT;
+        const offset = query.offset || 0;
+        const items = sessions.slice(offset, offset + limit);
+        return {
+            items,
+            total,
+            limit,
+            offset,
+            hasMore: offset + limit < total,
+        };
+    }
+    async get(key) {
+        const metadata = await this.getMetadata(key);
+        if (!metadata)
+            return null;
+        const messages = await this.loadMessages(key);
+        return {
+            ...metadata,
+            messages: this.convertMessages(messages),
+        };
+    }
+    async getMetadata(key) {
+        const index = await this.loadIndex();
+        const metadata = index.sessions.find((s) => s.key === key);
+        if (!metadata) {
+            // Try to load from file directly (orphaned session)
+            const scanned = await this.scanSessionFile(key);
+            if (scanned) {
+                index.sessions.push(scanned);
+                this.indexDirty = true;
+                return scanned;
+            }
+            return null;
+        }
+        return metadata;
+    }
+    async updateMetadata(key, updates) {
+        const index = await this.loadIndex();
+        const idx = index.sessions.findIndex((s) => s.key === key);
+        if (idx === -1) {
+            throw new Error(`Session not found: ${key}`);
+        }
+        index.sessions[idx] = {
+            ...index.sessions[idx],
+            ...updates,
+            updatedAt: new Date().toISOString(),
+        };
+        this.indexDirty = true;
+        await this.saveIndex();
+        log.debug({ key, updates }, 'Session metadata updated');
+    }
+    async delete(key) {
+        const index = await this.loadIndex();
+        const idx = index.sessions.findIndex((s) => s.key === key);
+        // Delete files
+        const safeKey = this.sanitizeKey(key);
+        const sessionPath = join(this.sessionsDir, `${safeKey}.json`);
+        const metaPath = join(this.sessionsDir, `${safeKey}.meta.json`);
+        try {
+            await unlink(sessionPath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        try {
+            await unlink(metaPath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        // Remove from index
+        if (idx !== -1) {
+            index.sessions.splice(idx, 1);
+            this.indexDirty = true;
+            await this.saveIndex();
+        }
+        log.info({ key }, 'Session deleted');
+        return true;
+    }
+    async deleteMany(keys) {
+        const success = [];
+        const failed = [];
+        for (const key of keys) {
+            try {
+                await this.delete(key);
+                success.push(key);
+            }
+            catch {
+                failed.push(key);
+            }
+        }
+        return { success, failed };
+    }
+    // ========== Status Operations ==========
+    async setStatus(key, status) {
+        await this.updateMetadata(key, { status });
+        if (status === SessionStatus.ARCHIVED) {
+            await this.moveToArchive(key);
+        }
+        else {
+            await this.moveFromArchive(key);
+        }
+    }
+    async archive(key) {
+        await this.setStatus(key, SessionStatus.ARCHIVED);
+    }
+    async unarchive(key) {
+        await this.setStatus(key, SessionStatus.ACTIVE);
+    }
+    async pin(key) {
+        await this.setStatus(key, SessionStatus.PINNED);
+    }
+    async unpin(key) {
+        await this.setStatus(key, SessionStatus.ACTIVE);
+    }
+    // ========== Message Operations ==========
+    async loadMessages(key) {
+        const safeKey = this.sanitizeKey(key);
+        const path = join(this.sessionsDir, `${safeKey}.json`);
+        try {
+            const data = await readFile(path, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            // Check archive - find the most recent archived file
+            const archivedFile = await this.findMostRecentArchive(safeKey);
+            if (!archivedFile) {
+                return [];
+            }
+            try {
+                const data = await readFile(archivedFile, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch {
+                return [];
+            }
+        }
+    }
+    /**
+     * Find the most recent archived session file for a given key.
+     * Archived files have format: {safeKey}.{timestamp}.json
+     */
+    async findMostRecentArchive(safeKey) {
+        try {
+            const files = await readdir(this.archiveDir);
+            const matchingFiles = files
+                .filter((f) => f.startsWith(`${safeKey}.`) && f.endsWith('.json') && !f.endsWith('.meta.json'))
+                .sort()
+                .reverse();
+            if (matchingFiles.length === 0) {
+                return null;
+            }
+            return join(this.archiveDir, matchingFiles[0]);
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveMessages(key, messages) {
+        const safeKey = this.sanitizeKey(key);
+        const path = join(this.sessionsDir, `${safeKey}.json`);
+        await mkdir(this.sessionsDir, { recursive: true });
+        await writeFile(path, JSON.stringify(messages, null, 2));
+        // Update or create metadata
+        const index = await this.loadIndex();
+        const existingIdx = index.sessions.findIndex((s) => s.key === key);
+        const now = new Date().toISOString();
+        const { channel, chatId } = this.parseSessionKey(key);
+        if (existingIdx !== -1) {
+            index.sessions[existingIdx] = {
+                ...index.sessions[existingIdx],
+                messageCount: messages.length,
+                estimatedTokens: this.estimateTokens(messages),
+                updatedAt: now,
+                lastAccessedAt: now,
+            };
+        }
+        else {
+            index.sessions.push({
+                key,
+                status: SessionStatus.ACTIVE,
+                tags: [],
+                createdAt: now,
+                updatedAt: now,
+                lastAccessedAt: now,
+                messageCount: messages.length,
+                estimatedTokens: this.estimateTokens(messages),
+                compactedCount: 0,
+                sourceChannel: channel,
+                sourceChatId: chatId,
+            });
+        }
+        this.indexDirty = true;
+        await this.saveIndex();
+    }
+    // ========== Sliding Window & Compaction ==========
+    /**
+     * Get window stats for messages
+     */
+    getWindowStats(messages) {
+        return this.window.getStats(messages);
+    }
+    /**
+     * Check if session needs compaction
+     */
+    needsCompaction(key, messages, contextWindow) {
+        return this.compactor.needsCompaction(messages, contextWindow);
+    }
+    /**
+     * Prepare compaction (check if needed)
+     */
+    prepareCompaction(key, messages, contextWindow) {
+        const result = this.compactor.needsCompaction(messages, contextWindow);
+        return {
+            needsCompaction: result.needed,
+            messages,
+            stats: result,
+        };
+    }
+    /**
+     * Apply compaction result to messages
+     */
+    async applyCompaction(key, messages, result) {
+        const compacted = this.compactor.applyCompaction(messages, result);
+        const metadata = await this.getMetadata(key);
+        if (metadata) {
+            await this.updateMetadata(key, {
+                compactedCount: metadata.compactedCount + 1,
+            });
+        }
+        log.info({
+            key,
+            tokensBefore: result.tokensBefore,
+            tokensAfter: result.tokensAfter,
+            keptMessages: compacted.length,
+        }, 'Session compacted');
+        return compacted;
+    }
+    /**
+     * Compact session with LLM summary
+     */
+    async compact(key, messages, contextWindow, instructions) {
+        const result = await this.compactor.compact(messages, instructions);
+        if (result.compacted) {
+            await this.applyCompaction(key, messages, result);
+        }
+        return result;
+    }
+    /**
+     * Get compaction stats for a session
+     */
+    async getCompactionStats(key) {
+        const metadata = await this.getMetadata(key);
+        if (!metadata)
+            return undefined;
+        return {
+            compactionCount: metadata.compactedCount,
+            totalTokensBefore: 0,
+            totalTokensAfter: 0,
+            lastCompactionAt: undefined,
+        };
+    }
+    // ========== MemoryStore API Aliases ==========
+    /** Alias for delete */
+    async deleteSession(key) {
+        return this.delete(key);
+    }
+    /** Alias for loadMessages */
+    async load(key) {
+        return this.loadMessages(key);
+    }
+    /** Alias for saveMessages */
+    async save(key, messages) {
+        return this.saveMessages(key, messages);
+    }
+    /** Alias for estimateTokens */
+    async estimateTokenUsage(key, messages) {
+        return this.estimateTokens(messages);
+    }
+    // ========== Search ==========
+    async searchInSession(key, keyword) {
+        const messages = await this.loadMessages(key);
+        const keywordLower = keyword.toLowerCase();
+        return this.convertMessages(messages.filter((m) => {
+            const content = this.extractTextContent(m.content);
+            return content.toLowerCase().includes(keywordLower);
+        }));
+    }
+    // ========== Export/Import ==========
+    async exportSession(key, format) {
+        const detail = await this.get(key);
+        if (!detail) {
+            throw new Error(`Session not found: ${key}`);
+        }
+        if (format === 'json') {
+            const exportData = {
+                version: INDEX_VERSION,
+                exportedAt: new Date().toISOString(),
+                metadata: detail,
+                messages: detail.messages,
+            };
+            return JSON.stringify(exportData, null, 2);
+        }
+        else {
+            // Markdown format
+            const lines = [
+                `# ${detail.name || detail.key}`,
+                '',
+                `- **Channel:** ${detail.sourceChannel}`,
+                `- **Created:** ${detail.createdAt}`,
+                `- **Messages:** ${detail.messageCount}`,
+                `- **Tags:** ${detail.tags.join(', ') || 'none'}`,
+                '',
+                '---',
+                '',
+            ];
+            for (const msg of detail.messages) {
+                const role = msg.role === 'assistant' ? 'Assistant' : msg.role === 'user' ? 'User' : msg.role;
+                lines.push(`## ${role}`);
+                lines.push('');
+                lines.push(msg.content);
+                lines.push('');
+                lines.push('---');
+                lines.push('');
+            }
+            return lines.join('\n');
+        }
+    }
+    // ========== Statistics ==========
+    async getStats() {
+        const index = await this.loadIndex();
+        const sessions = index.sessions;
+        const byChannel = {};
+        for (const s of sessions) {
+            byChannel[s.sourceChannel] = (byChannel[s.sourceChannel] || 0) + 1;
+        }
+        let oldestSession;
+        let newestSession;
+        if (sessions.length > 0) {
+            const sorted = [...sessions].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            oldestSession = sorted[0].createdAt;
+            newestSession = sorted[sorted.length - 1].createdAt;
+        }
+        return {
+            totalSessions: sessions.length,
+            activeSessions: sessions.filter((s) => s.status === SessionStatus.ACTIVE || s.status === SessionStatus.IDLE).length,
+            archivedSessions: sessions.filter((s) => s.status === SessionStatus.ARCHIVED).length,
+            pinnedSessions: sessions.filter((s) => s.status === SessionStatus.PINNED).length,
+            totalMessages: sessions.reduce((sum, s) => sum + s.messageCount, 0),
+            totalTokens: sessions.reduce((sum, s) => sum + s.estimatedTokens, 0),
+            oldestSession,
+            newestSession,
+            byChannel,
+        };
+    }
+    // ========== Cleanup ==========
+    async archiveOld(olderThanDays) {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - olderThanDays);
+        const index = await this.loadIndex();
+        let archived = 0;
+        for (const session of index.sessions) {
+            if (session.status !== SessionStatus.ARCHIVED && session.status !== SessionStatus.PINNED) {
+                const lastAccess = new Date(session.lastAccessedAt);
+                if (lastAccess < cutoff) {
+                    await this.archive(session.key);
+                    archived++;
+                }
+            }
+        }
+        return archived;
+    }
+    // ========== Helper Methods ==========
+    sanitizeKey(key) {
+        return key.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+    fileNameToKey(fileName) {
+        // Reverse of sanitizeKey - try to restore original format
+        // telegram_123456 -> telegram:123456
+        return fileName.replace(/^([^_]+)_(.+)$/, '$1:$2');
+    }
+    parseSessionKey(key) {
+        const parts = key.split(':');
+        if (parts.length >= 2) {
+            return { channel: parts[0], chatId: parts.slice(1).join(':') };
+        }
+        return { channel: 'unknown', chatId: key };
+    }
+    estimateTokens(messages) {
+        // Rough estimate: 1 token ≈ 4 characters
+        let total = 0;
+        for (const msg of messages) {
+            const text = this.extractTextContent(msg.content);
+            total += Math.ceil(text.length / 4);
+        }
+        return total;
+    }
+    extractTextContent(content) {
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            return content
+                .filter((c) => typeof c === 'object' && c !== null && 'type' in c && c.type === 'text')
+                .map((c) => c.text || '')
+                .join('');
+        }
+        return '';
+    }
+    convertMessages(messages) {
+        return messages.map((m) => ({
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : this.extractTextContent(m.content),
+            timestamp: m.timestamp ? new Date(m.timestamp).toISOString() : undefined,
+            tool_call_id: m.tool_call_id || m.toolCallId,
+            tool_calls: m.tool_calls,
+            name: m.name,
+        }));
+    }
+    async moveToArchive(key) {
+        const safeKey = this.sanitizeKey(key);
+        const sourcePath = join(this.sessionsDir, `${safeKey}.json`);
+        // Use timestamped filename to avoid overwriting previous archives
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const targetPath = join(this.archiveDir, `${safeKey}.${timestamp}.json`);
+        try {
+            const data = await readFile(sourcePath, 'utf-8');
+            await writeFile(targetPath, data);
+            await unlink(sourcePath);
+            // Move meta file if exists
+            const metaSource = join(this.sessionsDir, `${safeKey}.meta.json`);
+            const metaTarget = join(this.archiveDir, `${safeKey}.${timestamp}.meta.json`);
+            try {
+                const metaData = await readFile(metaSource, 'utf-8');
+                await writeFile(metaTarget, metaData);
+                await unlink(metaSource);
+            }
+            catch {
+                // Meta file might not exist
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+    }
+    async moveFromArchive(key) {
+        const safeKey = this.sanitizeKey(key);
+        const sourcePath = await this.findMostRecentArchive(safeKey);
+        if (!sourcePath) {
+            return;
+        }
+        const targetPath = join(this.sessionsDir, `${safeKey}.json`);
+        try {
+            const data = await readFile(sourcePath, 'utf-8');
+            await writeFile(targetPath, data);
+            await unlink(sourcePath);
+            // Move meta file if exists (find the corresponding meta file)
+            const metaSource = sourcePath.replace('.json', '.meta.json');
+            const metaTarget = join(this.sessionsDir, `${safeKey}.meta.json`);
+            try {
+                const metaData = await readFile(metaSource, 'utf-8');
+                await writeFile(metaTarget, metaData);
+                await unlink(metaSource);
+            }
+            catch {
+                // Meta file might not exist
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+    }
+    // ========== Legacy Compatibility ==========
+    async migrateFromLegacy() {
+        // Migrate old .sessions/*.json files without index
+        const files = await this.scanSessionFiles();
+        let migrated = 0;
+        for (const file of files) {
+            if (file.endsWith('.json') && !file.endsWith('.meta.json')) {
+                const key = this.fileNameToKey(file.replace('.json', ''));
+                const metadata = await this.getMetadata(key);
+                if (!metadata) {
+                    const scanned = await this.scanSessionFile(key);
+                    if (scanned) {
+                        const index = await this.loadIndex();
+                        index.sessions.push(scanned);
+                        migrated++;
+                    }
+                }
+            }
+        }
+        if (migrated > 0) {
+            this.indexDirty = true;
+            await this.saveIndex();
+        }
+        log.info({ migrated }, 'Migrated legacy sessions');
+        return migrated;
+    }
+}
+//# sourceMappingURL=store.js.map