@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

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

@@ -1,404 +0,0 @@
-/**
- * @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

@@ -1,64 +0,0 @@
-/**
- * @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