@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/session/storage/sqlite.ts

@@ -1,794 +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 { join } from "path";
-import { randomUUID } from "crypto";
-import type {
-  Session,
-  CreateSessionOptions,
-  UpdateSessionOptions,
-  ListSessionsOptions,
-  SessionMessage,
-  SessionCheckpoint,
-  GetMessagesOptions,
-  SessionCheckpointsMeta,
-  SessionMetadata,
-  SearchMessagesOptions,
-  MessageMatch,
-} from "../types";
-import type { SessionStore } from "../session-store";
-import { SessionMessageConverter } from "../session-message-converter";
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/**
- * Generate a unique session ID using crypto UUID
- */
-function generateSessionId(): string {
-  return `session_${randomUUID()}`;
-}
-
-/**
- * Generate a unique message ID using crypto UUID
- */
-function generateMessageId(): string {
-  return `msg_${randomUUID()}`;
-}
-
-/**
- * Get default data directory for session storage
- */
-function getDefaultDataDir(): string {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  return join(home, ".local", "share");
-}
-
-/**
- * Get default database path for session storage
- */
-function getDefaultSessionDbPath(): string {
-  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 implements SessionStore {
-  private db: any = null;
-  private dbPath: string;
-  private initialized = false;
-
-  // In-memory cache for performance
-  private sessionsCache = new Map<string, Session>();
-  private messagesCache = new Map<string, SessionMessage[]>();
-  private checkpointsCache = new Map<string, SessionCheckpoint[]>();
-  private messageConverter = new SessionMessageConverter();
-
-  constructor(dbPath?: string) {
-    this.dbPath = dbPath || getDefaultSessionDbPath();
-  }
-
-  // ========================================================================
-  // Initialization
-  // ========================================================================
-
-  private async initialize(): Promise<void> {
-    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: CreateSessionOptions): Promise<Session> {
-    await this.initialize();
-
-    const now = Date.now();
-    const session: 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: [] },
-      } as SessionMetadata,
-    };
-
-    // 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: string): Promise<Session | undefined> {
-    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?: ListSessionsOptions): Promise<Session[]> {
-    await this.initialize();
-
-    let sql = "SELECT * FROM session";
-    const params: any[] = [];
-    const conditions: string[] = [];
-
-    // 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: any) => this.rowToSession(row));
-  }
-
-  async getCount(): Promise<number> {
-    await this.initialize();
-    const result = this.db.prepare("SELECT COUNT(*) as count FROM session").get() as { count: number };
-    return result.count;
-  }
-
-  async update(id: string, updates: UpdateSessionOptions): Promise<boolean> {
-    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 } as SessionMetadata;
-    }
-    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: string): Promise<boolean> {
-    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: string,
-    message: { role: string; content: string; parts?: unknown[]; metadata?: Record<string, unknown> }
-  ): Promise<string> {
-    await this.initialize();
-
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-
-    const now = Date.now();
-    const msg: SessionMessage = {
-      id: generateMessageId(),
-      sessionID: sessionId,
-      role: message.role as SessionMessage["role"],
-      content: message.content,
-      timestamp: now,
-      parts: message.parts as SessionMessage["parts"],
-      metadata: message.metadata as SessionMessage["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
-    } as SessionMetadata;
-    
-    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: string,
-    offset = 0,
-    limit = 50,
-    options?: GetMessagesOptions
-  ): Promise<SessionMessage[]> {
-    await this.initialize();
-
-    let sql = "SELECT * FROM message WHERE session_id = ?";
-    let countSql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
-    const params: any[] = [sessionId];
-    const countParams: any[] = [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: any) => this.rowToMessage(row));
-  }
-
-  async getMessageCount(sessionId: string, includeArchived = false): Promise<number> {
-    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: string, role: string): Promise<number[]> {
-    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) as { idx: number }[];
-    return rows.map(row => row.idx);
-  }
-
-  // ========================================================================
-  // Checkpoint Management
-  // ========================================================================
-
-  async saveCheckpoint(sessionId: string, checkpoint: SessionCheckpoint): Promise<void> {
-    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 as Record<string, unknown> || {};
-    const checkpointsMeta: SessionCheckpointsMeta = (meta.checkpoints as SessionCheckpointsMeta) || { 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 as Record<string, SessionCheckpoint>)[checkpoint.id] = checkpoint;
-    
-    session.metadata = meta as SessionMetadata;
-    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: string): Promise<SessionCheckpoint[]> {
-    await this.initialize();
-
-    const session = await this.get(sessionId);
-    if (!session) return [];
-
-    const meta = session.metadata as Record<string, unknown>;
-    const checkpointDetails = meta?.checkpointDetails as Record<string, SessionCheckpoint>;
-    if (!checkpointDetails) return [];
-
-    return Object.values(checkpointDetails);
-  }
-
-  async getCheckpoint(sessionId: string, checkpointId: string): Promise<SessionCheckpoint | undefined> {
-    await this.initialize();
-
-    const checkpoints = await this.getCheckpoints(sessionId);
-    return checkpoints.find((cp) => cp.id === checkpointId);
-  }
-
-  async deleteCheckpoint(sessionId: string, checkpointId: string): Promise<boolean> {
-    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 as Record<string, unknown> || {};
-    const checkpointsMeta: SessionCheckpointsMeta = (meta.checkpoints as SessionCheckpointsMeta) || { checkpoints: [] };
-    checkpointsMeta.checkpoints = checkpointsMeta.checkpoints.filter((cp) => cp.id !== checkpointId);
-    checkpointsMeta.latestCheckpointId = checkpoints[checkpoints.length - 1]?.id;
-    
-    if (meta.checkpointDetails) {
-      delete (meta.checkpointDetails as Record<string, SessionCheckpoint>)[checkpointId];
-    }
-    
-    session.metadata = meta as SessionMetadata;
-
-    // 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: string, checkpointId: string, beforeIndex: number): Promise<number> {
-    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: string, offset = 0, limit = 50): Promise<SessionMessage[]> {
-    return this.getMessages(sessionId, offset, limit, { includeArchived: false });
-  }
-
-  // ========================================================================
-  // Search [new]
-  // ========================================================================
-
-  async searchMessages(options: SearchMessagesOptions): Promise<MessageMatch[]> {
-    await this.initialize();
-    
-    const matches: MessageMatch[] = [];
-    const {
-      query,
-      sessionId,
-      limit = 10,
-      beforeTime,
-      afterTime,
-      includeArchived = false,
-    } = options;
-
-    // Build SQL query
-    let sql = "SELECT * FROM message WHERE 1=1";
-    const params: any[] = [];
-
-    // 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 as string).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 as MessageMatch["role"],
-          content: row.content,
-          timestamp: row.timestamp,
-        });
-
-        if (matches.length >= limit) break;
-      }
-    }
-
-    return matches;
-  }
-
-  /**
-   * Parse simple query into terms
-   */
-  private parseQuery(query: string): { required: string[]; excluded: string[] } {
-    // Remove quoted phrases (simplified)
-    const terms = query.split(/\s+/).filter((t) => !t.startsWith('"') && !t.endsWith('"'));
-    
-    const required: string[] = [];
-    const excluded: string[] = [];
-    
-    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(): Promise<void> {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-    this.sessionsCache.clear();
-    this.messagesCache.clear();
-    this.checkpointsCache.clear();
-    this.initialized = false;
-  }
-
-  // ========================================================================
-  // Row Conversions
-  // ========================================================================
-
-  private rowToSession(row: any): Session {
-    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,
-    };
-  }
-
-  private rowToMessage(row: any): SessionMessage {
-    // Parse the raw message from database
-    const rawMessage: Partial<SessionMessage> = {
-      id: row.id,
-      sessionID: row.session_id,
-      role: row.role as SessionMessage["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 };