@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/session/storage/sqlite.js

@@ -0,0 +1,616 @@
+/**
+ * @fileoverview SQLite Session Store
+ *
+ * SQLite-based implementation of SessionStore with checkpoint support.
+ * Uses Bun's built-in bun:sqlite module for persistence.
+ */
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { SessionMessageConverter } from "../session-message-converter.js";
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Generate a unique session ID using crypto UUID
+ */
+function generateSessionId() {
+    return `session_${randomUUID()}`;
+}
+/**
+ * Generate a unique message ID using crypto UUID
+ */
+function generateMessageId() {
+    return `msg_${randomUUID()}`;
+}
+/**
+ * Get default data directory for session storage
+ */
+function getDefaultDataDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    return join(home, ".local", "share");
+}
+/**
+ * Get default database path for session storage
+ */
+function getDefaultSessionDbPath() {
+    return join(getDefaultDataDir(), "roy-agent", "sessions.db");
+}
+// ============================================================================
+// SQLiteSessionStore
+// ============================================================================
+/**
+ * SQLite-based Session Store with checkpoint support
+ *
+ * Provides persistent storage for sessions and messages using SQLite.
+ * Follows the same interface as MemorySessionStore but persists to disk.
+ */
+export class SQLiteSessionStore {
+    db = null;
+    dbPath;
+    initialized = false;
+    // In-memory cache for performance
+    sessionsCache = new Map();
+    messagesCache = new Map();
+    checkpointsCache = new Map();
+    messageConverter = new SessionMessageConverter();
+    constructor(dbPath) {
+        this.dbPath = dbPath || getDefaultSessionDbPath();
+    }
+    // ========================================================================
+    // Initialization
+    // ========================================================================
+    async initialize() {
+        if (this.initialized)
+            return;
+        // 使用 Bun 内置的 bun:sqlite
+        const { Database } = require("bun:sqlite");
+        // 确保目录存在
+        if (this.dbPath !== ":memory:") {
+            const fs = require("fs");
+            const path = require("path");
+            const dir = path.dirname(this.dbPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        this.db = new Database(this.dbPath);
+        // 创建表
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS session (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        directory TEXT NOT NULL,
+        parent_id TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        message_count INTEGER DEFAULT 0,
+        metadata TEXT
+      )
+    `);
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS message (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        parts TEXT,
+        is_archived INTEGER DEFAULT 0,
+        archived_at INTEGER,
+        checkpoint_id TEXT,
+        metadata TEXT,
+        FOREIGN KEY (session_id) REFERENCES session(id) ON DELETE CASCADE
+      )
+    `);
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_message_session ON message(session_id)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_message_checkpoint ON message(checkpoint_id)");
+        this.initialized = true;
+    }
+    // ========================================================================
+    // Session CRUD
+    // ========================================================================
+    async create(options) {
+        await this.initialize();
+        const now = Date.now();
+        const session = {
+            id: options.id ?? generateSessionId(), // Use custom ID if provided
+            title: options.title ?? "Session",
+            directory: options.directory ?? "/tmp",
+            parentID: options.parentID,
+            createdAt: now,
+            updatedAt: now,
+            messageCount: 0,
+            metadata: {
+                ...options.metadata,
+                messageCount: 0,
+                checkpoints: { checkpoints: [] },
+            },
+        };
+        // Check for duplicate ID (in case)
+        const existing = this.db.prepare("SELECT id FROM session WHERE id = ?").get(session.id);
+        if (existing) {
+            throw new Error(`Session with ID '${session.id}' already exists`);
+        }
+        // Insert into database
+        const stmt = this.db.prepare(`
+      INSERT INTO session (id, title, directory, parent_id, created_at, updated_at, message_count, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(session.id, session.title, session.directory, session.parentID || null, session.createdAt, session.updatedAt, session.messageCount, JSON.stringify(session.metadata));
+        // Update cache
+        this.sessionsCache.set(session.id, session);
+        this.messagesCache.set(session.id, []);
+        this.checkpointsCache.set(session.id, []);
+        return session;
+    }
+    async get(id) {
+        await this.initialize();
+        // Check cache first
+        const cached = this.sessionsCache.get(id);
+        if (cached)
+            return cached;
+        // Query from database
+        const row = this.db.prepare("SELECT * FROM session WHERE id = ?").get(id);
+        if (!row)
+            return undefined;
+        const session = this.rowToSession(row);
+        this.sessionsCache.set(session.id, session);
+        return session;
+    }
+    async list(options) {
+        await this.initialize();
+        let sql = "SELECT * FROM session";
+        const params = [];
+        const conditions = [];
+        // Filter by metadata
+        if (options?.filter?.metadata) {
+            for (const [key, value] of Object.entries(options.filter.metadata)) {
+                conditions.push(`json_extract(metadata, '$.${key}') = ?`);
+                params.push(JSON.stringify(value));
+            }
+        }
+        // Filter by time range
+        if (options?.filter?.startTime) {
+            conditions.push("created_at >= ?");
+            params.push(options.filter.startTime);
+        }
+        if (options?.filter?.endTime) {
+            conditions.push("created_at <= ?");
+            params.push(options.filter.endTime);
+        }
+        if (conditions.length > 0) {
+            sql += " WHERE " + conditions.join(" AND ");
+        }
+        // Sort
+        const sortField = options?.sort?.field ?? "updatedAt";
+        const sortOrder = options?.sort?.order ?? "desc";
+        const orderColumn = sortField === "title" ? "title"
+            : sortField === "createdAt" ? "created_at"
+                : "updated_at";
+        sql += ` ORDER BY ${orderColumn} ${sortOrder.toUpperCase()}`;
+        // Paginate
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? 100;
+        sql += " LIMIT ? OFFSET ?";
+        params.push(limit, offset);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.rowToSession(row));
+    }
+    async getCount() {
+        await this.initialize();
+        const result = this.db.prepare("SELECT COUNT(*) as count FROM session").get();
+        return result.count;
+    }
+    async update(id, updates) {
+        await this.initialize();
+        const session = await this.get(id);
+        if (!session)
+            return false;
+        // Update fields
+        if (updates.title !== undefined) {
+            session.title = updates.title;
+        }
+        if (updates.metadata !== undefined) {
+            session.metadata = { ...session.metadata, ...updates.metadata };
+        }
+        session.updatedAt = Date.now();
+        // Update database
+        const stmt = this.db.prepare(`
+      UPDATE session 
+      SET title = ?, metadata = ?, updated_at = ?
+      WHERE id = ?
+    `);
+        stmt.run(session.title, JSON.stringify(session.metadata), session.updatedAt, id);
+        // Update cache
+        this.sessionsCache.set(id, session);
+        return true;
+    }
+    async delete(id) {
+        await this.initialize();
+        const session = await this.get(id);
+        if (!session)
+            return false;
+        // Delete from database (messages will cascade)
+        this.db.prepare("DELETE FROM session WHERE id = ?").run(id);
+        // Clean up cache
+        this.sessionsCache.delete(id);
+        this.messagesCache.delete(id);
+        this.checkpointsCache.delete(id);
+        return true;
+    }
+    // ========================================================================
+    // Messages
+    // ========================================================================
+    async addMessage(sessionId, message) {
+        await this.initialize();
+        const session = await this.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const now = Date.now();
+        const msg = {
+            id: generateMessageId(),
+            sessionID: sessionId,
+            role: message.role,
+            content: message.content,
+            timestamp: now,
+            parts: message.parts,
+            metadata: message.metadata,
+        };
+        // Insert into database
+        const stmt = this.db.prepare(`
+      INSERT INTO message (id, session_id, role, content, timestamp, parts, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(msg.id, msg.sessionID, msg.role, msg.content, msg.timestamp, msg.parts ? JSON.stringify(msg.parts) : null, msg.metadata ? JSON.stringify(msg.metadata) : null);
+        // Update message count
+        const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
+        session.messageCount = countResult?.count || 0;
+        session.updatedAt = now;
+        // Update metadata with messageCount
+        session.metadata = {
+            ...session.metadata,
+            messageCount: session.messageCount
+        };
+        this.db.prepare(`
+      UPDATE session SET message_count = ?, metadata = ?, updated_at = ? WHERE id = ?
+    `).run(session.messageCount, JSON.stringify(session.metadata), session.updatedAt, sessionId);
+        // Update cache
+        const messages = this.messagesCache.get(sessionId) ?? [];
+        messages.push(msg);
+        this.messagesCache.set(sessionId, messages);
+        this.sessionsCache.set(sessionId, session);
+        return msg.id;
+    }
+    async getMessages(sessionId, offset = 0, limit = 50, options) {
+        await this.initialize();
+        let sql = "SELECT * FROM message WHERE session_id = ?";
+        let countSql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
+        const params = [sessionId];
+        const countParams = [sessionId];
+        // Filter by archived status
+        if (!options?.includeArchived) {
+            sql += " AND is_archived = 0";
+            countSql += " AND is_archived = 0";
+        }
+        // Handle fromCheckpointId
+        if (options?.fromCheckpointId) {
+            sql += " AND timestamp >= (SELECT MIN(timestamp) FROM message WHERE session_id = ? AND json_extract(metadata, '$.checkpointId') = ?)";
+            params.push(sessionId, options.fromCheckpointId);
+        }
+        // Handle negative offset: count total messages first, then calculate actual offset
+        // offset = -1, limit = 50: latest 50 messages → offset = total - limit
+        // offset = -2, limit = 50: 2nd latest 50 messages → offset = total - 2*limit
+        let actualOffset = offset;
+        if (offset < 0) {
+            const totalResult = this.db.prepare(countSql).get(...countParams);
+            const total = totalResult?.count || 0;
+            actualOffset = Math.max(0, total + offset * limit);
+        }
+        // Sort
+        if (options?.reverse) {
+            sql += " ORDER BY timestamp DESC";
+        }
+        else {
+            sql += " ORDER BY timestamp ASC";
+        }
+        // Paginate
+        sql += " LIMIT ? OFFSET ?";
+        params.push(limit, actualOffset);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.rowToMessage(row));
+    }
+    async getMessageCount(sessionId, includeArchived = false) {
+        await this.initialize();
+        let sql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
+        if (!includeArchived) {
+            sql += " AND is_archived = 0";
+        }
+        const result = this.db.prepare(sql).get(sessionId);
+        return result?.count || 0;
+    }
+    async getMessageIndexes(sessionId, role) {
+        await this.initialize();
+        // Use ROW_NUMBER() to get the offset index based on timestamp ASC order
+        // This ensures the index matches what getMessages returns with default ordering
+        const sql = `
+      SELECT idx FROM (
+        SELECT 
+          ROW_NUMBER() OVER (ORDER BY timestamp ASC) - 1 as idx,
+          role
+        FROM message 
+        WHERE session_id = ? AND is_archived = 0
+      ) ranked
+      WHERE role = ?
+    `;
+        const rows = this.db.prepare(sql).all(sessionId, role);
+        return rows.map(row => row.idx);
+    }
+    // ========================================================================
+    // Checkpoint Management
+    // ========================================================================
+    async saveCheckpoint(sessionId, checkpoint) {
+        await this.initialize();
+        const session = await this.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Save to checkpoints cache
+        const cps = this.checkpointsCache.get(sessionId) ?? [];
+        cps.push(checkpoint);
+        this.checkpointsCache.set(sessionId, cps);
+        // Update session metadata
+        const meta = session.metadata || {};
+        const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
+        checkpointsMeta.checkpoints.push({
+            id: checkpoint.id,
+            messageIndex: checkpoint.messageIndex,
+            title: checkpoint.title,
+            createdAt: checkpoint.createdAt,
+            type: checkpoint.type,
+        });
+        checkpointsMeta.latestCheckpointId = checkpoint.id;
+        meta.checkpoints = checkpointsMeta;
+        // Store checkpoint details separately
+        if (!meta.checkpointDetails) {
+            meta.checkpointDetails = {};
+        }
+        meta.checkpointDetails[checkpoint.id] = checkpoint;
+        session.metadata = meta;
+        session.updatedAt = Date.now();
+        // Update database
+        const stmt = this.db.prepare(`
+      UPDATE session SET metadata = ?, updated_at = ? WHERE id = ?
+    `);
+        stmt.run(JSON.stringify(session.metadata), session.updatedAt, sessionId);
+        // Update cache
+        this.sessionsCache.set(sessionId, session);
+    }
+    async getCheckpoints(sessionId) {
+        await this.initialize();
+        const session = await this.get(sessionId);
+        if (!session)
+            return [];
+        const meta = session.metadata;
+        const checkpointDetails = meta?.checkpointDetails;
+        if (!checkpointDetails)
+            return [];
+        return Object.values(checkpointDetails);
+    }
+    async getCheckpoint(sessionId, checkpointId) {
+        await this.initialize();
+        const checkpoints = await this.getCheckpoints(sessionId);
+        return checkpoints.find((cp) => cp.id === checkpointId);
+    }
+    async deleteCheckpoint(sessionId, checkpointId) {
+        await this.initialize();
+        const session = await this.get(sessionId);
+        if (!session)
+            return false;
+        const checkpoints = this.checkpointsCache.get(sessionId) ?? [];
+        const index = checkpoints.findIndex((cp) => cp.id === checkpointId);
+        if (index === -1)
+            return false;
+        // Remove checkpoint
+        checkpoints.splice(index, 1);
+        this.checkpointsCache.set(sessionId, checkpoints);
+        // Restore archived messages
+        this.db.prepare(`
+      UPDATE message SET is_archived = 0, archived_at = NULL, checkpoint_id = NULL
+      WHERE session_id = ? AND checkpoint_id = ?
+    `).run(sessionId, checkpointId);
+        // Update session metadata
+        const meta = session.metadata || {};
+        const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
+        checkpointsMeta.checkpoints = checkpointsMeta.checkpoints.filter((cp) => cp.id !== checkpointId);
+        checkpointsMeta.latestCheckpointId = checkpoints[checkpoints.length - 1]?.id;
+        if (meta.checkpointDetails) {
+            delete meta.checkpointDetails[checkpointId];
+        }
+        session.metadata = meta;
+        // Update message count
+        const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
+        session.messageCount = countResult?.count || 0;
+        session.updatedAt = Date.now();
+        // Update database
+        this.db.prepare(`
+      UPDATE session SET metadata = ?, message_count = ?, updated_at = ? WHERE id = ?
+    `).run(JSON.stringify(session.metadata), session.messageCount, session.updatedAt, sessionId);
+        // Update cache
+        this.sessionsCache.set(sessionId, session);
+        return true;
+    }
+    async archiveMessages(sessionId, checkpointId, beforeIndex) {
+        await this.initialize();
+        const session = await this.get(sessionId);
+        if (!session)
+            return 0;
+        const now = Date.now();
+        // Archive messages before the index
+        const result = this.db.prepare(`
+      UPDATE message 
+      SET is_archived = 1, archived_at = ?, checkpoint_id = ?
+      WHERE session_id = ? AND id IN (
+        SELECT id FROM message WHERE session_id = ? AND is_archived = 0
+        ORDER BY timestamp ASC LIMIT ?
+      )
+    `).run(now, checkpointId, sessionId, sessionId, beforeIndex);
+        // Update message count
+        const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
+        session.messageCount = countResult?.count || 0;
+        session.updatedAt = now;
+        // Update database
+        this.db.prepare(`
+      UPDATE session SET message_count = ?, updated_at = ? WHERE id = ?
+    `).run(session.messageCount, session.updatedAt, sessionId);
+        // Update cache
+        this.sessionsCache.set(sessionId, session);
+        this.messagesCache.delete(sessionId); // Clear message cache
+        return result.changes;
+    }
+    async getActiveMessages(sessionId, offset = 0, limit = 50) {
+        return this.getMessages(sessionId, offset, limit, { includeArchived: false });
+    }
+    // ========================================================================
+    // Search [new]
+    // ========================================================================
+    async searchMessages(options) {
+        await this.initialize();
+        const matches = [];
+        const { query, sessionId, limit = 10, beforeTime, afterTime, includeArchived = false, } = options;
+        // Build SQL query
+        let sql = "SELECT * FROM message WHERE 1=1";
+        const params = [];
+        // Filter by session
+        if (sessionId) {
+            sql += " AND session_id = ?";
+            params.push(sessionId);
+        }
+        // Filter by archived status
+        if (!includeArchived) {
+            sql += " AND is_archived = 0";
+        }
+        // Filter by time
+        if (beforeTime) {
+            sql += " AND timestamp <= ?";
+            params.push(beforeTime);
+        }
+        if (afterTime) {
+            sql += " AND timestamp >= ?";
+            params.push(afterTime);
+        }
+        // Order by timestamp
+        sql += " ORDER BY timestamp DESC";
+        // Limit
+        sql += " LIMIT ?";
+        params.push(limit * 10); // Get more than limit to filter by query
+        const rows = this.db.prepare(sql).all(...params);
+        // Parse query for simple text matching
+        const queryTerms = this.parseQuery(query);
+        const lowerQuery = query.toLowerCase();
+        // Filter and match messages
+        for (const row of rows) {
+            const content = row.content.toLowerCase();
+            // Check if content matches query
+            let matchesQuery = true;
+            // Check excluded terms
+            for (const term of queryTerms.excluded) {
+                if (content.includes(term.toLowerCase())) {
+                    matchesQuery = false;
+                    break;
+                }
+            }
+            // Check required terms
+            if (matchesQuery && queryTerms.required.length > 0) {
+                for (const term of queryTerms.required) {
+                    if (!content.includes(term.toLowerCase())) {
+                        matchesQuery = false;
+                        break;
+                    }
+                }
+            }
+            // Simple fallback: check if query string appears in content
+            if (!matchesQuery && lowerQuery && content.includes(lowerQuery)) {
+                matchesQuery = true;
+            }
+            if (matchesQuery) {
+                matches.push({
+                    messageId: row.id,
+                    sessionId: row.session_id,
+                    role: row.role,
+                    content: row.content,
+                    timestamp: row.timestamp,
+                });
+                if (matches.length >= limit)
+                    break;
+            }
+        }
+        return matches;
+    }
+    /**
+     * Parse simple query into terms
+     */
+    parseQuery(query) {
+        // Remove quoted phrases (simplified)
+        const terms = query.split(/\s+/).filter((t) => !t.startsWith('"') && !t.endsWith('"'));
+        const required = [];
+        const excluded = [];
+        for (const term of terms) {
+            if (term.startsWith("-") || term.toUpperCase().startsWith("NOT ")) {
+                excluded.push(term.replace(/^-|^NOT /i, ""));
+            }
+            else {
+                required.push(term);
+            }
+        }
+        return { required, excluded };
+    }
+    // ========================================================================
+    // Lifecycle
+    // ========================================================================
+    async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+        this.sessionsCache.clear();
+        this.messagesCache.clear();
+        this.checkpointsCache.clear();
+        this.initialized = false;
+    }
+    // ========================================================================
+    // Row Conversions
+    // ========================================================================
+    rowToSession(row) {
+        return {
+            id: row.id,
+            title: row.title,
+            directory: row.directory,
+            parentID: row.parent_id,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            messageCount: row.message_count,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        };
+    }
+    rowToMessage(row) {
+        // Parse the raw message from database
+        const rawMessage = {
+            id: row.id,
+            sessionID: row.session_id,
+            role: row.role,
+            content: row.content,
+            timestamp: row.timestamp,
+            parts: row.parts ? JSON.parse(row.parts) : undefined,
+            isArchived: row.is_archived === 1,
+            archivedAt: row.archived_at || undefined,
+            checkpointId: row.checkpoint_id || undefined,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        };
+        // Apply migration for backward compatibility with old format
+        return this.messageConverter.migrateMessage(rawMessage);
+    }
+}
+// Export helper functions
+export { getDefaultSessionDbPath, getDefaultDataDir };
+//# sourceMappingURL=sqlite.js.map