@lov3kaizen/agentsea-memory 0.5.1

package/dist/chunk-GACX3FPR.js

@@ -0,0 +1,1402 @@
+// src/stores/implementations/InMemoryStore.ts
+import { LRUCache } from "lru-cache";
+var InMemoryStore = class {
+  cache;
+  constructor(config = {}) {
+    this.cache = new LRUCache({
+      max: config.maxSize ?? 1e4,
+      ttl: config.ttl,
+      updateAgeOnGet: true
+    });
+  }
+  /**
+   * Add a memory entry
+   */
+  async add(entry) {
+    this.cache.set(entry.id, entry);
+    return Promise.resolve(entry.id);
+  }
+  /**
+   * Get a memory entry by ID
+   */
+  async get(id) {
+    const entry = this.cache.get(id);
+    if (entry) {
+      entry.accessCount++;
+      entry.lastAccessedAt = Date.now();
+      this.cache.set(id, entry);
+    }
+    return Promise.resolve(entry ?? null);
+  }
+  /**
+   * Update a memory entry
+   */
+  async update(id, updates) {
+    const entry = this.cache.get(id);
+    if (!entry) {
+      return Promise.resolve(false);
+    }
+    const updated = {
+      ...entry,
+      ...updates,
+      metadata: {
+        ...entry.metadata,
+        ...updates.metadata
+      },
+      updatedAt: Date.now()
+    };
+    this.cache.set(id, updated);
+    return Promise.resolve(true);
+  }
+  /**
+   * Delete a memory entry
+   */
+  async delete(id) {
+    return Promise.resolve(this.cache.delete(id));
+  }
+  /**
+   * Query memory entries
+   */
+  async query(options) {
+    const entries = [];
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    for (const entry of this.cache.values()) {
+      if (this.matchesQuery(entry, options)) {
+        entries.push(entry);
+      }
+    }
+    entries.sort((a, b) => b.timestamp - a.timestamp);
+    const paginated = entries.slice(offset, offset + limit);
+    return Promise.resolve({
+      entries: paginated,
+      total: entries.length,
+      hasMore: offset + limit < entries.length
+    });
+  }
+  /**
+   * Search by vector similarity
+   */
+  async search(embedding, options) {
+    const results = [];
+    for (const entry of this.cache.values()) {
+      if (!entry.embedding) {
+        continue;
+      }
+      if (options.filter) {
+        if (!this.matchesFilter(entry, options.filter)) {
+          continue;
+        }
+      }
+      if (options.namespace && entry.metadata.namespace !== options.namespace) {
+        continue;
+      }
+      const score = this.cosineSimilarity(embedding, entry.embedding);
+      if (options.minScore !== void 0 && score < options.minScore) {
+        continue;
+      }
+      results.push({ entry, score });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return Promise.resolve(results.slice(0, options.topK));
+  }
+  /**
+   * Clear entries
+   */
+  async clear(options) {
+    if (!options) {
+      const size = this.cache.size;
+      this.cache.clear();
+      return Promise.resolve(size);
+    }
+    let deleted = 0;
+    const toDelete = [];
+    for (const [id, entry] of this.cache.entries()) {
+      let shouldDelete = true;
+      if (options.namespace && entry.metadata.namespace !== options.namespace) {
+        shouldDelete = false;
+      }
+      if (options.userId && entry.metadata.userId !== options.userId) {
+        shouldDelete = false;
+      }
+      if (shouldDelete) {
+        toDelete.push(id);
+      }
+    }
+    for (const id of toDelete) {
+      this.cache.delete(id);
+      deleted++;
+    }
+    return Promise.resolve(deleted);
+  }
+  /**
+   * Count entries
+   */
+  async count(options) {
+    if (!options) {
+      return Promise.resolve(this.cache.size);
+    }
+    let count = 0;
+    for (const entry of this.cache.values()) {
+      if (this.matchesQuery(entry, options)) {
+        count++;
+      }
+    }
+    return Promise.resolve(count);
+  }
+  /**
+   * Close the store (no-op for in-memory)
+   */
+  async close() {
+  }
+  /**
+   * Check if entry matches query
+   */
+  matchesQuery(entry, options) {
+    if (options.query) {
+      const queryLower = options.query.toLowerCase();
+      if (!entry.content.toLowerCase().includes(queryLower)) {
+        return false;
+      }
+    }
+    if (options.userId && entry.metadata.userId !== options.userId) {
+      return false;
+    }
+    if (options.agentId && entry.metadata.agentId !== options.agentId) {
+      return false;
+    }
+    if (options.conversationId && entry.metadata.conversationId !== options.conversationId) {
+      return false;
+    }
+    if (options.sessionId && entry.metadata.sessionId !== options.sessionId) {
+      return false;
+    }
+    if (options.namespace && entry.metadata.namespace !== options.namespace) {
+      return false;
+    }
+    if (options.types && options.types.length > 0) {
+      if (!options.types.includes(entry.type)) {
+        return false;
+      }
+    }
+    if (options.tags && options.tags.length > 0) {
+      const entryTags = entry.metadata.tags ?? [];
+      const hasAllTags = options.tags.every((tag) => entryTags.includes(tag));
+      if (!hasAllTags) {
+        return false;
+      }
+    }
+    if (options.minImportance !== void 0 && entry.importance < options.minImportance) {
+      return false;
+    }
+    if (options.startTime !== void 0 && entry.timestamp < options.startTime) {
+      return false;
+    }
+    if (options.endTime !== void 0 && entry.timestamp > options.endTime) {
+      return false;
+    }
+    if (!options.includeExpired && entry.expiresAt) {
+      if (entry.expiresAt < Date.now()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if entry matches filter
+   */
+  matchesFilter(entry, filter) {
+    for (const [key, value] of Object.entries(filter)) {
+      if (value === void 0) continue;
+      if (key in entry.metadata) {
+        if (Array.isArray(value)) {
+          if (!value.includes(entry.metadata[key])) {
+            return false;
+          }
+        } else if (entry.metadata[key] !== value) {
+          return false;
+        }
+      } else if (key in entry) {
+        const entryValue = entry[key];
+        if (Array.isArray(value)) {
+          if (!value.includes(entryValue)) {
+            return false;
+          }
+        } else if (entryValue !== value) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Calculate cosine similarity
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    if (magnitude === 0) {
+      return 0;
+    }
+    return dotProduct / magnitude;
+  }
+  /**
+   * Get all entries (for debugging)
+   */
+  getAllEntries() {
+    return Array.from(this.cache.values());
+  }
+  /**
+   * Get cache size
+   */
+  get size() {
+    return this.cache.size;
+  }
+};
+function createInMemoryStore(config) {
+  return new InMemoryStore(config);
+}
+
+// src/stores/implementations/SQLiteStore.ts
+var SQLiteStore = class {
+  db = null;
+  config;
+  tableName;
+  constructor(config) {
+    this.config = config;
+    this.tableName = config.tableName ?? "memories";
+  }
+  /**
+   * Initialize the database
+   */
+  async initialize() {
+    const BetterSqlite3 = (await import("better-sqlite3")).default;
+    this.db = new BetterSqlite3(this.config.path);
+    if (this.config.enableWAL !== false) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        content TEXT NOT NULL,
+        embedding BLOB,
+        type TEXT NOT NULL,
+        importance REAL NOT NULL,
+        metadata TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        expires_at INTEGER,
+        parent_id TEXT,
+        access_count INTEGER DEFAULT 0,
+        last_accessed_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_timestamp ON ${this.tableName}(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_type ON ${this.tableName}(type);
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_importance ON ${this.tableName}(importance);
+    `);
+  }
+  /**
+   * Ensure database is initialized
+   */
+  async ensureInitialized() {
+    if (!this.db) {
+      await this.initialize();
+    }
+    return this.db;
+  }
+  /**
+   * Add a memory entry
+   */
+  async add(entry) {
+    const db = await this.ensureInitialized();
+    const stmt = db.prepare(`
+      INSERT INTO ${this.tableName} (
+        id, content, embedding, type, importance, metadata,
+        timestamp, expires_at, parent_id, access_count,
+        last_accessed_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      entry.id,
+      entry.content,
+      entry.embedding ? this.serializeVector(entry.embedding) : null,
+      entry.type,
+      entry.importance,
+      JSON.stringify(entry.metadata),
+      entry.timestamp,
+      entry.expiresAt ?? null,
+      entry.parentId ?? null,
+      entry.accessCount,
+      entry.lastAccessedAt ?? null,
+      entry.createdAt,
+      entry.updatedAt
+    );
+    return entry.id;
+  }
+  /**
+   * Get a memory entry by ID
+   */
+  async get(id) {
+    const db = await this.ensureInitialized();
+    const stmt = db.prepare(`SELECT * FROM ${this.tableName} WHERE id = ?`);
+    const row = stmt.get(id);
+    if (!row) {
+      return null;
+    }
+    const updateStmt = db.prepare(`
+      UPDATE ${this.tableName}
+      SET access_count = access_count + 1, last_accessed_at = ?
+      WHERE id = ?
+    `);
+    updateStmt.run(Date.now(), id);
+    return Promise.resolve(this.rowToEntry(row));
+  }
+  /**
+   * Update a memory entry
+   */
+  async update(id, updates) {
+    const db = await this.ensureInitialized();
+    const existing = await this.get(id);
+    if (!existing) {
+      return false;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata
+      },
+      updatedAt: Date.now()
+    };
+    const stmt = db.prepare(`
+      UPDATE ${this.tableName}
+      SET content = ?, embedding = ?, type = ?, importance = ?,
+          metadata = ?, expires_at = ?, updated_at = ?
+      WHERE id = ?
+    `);
+    const result = stmt.run(
+      updated.content,
+      updated.embedding ? this.serializeVector(updated.embedding) : null,
+      updated.type,
+      updated.importance,
+      JSON.stringify(updated.metadata),
+      updated.expiresAt ?? null,
+      updated.updatedAt,
+      id
+    );
+    return result.changes > 0;
+  }
+  /**
+   * Delete a memory entry
+   */
+  async delete(id) {
+    const db = await this.ensureInitialized();
+    const stmt = db.prepare(`DELETE FROM ${this.tableName} WHERE id = ?`);
+    const result = stmt.run(id);
+    return result.changes > 0;
+  }
+  /**
+   * Query memory entries
+   */
+  async query(options) {
+    const db = await this.ensureInitialized();
+    const conditions = [];
+    const params = [];
+    if (options.query) {
+      conditions.push("content LIKE ?");
+      params.push(`%${options.query}%`);
+    }
+    if (options.userId) {
+      conditions.push("json_extract(metadata, '$.userId') = ?");
+      params.push(options.userId);
+    }
+    if (options.agentId) {
+      conditions.push("json_extract(metadata, '$.agentId') = ?");
+      params.push(options.agentId);
+    }
+    if (options.conversationId) {
+      conditions.push("json_extract(metadata, '$.conversationId') = ?");
+      params.push(options.conversationId);
+    }
+    if (options.namespace) {
+      conditions.push("json_extract(metadata, '$.namespace') = ?");
+      params.push(options.namespace);
+    }
+    if (options.types && options.types.length > 0) {
+      const placeholders = options.types.map(() => "?").join(", ");
+      conditions.push(`type IN (${placeholders})`);
+      params.push(...options.types);
+    }
+    if (options.minImportance !== void 0) {
+      conditions.push("importance >= ?");
+      params.push(options.minImportance);
+    }
+    if (options.startTime !== void 0) {
+      conditions.push("timestamp >= ?");
+      params.push(options.startTime);
+    }
+    if (options.endTime !== void 0) {
+      conditions.push("timestamp <= ?");
+      params.push(options.endTime);
+    }
+    if (!options.includeExpired) {
+      conditions.push("(expires_at IS NULL OR expires_at > ?)");
+      params.push(Date.now());
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countStmt = db.prepare(
+      `SELECT COUNT(*) as count FROM ${this.tableName} ${whereClause}`
+    );
+    const countResult = countStmt.get(...params);
+    const total = countResult.count;
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const queryStmt = db.prepare(`
+      SELECT * FROM ${this.tableName}
+      ${whereClause}
+      ORDER BY timestamp DESC
+      LIMIT ? OFFSET ?
+    `);
+    const rows = queryStmt.all(...params, limit, offset);
+    const entries = rows.map((row) => this.rowToEntry(row));
+    return {
+      entries,
+      total,
+      hasMore: offset + limit < total
+    };
+  }
+  /**
+   * Search by vector similarity
+   */
+  async search(embedding, options) {
+    const db = await this.ensureInitialized();
+    const conditions = ["embedding IS NOT NULL"];
+    const params = [];
+    if (options.namespace) {
+      conditions.push("json_extract(metadata, '$.namespace') = ?");
+      params.push(options.namespace);
+    }
+    if (options.filter) {
+      for (const [key, value] of Object.entries(options.filter)) {
+        if (value !== void 0) {
+          if (Array.isArray(value)) {
+            const placeholders = value.map(() => "?").join(", ");
+            conditions.push(
+              `json_extract(metadata, '$.${key}') IN (${placeholders})`
+            );
+            params.push(...value);
+          } else {
+            conditions.push(`json_extract(metadata, '$.${key}') = ?`);
+            params.push(value);
+          }
+        }
+      }
+    }
+    const whereClause = `WHERE ${conditions.join(" AND ")}`;
+    const stmt = db.prepare(`SELECT * FROM ${this.tableName} ${whereClause}`);
+    const rows = stmt.all(...params);
+    const results = [];
+    for (const row of rows) {
+      const entry = this.rowToEntry(row);
+      if (!entry.embedding) continue;
+      const score = this.cosineSimilarity(embedding, entry.embedding);
+      if (options.minScore === void 0 || score >= options.minScore) {
+        results.push({ entry, score });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return Promise.resolve(results.slice(0, options.topK));
+  }
+  /**
+   * Clear entries
+   */
+  async clear(options) {
+    const db = await this.ensureInitialized();
+    if (!options) {
+      const stmt2 = db.prepare(`DELETE FROM ${this.tableName}`);
+      const result2 = stmt2.run();
+      return result2.changes;
+    }
+    const conditions = [];
+    const params = [];
+    if (options.namespace) {
+      conditions.push("json_extract(metadata, '$.namespace') = ?");
+      params.push(options.namespace);
+    }
+    if (options.userId) {
+      conditions.push("json_extract(metadata, '$.userId') = ?");
+      params.push(options.userId);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const stmt = db.prepare(`DELETE FROM ${this.tableName} ${whereClause}`);
+    const result = stmt.run(...params);
+    return result.changes;
+  }
+  /**
+   * Count entries
+   */
+  async count(options) {
+    const db = await this.ensureInitialized();
+    if (!options) {
+      const stmt = db.prepare(
+        `SELECT COUNT(*) as count FROM ${this.tableName}`
+      );
+      const result = stmt.get();
+      return result.count;
+    }
+    const { total } = await this.query({ ...options, limit: 0 });
+    return total;
+  }
+  /**
+   * Close the database
+   */
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Convert database row to MemoryEntry
+   */
+  rowToEntry(row) {
+    return {
+      id: row.id,
+      content: row.content,
+      embedding: row.embedding ? this.deserializeVector(row.embedding) : void 0,
+      type: row.type,
+      importance: row.importance,
+      metadata: JSON.parse(row.metadata),
+      timestamp: row.timestamp,
+      expiresAt: row.expires_at,
+      parentId: row.parent_id,
+      accessCount: row.access_count,
+      lastAccessedAt: row.last_accessed_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Serialize vector to buffer
+   */
+  serializeVector(vector) {
+    const buffer = Buffer.alloc(vector.length * 4);
+    for (let i = 0; i < vector.length; i++) {
+      buffer.writeFloatLE(vector[i], i * 4);
+    }
+    return buffer;
+  }
+  /**
+   * Deserialize vector from buffer
+   */
+  deserializeVector(buffer) {
+    const vector = [];
+    for (let i = 0; i < buffer.length / 4; i++) {
+      vector.push(buffer.readFloatLE(i * 4));
+    }
+    return vector;
+  }
+  /**
+   * Calculate cosine similarity
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    if (magnitude === 0) {
+      return 0;
+    }
+    return dotProduct / magnitude;
+  }
+};
+async function createSQLiteStore(config) {
+  const store = new SQLiteStore(config);
+  await store.initialize();
+  return store;
+}
+
+// src/stores/implementations/PostgresStore.ts
+var PostgresStore = class {
+  pool = null;
+  config;
+  tableName;
+  vectorDimensions;
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+    this.tableName = config.tableName ?? "memories";
+    this.vectorDimensions = config.vectorDimensions ?? 1536;
+  }
+  /**
+   * Initialize the database
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const { Pool } = await import("pg");
+    if (this.config.connectionString) {
+      this.pool = new Pool({
+        connectionString: this.config.connectionString,
+        max: this.config.poolSize ?? 10,
+        ssl: this.config.ssl
+      });
+    } else {
+      this.pool = new Pool({
+        host: this.config.host ?? "localhost",
+        port: this.config.port ?? 5432,
+        database: this.config.database ?? "agentsea",
+        user: this.config.user ?? "postgres",
+        password: this.config.password,
+        max: this.config.poolSize ?? 10,
+        ssl: this.config.ssl
+      });
+    }
+    await this.pool.query("CREATE EXTENSION IF NOT EXISTS vector");
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        content TEXT NOT NULL,
+        embedding vector(${this.vectorDimensions}),
+        type TEXT NOT NULL,
+        importance REAL NOT NULL,
+        metadata JSONB NOT NULL,
+        timestamp BIGINT NOT NULL,
+        expires_at BIGINT,
+        parent_id TEXT,
+        access_count INTEGER DEFAULT 0,
+        last_accessed_at BIGINT,
+        created_at BIGINT NOT NULL,
+        updated_at BIGINT NOT NULL
+      )
+    `);
+    await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_timestamp ON ${this.tableName}(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_type ON ${this.tableName}(type);
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_importance ON ${this.tableName}(importance);
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_metadata ON ${this.tableName} USING GIN(metadata);
+    `);
+    await this.pool.query(
+      `
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_embedding
+      ON ${this.tableName} USING ivfflat (embedding vector_cosine_ops)
+      WITH (lists = 100)
+    `
+    ).catch(() => {
+    });
+    this.initialized = true;
+  }
+  /**
+   * Ensure database is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.pool;
+  }
+  /**
+   * Add a memory entry
+   */
+  async add(entry) {
+    const pool = await this.ensureInitialized();
+    const embeddingValue = entry.embedding ? `[${entry.embedding.join(",")}]` : null;
+    await pool.query(
+      `INSERT INTO ${this.tableName} (
+        id, content, embedding, type, importance, metadata,
+        timestamp, expires_at, parent_id, access_count,
+        last_accessed_at, created_at, updated_at
+      ) VALUES ($1, $2, $3::vector, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+      [
+        entry.id,
+        entry.content,
+        embeddingValue,
+        entry.type,
+        entry.importance,
+        JSON.stringify(entry.metadata),
+        entry.timestamp,
+        entry.expiresAt ?? null,
+        entry.parentId ?? null,
+        entry.accessCount,
+        entry.lastAccessedAt ?? null,
+        entry.createdAt,
+        entry.updatedAt
+      ]
+    );
+    return entry.id;
+  }
+  /**
+   * Get a memory entry by ID
+   */
+  async get(id) {
+    const pool = await this.ensureInitialized();
+    const result = await pool.query(
+      `SELECT * FROM ${this.tableName} WHERE id = $1`,
+      [id]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    await pool.query(
+      `UPDATE ${this.tableName}
+       SET access_count = access_count + 1, last_accessed_at = $1
+       WHERE id = $2`,
+      [Date.now(), id]
+    );
+    return Promise.resolve(this.rowToEntry(result.rows[0]));
+  }
+  /**
+   * Update a memory entry
+   */
+  async update(id, updates) {
+    const pool = await this.ensureInitialized();
+    const existing = await this.get(id);
+    if (!existing) {
+      return false;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata
+      },
+      updatedAt: Date.now()
+    };
+    const embeddingValue = updated.embedding ? `[${updated.embedding.join(",")}]` : null;
+    const result = await pool.query(
+      `UPDATE ${this.tableName}
+       SET content = $1, embedding = $2::vector, type = $3, importance = $4,
+           metadata = $5, expires_at = $6, updated_at = $7
+       WHERE id = $8`,
+      [
+        updated.content,
+        embeddingValue,
+        updated.type,
+        updated.importance,
+        JSON.stringify(updated.metadata),
+        updated.expiresAt ?? null,
+        updated.updatedAt,
+        id
+      ]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Delete a memory entry
+   */
+  async delete(id) {
+    const pool = await this.ensureInitialized();
+    const result = await pool.query(
+      `DELETE FROM ${this.tableName} WHERE id = $1`,
+      [id]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Query memory entries
+   */
+  async query(options) {
+    const pool = await this.ensureInitialized();
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    if (options.query) {
+      conditions.push(`content ILIKE $${paramIndex}`);
+      params.push(`%${options.query}%`);
+      paramIndex++;
+    }
+    if (options.userId) {
+      conditions.push(`metadata->>'userId' = $${paramIndex}`);
+      params.push(options.userId);
+      paramIndex++;
+    }
+    if (options.agentId) {
+      conditions.push(`metadata->>'agentId' = $${paramIndex}`);
+      params.push(options.agentId);
+      paramIndex++;
+    }
+    if (options.conversationId) {
+      conditions.push(`metadata->>'conversationId' = $${paramIndex}`);
+      params.push(options.conversationId);
+      paramIndex++;
+    }
+    if (options.namespace) {
+      conditions.push(`metadata->>'namespace' = $${paramIndex}`);
+      params.push(options.namespace);
+      paramIndex++;
+    }
+    if (options.types && options.types.length > 0) {
+      conditions.push(`type = ANY($${paramIndex})`);
+      params.push(options.types);
+      paramIndex++;
+    }
+    if (options.minImportance !== void 0) {
+      conditions.push(`importance >= $${paramIndex}`);
+      params.push(options.minImportance);
+      paramIndex++;
+    }
+    if (options.startTime !== void 0) {
+      conditions.push(`timestamp >= $${paramIndex}`);
+      params.push(options.startTime);
+      paramIndex++;
+    }
+    if (options.endTime !== void 0) {
+      conditions.push(`timestamp <= $${paramIndex}`);
+      params.push(options.endTime);
+      paramIndex++;
+    }
+    if (!options.includeExpired) {
+      conditions.push(`(expires_at IS NULL OR expires_at > $${paramIndex})`);
+      params.push(Date.now());
+      paramIndex++;
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countResult = await pool.query(
+      `SELECT COUNT(*) as count FROM ${this.tableName} ${whereClause}`,
+      params
+    );
+    const total = parseInt(countResult.rows[0].count, 10);
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const queryResult = await pool.query(
+      `SELECT * FROM ${this.tableName}
+       ${whereClause}
+       ORDER BY timestamp DESC
+       LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+      [...params, limit, offset]
+    );
+    const entries = queryResult.rows.map((row) => this.rowToEntry(row));
+    return {
+      entries,
+      total,
+      hasMore: offset + limit < total
+    };
+  }
+  /**
+   * Search by vector similarity using pgvector
+   */
+  async search(embedding, options) {
+    const pool = await this.ensureInitialized();
+    const conditions = ["embedding IS NOT NULL"];
+    const params = [`[${embedding.join(",")}]`];
+    let paramIndex = 2;
+    if (options.namespace) {
+      conditions.push(`metadata->>'namespace' = $${paramIndex}`);
+      params.push(options.namespace);
+      paramIndex++;
+    }
+    if (options.filter) {
+      for (const [key, value] of Object.entries(options.filter)) {
+        if (value !== void 0) {
+          if (Array.isArray(value)) {
+            conditions.push(`metadata->>'${key}' = ANY($${paramIndex})`);
+            params.push(value);
+          } else {
+            conditions.push(`metadata->>'${key}' = $${paramIndex}`);
+            params.push(value);
+          }
+          paramIndex++;
+        }
+      }
+    }
+    const whereClause = `WHERE ${conditions.join(" AND ")}`;
+    const minScore = options.minScore ?? 0;
+    const result = await pool.query(
+      `SELECT *, 1 - (embedding <=> $1::vector) as score
+       FROM ${this.tableName}
+       ${whereClause}
+       AND 1 - (embedding <=> $1::vector) >= $${paramIndex}
+       ORDER BY embedding <=> $1::vector
+       LIMIT $${paramIndex + 1}`,
+      [...params, minScore, options.topK]
+    );
+    return result.rows.map((row) => ({
+      entry: this.rowToEntry(row),
+      score: parseFloat(row.score)
+    }));
+  }
+  /**
+   * Clear entries
+   */
+  async clear(options) {
+    const pool = await this.ensureInitialized();
+    if (!options) {
+      const result2 = await pool.query(`DELETE FROM ${this.tableName}`);
+      return result2.rowCount ?? 0;
+    }
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    if (options.namespace) {
+      conditions.push(`metadata->>'namespace' = $${paramIndex}`);
+      params.push(options.namespace);
+      paramIndex++;
+    }
+    if (options.userId) {
+      conditions.push(`metadata->>'userId' = $${paramIndex}`);
+      params.push(options.userId);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await pool.query(
+      `DELETE FROM ${this.tableName} ${whereClause}`,
+      params
+    );
+    return result.rowCount ?? 0;
+  }
+  /**
+   * Count entries
+   */
+  async count(options) {
+    const pool = await this.ensureInitialized();
+    if (!options) {
+      const result = await pool.query(
+        `SELECT COUNT(*) as count FROM ${this.tableName}`
+      );
+      return Promise.resolve(parseInt(result.rows[0].count, 10));
+    }
+    const { total } = await this.query({ ...options, limit: 0 });
+    return total;
+  }
+  /**
+   * Close the connection pool
+   */
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+      this.initialized = false;
+    }
+  }
+  /**
+   * Convert database row to MemoryEntry
+   */
+  rowToEntry(row) {
+    const embedding = row.embedding;
+    let embeddingArray;
+    if (embedding) {
+      const cleaned = embedding.replace(/[[\]]/g, "");
+      embeddingArray = cleaned.split(",").map((v) => parseFloat(v));
+    }
+    return {
+      id: row.id,
+      content: row.content,
+      embedding: embeddingArray,
+      type: row.type,
+      importance: parseFloat(row.importance),
+      metadata: row.metadata,
+      timestamp: parseInt(row.timestamp, 10),
+      expiresAt: row.expires_at ? parseInt(row.expires_at, 10) : void 0,
+      parentId: row.parent_id,
+      accessCount: parseInt(row.access_count, 10),
+      lastAccessedAt: row.last_accessed_at ? parseInt(row.last_accessed_at, 10) : void 0,
+      createdAt: parseInt(row.created_at, 10),
+      updatedAt: parseInt(row.updated_at, 10)
+    };
+  }
+};
+async function createPostgresStore(config) {
+  const store = new PostgresStore(config);
+  await store.initialize();
+  return store;
+}
+
+// src/stores/implementations/RedisStore.ts
+var RedisStore = class {
+  redis = null;
+  config;
+  keyPrefix;
+  ttl;
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+    this.keyPrefix = config.keyPrefix ?? "memory:";
+    this.ttl = config.ttl;
+  }
+  /**
+   * Initialize Redis connection
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const Redis = (await import("ioredis")).default;
+    if (this.config.url) {
+      this.redis = new Redis(this.config.url);
+    } else {
+      this.redis = new Redis({
+        host: this.config.host ?? "localhost",
+        port: this.config.port ?? 6379,
+        password: this.config.password,
+        db: this.config.db ?? 0
+      });
+    }
+    this.initialized = true;
+  }
+  /**
+   * Ensure Redis is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.redis;
+  }
+  /**
+   * Get key for memory entry
+   */
+  getKey(id) {
+    return `${this.keyPrefix}${id}`;
+  }
+  /**
+   * Get index key
+   */
+  getIndexKey(index) {
+    return `${this.keyPrefix}index:${index}`;
+  }
+  /**
+   * Add a memory entry
+   */
+  async add(entry) {
+    const redis = await this.ensureInitialized();
+    const key = this.getKey(entry.id);
+    const data = JSON.stringify(entry);
+    if (this.ttl || entry.expiresAt) {
+      const ttlMs = entry.expiresAt ? entry.expiresAt - Date.now() : this.ttl * 1e3;
+      if (ttlMs > 0) {
+        await redis.setex(key, Math.ceil(ttlMs / 1e3), data);
+      } else {
+        await redis.set(key, data);
+      }
+    } else {
+      await redis.set(key, data);
+    }
+    await this.addToIndexes(entry);
+    return entry.id;
+  }
+  /**
+   * Add entry to indexes
+   */
+  async addToIndexes(entry) {
+    const redis = await this.ensureInitialized();
+    const score = entry.timestamp;
+    await redis.zadd(this.getIndexKey("all"), score, entry.id);
+    await redis.zadd(this.getIndexKey(`type:${entry.type}`), score, entry.id);
+    const namespace = entry.metadata.namespace ?? "default";
+    await redis.zadd(
+      this.getIndexKey(`namespace:${namespace}`),
+      score,
+      entry.id
+    );
+    if (entry.metadata.userId) {
+      await redis.zadd(
+        this.getIndexKey(`user:${entry.metadata.userId}`),
+        score,
+        entry.id
+      );
+    }
+    if (entry.metadata.conversationId) {
+      await redis.zadd(
+        this.getIndexKey(`conversation:${entry.metadata.conversationId}`),
+        score,
+        entry.id
+      );
+    }
+  }
+  /**
+   * Remove entry from indexes
+   */
+  async removeFromIndexes(entry) {
+    const redis = await this.ensureInitialized();
+    await redis.zrem(this.getIndexKey("all"), entry.id);
+    await redis.zrem(this.getIndexKey(`type:${entry.type}`), entry.id);
+    const namespace = entry.metadata.namespace ?? "default";
+    await redis.zrem(this.getIndexKey(`namespace:${namespace}`), entry.id);
+    if (entry.metadata.userId) {
+      await redis.zrem(
+        this.getIndexKey(`user:${entry.metadata.userId}`),
+        entry.id
+      );
+    }
+    if (entry.metadata.conversationId) {
+      await redis.zrem(
+        this.getIndexKey(`conversation:${entry.metadata.conversationId}`),
+        entry.id
+      );
+    }
+  }
+  /**
+   * Get a memory entry by ID
+   */
+  async get(id) {
+    const redis = await this.ensureInitialized();
+    const key = this.getKey(id);
+    const data = await redis.get(key);
+    if (!data) {
+      return null;
+    }
+    const entry = JSON.parse(data);
+    entry.accessCount++;
+    entry.lastAccessedAt = Date.now();
+    await redis.set(key, JSON.stringify(entry));
+    return entry;
+  }
+  /**
+   * Update a memory entry
+   */
+  async update(id, updates) {
+    const redis = await this.ensureInitialized();
+    const existing = await this.get(id);
+    if (!existing) {
+      return false;
+    }
+    await this.removeFromIndexes(existing);
+    const updated = {
+      ...existing,
+      ...updates,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata
+      },
+      updatedAt: Date.now()
+    };
+    const key = this.getKey(id);
+    await redis.set(key, JSON.stringify(updated));
+    await this.addToIndexes(updated);
+    return true;
+  }
+  /**
+   * Delete a memory entry
+   */
+  async delete(id) {
+    const redis = await this.ensureInitialized();
+    const existing = await this.get(id);
+    if (!existing) {
+      return false;
+    }
+    await this.removeFromIndexes(existing);
+    const result = await redis.del(this.getKey(id));
+    return result > 0;
+  }
+  /**
+   * Query memory entries
+   */
+  async query(options) {
+    const redis = await this.ensureInitialized();
+    let indexKey = this.getIndexKey("all");
+    if (options.conversationId) {
+      indexKey = this.getIndexKey(`conversation:${options.conversationId}`);
+    } else if (options.userId) {
+      indexKey = this.getIndexKey(`user:${options.userId}`);
+    } else if (options.namespace) {
+      indexKey = this.getIndexKey(`namespace:${options.namespace}`);
+    } else if (options.types && options.types.length === 1) {
+      indexKey = this.getIndexKey(`type:${options.types[0]}`);
+    }
+    const minScore = options.startTime ?? "-inf";
+    const maxScore = options.endTime ?? "+inf";
+    const ids = await redis.zrevrangebyscore(
+      indexKey,
+      maxScore,
+      minScore,
+      "LIMIT",
+      0,
+      1e3
+      // Get more than needed for filtering
+    );
+    const entries = [];
+    const pipeline = redis.pipeline();
+    for (const id of ids) {
+      pipeline.get(this.getKey(id));
+    }
+    const results = await pipeline.exec();
+    if (results) {
+      for (const [err, data] of results) {
+        if (!err && data) {
+          const entry = JSON.parse(data);
+          if (this.matchesQuery(entry, options)) {
+            entries.push(entry);
+          }
+        }
+      }
+    }
+    const limit = options.limit ?? 100;
+    const offset = options.offset ?? 0;
+    const paginated = entries.slice(offset, offset + limit);
+    return {
+      entries: paginated,
+      total: entries.length,
+      hasMore: offset + limit < entries.length
+    };
+  }
+  /**
+   * Check if entry matches query
+   */
+  matchesQuery(entry, options) {
+    if (options.query) {
+      if (!entry.content.toLowerCase().includes(options.query.toLowerCase())) {
+        return false;
+      }
+    }
+    if (options.userId && entry.metadata.userId !== options.userId) {
+      return false;
+    }
+    if (options.agentId && entry.metadata.agentId !== options.agentId) {
+      return false;
+    }
+    if (options.conversationId && entry.metadata.conversationId !== options.conversationId) {
+      return false;
+    }
+    if (options.namespace && entry.metadata.namespace !== options.namespace) {
+      return false;
+    }
+    if (options.types && options.types.length > 0 && !options.types.includes(entry.type)) {
+      return false;
+    }
+    if (options.minImportance !== void 0 && entry.importance < options.minImportance) {
+      return false;
+    }
+    if (options.tags && options.tags.length > 0) {
+      const entryTags = entry.metadata.tags ?? [];
+      if (!options.tags.every((tag) => entryTags.includes(tag))) {
+        return false;
+      }
+    }
+    if (!options.includeExpired && entry.expiresAt && entry.expiresAt < Date.now()) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Search by vector similarity
+   */
+  async search(embedding, options) {
+    const { entries } = await this.query({
+      limit: 1e4,
+      namespace: options.namespace
+    });
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.embedding) continue;
+      if (options.filter) {
+        let matches = true;
+        for (const [key, value] of Object.entries(options.filter)) {
+          if (value !== void 0) {
+            const metaValue = entry.metadata[key];
+            if (Array.isArray(value)) {
+              if (!value.includes(metaValue)) {
+                matches = false;
+                break;
+              }
+            } else if (metaValue !== value) {
+              matches = false;
+              break;
+            }
+          }
+        }
+        if (!matches) continue;
+      }
+      const score = this.cosineSimilarity(embedding, entry.embedding);
+      if (options.minScore === void 0 || score >= options.minScore) {
+        results.push({ entry, score });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return Promise.resolve(results.slice(0, options.topK));
+  }
+  /**
+   * Calculate cosine similarity
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+  }
+  /**
+   * Clear entries
+   */
+  async clear(options) {
+    const redis = await this.ensureInitialized();
+    if (!options) {
+      const keys = await redis.keys(`${this.keyPrefix}*`);
+      if (keys.length > 0) {
+        await redis.del(...keys);
+      }
+      return keys.length;
+    }
+    const { entries } = await this.query({
+      namespace: options.namespace,
+      userId: options.userId,
+      limit: 1e5
+    });
+    for (const entry of entries) {
+      await this.delete(entry.id);
+    }
+    return entries.length;
+  }
+  /**
+   * Count entries
+   */
+  async count(options) {
+    const redis = await this.ensureInitialized();
+    if (!options) {
+      return Promise.resolve(redis.zcard(this.getIndexKey("all")));
+    }
+    const { total } = await this.query({ ...options, limit: 0 });
+    return total;
+  }
+  /**
+   * Close Redis connection
+   */
+  async close() {
+    if (this.redis) {
+      await this.redis.quit();
+      this.redis = null;
+      this.initialized = false;
+    }
+  }
+};
+async function createRedisStore(config) {
+  const store = new RedisStore(config);
+  await store.initialize();
+  return store;
+}
+
+export {
+  InMemoryStore,
+  createInMemoryStore,
+  SQLiteStore,
+  createSQLiteStore,
+  PostgresStore,
+  createPostgresStore,
+  RedisStore,
+  createRedisStore
+};