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

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

@@ -0,0 +1,404 @@
+/**
+ * @fileoverview Memory Session Store
+ *
+ * In-memory implementation of SessionStore with checkpoint support
+ */
+import { SessionMessageConverter } from "../session-message-converter.js";
+import { randomUUID } from "crypto";
+/**
+ * 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()}`;
+}
+/**
+ * Memory-based Session Store with checkpoint support
+ */
+export class MemorySessionStore {
+    sessions = new Map();
+    messages = new Map();
+    checkpoints = new Map();
+    messageConverter = new SessionMessageConverter();
+    // ========================================================================
+    // Session CRUD
+    // ========================================================================
+    async create(options) {
+        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
+        if (this.sessions.has(session.id)) {
+            throw new Error(`Session with ID '${session.id}' already exists`);
+        }
+        this.sessions.set(session.id, session);
+        this.messages.set(session.id, []);
+        this.checkpoints.set(session.id, []);
+        return session;
+    }
+    async get(id) {
+        return this.sessions.get(id);
+    }
+    async list(options) {
+        let sessions = Array.from(this.sessions.values());
+        // Filter by metadata
+        if (options?.filter?.metadata) {
+            sessions = sessions.filter((s) => {
+                for (const [key, value] of Object.entries(options.filter.metadata)) {
+                    if (s.metadata?.[key] !== value)
+                        return false;
+                }
+                return true;
+            });
+        }
+        // Filter by time range
+        if (options?.filter?.startTime) {
+            sessions = sessions.filter((s) => s.createdAt >= options.filter.startTime);
+        }
+        if (options?.filter?.endTime) {
+            sessions = sessions.filter((s) => s.createdAt <= options.filter.endTime);
+        }
+        // Sort
+        const sortField = options?.sort?.field ?? "updatedAt";
+        const sortOrder = options?.sort?.order ?? "desc";
+        sessions.sort((a, b) => {
+            let aVal;
+            let bVal;
+            if (sortField === "title") {
+                aVal = a.title;
+                bVal = b.title;
+            }
+            else if (sortField === "createdAt") {
+                aVal = a.createdAt;
+                bVal = b.createdAt;
+            }
+            else {
+                aVal = a.updatedAt;
+                bVal = b.updatedAt;
+            }
+            if (aVal < bVal)
+                return sortOrder === "asc" ? -1 : 1;
+            if (aVal > bVal)
+                return sortOrder === "asc" ? 1 : -1;
+            return 0;
+        });
+        // Paginate
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? 100;
+        return sessions.slice(offset, offset + limit);
+    }
+    async update(id, updates) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return false;
+        if (updates.title !== undefined) {
+            session.title = updates.title;
+        }
+        if (updates.metadata !== undefined) {
+            session.metadata = { ...session.metadata, ...updates.metadata };
+        }
+        session.updatedAt = Date.now();
+        return true;
+    }
+    async delete(id) {
+        const deleted = this.sessions.delete(id);
+        if (deleted) {
+            this.messages.delete(id);
+            this.checkpoints.delete(id);
+        }
+        return deleted;
+    }
+    async getCount() {
+        return this.sessions.size;
+    }
+    // ========================================================================
+    // Messages
+    // ========================================================================
+    async addMessage(sessionId, message) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Create raw message
+        const rawMessage = {
+            sessionID: sessionId,
+            role: message.role,
+            content: message.content,
+            parts: message.parts,
+            metadata: message.metadata,
+        };
+        // Apply migration to ensure new format (backward compatibility)
+        const msg = this.messageConverter.migrateMessage(rawMessage);
+        msg.id = generateMessageId();
+        msg.timestamp = Date.now();
+        const sessionMessages = this.messages.get(sessionId) ?? [];
+        sessionMessages.push(msg);
+        this.messages.set(sessionId, sessionMessages);
+        // Update message count (non-archived only)
+        session.messageCount = sessionMessages.filter((m) => !m.isArchived).length;
+        // Update metadata with messageCount
+        session.metadata = {
+            ...session.metadata,
+            messageCount: session.messageCount
+        };
+        session.updatedAt = Date.now();
+        return msg.id;
+    }
+    async getMessages(sessionId, offset = 0, limit = 50, options) {
+        let messages = this.messages.get(sessionId) ?? [];
+        // Handle archived messages
+        if (!options?.includeArchived) {
+            messages = messages.filter((m) => !m.isArchived);
+        }
+        // Handle fromCheckpointId
+        if (options?.fromCheckpointId) {
+            const checkpoint = await this.getCheckpoint(sessionId, options.fromCheckpointId);
+            if (checkpoint) {
+                const checkpointIndex = messages.findIndex((m) => m.metadata?.checkpointId === options.fromCheckpointId);
+                if (checkpointIndex >= 0) {
+                    messages = messages.slice(checkpointIndex);
+                }
+            }
+        }
+        // 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 total = messages.length;
+            actualOffset = Math.max(0, total + offset * limit);
+        }
+        // Handle reverse
+        if (options?.reverse) {
+            messages = messages.reverse();
+        }
+        return messages.slice(actualOffset, actualOffset + limit);
+    }
+    async getMessageCount(sessionId, includeArchived = false) {
+        const messages = this.messages.get(sessionId) ?? [];
+        if (includeArchived) {
+            return messages.length;
+        }
+        return messages.filter((m) => !m.isArchived).length;
+    }
+    async getMessageIndexes(sessionId, role) {
+        const messages = this.messages.get(sessionId) ?? [];
+        const indexes = [];
+        // Return index based on timestamp ASC order (same as getMessages default)
+        messages
+            .filter(m => !m.isArchived)
+            .forEach((msg, filteredIdx) => {
+            if (msg.role === role) {
+                indexes.push(filteredIdx);
+            }
+        });
+        return indexes;
+    }
+    // ========================================================================
+    // Checkpoint Management
+    // ========================================================================
+    async saveCheckpoint(sessionId, checkpoint) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Save to checkpoints map
+        const cps = this.checkpoints.get(sessionId) ?? [];
+        cps.push(checkpoint);
+        this.checkpoints.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();
+    }
+    async getCheckpoints(sessionId) {
+        return this.checkpoints.get(sessionId) ?? [];
+    }
+    async getCheckpoint(sessionId, checkpointId) {
+        const cps = this.checkpoints.get(sessionId) ?? [];
+        return cps.find((cp) => cp.id === checkpointId);
+    }
+    async deleteCheckpoint(sessionId, checkpointId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        const cps = this.checkpoints.get(sessionId) ?? [];
+        const index = cps.findIndex((cp) => cp.id === checkpointId);
+        if (index === -1)
+            return false;
+        // Remove checkpoint
+        cps.splice(index, 1);
+        this.checkpoints.set(sessionId, cps);
+        // Restore archived messages
+        const messages = this.messages.get(sessionId) ?? [];
+        for (const msg of messages) {
+            if (msg.checkpointId === checkpointId) {
+                msg.isArchived = false;
+                msg.archivedAt = undefined;
+                msg.checkpointId = undefined;
+            }
+        }
+        // Update session metadata
+        const meta = session.metadata || {};
+        const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
+        checkpointsMeta.checkpoints = checkpointsMeta.checkpoints.filter((cp) => cp.id !== checkpointId);
+        checkpointsMeta.latestCheckpointId = cps[cps.length - 1]?.id;
+        if (meta.checkpointDetails) {
+            delete meta.checkpointDetails[checkpointId];
+        }
+        session.metadata = meta;
+        session.messageCount = messages.filter((m) => !m.isArchived).length;
+        session.updatedAt = Date.now();
+        return true;
+    }
+    async archiveMessages(sessionId, checkpointId, beforeIndex) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return 0;
+        const messages = this.messages.get(sessionId) ?? [];
+        let archivedCount = 0;
+        for (let i = 0; i < beforeIndex; i++) {
+            if (!messages[i].isArchived) {
+                messages[i].isArchived = true;
+                messages[i].archivedAt = Date.now();
+                messages[i].checkpointId = checkpointId;
+                archivedCount++;
+            }
+        }
+        // Update session message count (non-archived only)
+        session.messageCount = messages.filter((m) => !m.isArchived).length;
+        session.updatedAt = Date.now();
+        return archivedCount;
+    }
+    async getActiveMessages(sessionId, offset = 0, limit = 50) {
+        const messages = this.messages.get(sessionId) ?? [];
+        const activeMessages = messages.filter((m) => !m.isArchived);
+        return activeMessages.slice(offset, offset + limit);
+    }
+    // ========================================================================
+    // Search [new]
+    // ========================================================================
+    async searchMessages(options) {
+        const matches = [];
+        const { query, sessionId, limit = 10, beforeTime, afterTime, includeArchived = false, } = options;
+        // Determine which sessions to search
+        let sessionsToSearch;
+        if (sessionId) {
+            const session = await this.get(sessionId);
+            sessionsToSearch = session ? [session] : [];
+        }
+        else {
+            sessionsToSearch = Array.from(this.sessions.values());
+        }
+        // Parse query for simple text matching
+        const queryTerms = this.parseQuery(query);
+        // Search through each session's messages
+        for (const session of sessionsToSearch) {
+            // Time constraint on session
+            if (beforeTime && session.updatedAt > beforeTime)
+                continue;
+            if (afterTime && session.updatedAt < afterTime)
+                continue;
+            let messages = this.messages.get(session.id) ?? [];
+            // Filter archived messages if needed
+            if (!includeArchived) {
+                messages = messages.filter((m) => !m.isArchived);
+            }
+            // Search through messages
+            for (const msg of messages) {
+                // Time constraint on message
+                if (beforeTime && msg.timestamp > beforeTime)
+                    continue;
+                if (afterTime && msg.timestamp < afterTime)
+                    continue;
+                // Simple text search
+                const content = msg.content.toLowerCase();
+                let matchesQuery = true;
+                for (const term of queryTerms.required) {
+                    if (!content.includes(term.toLowerCase())) {
+                        matchesQuery = false;
+                        break;
+                    }
+                }
+                for (const term of queryTerms.excluded) {
+                    if (content.includes(term.toLowerCase())) {
+                        matchesQuery = false;
+                        break;
+                    }
+                }
+                if (matchesQuery) {
+                    matches.push({
+                        messageId: msg.id,
+                        sessionId: session.id,
+                        role: msg.role,
+                        content: msg.content,
+                        timestamp: msg.timestamp,
+                    });
+                    if (matches.length >= limit) {
+                        return matches;
+                    }
+                }
+            }
+        }
+        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.startsWith("NOT ")) {
+                excluded.push(term.replace(/^-|^NOT /i, ""));
+            }
+            else {
+                required.push(term);
+            }
+        }
+        return { required, excluded };
+    }
+    // ========================================================================
+    // Lifecycle
+    // ========================================================================
+    async close() {
+        this.sessions.clear();
+        this.messages.clear();
+        this.checkpoints.clear();
+    }
+}
+//# sourceMappingURL=memory.js.map

package/dist/core/src/env/session/storage/sqlite.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview SQLite Session Store
+ *
+ * SQLite-based implementation of SessionStore with checkpoint support.
+ * Uses Bun's built-in bun:sqlite module for persistence.
+ */
+import type { Session, CreateSessionOptions, UpdateSessionOptions, ListSessionsOptions, SessionMessage, SessionCheckpoint, GetMessagesOptions, SearchMessagesOptions, MessageMatch } from "../types";
+import type { SessionStore } from "../session-store";
+/**
+ * Get default data directory for session storage
+ */
+declare function getDefaultDataDir(): string;
+/**
+ * Get default database path for session storage
+ */
+declare function getDefaultSessionDbPath(): string;
+/**
+ * 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 declare class SQLiteSessionStore implements SessionStore {
+    private db;
+    private dbPath;
+    private initialized;
+    private sessionsCache;
+    private messagesCache;
+    private checkpointsCache;
+    private messageConverter;
+    constructor(dbPath?: string);
+    private initialize;
+    create(options: CreateSessionOptions): Promise<Session>;
+    get(id: string): Promise<Session | undefined>;
+    list(options?: ListSessionsOptions): Promise<Session[]>;
+    getCount(): Promise<number>;
+    update(id: string, updates: UpdateSessionOptions): Promise<boolean>;
+    delete(id: string): Promise<boolean>;
+    addMessage(sessionId: string, message: {
+        role: string;
+        content: string;
+        parts?: unknown[];
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    getMessages(sessionId: string, offset?: number, limit?: number, options?: GetMessagesOptions): Promise<SessionMessage[]>;
+    getMessageCount(sessionId: string, includeArchived?: boolean): Promise<number>;
+    getMessageIndexes(sessionId: string, role: string): Promise<number[]>;
+    saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void>;
+    getCheckpoints(sessionId: string): Promise<SessionCheckpoint[]>;
+    getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined>;
+    deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
+    archiveMessages(sessionId: string, checkpointId: string, beforeIndex: number): Promise<number>;
+    getActiveMessages(sessionId: string, offset?: number, limit?: number): Promise<SessionMessage[]>;
+    searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]>;
+    /**
+     * Parse simple query into terms
+     */
+    private parseQuery;
+    close(): Promise<void>;
+    private rowToSession;
+    private rowToMessage;
+}
+export { getDefaultSessionDbPath, getDefaultDataDir };
+//# sourceMappingURL=sqlite.d.ts.map