agent-inbox 0.0.1 → 0.1.1

package/src/storage/sqlite.ts

@@ -0,0 +1,645 @@
+import Database from "better-sqlite3";
+import type {
+  Agent,
+  Message,
+  Conversation,
+  Turn,
+  Thread,
+  Recipient,
+  MessageContent,
+  Participant,
+} from "../types.js";
+import type { Storage, InboxQuery, ThreadQuery } from "./interface.js";
+
+export interface SqliteStorageOptions {
+  path: string; // ":memory:" for in-memory, or file path
+}
+
+export class SqliteStorage implements Storage {
+  private db: Database.Database;
+
+  constructor(opts: SqliteStorageOptions) {
+    this.db = new Database(opts.path);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.migrate();
+  }
+
+  private migrate(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agents (
+        agent_id TEXT PRIMARY KEY,
+        display_name TEXT,
+        program TEXT,
+        model TEXT,
+        scope TEXT NOT NULL DEFAULT 'default',
+        status TEXT NOT NULL DEFAULT 'active',
+        metadata TEXT NOT NULL DEFAULT '{}',
+        registered_at TEXT NOT NULL,
+        last_active_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        scope TEXT NOT NULL DEFAULT 'default',
+        sender_id TEXT NOT NULL,
+        subject TEXT,
+        content TEXT NOT NULL,
+        thread_tag TEXT,
+        in_reply_to TEXT,
+        conversation_id TEXT,
+        importance TEXT NOT NULL DEFAULT 'normal',
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS recipients (
+        message_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'to',
+        delivered_at TEXT,
+        read_at TEXT,
+        ack_at TEXT,
+        PRIMARY KEY (message_id, agent_id),
+        FOREIGN KEY (message_id) REFERENCES messages(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS conversations (
+        id TEXT PRIMARY KEY,
+        scope TEXT NOT NULL DEFAULT 'default',
+        subject TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS participants (
+        conversation_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        role TEXT,
+        joined_at TEXT NOT NULL,
+        PRIMARY KEY (conversation_id, agent_id),
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS turns (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        participant_id TEXT NOT NULL,
+        source_message_id TEXT,
+        content_type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        thread_id TEXT,
+        in_reply_to TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS threads (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        root_turn_id TEXT NOT NULL,
+        parent_thread_id TEXT,
+        subject TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+      );
+
+      -- Indexes for common queries
+      CREATE INDEX IF NOT EXISTS idx_messages_scope ON messages(scope);
+      CREATE INDEX IF NOT EXISTS idx_messages_sender ON messages(sender_id);
+      CREATE INDEX IF NOT EXISTS idx_messages_thread_tag ON messages(thread_tag, scope);
+      CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id);
+      CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at);
+      CREATE INDEX IF NOT EXISTS idx_recipients_agent ON recipients(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_turns_conversation ON turns(conversation_id);
+      CREATE INDEX IF NOT EXISTS idx_agents_scope ON agents(scope);
+
+      -- FTS5 virtual table for full-text search
+      CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+        id UNINDEXED,
+        subject,
+        text_content,
+        content='messages',
+        content_rowid='rowid'
+      );
+
+      -- Triggers to keep FTS in sync
+      CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+        INSERT INTO messages_fts(rowid, id, subject, text_content)
+        VALUES (NEW.rowid, NEW.id, NEW.subject,
+          CASE WHEN json_extract(NEW.content, '$.type') = 'text'
+               THEN json_extract(NEW.content, '$.text')
+               ELSE '' END);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+        INSERT INTO messages_fts(messages_fts, rowid, id, subject, text_content)
+        VALUES ('delete', OLD.rowid, OLD.id, OLD.subject,
+          CASE WHEN json_extract(OLD.content, '$.type') = 'text'
+               THEN json_extract(OLD.content, '$.text')
+               ELSE '' END);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN
+        INSERT INTO messages_fts(messages_fts, rowid, id, subject, text_content)
+        VALUES ('delete', OLD.rowid, OLD.id, OLD.subject,
+          CASE WHEN json_extract(OLD.content, '$.type') = 'text'
+               THEN json_extract(OLD.content, '$.text')
+               ELSE '' END);
+        INSERT INTO messages_fts(rowid, id, subject, text_content)
+        VALUES (NEW.rowid, NEW.id, NEW.subject,
+          CASE WHEN json_extract(NEW.content, '$.type') = 'text'
+               THEN json_extract(NEW.content, '$.text')
+               ELSE '' END);
+      END;
+    `);
+  }
+
+  // --- Agents ---
+
+  getAgent(agentId: string): Agent | undefined {
+    const row = this.db
+      .prepare("SELECT * FROM agents WHERE agent_id = ?")
+      .get(agentId) as AgentRow | undefined;
+    return row ? rowToAgent(row) : undefined;
+  }
+
+  putAgent(agent: Agent): void {
+    this.db
+      .prepare(
+        `INSERT OR REPLACE INTO agents
+         (agent_id, display_name, program, model, scope, status, metadata, registered_at, last_active_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        agent.agent_id,
+        agent.display_name ?? null,
+        agent.program ?? null,
+        agent.model ?? null,
+        agent.scope,
+        agent.status,
+        JSON.stringify(agent.metadata),
+        agent.registered_at,
+        agent.last_active_at
+      );
+  }
+
+  listAgents(scope?: string): Agent[] {
+    if (scope) {
+      return (
+        this.db.prepare("SELECT * FROM agents WHERE scope = ?").all(scope) as AgentRow[]
+      ).map(rowToAgent);
+    }
+    return (this.db.prepare("SELECT * FROM agents").all() as AgentRow[]).map(rowToAgent);
+  }
+
+  removeAgent(agentId: string): boolean {
+    const result = this.db
+      .prepare("DELETE FROM agents WHERE agent_id = ?")
+      .run(agentId);
+    return result.changes > 0;
+  }
+
+  // --- Messages ---
+
+  getMessage(id: string): Message | undefined {
+    const row = this.db
+      .prepare("SELECT * FROM messages WHERE id = ?")
+      .get(id) as MessageRow | undefined;
+    if (!row) return undefined;
+    return this.rowToMessage(row);
+  }
+
+  putMessage(message: Message): Message {
+    const upsertMsg = this.db.prepare(
+      `INSERT OR REPLACE INTO messages
+       (id, scope, sender_id, subject, content, thread_tag, in_reply_to, conversation_id, importance, metadata, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const upsertRecipient = this.db.prepare(
+      `INSERT OR REPLACE INTO recipients
+       (message_id, agent_id, kind, delivered_at, read_at, ack_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    );
+
+    this.db.transaction(() => {
+      upsertMsg.run(
+        message.id,
+        message.scope,
+        message.sender_id,
+        message.subject ?? null,
+        JSON.stringify(message.content),
+        message.thread_tag ?? null,
+        message.in_reply_to ?? null,
+        message.conversation_id ?? null,
+        message.importance,
+        JSON.stringify(message.metadata),
+        message.created_at
+      );
+      // Delete old recipients and re-insert
+      this.db
+        .prepare("DELETE FROM recipients WHERE message_id = ?")
+        .run(message.id);
+      for (const r of message.recipients) {
+        upsertRecipient.run(
+          message.id,
+          r.agent_id,
+          r.kind,
+          r.delivered_at ?? null,
+          r.read_at ?? null,
+          r.ack_at ?? null
+        );
+      }
+    })();
+
+    return message;
+  }
+
+  getInbox(agentId: string, opts?: InboxQuery): Message[] {
+    let sql = `
+      SELECT m.* FROM messages m
+      JOIN recipients r ON r.message_id = m.id
+      WHERE r.agent_id = ?
+    `;
+    const params: unknown[] = [agentId];
+
+    if (opts?.unreadOnly) {
+      sql += " AND r.read_at IS NULL";
+    }
+    if (opts?.since) {
+      sql += " AND m.created_at >= ?";
+      params.push(opts.since);
+    }
+    sql += " ORDER BY m.created_at ASC";
+    if (opts?.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+
+    const rows = this.db.prepare(sql).all(...params) as MessageRow[];
+    return rows.map((row) => this.rowToMessage(row));
+  }
+
+  getThread(query: ThreadQuery): Message[] {
+    const rows = this.db
+      .prepare(
+        "SELECT * FROM messages WHERE thread_tag = ? AND scope = ? ORDER BY created_at ASC"
+      )
+      .all(query.threadTag, query.scope) as MessageRow[];
+    return rows.map((row) => this.rowToMessage(row));
+  }
+
+  getSentMessages(agentId: string, limit?: number): Message[] {
+    let sql = "SELECT * FROM messages WHERE sender_id = ? ORDER BY created_at ASC";
+    const params: unknown[] = [agentId];
+    if (limit) {
+      sql += " LIMIT ?";
+      params.push(limit);
+    }
+    const rows = this.db.prepare(sql).all(...params) as MessageRow[];
+    return rows.map((row) => this.rowToMessage(row));
+  }
+
+  searchMessages(query: string, scope?: string): Message[] {
+    let sql: string;
+    let params: unknown[];
+
+    if (scope) {
+      sql = `
+        SELECT m.* FROM messages m
+        JOIN messages_fts fts ON fts.id = m.id
+        WHERE messages_fts MATCH ? AND m.scope = ?
+        ORDER BY m.created_at ASC
+      `;
+      params = [query, scope];
+    } else {
+      sql = `
+        SELECT m.* FROM messages m
+        JOIN messages_fts fts ON fts.id = m.id
+        WHERE messages_fts MATCH ?
+        ORDER BY m.created_at ASC
+      `;
+      params = [query];
+    }
+
+    try {
+      const rows = this.db.prepare(sql).all(...params) as MessageRow[];
+      return rows.map((row) => this.rowToMessage(row));
+    } catch {
+      // FTS query syntax error — fall back to LIKE
+      return this.searchMessagesLike(query, scope);
+    }
+  }
+
+  private searchMessagesLike(query: string, scope?: string): Message[] {
+    const pattern = `%${query}%`;
+    let sql = `
+      SELECT * FROM messages
+      WHERE (subject LIKE ? OR content LIKE ?)
+    `;
+    const params: unknown[] = [pattern, pattern];
+    if (scope) {
+      sql += " AND scope = ?";
+      params.push(scope);
+    }
+    sql += " ORDER BY created_at ASC";
+    const rows = this.db.prepare(sql).all(...params) as MessageRow[];
+    return rows.map((row) => this.rowToMessage(row));
+  }
+
+  // --- Conversations ---
+
+  getConversation(id: string): Conversation | undefined {
+    const row = this.db
+      .prepare("SELECT * FROM conversations WHERE id = ?")
+      .get(id) as ConversationRow | undefined;
+    if (!row) return undefined;
+    return this.rowToConversation(row);
+  }
+
+  putConversation(conversation: Conversation): Conversation {
+    this.db.transaction(() => {
+      this.db
+        .prepare(
+          `INSERT OR REPLACE INTO conversations
+           (id, scope, subject, status, metadata, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(
+          conversation.id,
+          conversation.scope,
+          conversation.subject ?? null,
+          conversation.status,
+          JSON.stringify(conversation.metadata),
+          conversation.created_at,
+          conversation.updated_at
+        );
+      // Re-sync participants
+      this.db
+        .prepare("DELETE FROM participants WHERE conversation_id = ?")
+        .run(conversation.id);
+      const insertP = this.db.prepare(
+        `INSERT INTO participants (conversation_id, agent_id, role, joined_at) VALUES (?, ?, ?, ?)`
+      );
+      for (const p of conversation.participants) {
+        insertP.run(conversation.id, p.agent_id, p.role ?? null, p.joined_at);
+      }
+    })();
+    return conversation;
+  }
+
+  listConversations(scope?: string): Conversation[] {
+    let rows: ConversationRow[];
+    if (scope) {
+      rows = this.db
+        .prepare("SELECT * FROM conversations WHERE scope = ? ORDER BY updated_at DESC")
+        .all(scope) as ConversationRow[];
+    } else {
+      rows = this.db
+        .prepare("SELECT * FROM conversations ORDER BY updated_at DESC")
+        .all() as ConversationRow[];
+    }
+    return rows.map((row) => this.rowToConversation(row));
+  }
+
+  // --- Turns ---
+
+  addTurn(turn: Turn): void {
+    this.db
+      .prepare(
+        `INSERT INTO turns
+         (id, conversation_id, participant_id, source_message_id, content_type, content, thread_id, in_reply_to, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        turn.id,
+        turn.conversation_id,
+        turn.participant_id,
+        turn.source_message_id ?? null,
+        turn.content_type,
+        JSON.stringify(turn.content),
+        turn.thread_id ?? null,
+        turn.in_reply_to ?? null,
+        turn.created_at
+      );
+  }
+
+  getTurns(conversationId: string): Turn[] {
+    const rows = this.db
+      .prepare(
+        "SELECT * FROM turns WHERE conversation_id = ? ORDER BY created_at ASC"
+      )
+      .all(conversationId) as TurnRow[];
+    return rows.map(rowToTurn);
+  }
+
+  // --- Threads ---
+
+  getThread2(id: string): Thread | undefined {
+    const row = this.db
+      .prepare("SELECT * FROM threads WHERE id = ?")
+      .get(id) as ThreadRow | undefined;
+    return row ? rowToThread(row) : undefined;
+  }
+
+  putThread(thread: Thread): Thread {
+    this.db
+      .prepare(
+        `INSERT OR REPLACE INTO threads
+         (id, conversation_id, root_turn_id, parent_thread_id, subject, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        thread.id,
+        thread.conversation_id,
+        thread.root_turn_id,
+        thread.parent_thread_id ?? null,
+        thread.subject ?? null,
+        thread.created_at
+      );
+    return thread;
+  }
+
+  getThreadsByConversation(conversationId: string): Thread[] {
+    const rows = this.db
+      .prepare("SELECT * FROM threads WHERE conversation_id = ?")
+      .all(conversationId) as ThreadRow[];
+    return rows.map(rowToThread);
+  }
+
+  // --- Helpers ---
+
+  private getRecipients(messageId: string): Recipient[] {
+    const rows = this.db
+      .prepare("SELECT * FROM recipients WHERE message_id = ?")
+      .all(messageId) as RecipientRow[];
+    return rows.map((r) => ({
+      agent_id: r.agent_id,
+      kind: r.kind as Recipient["kind"],
+      delivered_at: r.delivered_at ?? undefined,
+      read_at: r.read_at ?? undefined,
+      ack_at: r.ack_at ?? undefined,
+    }));
+  }
+
+  private getParticipants(conversationId: string): Participant[] {
+    const rows = this.db
+      .prepare("SELECT * FROM participants WHERE conversation_id = ?")
+      .all(conversationId) as ParticipantRow[];
+    return rows.map((r) => ({
+      agent_id: r.agent_id,
+      role: r.role ?? undefined,
+      joined_at: r.joined_at,
+    }));
+  }
+
+  private rowToMessage(row: MessageRow): Message {
+    return {
+      id: row.id,
+      scope: row.scope,
+      sender_id: row.sender_id,
+      recipients: this.getRecipients(row.id),
+      subject: row.subject ?? undefined,
+      content: JSON.parse(row.content) as MessageContent,
+      thread_tag: row.thread_tag ?? undefined,
+      in_reply_to: row.in_reply_to ?? undefined,
+      conversation_id: row.conversation_id ?? undefined,
+      importance: row.importance as Message["importance"],
+      metadata: JSON.parse(row.metadata),
+      created_at: row.created_at,
+    };
+  }
+
+  private rowToConversation(row: ConversationRow): Conversation {
+    return {
+      id: row.id,
+      scope: row.scope,
+      subject: row.subject ?? undefined,
+      status: row.status as Conversation["status"],
+      participants: this.getParticipants(row.id),
+      metadata: JSON.parse(row.metadata),
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+    };
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}
+
+// --- Row types ---
+
+interface AgentRow {
+  agent_id: string;
+  display_name: string | null;
+  program: string | null;
+  model: string | null;
+  scope: string;
+  status: string;
+  metadata: string;
+  registered_at: string;
+  last_active_at: string;
+}
+
+interface MessageRow {
+  id: string;
+  scope: string;
+  sender_id: string;
+  subject: string | null;
+  content: string;
+  thread_tag: string | null;
+  in_reply_to: string | null;
+  conversation_id: string | null;
+  importance: string;
+  metadata: string;
+  created_at: string;
+}
+
+interface RecipientRow {
+  message_id: string;
+  agent_id: string;
+  kind: string;
+  delivered_at: string | null;
+  read_at: string | null;
+  ack_at: string | null;
+}
+
+interface ConversationRow {
+  id: string;
+  scope: string;
+  subject: string | null;
+  status: string;
+  metadata: string;
+  created_at: string;
+  updated_at: string;
+}
+
+interface ParticipantRow {
+  conversation_id: string;
+  agent_id: string;
+  role: string | null;
+  joined_at: string;
+}
+
+interface TurnRow {
+  id: string;
+  conversation_id: string;
+  participant_id: string;
+  source_message_id: string | null;
+  content_type: string;
+  content: string;
+  thread_id: string | null;
+  in_reply_to: string | null;
+  created_at: string;
+}
+
+interface ThreadRow {
+  id: string;
+  conversation_id: string;
+  root_turn_id: string;
+  parent_thread_id: string | null;
+  subject: string | null;
+  created_at: string;
+}
+
+function rowToAgent(row: AgentRow): Agent {
+  return {
+    agent_id: row.agent_id,
+    display_name: row.display_name ?? undefined,
+    program: row.program ?? undefined,
+    model: row.model ?? undefined,
+    scope: row.scope,
+    status: row.status as Agent["status"],
+    metadata: JSON.parse(row.metadata),
+    registered_at: row.registered_at,
+    last_active_at: row.last_active_at,
+  };
+}
+
+function rowToTurn(row: TurnRow): Turn {
+  return {
+    id: row.id,
+    conversation_id: row.conversation_id,
+    participant_id: row.participant_id,
+    source_message_id: row.source_message_id ?? undefined,
+    content_type: row.content_type,
+    content: JSON.parse(row.content) as MessageContent,
+    thread_id: row.thread_id ?? undefined,
+    in_reply_to: row.in_reply_to ?? undefined,
+    created_at: row.created_at,
+  };
+}
+
+function rowToThread(row: ThreadRow): Thread {
+  return {
+    id: row.id,
+    conversation_id: row.conversation_id,
+    root_turn_id: row.root_turn_id,
+    parent_thread_id: row.parent_thread_id ?? undefined,
+    subject: row.subject ?? undefined,
+    created_at: row.created_at,
+  };
+}