@ai-setting/roy-agent-core 1.5.15-test → 1.5.16-test

package/dist/shared/@ai-setting/roy-agent-core-d7cyjkf7.js

@@ -0,0 +1,872 @@
+import {
+  SessionMessageConverter
+} from "./roy-agent-core-jfh9q2qh.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/session/storage/memory.ts
+import { randomUUID } from "crypto";
+function generateSessionId() {
+  return `session_${randomUUID()}`;
+}
+function generateMessageId() {
+  return `msg_${randomUUID()}`;
+}
+
+class MemorySessionStore {
+  sessions = new Map;
+  messages = new Map;
+  checkpoints = new Map;
+  messageConverter = new SessionMessageConverter;
+  async create(options) {
+    const now = Date.now();
+    const session = {
+      id: options.id ?? generateSessionId(),
+      title: options.title ?? "Session",
+      directory: options.directory ?? "/tmp",
+      parentID: options.parentID,
+      createdAt: now,
+      updatedAt: now,
+      messageCount: 0,
+      metadata: {
+        ...options.metadata,
+        messageCount: 0,
+        checkpoints: { checkpoints: [] }
+      }
+    };
+    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());
+    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;
+      });
+    }
+    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);
+    }
+    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;
+    });
+    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;
+  }
+  async addMessage(sessionId, message) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const rawMessage = {
+      sessionID: sessionId,
+      role: message.role,
+      content: message.content,
+      parts: message.parts,
+      metadata: message.metadata
+    };
+    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);
+    session.messageCount = sessionMessages.filter((m) => !m.isArchived).length;
+    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) ?? [];
+    if (!options?.includeArchived) {
+      messages = messages.filter((m) => !m.isArchived);
+    }
+    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);
+        }
+      }
+    }
+    let actualOffset = offset;
+    if (offset < 0) {
+      const total = messages.length;
+      actualOffset = Math.max(0, total + offset * limit);
+    }
+    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 = [];
+    messages.filter((m) => !m.isArchived).forEach((msg, filteredIdx) => {
+      if (msg.role === role) {
+        indexes.push(filteredIdx);
+      }
+    });
+    return indexes;
+  }
+  async saveCheckpoint(sessionId, checkpoint) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const cps = this.checkpoints.get(sessionId) ?? [];
+    cps.push(checkpoint);
+    this.checkpoints.set(sessionId, cps);
+    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;
+    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;
+    cps.splice(index, 1);
+    this.checkpoints.set(sessionId, cps);
+    const messages = this.messages.get(sessionId) ?? [];
+    for (const msg of messages) {
+      if (msg.checkpointId === checkpointId) {
+        msg.isArchived = false;
+        msg.archivedAt = undefined;
+        msg.checkpointId = undefined;
+      }
+    }
+    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++;
+      }
+    }
+    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);
+  }
+  async searchMessages(options) {
+    const matches = [];
+    const {
+      query,
+      sessionId,
+      limit = 10,
+      beforeTime,
+      afterTime,
+      includeArchived = false
+    } = options;
+    let sessionsToSearch;
+    if (sessionId) {
+      const session = await this.get(sessionId);
+      sessionsToSearch = session ? [session] : [];
+    } else {
+      sessionsToSearch = Array.from(this.sessions.values());
+    }
+    const queryTerms = this.parseQuery(query);
+    for (const session of sessionsToSearch) {
+      if (beforeTime && session.updatedAt > beforeTime)
+        continue;
+      if (afterTime && session.updatedAt < afterTime)
+        continue;
+      let messages = this.messages.get(session.id) ?? [];
+      if (!includeArchived) {
+        messages = messages.filter((m) => !m.isArchived);
+      }
+      for (const msg of messages) {
+        if (beforeTime && msg.timestamp > beforeTime)
+          continue;
+        if (afterTime && msg.timestamp < afterTime)
+          continue;
+        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;
+  }
+  parseQuery(query) {
+    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 };
+  }
+  async close() {
+    this.sessions.clear();
+    this.messages.clear();
+    this.checkpoints.clear();
+  }
+}
+// src/env/session/storage/sqlite.ts
+import { join } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function getDatabaseClass() {
+  if (typeof Bun !== "undefined") {
+    const { Database } = __require("bun:sqlite");
+    return Database;
+  } else {
+    return __require("better-sqlite3");
+  }
+}
+function createCompatibleDatabase(path) {
+  const Database = getDatabaseClass();
+  const db = new Database(path);
+  if (typeof db.run !== "function") {
+    db.run = function(sql, ...params) {
+      if (params.length > 0) {
+        return this.prepare(sql).run(...params);
+      } else {
+        return this.exec(sql);
+      }
+    };
+  }
+  return db;
+}
+function generateSessionId2() {
+  return `session_${randomUUID2()}`;
+}
+function generateMessageId2() {
+  return `msg_${randomUUID2()}`;
+}
+function getDefaultDataDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share");
+}
+function getDefaultSessionDbPath() {
+  return join(getDefaultDataDir(), "roy-agent", "sessions.db");
+}
+
+class SQLiteSessionStore {
+  db = null;
+  dbPath;
+  initialized = false;
+  sessionsCache = new Map;
+  messagesCache = new Map;
+  checkpointsCache = new Map;
+  messageConverter = new SessionMessageConverter;
+  constructor(dbPath) {
+    this.dbPath = dbPath || getDefaultSessionDbPath();
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    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 = createCompatibleDatabase(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;
+  }
+  async create(options) {
+    await this.initialize();
+    const now = Date.now();
+    const session = {
+      id: options.id ?? generateSessionId2(),
+      title: options.title ?? "Session",
+      directory: options.directory ?? "/tmp",
+      parentID: options.parentID,
+      createdAt: now,
+      updatedAt: now,
+      messageCount: 0,
+      metadata: {
+        ...options.metadata,
+        messageCount: 0,
+        checkpoints: { checkpoints: [] }
+      }
+    };
+    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`);
+    }
+    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));
+    this.sessionsCache.set(session.id, session);
+    this.messagesCache.set(session.id, []);
+    this.checkpointsCache.set(session.id, []);
+    return session;
+  }
+  async get(id) {
+    await this.initialize();
+    const cached = this.sessionsCache.get(id);
+    if (cached)
+      return cached;
+    const row = this.db.prepare("SELECT * FROM session WHERE id = ?").get(id);
+    if (!row)
+      return;
+    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 = [];
+    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));
+      }
+    }
+    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 ");
+    }
+    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()}`;
+    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;
+    if (updates.title !== undefined) {
+      session.title = updates.title;
+    }
+    if (updates.metadata !== undefined) {
+      session.metadata = { ...session.metadata, ...updates.metadata };
+    }
+    session.updatedAt = Date.now();
+    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);
+    this.sessionsCache.set(id, session);
+    return true;
+  }
+  async delete(id) {
+    await this.initialize();
+    const session = await this.get(id);
+    if (!session)
+      return false;
+    this.db.prepare("DELETE FROM session WHERE id = ?").run(id);
+    this.sessionsCache.delete(id);
+    this.messagesCache.delete(id);
+    this.checkpointsCache.delete(id);
+    return true;
+  }
+  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: generateMessageId2(),
+      sessionID: sessionId,
+      role: message.role,
+      content: message.content,
+      timestamp: now,
+      parts: message.parts,
+      metadata: message.metadata
+    };
+    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);
+    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;
+    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);
+    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];
+    if (!options?.includeArchived) {
+      sql += " AND is_archived = 0";
+      countSql += " AND is_archived = 0";
+    }
+    if (options?.fromCheckpointId) {
+      sql += " AND timestamp >= (SELECT MIN(timestamp) FROM message WHERE session_id = ? AND json_extract(metadata, '$.checkpointId') = ?)";
+      params.push(sessionId, options.fromCheckpointId);
+    }
+    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);
+    }
+    if (options?.reverse) {
+      sql += " ORDER BY timestamp DESC";
+    } else {
+      sql += " ORDER BY timestamp ASC";
+    }
+    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();
+    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);
+  }
+  async saveCheckpoint(sessionId, checkpoint) {
+    await this.initialize();
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const cps = this.checkpointsCache.get(sessionId) ?? [];
+    cps.push(checkpoint);
+    this.checkpointsCache.set(sessionId, cps);
+    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;
+    if (!meta.checkpointDetails) {
+      meta.checkpointDetails = {};
+    }
+    meta.checkpointDetails[checkpoint.id] = checkpoint;
+    session.metadata = meta;
+    session.updatedAt = Date.now();
+    const stmt = this.db.prepare(`
+      UPDATE session SET metadata = ?, updated_at = ? WHERE id = ?
+    `);
+    stmt.run(JSON.stringify(session.metadata), session.updatedAt, sessionId);
+    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;
+    checkpoints.splice(index, 1);
+    this.checkpointsCache.set(sessionId, checkpoints);
+    this.db.prepare(`
+      UPDATE message SET is_archived = 0, archived_at = NULL, checkpoint_id = NULL
+      WHERE session_id = ? AND checkpoint_id = ?
+    `).run(sessionId, checkpointId);
+    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;
+    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();
+    this.db.prepare(`
+      UPDATE session SET metadata = ?, message_count = ?, updated_at = ? WHERE id = ?
+    `).run(JSON.stringify(session.metadata), session.messageCount, session.updatedAt, sessionId);
+    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();
+    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);
+    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;
+    this.db.prepare(`
+      UPDATE session SET message_count = ?, updated_at = ? WHERE id = ?
+    `).run(session.messageCount, session.updatedAt, sessionId);
+    this.sessionsCache.set(sessionId, session);
+    this.messagesCache.delete(sessionId);
+    return result.changes;
+  }
+  async getActiveMessages(sessionId, offset = 0, limit = 50) {
+    return this.getMessages(sessionId, offset, limit, { includeArchived: false });
+  }
+  async searchMessages(options) {
+    await this.initialize();
+    const matches = [];
+    const {
+      query,
+      sessionId,
+      limit = 10,
+      beforeTime,
+      afterTime,
+      includeArchived = false
+    } = options;
+    let sql = "SELECT * FROM message WHERE 1=1";
+    const params = [];
+    if (sessionId) {
+      sql += " AND session_id = ?";
+      params.push(sessionId);
+    }
+    if (!includeArchived) {
+      sql += " AND is_archived = 0";
+    }
+    if (beforeTime) {
+      sql += " AND timestamp <= ?";
+      params.push(beforeTime);
+    }
+    if (afterTime) {
+      sql += " AND timestamp >= ?";
+      params.push(afterTime);
+    }
+    sql += " ORDER BY timestamp DESC";
+    sql += " LIMIT ?";
+    params.push(limit * 10);
+    const rows = this.db.prepare(sql).all(...params);
+    const queryTerms = this.parseQuery(query);
+    const lowerQuery = query.toLowerCase();
+    for (const row of rows) {
+      const content = row.content.toLowerCase();
+      let matchesQuery = true;
+      for (const term of queryTerms.excluded) {
+        if (content.includes(term.toLowerCase())) {
+          matchesQuery = false;
+          break;
+        }
+      }
+      if (matchesQuery && queryTerms.required.length > 0) {
+        for (const term of queryTerms.required) {
+          if (!content.includes(term.toLowerCase())) {
+            matchesQuery = false;
+            break;
+          }
+        }
+      }
+      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;
+  }
+  parseQuery(query) {
+    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 };
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.sessionsCache.clear();
+    this.messagesCache.clear();
+    this.checkpointsCache.clear();
+    this.initialized = false;
+  }
+  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) {
+    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
+    };
+    return this.messageConverter.migrateMessage(rawMessage);
+  }
+}
+export { MemorySessionStore, getDefaultDataDir, getDefaultSessionDbPath, SQLiteSessionStore };