claude-code-swarm 0.3.4 → 0.3.6

package/references/openhive/src/db/providers/sqlite.ts

@@ -0,0 +1,1383 @@
+/**
+ * SQLite Database Provider
+ *
+ * Wraps the existing DAL functions to implement the DatabaseProvider interface.
+ * Uses better-sqlite3 for synchronous SQLite access.
+ */
+
+import Database from 'better-sqlite3';
+import { nanoid } from 'nanoid';
+import bcrypt from 'bcrypt';
+import * as path from 'path';
+import * as fs from 'fs';
+import type {
+  DatabaseProvider,
+  SQLiteProviderConfig,
+  AgentRepository,
+  PostRepository,
+  CommentRepository,
+  HiveRepository,
+  VoteRepository,
+  FollowRepository,
+  InviteRepository,
+  UploadRepository,
+  InstanceRepository,
+  SearchRepository,
+  CreateAgentInput,
+  CreateHumanInput,
+  UpdateAgentInput,
+  CreatePostInput,
+  UpdatePostInput,
+  ListPostsOptions,
+  CreateCommentInput,
+  UpdateCommentInput,
+  ListCommentsOptions,
+  CreateHiveInput,
+  UpdateHiveInput,
+  CastVoteInput,
+  CreateInviteInput,
+  CreateUploadInput,
+  Upload,
+  CreateInstanceInput,
+  SearchOptions,
+  SearchResults,
+} from './types.js';
+import type { Agent, AgentPublic, Post, PostWithAuthor, Comment, CommentWithAuthor, Hive, Vote, Follow, InviteCode, FederatedInstance } from '../../types.js';
+
+const SALT_ROUNDS = 10;
+
+// Schema and migrations
+const CREATE_TABLES = `
+  CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT UNIQUE NOT NULL,
+    api_key_hash TEXT,
+    description TEXT,
+    avatar_url TEXT,
+    karma INTEGER DEFAULT 0,
+    is_verified INTEGER DEFAULT 0,
+    is_admin INTEGER DEFAULT 0,
+    metadata TEXT,
+    verification_status TEXT DEFAULT 'pending',
+    verification_data TEXT,
+    account_type TEXT DEFAULT 'agent',
+    email TEXT UNIQUE,
+    password_hash TEXT,
+    email_verified INTEGER DEFAULT 0,
+    password_reset_token TEXT,
+    password_reset_expires TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    last_seen_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS hives (
+    id TEXT PRIMARY KEY,
+    name TEXT UNIQUE NOT NULL,
+    description TEXT,
+    owner_id TEXT NOT NULL REFERENCES agents(id),
+    is_public INTEGER DEFAULT 1,
+    settings TEXT,
+    member_count INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS posts (
+    id TEXT PRIMARY KEY,
+    hive_id TEXT NOT NULL REFERENCES hives(id) ON DELETE CASCADE,
+    author_id TEXT NOT NULL REFERENCES agents(id),
+    title TEXT NOT NULL,
+    content TEXT,
+    url TEXT,
+    score INTEGER DEFAULT 0,
+    comment_count INTEGER DEFAULT 0,
+    is_pinned INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS comments (
+    id TEXT PRIMARY KEY,
+    post_id TEXT NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
+    parent_id TEXT REFERENCES comments(id),
+    author_id TEXT NOT NULL REFERENCES agents(id),
+    content TEXT NOT NULL,
+    score INTEGER DEFAULT 0,
+    depth INTEGER DEFAULT 0,
+    path TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS votes (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL REFERENCES agents(id),
+    target_type TEXT NOT NULL CHECK (target_type IN ('post', 'comment')),
+    target_id TEXT NOT NULL,
+    value INTEGER NOT NULL CHECK (value IN (-1, 1)),
+    created_at TEXT DEFAULT (datetime('now')),
+    UNIQUE(agent_id, target_type, target_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS memberships (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL REFERENCES agents(id),
+    hive_id TEXT NOT NULL REFERENCES hives(id) ON DELETE CASCADE,
+    role TEXT DEFAULT 'member' CHECK (role IN ('member', 'moderator', 'owner')),
+    joined_at TEXT DEFAULT (datetime('now')),
+    UNIQUE(agent_id, hive_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS follows (
+    id TEXT PRIMARY KEY,
+    follower_id TEXT NOT NULL REFERENCES agents(id),
+    following_id TEXT NOT NULL REFERENCES agents(id),
+    created_at TEXT DEFAULT (datetime('now')),
+    UNIQUE(follower_id, following_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS invite_codes (
+    id TEXT PRIMARY KEY,
+    code TEXT UNIQUE NOT NULL,
+    created_by TEXT REFERENCES agents(id),
+    used_by TEXT REFERENCES agents(id),
+    uses_left INTEGER DEFAULT 1,
+    expires_at TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS uploads (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL REFERENCES agents(id),
+    filename TEXT NOT NULL,
+    mime_type TEXT NOT NULL,
+    size INTEGER NOT NULL,
+    storage_key TEXT UNIQUE NOT NULL,
+    purpose TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS federated_instances (
+    id TEXT PRIMARY KEY,
+    url TEXT UNIQUE NOT NULL,
+    name TEXT NOT NULL,
+    public_key TEXT,
+    status TEXT DEFAULT 'pending',
+    is_trusted INTEGER DEFAULT 0,
+    agent_count INTEGER DEFAULT 0,
+    post_count INTEGER DEFAULT 0,
+    last_sync TEXT,
+    last_error TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  );
+
+  -- Indexes
+  CREATE INDEX IF NOT EXISTS idx_posts_hive ON posts(hive_id);
+  CREATE INDEX IF NOT EXISTS idx_posts_author ON posts(author_id);
+  CREATE INDEX IF NOT EXISTS idx_posts_created ON posts(created_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_comments_post ON comments(post_id);
+  CREATE INDEX IF NOT EXISTS idx_comments_path ON comments(path);
+  CREATE INDEX IF NOT EXISTS idx_votes_target ON votes(target_type, target_id);
+  CREATE INDEX IF NOT EXISTS idx_memberships_hive ON memberships(hive_id);
+  CREATE INDEX IF NOT EXISTS idx_memberships_agent ON memberships(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_follows_follower ON follows(follower_id);
+  CREATE INDEX IF NOT EXISTS idx_follows_following ON follows(following_id);
+  CREATE INDEX IF NOT EXISTS idx_uploads_agent ON uploads(agent_id);
+`;
+
+const CREATE_FTS = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS posts_fts USING fts5(title, content, content=posts, content_rowid=rowid);
+  CREATE VIRTUAL TABLE IF NOT EXISTS comments_fts USING fts5(content, content=comments, content_rowid=rowid);
+  CREATE VIRTUAL TABLE IF NOT EXISTS agents_fts USING fts5(name, description, content=agents, content_rowid=rowid);
+  CREATE VIRTUAL TABLE IF NOT EXISTS hives_fts USING fts5(name, description, content=hives, content_rowid=rowid);
+
+  -- Triggers to keep FTS in sync
+  CREATE TRIGGER IF NOT EXISTS posts_ai AFTER INSERT ON posts BEGIN
+    INSERT INTO posts_fts(rowid, title, content) VALUES (NEW.rowid, NEW.title, NEW.content);
+  END;
+  CREATE TRIGGER IF NOT EXISTS posts_ad AFTER DELETE ON posts BEGIN
+    INSERT INTO posts_fts(posts_fts, rowid, title, content) VALUES('delete', OLD.rowid, OLD.title, OLD.content);
+  END;
+  CREATE TRIGGER IF NOT EXISTS posts_au AFTER UPDATE ON posts BEGIN
+    INSERT INTO posts_fts(posts_fts, rowid, title, content) VALUES('delete', OLD.rowid, OLD.title, OLD.content);
+    INSERT INTO posts_fts(rowid, title, content) VALUES (NEW.rowid, NEW.title, NEW.content);
+  END;
+`;
+
+// Helper functions
+function rowToAgent(row: Record<string, unknown>): Agent {
+  return {
+    ...row,
+    is_verified: Boolean(row.is_verified),
+    is_admin: Boolean(row.is_admin),
+    email_verified: Boolean(row.email_verified),
+    account_type: (row.account_type as string) || 'agent',
+    metadata: row.metadata ? JSON.parse(row.metadata as string) : null,
+    verification_data: row.verification_data ? JSON.parse(row.verification_data as string) : null,
+  } as Agent;
+}
+
+function toPublicAgent(agent: Agent): AgentPublic {
+  return {
+    id: agent.id,
+    name: agent.name,
+    description: agent.description,
+    avatar_url: agent.avatar_url,
+    karma: agent.karma,
+    is_verified: agent.is_verified,
+    created_at: agent.created_at,
+    account_type: agent.account_type || 'agent',
+  };
+}
+
+// SQLite Provider Implementation
+export class SQLiteProvider implements DatabaseProvider {
+  readonly type = 'sqlite' as const;
+  private db: Database.Database;
+
+  agents: AgentRepository;
+  posts: PostRepository;
+  comments: CommentRepository;
+  hives: HiveRepository;
+  votes: VoteRepository;
+  follows: FollowRepository;
+  invites: InviteRepository;
+  uploads: UploadRepository;
+  instances: InstanceRepository;
+  search: SearchRepository;
+
+  // Sync repositories — stubs until sync layer is migrated to Provider pattern (NEW-11)
+  syncGroups: any = null;
+  syncPeers: any = null;
+  syncEvents: any = null;
+  syncPeerConfigs: any = null;
+
+  constructor(private config: SQLiteProviderConfig) {
+    // Ensure directory exists
+    const dbPath = path.resolve(config.path);
+    const dbDir = path.dirname(dbPath);
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('foreign_keys = ON');
+
+    // Initialize repositories
+    this.agents = this.createAgentRepository();
+    this.posts = this.createPostRepository();
+    this.comments = this.createCommentRepository();
+    this.hives = this.createHiveRepository();
+    this.votes = this.createVoteRepository();
+    this.follows = this.createFollowRepository();
+    this.invites = this.createInviteRepository();
+    this.uploads = this.createUploadRepository();
+    this.instances = this.createInstanceRepository();
+    this.search = this.createSearchRepository();
+  }
+
+  async initialize(): Promise<void> {
+    this.db.exec(CREATE_TABLES);
+    await this.migrate();
+  }
+
+  async close(): Promise<void> {
+    this.db.close();
+  }
+
+  async transaction<T>(fn: () => Promise<T>): Promise<T> {
+    const txn = this.db.transaction(async () => {
+      return await fn();
+    });
+    return txn() as T;
+  }
+
+  async migrate(): Promise<void> {
+    const version = await this.getSchemaVersion();
+
+    if (version === 0) {
+      // Fresh install
+      this.db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(6);
+      this.db.exec(CREATE_FTS);
+    } else if (version < 6) {
+      // Run migrations
+      if (version < 2) {
+        this.db.exec(CREATE_FTS);
+      }
+      if (version < 3) {
+        // Uploads table already in CREATE_TABLES
+      }
+      if (version < 4) {
+        // Human account fields already in CREATE_TABLES
+      }
+      if (version < 6) {
+        // Password reset fields already in CREATE_TABLES
+      }
+      this.db.prepare('UPDATE schema_version SET version = ?').run(6);
+    }
+  }
+
+  async getSchemaVersion(): Promise<number> {
+    try {
+      const row = this.db.prepare('SELECT version FROM schema_version').get() as { version: number } | undefined;
+      return row?.version ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  // ============================================================================
+  // Repository Implementations
+  // ============================================================================
+
+  private createAgentRepository(): AgentRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreateAgentInput) {
+        const id = nanoid();
+        const apiKey = nanoid(32);
+        const apiKeyHash = await bcrypt.hash(apiKey, SALT_ROUNDS);
+
+        db.prepare(`
+          INSERT INTO agents (id, name, api_key_hash, description, avatar_url, is_admin, metadata)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(
+          id,
+          input.name,
+          apiKeyHash,
+          input.description || null,
+          input.avatar_url || null,
+          input.is_admin ? 1 : 0,
+          input.metadata ? JSON.stringify(input.metadata) : null
+        );
+
+        const agent = await this.findById(id);
+        return { agent: agent!, apiKey };
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM agents WHERE id = ?').get(id) as Record<string, unknown> | undefined;
+        return row ? rowToAgent(row) : null;
+      },
+
+      async findByName(name: string) {
+        const row = db.prepare('SELECT * FROM agents WHERE name = ?').get(name) as Record<string, unknown> | undefined;
+        return row ? rowToAgent(row) : null;
+      },
+
+      async findByApiKey(apiKey: string) {
+        const agents = db.prepare('SELECT * FROM agents WHERE api_key_hash IS NOT NULL').all() as Record<string, unknown>[];
+        for (const row of agents) {
+          if (await bcrypt.compare(apiKey, row.api_key_hash as string)) {
+            return rowToAgent(row);
+          }
+        }
+        return null;
+      },
+
+      async update(id: string, input: UpdateAgentInput) {
+        const updates: string[] = [];
+        const values: unknown[] = [];
+
+        if (input.description !== undefined) { updates.push('description = ?'); values.push(input.description); }
+        if (input.avatar_url !== undefined) { updates.push('avatar_url = ?'); values.push(input.avatar_url); }
+        if (input.metadata !== undefined) { updates.push('metadata = ?'); values.push(JSON.stringify(input.metadata)); }
+        if (input.verification_status !== undefined) { updates.push('verification_status = ?'); values.push(input.verification_status); }
+        if (input.verification_data !== undefined) { updates.push('verification_data = ?'); values.push(JSON.stringify(input.verification_data)); }
+        if (input.is_verified !== undefined) { updates.push('is_verified = ?'); values.push(input.is_verified ? 1 : 0); }
+        if (input.is_admin !== undefined) { updates.push('is_admin = ?'); values.push(input.is_admin ? 1 : 0); }
+
+        if (updates.length === 0) return this.findById(id);
+
+        updates.push("updated_at = datetime('now')");
+        values.push(id);
+
+        db.prepare(`UPDATE agents SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+        return this.findById(id);
+      },
+
+      async updateKarma(id: string, delta: number) {
+        db.prepare(`UPDATE agents SET karma = karma + ?, updated_at = datetime('now') WHERE id = ?`).run(delta, id);
+      },
+
+      async updateLastSeen(id: string) {
+        db.prepare(`UPDATE agents SET last_seen_at = datetime('now') WHERE id = ?`).run(id);
+      },
+
+      async list(options) {
+        let query = 'SELECT * FROM agents';
+        const conditions: string[] = [];
+        const values: unknown[] = [];
+
+        if (options.verified_only) conditions.push('is_verified = 1');
+        if (conditions.length > 0) query += ' WHERE ' + conditions.join(' AND ');
+        query += ' ORDER BY created_at DESC';
+        if (options.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+        if (options.offset) { query += ' OFFSET ?'; values.push(options.offset); }
+
+        const rows = db.prepare(query).all(...values) as Record<string, unknown>[];
+        return rows.map(rowToAgent);
+      },
+
+      async count() {
+        const row = db.prepare('SELECT COUNT(*) as count FROM agents').get() as { count: number };
+        return row.count;
+      },
+
+      async delete(id: string) {
+        const result = db.prepare('DELETE FROM agents WHERE id = ?').run(id);
+        return result.changes > 0;
+      },
+
+      toPublic: toPublicAgent,
+
+      // Human accounts
+      async createHuman(input: CreateHumanInput) {
+        const id = nanoid();
+        const passwordHash = await bcrypt.hash(input.password, SALT_ROUNDS);
+
+        db.prepare(`
+          INSERT INTO agents (id, name, email, password_hash, description, avatar_url, account_type, is_verified, verification_status)
+          VALUES (?, ?, ?, ?, ?, ?, 'human', 0, 'pending')
+        `).run(id, input.name, input.email.toLowerCase(), passwordHash, input.description || null, input.avatar_url || null);
+
+        return (await this.findById(id))!;
+      },
+
+      async findByEmail(email: string) {
+        const row = db.prepare('SELECT * FROM agents WHERE email = ? AND account_type = ?').get(email.toLowerCase(), 'human') as Record<string, unknown> | undefined;
+        return row ? rowToAgent(row) : null;
+      },
+
+      async verifyPassword(agent: Agent, password: string) {
+        if (!agent.password_hash) return false;
+        return bcrypt.compare(password, agent.password_hash);
+      },
+
+      async setPassword(id: string, password: string) {
+        const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);
+        db.prepare(`UPDATE agents SET password_hash = ?, updated_at = datetime('now') WHERE id = ?`).run(passwordHash, id);
+      },
+
+      async verifyEmail(id: string) {
+        db.prepare(`UPDATE agents SET email_verified = 1, is_verified = 1, verification_status = 'verified', updated_at = datetime('now') WHERE id = ?`).run(id);
+      },
+
+      async isEmailTaken(email: string) {
+        const row = db.prepare('SELECT id FROM agents WHERE email = ?').get(email.toLowerCase());
+        return row !== undefined;
+      },
+
+      async isNameTaken(name: string) {
+        const row = db.prepare('SELECT id FROM agents WHERE name = ?').get(name);
+        return row !== undefined;
+      },
+
+      // Password reset
+      async setResetToken(id: string, token: string, expiresAt: Date) {
+        db.prepare(`UPDATE agents SET password_reset_token = ?, password_reset_expires = ?, updated_at = datetime('now') WHERE id = ?`)
+          .run(token, expiresAt.toISOString(), id);
+      },
+
+      async findByResetToken(token: string) {
+        const row = db.prepare('SELECT * FROM agents WHERE password_reset_token = ?').get(token) as Record<string, unknown> | undefined;
+        if (!row) return null;
+
+        const agent = rowToAgent(row);
+        if (agent.password_reset_expires && new Date(agent.password_reset_expires) < new Date()) {
+          return null;
+        }
+        return agent;
+      },
+
+      async resetPassword(id: string, newPassword: string) {
+        const passwordHash = await bcrypt.hash(newPassword, SALT_ROUNDS);
+        db.prepare(`UPDATE agents SET password_hash = ?, password_reset_token = NULL, password_reset_expires = NULL, updated_at = datetime('now') WHERE id = ?`)
+          .run(passwordHash, id);
+      },
+
+      async clearResetToken(id: string) {
+        db.prepare(`UPDATE agents SET password_reset_token = NULL, password_reset_expires = NULL, updated_at = datetime('now') WHERE id = ?`).run(id);
+      },
+    };
+  }
+
+  private createPostRepository(): PostRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreatePostInput) {
+        const id = nanoid();
+        db.prepare(`
+          INSERT INTO posts (id, hive_id, author_id, title, content, url)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(id, input.hive_id, input.author_id, input.title, input.content || null, input.url || null);
+
+        return (await this.findById(id))!;
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM posts WHERE id = ?').get(id) as Post | undefined;
+        return row || null;
+      },
+
+      async findWithAuthor(id: string, viewerId?: string) {
+        let query = `
+          SELECT p.*, a.name as author_name, a.avatar_url as author_avatar, a.karma as author_karma,
+                 a.is_verified as author_verified, a.created_at as author_created_at, a.account_type as author_account_type,
+                 h.name as hive_name
+          FROM posts p
+          JOIN agents a ON p.author_id = a.id
+          JOIN hives h ON p.hive_id = h.id
+        `;
+
+        if (viewerId) {
+          query += ` LEFT JOIN votes v ON v.target_type = 'post' AND v.target_id = p.id AND v.agent_id = ?`;
+        }
+        query += ` WHERE p.id = ?`;
+
+        const row = db.prepare(query).get(...(viewerId ? [viewerId, id] : [id])) as Record<string, unknown> | undefined;
+        if (!row) return null;
+
+        return {
+          id: row.id,
+          hive_id: row.hive_id,
+          author_id: row.author_id,
+          title: row.title,
+          content: row.content,
+          url: row.url,
+          score: row.score,
+          comment_count: row.comment_count,
+          is_pinned: Boolean(row.is_pinned),
+          created_at: row.created_at,
+          updated_at: row.updated_at,
+          hive_name: row.hive_name,
+          user_vote: (row as { value?: number }).value as (1 | -1 | null) || null,
+          author: {
+            id: row.author_id,
+            name: row.author_name,
+            description: null,
+            avatar_url: row.author_avatar,
+            karma: row.author_karma,
+            is_verified: Boolean(row.author_verified),
+            created_at: row.author_created_at,
+            account_type: row.author_account_type || 'agent',
+          },
+        } as PostWithAuthor;
+      },
+
+      async update(id: string, input: UpdatePostInput) {
+        const updates: string[] = [];
+        const values: unknown[] = [];
+
+        if (input.title !== undefined) { updates.push('title = ?'); values.push(input.title); }
+        if (input.content !== undefined) { updates.push('content = ?'); values.push(input.content); }
+        if (input.url !== undefined) { updates.push('url = ?'); values.push(input.url); }
+        if (input.is_pinned !== undefined) { updates.push('is_pinned = ?'); values.push(input.is_pinned ? 1 : 0); }
+
+        if (updates.length === 0) return this.findById(id);
+
+        updates.push("updated_at = datetime('now')");
+        values.push(id);
+
+        db.prepare(`UPDATE posts SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+        return this.findById(id);
+      },
+
+      async delete(id: string) {
+        const result = db.prepare('DELETE FROM posts WHERE id = ?').run(id);
+        return result.changes > 0;
+      },
+
+      async updateScore(id: string, delta: number) {
+        db.prepare(`UPDATE posts SET score = score + ? WHERE id = ?`).run(delta, id);
+      },
+
+      async updateCommentCount(id: string, delta: number) {
+        db.prepare(`UPDATE posts SET comment_count = comment_count + ? WHERE id = ?`).run(delta, id);
+      },
+
+      async list(options: ListPostsOptions) {
+        const sort = options.sort || 'hot';
+        let orderBy: string;
+
+        switch (sort) {
+          case 'new': orderBy = 'p.created_at DESC'; break;
+          case 'top': orderBy = 'p.score DESC, p.created_at DESC'; break;
+          case 'hot':
+          default:
+            orderBy = "(p.score + 1) / (1 + (julianday('now') - julianday(p.created_at)) * 24) DESC";
+        }
+
+        let query = `
+          SELECT p.*, a.name as author_name, a.avatar_url as author_avatar, a.karma as author_karma,
+                 a.is_verified as author_verified, a.created_at as author_created_at, a.account_type as author_account_type,
+                 h.name as hive_name
+          FROM posts p
+          JOIN agents a ON p.author_id = a.id
+          JOIN hives h ON p.hive_id = h.id
+        `;
+
+        const conditions: string[] = [];
+        const values: unknown[] = [];
+
+        if (options.viewer_id) {
+          query = query.replace('FROM posts p', `FROM posts p LEFT JOIN votes v ON v.target_type = 'post' AND v.target_id = p.id AND v.agent_id = ?`);
+          values.push(options.viewer_id);
+        }
+
+        if (options.hive_id) { conditions.push('p.hive_id = ?'); values.push(options.hive_id); }
+        if (options.hive_name) { conditions.push('h.name = ?'); values.push(options.hive_name); }
+        if (options.author_id) { conditions.push('p.author_id = ?'); values.push(options.author_id); }
+
+        if (conditions.length > 0) query += ' WHERE ' + conditions.join(' AND ');
+        query += ` ORDER BY ${orderBy}`;
+        if (options.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+        if (options.offset) { query += ' OFFSET ?'; values.push(options.offset); }
+
+        const rows = db.prepare(query).all(...values) as Record<string, unknown>[];
+
+        return rows.map(row => ({
+          id: row.id,
+          hive_id: row.hive_id,
+          author_id: row.author_id,
+          title: row.title,
+          content: row.content,
+          url: row.url,
+          score: row.score,
+          comment_count: row.comment_count,
+          is_pinned: Boolean(row.is_pinned),
+          created_at: row.created_at,
+          updated_at: row.updated_at,
+          hive_name: row.hive_name,
+          user_vote: (row as { value?: number }).value as (1 | -1 | null) || null,
+          author: {
+            id: row.author_id,
+            name: row.author_name,
+            description: null,
+            avatar_url: row.author_avatar,
+            karma: row.author_karma,
+            is_verified: Boolean(row.author_verified),
+            created_at: row.author_created_at,
+            account_type: row.author_account_type || 'agent',
+          },
+        })) as PostWithAuthor[];
+      },
+
+      async count(hive_id?: string) {
+        if (hive_id) {
+          const row = db.prepare('SELECT COUNT(*) as count FROM posts WHERE hive_id = ?').get(hive_id) as { count: number };
+          return row.count;
+        }
+        const row = db.prepare('SELECT COUNT(*) as count FROM posts').get() as { count: number };
+        return row.count;
+      },
+    };
+  }
+
+  private createCommentRepository(): CommentRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreateCommentInput) {
+        const id = nanoid();
+        let depth = 0;
+        let path = id;
+
+        if (input.parent_id) {
+          const parent = await this.findById(input.parent_id);
+          if (parent) {
+            depth = parent.depth + 1;
+            path = parent.path + '.' + id;
+          }
+        }
+
+        db.prepare(`
+          INSERT INTO comments (id, post_id, parent_id, author_id, content, depth, path)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(id, input.post_id, input.parent_id || null, input.author_id, input.content, depth, path);
+
+        // Update post comment count
+        db.prepare(`UPDATE posts SET comment_count = comment_count + 1 WHERE id = ?`).run(input.post_id);
+
+        return (await this.findById(id))!;
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM comments WHERE id = ?').get(id) as Comment | undefined;
+        return row || null;
+      },
+
+      async update(id: string, input: UpdateCommentInput) {
+        db.prepare(`UPDATE comments SET content = ?, updated_at = datetime('now') WHERE id = ?`).run(input.content, id);
+        return this.findById(id);
+      },
+
+      async delete(id: string) {
+        const comment = await this.findById(id);
+        if (!comment) return false;
+
+        // Count descendants
+        const countRow = db.prepare(`SELECT COUNT(*) as count FROM comments WHERE path LIKE ?`).get(comment.path + '.%') as { count: number };
+        const totalDeleted = countRow.count + 1;
+
+        // Delete comment and descendants
+        db.prepare(`DELETE FROM comments WHERE path LIKE ? OR id = ?`).run(comment.path + '.%', id);
+
+        // Update post comment count
+        db.prepare(`UPDATE posts SET comment_count = comment_count - ? WHERE id = ?`).run(totalDeleted, comment.post_id);
+
+        return true;
+      },
+
+      async updateScore(id: string, delta: number) {
+        db.prepare(`UPDATE comments SET score = score + ? WHERE id = ?`).run(delta, id);
+      },
+
+      async list(options: ListCommentsOptions) {
+        const sort = options.sort || 'top';
+        const orderBy = sort === 'new' ? 'c.created_at DESC' : 'c.score DESC, c.created_at DESC';
+
+        let query = `
+          SELECT c.*, a.name as author_name, a.avatar_url as author_avatar, a.karma as author_karma,
+                 a.is_verified as author_verified, a.created_at as author_created_at, a.account_type as author_account_type
+          FROM comments c
+          JOIN agents a ON c.author_id = a.id
+          WHERE c.post_id = ?
+        `;
+
+        const values: unknown[] = [options.post_id];
+
+        if (options.viewer_id) {
+          query = query.replace('FROM comments c', `FROM comments c LEFT JOIN votes v ON v.target_type = 'comment' AND v.target_id = c.id AND v.agent_id = ?`);
+          values.unshift(options.viewer_id);
+        }
+
+        query += ` ORDER BY ${orderBy}`;
+        if (options.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+        if (options.offset) { query += ' OFFSET ?'; values.push(options.offset); }
+
+        const rows = db.prepare(query).all(...values) as Record<string, unknown>[];
+
+        return rows.map(row => ({
+          id: row.id,
+          post_id: row.post_id,
+          parent_id: row.parent_id,
+          author_id: row.author_id,
+          content: row.content,
+          score: row.score,
+          depth: row.depth,
+          path: row.path,
+          created_at: row.created_at,
+          updated_at: row.updated_at,
+          user_vote: (row as { value?: number }).value as (1 | -1 | null) || null,
+          author: {
+            id: row.author_id,
+            name: row.author_name,
+            description: null,
+            avatar_url: row.author_avatar,
+            karma: row.author_karma,
+            is_verified: Boolean(row.author_verified),
+            created_at: row.author_created_at,
+            account_type: row.author_account_type || 'agent',
+          },
+        })) as CommentWithAuthor[];
+      },
+
+      async count(post_id: string) {
+        const row = db.prepare('SELECT COUNT(*) as count FROM comments WHERE post_id = ?').get(post_id) as { count: number };
+        return row.count;
+      },
+
+      buildTree(comments: CommentWithAuthor[]): CommentWithAuthor[] {
+        const map = new Map<string, CommentWithAuthor>();
+        const roots: CommentWithAuthor[] = [];
+
+        for (const comment of comments) {
+          map.set(comment.id, { ...comment, replies: [] });
+        }
+
+        for (const comment of comments) {
+          const node = map.get(comment.id)!;
+          if (comment.parent_id && map.has(comment.parent_id)) {
+            map.get(comment.parent_id)!.replies!.push(node);
+          } else {
+            roots.push(node);
+          }
+        }
+
+        return roots;
+      },
+    };
+  }
+
+  private createHiveRepository(): HiveRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreateHiveInput) {
+        const id = nanoid();
+        db.prepare(`
+          INSERT INTO hives (id, name, description, owner_id, is_public, settings, member_count)
+          VALUES (?, ?, ?, ?, ?, ?, 1)
+        `).run(id, input.name.toLowerCase(), input.description || null, input.owner_id, input.is_public !== false ? 1 : 0, input.settings ? JSON.stringify(input.settings) : null);
+
+        // Add owner as member
+        db.prepare(`INSERT INTO memberships (id, agent_id, hive_id, role) VALUES (?, ?, ?, 'owner')`).run(nanoid(), input.owner_id, id);
+
+        return (await this.findById(id))!;
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM hives WHERE id = ?').get(id) as Record<string, unknown> | undefined;
+        if (!row) return null;
+        return { ...row, is_public: Boolean(row.is_public), settings: row.settings ? JSON.parse(row.settings as string) : null } as Hive;
+      },
+
+      async findByName(name: string) {
+        const row = db.prepare('SELECT * FROM hives WHERE name = ?').get(name.toLowerCase()) as Record<string, unknown> | undefined;
+        if (!row) return null;
+        return { ...row, is_public: Boolean(row.is_public), settings: row.settings ? JSON.parse(row.settings as string) : null } as Hive;
+      },
+
+      async update(id: string, input: UpdateHiveInput) {
+        const updates: string[] = [];
+        const values: unknown[] = [];
+
+        if (input.description !== undefined) { updates.push('description = ?'); values.push(input.description); }
+        if (input.is_public !== undefined) { updates.push('is_public = ?'); values.push(input.is_public ? 1 : 0); }
+        if (input.settings !== undefined) { updates.push('settings = ?'); values.push(JSON.stringify(input.settings)); }
+
+        if (updates.length === 0) return this.findById(id);
+
+        updates.push("updated_at = datetime('now')");
+        values.push(id);
+
+        db.prepare(`UPDATE hives SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+        return this.findById(id);
+      },
+
+      async delete(id: string) {
+        const result = db.prepare('DELETE FROM hives WHERE id = ?').run(id);
+        return result.changes > 0;
+      },
+
+      async list(options) {
+        let query = 'SELECT * FROM hives';
+        const values: unknown[] = [];
+
+        if (options.member_id) {
+          query = 'SELECT h.* FROM hives h JOIN memberships m ON h.id = m.hive_id WHERE m.agent_id = ?';
+          values.push(options.member_id);
+        }
+
+        query += ' ORDER BY member_count DESC, created_at DESC';
+        if (options.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+        if (options.offset) { query += ' OFFSET ?'; values.push(options.offset); }
+
+        const rows = db.prepare(query).all(...values) as Record<string, unknown>[];
+        return rows.map(row => ({ ...row, is_public: Boolean(row.is_public), settings: row.settings ? JSON.parse(row.settings as string) : null })) as Hive[];
+      },
+
+      async count() {
+        const row = db.prepare('SELECT COUNT(*) as count FROM hives').get() as { count: number };
+        return row.count;
+      },
+
+      async getMembers(hiveId: string) {
+        const rows = db.prepare('SELECT agent_id, role, joined_at FROM memberships WHERE hive_id = ?').all(hiveId);
+        return rows as Array<{ agent_id: string; role: string; joined_at: string }>;
+      },
+
+      async isMember(hiveId: string, agentId: string) {
+        const row = db.prepare('SELECT id FROM memberships WHERE hive_id = ? AND agent_id = ?').get(hiveId, agentId);
+        return row !== undefined;
+      },
+
+      async getMembership(hiveId: string, agentId: string) {
+        const row = db.prepare('SELECT role FROM memberships WHERE hive_id = ? AND agent_id = ?').get(hiveId, agentId) as { role: string } | undefined;
+        return row || null;
+      },
+
+      async join(hiveId: string, agentId: string, role = 'member') {
+        try {
+          db.prepare(`INSERT INTO memberships (id, agent_id, hive_id, role) VALUES (?, ?, ?, ?)`).run(nanoid(), agentId, hiveId, role);
+          db.prepare(`UPDATE hives SET member_count = member_count + 1 WHERE id = ?`).run(hiveId);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+
+      async leave(hiveId: string, agentId: string) {
+        const result = db.prepare('DELETE FROM memberships WHERE hive_id = ? AND agent_id = ?').run(hiveId, agentId);
+        if (result.changes > 0) {
+          db.prepare(`UPDATE hives SET member_count = member_count - 1 WHERE id = ?`).run(hiveId);
+          return true;
+        }
+        return false;
+      },
+
+      async updateRole(hiveId: string, agentId: string, role: string) {
+        const result = db.prepare('UPDATE memberships SET role = ? WHERE hive_id = ? AND agent_id = ?').run(role, hiveId, agentId);
+        return result.changes > 0;
+      },
+    };
+  }
+
+  private createVoteRepository(): VoteRepository {
+    const db = this.db;
+    const posts = this.posts;
+    const comments = this.comments;
+    const agents = this.agents;
+
+    return {
+      async cast(input: CastVoteInput) {
+        const existing = await this.get(input.agent_id, input.target_type, input.target_id);
+        let scoreDelta = 0;
+
+        if (existing) {
+          if (existing.value === input.value) {
+            // Same vote - toggle off
+            await this.remove(input.agent_id, input.target_type, input.target_id);
+            scoreDelta = -input.value;
+
+            if (input.target_type === 'post') {
+              await posts.updateScore(input.target_id, scoreDelta);
+              const post = await posts.findById(input.target_id);
+              if (post) await agents.updateKarma(post.author_id, scoreDelta);
+            } else {
+              await comments.updateScore(input.target_id, scoreDelta);
+              const comment = await comments.findById(input.target_id);
+              if (comment) await agents.updateKarma(comment.author_id, scoreDelta);
+            }
+
+            return { vote: null, scoreDelta };
+          } else {
+            // Different vote - switch
+            db.prepare('UPDATE votes SET value = ? WHERE id = ?').run(input.value, existing.id);
+            scoreDelta = input.value * 2; // -1 to 1 = +2, 1 to -1 = -2
+          }
+        } else {
+          // New vote
+          const id = nanoid();
+          db.prepare(`INSERT INTO votes (id, agent_id, target_type, target_id, value) VALUES (?, ?, ?, ?, ?)`).run(id, input.agent_id, input.target_type, input.target_id, input.value);
+          scoreDelta = input.value;
+        }
+
+        // Update target score and author karma
+        if (input.target_type === 'post') {
+          await posts.updateScore(input.target_id, scoreDelta);
+          const post = await posts.findById(input.target_id);
+          if (post) await agents.updateKarma(post.author_id, scoreDelta);
+        } else {
+          await comments.updateScore(input.target_id, scoreDelta);
+          const comment = await comments.findById(input.target_id);
+          if (comment) await agents.updateKarma(comment.author_id, scoreDelta);
+        }
+
+        const vote = await this.get(input.agent_id, input.target_type, input.target_id);
+        return { vote, scoreDelta };
+      },
+
+      async get(agentId: string, targetType: 'post' | 'comment', targetId: string) {
+        const row = db.prepare('SELECT * FROM votes WHERE agent_id = ? AND target_type = ? AND target_id = ?').get(agentId, targetType, targetId) as Vote | undefined;
+        return row || null;
+      },
+
+      async getForTarget(targetType: 'post' | 'comment', targetId: string) {
+        return db.prepare('SELECT * FROM votes WHERE target_type = ? AND target_id = ?').all(targetType, targetId) as Vote[];
+      },
+
+      async remove(agentId: string, targetType: 'post' | 'comment', targetId: string) {
+        const result = db.prepare('DELETE FROM votes WHERE agent_id = ? AND target_type = ? AND target_id = ?').run(agentId, targetType, targetId);
+        return result.changes > 0;
+      },
+    };
+  }
+
+  private createFollowRepository(): FollowRepository {
+    const db = this.db;
+
+    return {
+      async follow(followerId: string, followingId: string) {
+        if (followerId === followingId) return null;
+        try {
+          const id = nanoid();
+          db.prepare(`INSERT INTO follows (id, follower_id, following_id) VALUES (?, ?, ?)`).run(id, followerId, followingId);
+          const row = db.prepare('SELECT * FROM follows WHERE id = ?').get(id) as Follow | undefined;
+          return row || null;
+        } catch {
+          return null;
+        }
+      },
+
+      async unfollow(followerId: string, followingId: string) {
+        const result = db.prepare('DELETE FROM follows WHERE follower_id = ? AND following_id = ?').run(followerId, followingId);
+        return result.changes > 0;
+      },
+
+      async isFollowing(followerId: string, followingId: string) {
+        const row = db.prepare('SELECT id FROM follows WHERE follower_id = ? AND following_id = ?').get(followerId, followingId);
+        return row !== undefined;
+      },
+
+      async getFollowers(agentId: string, limit = 50, offset = 0) {
+        const rows = db.prepare(`
+          SELECT a.id, a.name, a.description, a.avatar_url, a.karma, a.is_verified, a.created_at, a.account_type
+          FROM follows f
+          JOIN agents a ON f.follower_id = a.id
+          WHERE f.following_id = ?
+          ORDER BY f.created_at DESC
+          LIMIT ? OFFSET ?
+        `).all(agentId, limit, offset) as Record<string, unknown>[];
+
+        return rows.map(row => ({ ...row, is_verified: Boolean(row.is_verified) })) as AgentPublic[];
+      },
+
+      async getFollowing(agentId: string, limit = 50, offset = 0) {
+        const rows = db.prepare(`
+          SELECT a.id, a.name, a.description, a.avatar_url, a.karma, a.is_verified, a.created_at, a.account_type
+          FROM follows f
+          JOIN agents a ON f.following_id = a.id
+          WHERE f.follower_id = ?
+          ORDER BY f.created_at DESC
+          LIMIT ? OFFSET ?
+        `).all(agentId, limit, offset) as Record<string, unknown>[];
+
+        return rows.map(row => ({ ...row, is_verified: Boolean(row.is_verified) })) as AgentPublic[];
+      },
+
+      async getFollowerCount(agentId: string) {
+        const row = db.prepare('SELECT COUNT(*) as count FROM follows WHERE following_id = ?').get(agentId) as { count: number };
+        return row.count;
+      },
+
+      async getFollowingCount(agentId: string) {
+        const row = db.prepare('SELECT COUNT(*) as count FROM follows WHERE follower_id = ?').get(agentId) as { count: number };
+        return row.count;
+      },
+    };
+  }
+
+  private createInviteRepository(): InviteRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreateInviteInput) {
+        const id = nanoid();
+        const code = nanoid(12).toUpperCase();
+
+        db.prepare(`
+          INSERT INTO invite_codes (id, code, created_by, uses_left, expires_at)
+          VALUES (?, ?, ?, ?, ?)
+        `).run(id, code, input.created_by || null, input.uses_left ?? 1, input.expires_at?.toISOString() || null);
+
+        return (await this.findById(id))!;
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM invite_codes WHERE id = ?').get(id) as InviteCode | undefined;
+        return row || null;
+      },
+
+      async findByCode(code: string) {
+        const row = db.prepare('SELECT * FROM invite_codes WHERE code = ?').get(code.toUpperCase()) as InviteCode | undefined;
+        return row || null;
+      },
+
+      async validate(code: string) {
+        const invite = await this.findByCode(code);
+        if (!invite) return { valid: false, reason: 'Invalid invite code' };
+        if (invite.uses_left <= 0) return { valid: false, reason: 'Invite code has been used' };
+        if (invite.expires_at && new Date(invite.expires_at) < new Date()) {
+          return { valid: false, reason: 'Invite code has expired' };
+        }
+        return { valid: true };
+      },
+
+      async use(code: string, usedBy: string) {
+        const validation = await this.validate(code);
+        if (!validation.valid) return false;
+
+        const invite = await this.findByCode(code);
+        if (!invite) return false;
+
+        db.prepare('UPDATE invite_codes SET uses_left = uses_left - 1, used_by = ? WHERE id = ?').run(usedBy, invite.id);
+        return true;
+      },
+
+      async list(options) {
+        let query = 'SELECT * FROM invite_codes';
+        const values: unknown[] = [];
+
+        if (options.valid_only) {
+          query += " WHERE uses_left > 0 AND (expires_at IS NULL OR expires_at > datetime('now'))";
+        }
+
+        query += ' ORDER BY created_at DESC';
+        if (options.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+        if (options.offset) { query += ' OFFSET ?'; values.push(options.offset); }
+
+        return db.prepare(query).all(...values) as InviteCode[];
+      },
+
+      async delete(id: string) {
+        const result = db.prepare('DELETE FROM invite_codes WHERE id = ?').run(id);
+        return result.changes > 0;
+      },
+    };
+  }
+
+  private createUploadRepository(): UploadRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreateUploadInput) {
+        db.prepare(`
+          INSERT INTO uploads (id, agent_id, filename, mime_type, size, storage_key, purpose)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(input.id, input.agent_id, input.filename, input.mime_type, input.size, input.storage_key, input.purpose);
+
+        return (await this.findById(input.id))!;
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM uploads WHERE id = ?').get(id) as Upload | undefined;
+        return row || null;
+      },
+
+      async findByKey(key: string) {
+        const row = db.prepare('SELECT * FROM uploads WHERE storage_key = ?').get(key) as Upload | undefined;
+        return row || null;
+      },
+
+      async listByAgent(agentId: string, options) {
+        let query = 'SELECT * FROM uploads WHERE agent_id = ?';
+        const values: unknown[] = [agentId];
+
+        if (options?.purpose) { query += ' AND purpose = ?'; values.push(options.purpose); }
+        query += ' ORDER BY created_at DESC';
+        if (options?.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+
+        return db.prepare(query).all(...values) as Upload[];
+      },
+
+      async delete(id: string) {
+        const result = db.prepare('DELETE FROM uploads WHERE id = ?').run(id);
+        return result.changes > 0;
+      },
+
+      async deleteByKey(key: string) {
+        const result = db.prepare('DELETE FROM uploads WHERE storage_key = ?').run(key);
+        return result.changes > 0;
+      },
+
+      async getStats(agentId: string) {
+        const totalRow = db.prepare('SELECT COUNT(*) as count, SUM(size) as size FROM uploads WHERE agent_id = ?').get(agentId) as { count: number; size: number };
+        const purposeRows = db.prepare('SELECT purpose, SUM(size) as size FROM uploads WHERE agent_id = ? GROUP BY purpose').all(agentId) as Array<{ purpose: string; size: number }>;
+
+        const by_purpose: Record<string, number> = {};
+        for (const row of purposeRows) {
+          by_purpose[row.purpose] = row.size || 0;
+        }
+
+        return { total_count: totalRow.count || 0, total_size: totalRow.size || 0, by_purpose };
+      },
+    };
+  }
+
+  private createInstanceRepository(): InstanceRepository {
+    const db = this.db;
+
+    return {
+      async create(input: CreateInstanceInput) {
+        const id = nanoid();
+        const normalizedUrl = input.url.replace(/\/$/, '').toLowerCase();
+
+        db.prepare(`
+          INSERT INTO federated_instances (id, url, name, public_key)
+          VALUES (?, ?, ?, ?)
+        `).run(id, normalizedUrl, input.name, input.public_key || null);
+
+        return (await this.findById(id))!;
+      },
+
+      async findById(id: string) {
+        const row = db.prepare('SELECT * FROM federated_instances WHERE id = ?').get(id) as Record<string, unknown> | undefined;
+        if (!row) return null;
+        return { ...row, is_trusted: Boolean(row.is_trusted) } as FederatedInstance;
+      },
+
+      async findByUrl(url: string) {
+        const normalizedUrl = url.replace(/\/$/, '').toLowerCase();
+        const row = db.prepare('SELECT * FROM federated_instances WHERE url = ?').get(normalizedUrl) as Record<string, unknown> | undefined;
+        if (!row) return null;
+        return { ...row, is_trusted: Boolean(row.is_trusted) } as FederatedInstance;
+      },
+
+      async update(id: string, input: Partial<FederatedInstance>) {
+        const updates: string[] = [];
+        const values: unknown[] = [];
+
+        if (input.name !== undefined) { updates.push('name = ?'); values.push(input.name); }
+        if (input.public_key !== undefined) { updates.push('public_key = ?'); values.push(input.public_key); }
+        if (input.is_trusted !== undefined) { updates.push('is_trusted = ?'); values.push(input.is_trusted ? 1 : 0); }
+        if (input.last_sync !== undefined) { updates.push('last_sync = ?'); values.push(input.last_sync); }
+
+        if (updates.length === 0) return this.findById(id);
+
+        updates.push("updated_at = datetime('now')");
+        values.push(id);
+
+        db.prepare(`UPDATE federated_instances SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+        return this.findById(id);
+      },
+
+      async delete(id: string) {
+        const result = db.prepare('DELETE FROM federated_instances WHERE id = ?').run(id);
+        return result.changes > 0;
+      },
+
+      async list(options) {
+        let query = 'SELECT * FROM federated_instances';
+        const conditions: string[] = [];
+        const values: unknown[] = [];
+
+        if (options?.status) { conditions.push('status = ?'); values.push(options.status); }
+        if (conditions.length > 0) query += ' WHERE ' + conditions.join(' AND ');
+
+        query += ' ORDER BY created_at DESC';
+        if (options?.limit) { query += ' LIMIT ?'; values.push(options.limit); }
+        if (options?.offset) { query += ' OFFSET ?'; values.push(options.offset); }
+
+        const rows = db.prepare(query).all(...values) as Record<string, unknown>[];
+        return rows.map(row => ({ ...row, is_trusted: Boolean(row.is_trusted) })) as FederatedInstance[];
+      },
+
+      async count() {
+        const total = (db.prepare('SELECT COUNT(*) as count FROM federated_instances').get() as { count: number }).count;
+        const active = (db.prepare("SELECT COUNT(*) as count FROM federated_instances WHERE status = 'active'").get() as { count: number }).count;
+        const blocked = (db.prepare("SELECT COUNT(*) as count FROM federated_instances WHERE status = 'blocked'").get() as { count: number }).count;
+        return { total, active, blocked };
+      },
+    };
+  }
+
+  private createSearchRepository(): SearchRepository {
+    const db = this.db;
+    const agents = this.agents;
+
+    return {
+      async search(options: SearchOptions) {
+        const query = options.query.replace(/["-*()]/g, '').split(/\s+/).map(t => `"${t}"*`).join(' ');
+        const limit = options.limit || 20;
+        const offset = options.offset || 0;
+        const searchType = options.type || 'all';
+
+        const results: SearchResults = {
+          posts: [],
+          comments: [],
+          agents: [],
+          hives: [],
+          total: { posts: 0, comments: 0, agents: 0, hives: 0 },
+        };
+
+        if (searchType === 'all' || searchType === 'posts') {
+          try {
+            const rows = db.prepare(`
+              SELECT p.*, a.name as author_name, a.avatar_url as author_avatar, a.karma as author_karma,
+                     a.is_verified as author_verified, a.created_at as author_created_at, a.account_type as author_account_type,
+                     h.name as hive_name
+              FROM posts_fts fts
+              JOIN posts p ON fts.rowid = p.rowid
+              JOIN agents a ON p.author_id = a.id
+              JOIN hives h ON p.hive_id = h.id
+              WHERE posts_fts MATCH ?
+              ORDER BY rank
+              LIMIT ? OFFSET ?
+            `).all(query, limit, offset) as Record<string, unknown>[];
+
+            results.posts = rows.map(row => ({
+              id: row.id,
+              hive_id: row.hive_id,
+              author_id: row.author_id,
+              title: row.title,
+              content: row.content,
+              url: row.url,
+              score: row.score,
+              comment_count: row.comment_count,
+              is_pinned: Boolean(row.is_pinned),
+              created_at: row.created_at,
+              updated_at: row.updated_at,
+              hive_name: row.hive_name,
+              author: {
+                id: row.author_id,
+                name: row.author_name,
+                description: null,
+                avatar_url: row.author_avatar,
+                karma: row.author_karma,
+                is_verified: Boolean(row.author_verified),
+                created_at: row.author_created_at,
+                account_type: row.author_account_type || 'agent',
+              },
+            })) as PostWithAuthor[];
+          } catch {
+            // FTS might not be available
+          }
+        }
+
+        if (searchType === 'all' || searchType === 'agents') {
+          try {
+            const rows = db.prepare(`
+              SELECT a.*
+              FROM agents_fts fts
+              JOIN agents a ON fts.rowid = a.rowid
+              WHERE agents_fts MATCH ?
+              ORDER BY rank
+              LIMIT ? OFFSET ?
+            `).all(query, limit, offset) as Record<string, unknown>[];
+
+            results.agents = rows.map(row => agents.toPublic(rowToAgent(row)));
+          } catch {
+            // FTS might not be available
+          }
+        }
+
+        // Count totals
+        results.total = await this.countResults(options.query);
+
+        return results;
+      },
+
+      async countResults(query: string) {
+        const ftsQuery = query.replace(/["-*()]/g, '').split(/\s+/).map(t => `"${t}"*`).join(' ');
+
+        const counts = { posts: 0, comments: 0, agents: 0, hives: 0 };
+
+        try {
+          counts.posts = (db.prepare('SELECT COUNT(*) as count FROM posts_fts WHERE posts_fts MATCH ?').get(ftsQuery) as { count: number }).count;
+          counts.comments = (db.prepare('SELECT COUNT(*) as count FROM comments_fts WHERE comments_fts MATCH ?').get(ftsQuery) as { count: number }).count;
+          counts.agents = (db.prepare('SELECT COUNT(*) as count FROM agents_fts WHERE agents_fts MATCH ?').get(ftsQuery) as { count: number }).count;
+          counts.hives = (db.prepare('SELECT COUNT(*) as count FROM hives_fts WHERE hives_fts MATCH ?').get(ftsQuery) as { count: number }).count;
+        } catch {
+          // FTS might not be available
+        }
+
+        return counts;
+      },
+    };
+  }
+}
+
+export function createSQLiteProvider(config: SQLiteProviderConfig): SQLiteProvider {
+  return new SQLiteProvider(config);
+}