@mzhub/mem-ts 0.1.0

package/dist/adapters/index.mjs

@@ -0,0 +1,1542 @@
+import { v4 } from 'uuid';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+// src/adapters/BaseAdapter.ts
+var BaseAdapter = class {
+  initialized = false;
+  // =========================================================================
+  // Utility Methods
+  // =========================================================================
+  /**
+   * Check if adapter is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Ensure adapter is initialized before operations
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+};
+var InMemoryAdapter = class extends BaseAdapter {
+  users = /* @__PURE__ */ new Map();
+  async initialize() {
+    this.initialized = true;
+  }
+  async close() {
+    this.users.clear();
+    this.initialized = false;
+  }
+  getUserData(userId) {
+    let userData = this.users.get(userId);
+    if (!userData) {
+      userData = {
+        facts: /* @__PURE__ */ new Map(),
+        conversations: [],
+        sessions: /* @__PURE__ */ new Map()
+      };
+      this.users.set(userId, userData);
+    }
+    return userData;
+  }
+  // =========================================================================
+  // Fact Operations
+  // =========================================================================
+  async getFacts(userId, filter) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    let facts = Array.from(userData.facts.values());
+    if (filter) {
+      if (filter.subject) {
+        facts = facts.filter((f) => f.subject === filter.subject);
+      }
+      if (filter.predicate) {
+        facts = facts.filter((f) => f.predicate === filter.predicate);
+      }
+      if (filter.predicates && filter.predicates.length > 0) {
+        facts = facts.filter((f) => filter.predicates.includes(f.predicate));
+      }
+      if (filter.validOnly !== false) {
+        facts = facts.filter((f) => f.invalidatedAt === null);
+      }
+      if (filter.orderBy) {
+        facts.sort((a, b) => {
+          const aVal = a[filter.orderBy];
+          const bVal = b[filter.orderBy];
+          if (aVal instanceof Date && bVal instanceof Date) {
+            return filter.orderDir === "desc" ? bVal.getTime() - aVal.getTime() : aVal.getTime() - bVal.getTime();
+          }
+          if (typeof aVal === "number" && typeof bVal === "number") {
+            return filter.orderDir === "desc" ? bVal - aVal : aVal - bVal;
+          }
+          return 0;
+        });
+      }
+      if (filter.limit) {
+        facts = facts.slice(0, filter.limit);
+      }
+    }
+    return facts;
+  }
+  async getFactById(userId, factId) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    return userData.facts.get(factId) || null;
+  }
+  async upsertFact(userId, fact) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    const existingFact = Array.from(userData.facts.values()).find(
+      (f) => f.subject === fact.subject && f.predicate === fact.predicate && f.invalidatedAt === null
+    );
+    const now = /* @__PURE__ */ new Date();
+    if (existingFact) {
+      const updated = {
+        ...existingFact,
+        ...fact,
+        updatedAt: now
+      };
+      userData.facts.set(existingFact.id, updated);
+      return updated;
+    }
+    const newFact = {
+      ...fact,
+      id: v4(),
+      createdAt: now,
+      updatedAt: now
+    };
+    userData.facts.set(newFact.id, newFact);
+    return newFact;
+  }
+  async updateFact(userId, factId, updates) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    const fact = userData.facts.get(factId);
+    if (!fact) {
+      throw new Error(`Fact not found: ${factId}`);
+    }
+    const updated = {
+      ...fact,
+      ...updates,
+      id: fact.id,
+      // Prevent ID change
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    userData.facts.set(factId, updated);
+    return updated;
+  }
+  async deleteFact(userId, factId, _reason) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    const fact = userData.facts.get(factId);
+    if (fact) {
+      fact.invalidatedAt = /* @__PURE__ */ new Date();
+      userData.facts.set(factId, fact);
+    }
+  }
+  async hardDeleteFact(userId, factId) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    userData.facts.delete(factId);
+  }
+  // =========================================================================
+  // Conversation Operations
+  // =========================================================================
+  async getConversationHistory(userId, limit, sessionId) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    let conversations = [...userData.conversations];
+    if (sessionId) {
+      conversations = conversations.filter((c) => c.sessionId === sessionId);
+    }
+    conversations.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    if (limit) {
+      conversations = conversations.slice(0, limit);
+    }
+    return conversations;
+  }
+  async saveConversation(userId, exchange) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    const newExchange = {
+      ...exchange,
+      id: v4()
+    };
+    userData.conversations.push(newExchange);
+    const session = userData.sessions.get(exchange.sessionId);
+    if (session) {
+      session.messageCount++;
+    }
+    return newExchange;
+  }
+  // =========================================================================
+  // Session Operations
+  // =========================================================================
+  async getSessions(userId, limit) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    let sessions = Array.from(userData.sessions.values());
+    sessions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+    if (limit) {
+      sessions = sessions.slice(0, limit);
+    }
+    return sessions;
+  }
+  async getSession(userId, sessionId) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    return userData.sessions.get(sessionId) || null;
+  }
+  async createSession(userId) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    const session = {
+      id: v4(),
+      userId,
+      startedAt: /* @__PURE__ */ new Date(),
+      endedAt: null,
+      messageCount: 0
+    };
+    userData.sessions.set(session.id, session);
+    return session;
+  }
+  async endSession(userId, sessionId, summary) {
+    await this.ensureInitialized();
+    const userData = this.getUserData(userId);
+    const session = userData.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    session.endedAt = /* @__PURE__ */ new Date();
+    if (summary) {
+      session.summary = summary;
+    }
+    userData.sessions.set(sessionId, session);
+    return session;
+  }
+  // =========================================================================
+  // Utility Methods
+  // =========================================================================
+  /**
+   * Clear all data for a user (useful for testing)
+   */
+  async clearUser(userId) {
+    this.users.delete(userId);
+  }
+  /**
+   * Clear all data (useful for testing)
+   */
+  async clearAll() {
+    this.users.clear();
+  }
+  /**
+   * Export all data for a user (for portability)
+   */
+  async exportUser(userId) {
+    const userData = this.getUserData(userId);
+    return {
+      facts: Array.from(userData.facts.values()),
+      conversations: userData.conversations,
+      sessions: Array.from(userData.sessions.values())
+    };
+  }
+  /**
+   * Import data for a user
+   */
+  async importUser(userId, data) {
+    const userData = this.getUserData(userId);
+    for (const fact of data.facts) {
+      userData.facts.set(fact.id, fact);
+    }
+    userData.conversations.push(...data.conversations);
+    for (const session of data.sessions) {
+      userData.sessions.set(session.id, session);
+    }
+  }
+};
+var JSONFileAdapter = class extends BaseAdapter {
+  basePath;
+  prettyPrint;
+  constructor(config = {}) {
+    super();
+    this.basePath = config.path || "./.mem-ts";
+    this.prettyPrint = config.prettyPrint ?? process.env.NODE_ENV !== "production";
+  }
+  async initialize() {
+    await fs.mkdir(path.join(this.basePath, "users"), { recursive: true });
+    this.initialized = true;
+  }
+  async close() {
+    this.initialized = false;
+  }
+  // =========================================================================
+  // File I/O Helpers
+  // =========================================================================
+  getUserPath(userId) {
+    const safeUserId = userId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path.join(this.basePath, "users", safeUserId);
+  }
+  async ensureUserDir(userId) {
+    await fs.mkdir(this.getUserPath(userId), { recursive: true });
+  }
+  async readFile(userId, filename, defaultValue) {
+    const filePath = path.join(this.getUserPath(userId), filename);
+    try {
+      const data = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(data, this.dateReviver);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return defaultValue;
+      }
+      throw error;
+    }
+  }
+  async writeFile(userId, filename, data) {
+    await this.ensureUserDir(userId);
+    const filePath = path.join(this.getUserPath(userId), filename);
+    const json = this.prettyPrint ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    await fs.writeFile(filePath, json, "utf-8");
+  }
+  // Date reviver for JSON.parse
+  dateReviver(_key, value) {
+    if (typeof value === "string") {
+      const dateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+      if (dateRegex.test(value)) {
+        return new Date(value);
+      }
+    }
+    return value;
+  }
+  // =========================================================================
+  // Fact Operations
+  // =========================================================================
+  async getFacts(userId, filter) {
+    await this.ensureInitialized();
+    let facts = await this.readFile(userId, "facts.json", []);
+    if (filter) {
+      if (filter.subject) {
+        facts = facts.filter((f) => f.subject === filter.subject);
+      }
+      if (filter.predicate) {
+        facts = facts.filter((f) => f.predicate === filter.predicate);
+      }
+      if (filter.predicates && filter.predicates.length > 0) {
+        facts = facts.filter((f) => filter.predicates.includes(f.predicate));
+      }
+      if (filter.validOnly !== false) {
+        facts = facts.filter((f) => f.invalidatedAt === null);
+      }
+      if (filter.orderBy) {
+        facts.sort((a, b) => {
+          const aVal = a[filter.orderBy];
+          const bVal = b[filter.orderBy];
+          if (aVal instanceof Date && bVal instanceof Date) {
+            return filter.orderDir === "desc" ? bVal.getTime() - aVal.getTime() : aVal.getTime() - bVal.getTime();
+          }
+          if (typeof aVal === "number" && typeof bVal === "number") {
+            return filter.orderDir === "desc" ? bVal - aVal : aVal - bVal;
+          }
+          return 0;
+        });
+      }
+      if (filter.limit) {
+        facts = facts.slice(0, filter.limit);
+      }
+    }
+    return facts;
+  }
+  async getFactById(userId, factId) {
+    await this.ensureInitialized();
+    const facts = await this.readFile(userId, "facts.json", []);
+    return facts.find((f) => f.id === factId) || null;
+  }
+  async upsertFact(userId, fact) {
+    await this.ensureInitialized();
+    const facts = await this.readFile(userId, "facts.json", []);
+    const existingIndex = facts.findIndex(
+      (f) => f.subject === fact.subject && f.predicate === fact.predicate && f.invalidatedAt === null
+    );
+    const now = /* @__PURE__ */ new Date();
+    if (existingIndex >= 0) {
+      const updated = {
+        ...facts[existingIndex],
+        ...fact,
+        updatedAt: now
+      };
+      facts[existingIndex] = updated;
+      await this.writeFile(userId, "facts.json", facts);
+      return updated;
+    }
+    const newFact = {
+      ...fact,
+      id: v4(),
+      createdAt: now,
+      updatedAt: now
+    };
+    facts.push(newFact);
+    await this.writeFile(userId, "facts.json", facts);
+    return newFact;
+  }
+  async updateFact(userId, factId, updates) {
+    await this.ensureInitialized();
+    const facts = await this.readFile(userId, "facts.json", []);
+    const index = facts.findIndex((f) => f.id === factId);
+    if (index === -1) {
+      throw new Error(`Fact not found: ${factId}`);
+    }
+    const updated = {
+      ...facts[index],
+      ...updates,
+      id: facts[index].id,
+      // Prevent ID change
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    facts[index] = updated;
+    await this.writeFile(userId, "facts.json", facts);
+    return updated;
+  }
+  async deleteFact(userId, factId, _reason) {
+    await this.ensureInitialized();
+    const facts = await this.readFile(userId, "facts.json", []);
+    const index = facts.findIndex((f) => f.id === factId);
+    if (index >= 0) {
+      facts[index].invalidatedAt = /* @__PURE__ */ new Date();
+      await this.writeFile(userId, "facts.json", facts);
+    }
+  }
+  async hardDeleteFact(userId, factId) {
+    await this.ensureInitialized();
+    const facts = await this.readFile(userId, "facts.json", []);
+    const filtered = facts.filter((f) => f.id !== factId);
+    await this.writeFile(userId, "facts.json", filtered);
+  }
+  // =========================================================================
+  // Conversation Operations
+  // =========================================================================
+  async getConversationHistory(userId, limit, sessionId) {
+    await this.ensureInitialized();
+    let conversations = await this.readFile(
+      userId,
+      "conversations.json",
+      []
+    );
+    if (sessionId) {
+      conversations = conversations.filter((c) => c.sessionId === sessionId);
+    }
+    conversations.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    if (limit) {
+      conversations = conversations.slice(0, limit);
+    }
+    return conversations;
+  }
+  async saveConversation(userId, exchange) {
+    await this.ensureInitialized();
+    const conversations = await this.readFile(
+      userId,
+      "conversations.json",
+      []
+    );
+    const newExchange = {
+      ...exchange,
+      id: v4()
+    };
+    conversations.push(newExchange);
+    await this.writeFile(userId, "conversations.json", conversations);
+    const sessions = await this.readFile(
+      userId,
+      "sessions.json",
+      []
+    );
+    const sessionIndex = sessions.findIndex((s) => s.id === exchange.sessionId);
+    if (sessionIndex >= 0) {
+      sessions[sessionIndex].messageCount++;
+      await this.writeFile(userId, "sessions.json", sessions);
+    }
+    return newExchange;
+  }
+  // =========================================================================
+  // Session Operations
+  // =========================================================================
+  async getSessions(userId, limit) {
+    await this.ensureInitialized();
+    let sessions = await this.readFile(userId, "sessions.json", []);
+    sessions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+    if (limit) {
+      sessions = sessions.slice(0, limit);
+    }
+    return sessions;
+  }
+  async getSession(userId, sessionId) {
+    await this.ensureInitialized();
+    const sessions = await this.readFile(
+      userId,
+      "sessions.json",
+      []
+    );
+    return sessions.find((s) => s.id === sessionId) || null;
+  }
+  async createSession(userId) {
+    await this.ensureInitialized();
+    const sessions = await this.readFile(
+      userId,
+      "sessions.json",
+      []
+    );
+    const session = {
+      id: v4(),
+      userId,
+      startedAt: /* @__PURE__ */ new Date(),
+      endedAt: null,
+      messageCount: 0
+    };
+    sessions.push(session);
+    await this.writeFile(userId, "sessions.json", sessions);
+    return session;
+  }
+  async endSession(userId, sessionId, summary) {
+    await this.ensureInitialized();
+    const sessions = await this.readFile(
+      userId,
+      "sessions.json",
+      []
+    );
+    const index = sessions.findIndex((s) => s.id === sessionId);
+    if (index === -1) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    sessions[index].endedAt = /* @__PURE__ */ new Date();
+    if (summary) {
+      sessions[index].summary = summary;
+    }
+    await this.writeFile(userId, "sessions.json", sessions);
+    return sessions[index];
+  }
+  // =========================================================================
+  // Utility Methods
+  // =========================================================================
+  /**
+   * Export all data for a user (for portability)
+   */
+  async exportUser(userId) {
+    return {
+      facts: await this.readFile(userId, "facts.json", []),
+      conversations: await this.readFile(
+        userId,
+        "conversations.json",
+        []
+      ),
+      sessions: await this.readFile(userId, "sessions.json", [])
+    };
+  }
+  /**
+   * Import data for a user
+   */
+  async importUser(userId, data) {
+    await this.writeFile(userId, "facts.json", data.facts);
+    await this.writeFile(userId, "conversations.json", data.conversations);
+    await this.writeFile(userId, "sessions.json", data.sessions);
+  }
+  /**
+   * Delete all data for a user
+   */
+  async deleteUser(userId) {
+    const userPath = this.getUserPath(userId);
+    await fs.rm(userPath, { recursive: true, force: true });
+  }
+};
+
+// src/adapters/MongoDBAdapter.ts
+var MongoDBAdapter = class extends BaseAdapter {
+  config;
+  client;
+  db;
+  collectionPrefix;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.collectionPrefix = config.collectionPrefix || "memts_";
+  }
+  async getClient() {
+    if (this.client) return this.client;
+    try {
+      const { MongoClient } = await import('mongodb');
+      this.client = new MongoClient(this.config.uri);
+      await this.client.connect();
+      return this.client;
+    } catch {
+      throw new Error("MongoDB driver not installed. Run: npm install mongodb");
+    }
+  }
+  getCollection(name) {
+    return this.db.collection(`${this.collectionPrefix}${name}`);
+  }
+  async initialize() {
+    const client = await this.getClient();
+    const dbName = this.config.database || "memts";
+    this.db = client.db(dbName);
+    const facts = this.getCollection("facts");
+    await facts.createIndex({ userId: 1, subject: 1, predicate: 1 });
+    await facts.createIndex({ userId: 1, invalidatedAt: 1 });
+    await facts.createIndex({ userId: 1, updatedAt: -1 });
+    const conversations = this.getCollection("conversations");
+    await conversations.createIndex({ userId: 1, sessionId: 1 });
+    await conversations.createIndex({ userId: 1, timestamp: -1 });
+    const sessions = this.getCollection("sessions");
+    await sessions.createIndex({ userId: 1, startedAt: -1 });
+    this.initialized = true;
+  }
+  async close() {
+    if (this.client) {
+      await this.client.close();
+      this.client = void 0;
+      this.db = void 0;
+    }
+    this.initialized = false;
+  }
+  // =========================================================================
+  // Fact Operations
+  // =========================================================================
+  async getFacts(userId, filter) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("facts");
+    const query = { userId };
+    if (filter?.subject) query.subject = filter.subject;
+    if (filter?.predicate) query.predicate = filter.predicate;
+    if (filter?.predicates?.length) {
+      query.predicate = { $in: filter.predicates };
+    }
+    if (filter?.validOnly !== false) {
+      query.invalidatedAt = null;
+    }
+    let cursor = collection.find(query);
+    if (filter?.orderBy) {
+      const dir = filter.orderDir === "asc" ? 1 : -1;
+      cursor = cursor.sort({ [filter.orderBy]: dir });
+    }
+    if (filter?.limit) {
+      cursor = cursor.limit(filter.limit);
+    }
+    const docs = await cursor.toArray();
+    return docs.map(this.docToFact);
+  }
+  async getFactById(userId, factId) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("facts");
+    const doc = await collection.findOne({ userId, id: factId });
+    return doc ? this.docToFact(doc) : null;
+  }
+  async upsertFact(userId, fact) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("facts");
+    const { v4: uuidv43 } = await import('uuid');
+    const now = /* @__PURE__ */ new Date();
+    const existing = await collection.findOne({
+      userId,
+      subject: fact.subject,
+      predicate: fact.predicate,
+      invalidatedAt: null
+    });
+    if (existing) {
+      await collection.updateOne(
+        { _id: existing._id },
+        {
+          $set: {
+            object: fact.object,
+            confidence: fact.confidence,
+            source: fact.source,
+            updatedAt: now,
+            metadata: fact.metadata
+          }
+        }
+      );
+      return this.docToFact({
+        ...existing,
+        object: fact.object,
+        updatedAt: now
+      });
+    }
+    const newFact = {
+      id: uuidv43(),
+      userId,
+      ...fact,
+      createdAt: now,
+      updatedAt: now
+    };
+    await collection.insertOne(newFact);
+    return this.docToFact(newFact);
+  }
+  async updateFact(userId, factId, updates) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("facts");
+    const result = await collection.findOneAndUpdate(
+      { userId, id: factId },
+      {
+        $set: {
+          ...updates,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      },
+      { returnDocument: "after" }
+    );
+    if (!result) {
+      throw new Error(`Fact not found: ${factId}`);
+    }
+    return this.docToFact(result);
+  }
+  async deleteFact(userId, factId, _reason) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("facts");
+    await collection.updateOne(
+      { userId, id: factId },
+      { $set: { invalidatedAt: /* @__PURE__ */ new Date() } }
+    );
+  }
+  async hardDeleteFact(userId, factId) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("facts");
+    await collection.deleteOne({ userId, id: factId });
+  }
+  // =========================================================================
+  // Conversation Operations
+  // =========================================================================
+  async getConversationHistory(userId, limit, sessionId) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("conversations");
+    const query = { userId };
+    if (sessionId) query.sessionId = sessionId;
+    let cursor = collection.find(query).sort({ timestamp: -1 });
+    if (limit) {
+      cursor = cursor.limit(limit);
+    }
+    const docs = await cursor.toArray();
+    return docs.map(this.docToConversation);
+  }
+  async saveConversation(userId, exchange) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("conversations");
+    const { v4: uuidv43 } = await import('uuid');
+    const newExchange = {
+      id: uuidv43(),
+      ...exchange
+    };
+    await collection.insertOne(newExchange);
+    const sessionsCollection = this.getCollection("sessions");
+    await sessionsCollection.updateOne(
+      { userId, id: exchange.sessionId },
+      { $inc: { messageCount: 1 } }
+    );
+    return this.docToConversation(newExchange);
+  }
+  // =========================================================================
+  // Session Operations
+  // =========================================================================
+  async getSessions(userId, limit) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("sessions");
+    let cursor = collection.find({ userId }).sort({ startedAt: -1 });
+    if (limit) {
+      cursor = cursor.limit(limit);
+    }
+    const docs = await cursor.toArray();
+    return docs.map(this.docToSession);
+  }
+  async getSession(userId, sessionId) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("sessions");
+    const doc = await collection.findOne({ userId, id: sessionId });
+    return doc ? this.docToSession(doc) : null;
+  }
+  async createSession(userId) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("sessions");
+    const { v4: uuidv43 } = await import('uuid');
+    const session = {
+      id: uuidv43(),
+      userId,
+      startedAt: /* @__PURE__ */ new Date(),
+      endedAt: null,
+      messageCount: 0
+    };
+    await collection.insertOne(session);
+    return this.docToSession(session);
+  }
+  async endSession(userId, sessionId, summary) {
+    await this.ensureInitialized();
+    const collection = this.getCollection("sessions");
+    const result = await collection.findOneAndUpdate(
+      { userId, id: sessionId },
+      {
+        $set: {
+          endedAt: /* @__PURE__ */ new Date(),
+          ...summary && { summary }
+        }
+      },
+      { returnDocument: "after" }
+    );
+    if (!result) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return this.docToSession(result);
+  }
+  // =========================================================================
+  // Helper Methods
+  // =========================================================================
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  docToFact(doc) {
+    return {
+      id: doc.id,
+      subject: doc.subject,
+      predicate: doc.predicate,
+      object: doc.object,
+      confidence: doc.confidence,
+      importance: doc.importance ?? 5,
+      source: doc.source,
+      sourceConversationId: doc.sourceConversationId,
+      createdAt: new Date(doc.createdAt),
+      updatedAt: new Date(doc.updatedAt),
+      invalidatedAt: doc.invalidatedAt ? new Date(doc.invalidatedAt) : null,
+      accessCount: doc.accessCount ?? 0,
+      lastAccessedAt: doc.lastAccessedAt ? new Date(doc.lastAccessedAt) : void 0,
+      metadata: doc.metadata
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  docToConversation(doc) {
+    return {
+      id: doc.id,
+      userId: doc.userId,
+      sessionId: doc.sessionId,
+      userMessage: doc.userMessage,
+      assistantResponse: doc.assistantResponse,
+      timestamp: new Date(doc.timestamp),
+      metadata: doc.metadata
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  docToSession(doc) {
+    return {
+      id: doc.id,
+      userId: doc.userId,
+      startedAt: new Date(doc.startedAt),
+      endedAt: doc.endedAt ? new Date(doc.endedAt) : null,
+      messageCount: doc.messageCount,
+      summary: doc.summary
+    };
+  }
+};
+
+// src/adapters/PostgresAdapter.ts
+var PostgresAdapter = class extends BaseAdapter {
+  config;
+  pool;
+  schema;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.schema = config.schema || "memts";
+  }
+  async getPool() {
+    if (this.pool) return this.pool;
+    try {
+      const { Pool } = await import('pg');
+      this.pool = new Pool({
+        connectionString: this.config.connectionString
+      });
+      return this.pool;
+    } catch {
+      throw new Error("PostgreSQL driver not installed. Run: npm install pg");
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async query(sql, params) {
+    const pool = await this.getPool();
+    return pool.query(sql, params);
+  }
+  async initialize() {
+    await this.getPool();
+    await this.query(`CREATE SCHEMA IF NOT EXISTS ${this.schema}`);
+    await this.query(`
+      CREATE TABLE IF NOT EXISTS ${this.schema}.facts (
+        id UUID PRIMARY KEY,
+        user_id VARCHAR(255) NOT NULL,
+        subject VARCHAR(255) NOT NULL,
+        predicate VARCHAR(255) NOT NULL,
+        object TEXT NOT NULL,
+        confidence REAL DEFAULT 0.8,
+        source VARCHAR(255),
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        invalidated_at TIMESTAMPTZ,
+        metadata JSONB
+      )
+    `);
+    await this.query(`
+      CREATE INDEX IF NOT EXISTS idx_facts_user_subject_predicate 
+      ON ${this.schema}.facts (user_id, subject, predicate)
+    `);
+    await this.query(`
+      CREATE INDEX IF NOT EXISTS idx_facts_user_valid 
+      ON ${this.schema}.facts (user_id, invalidated_at)
+    `);
+    await this.query(`
+      CREATE TABLE IF NOT EXISTS ${this.schema}.conversations (
+        id UUID PRIMARY KEY,
+        user_id VARCHAR(255) NOT NULL,
+        session_id VARCHAR(255) NOT NULL,
+        user_message TEXT NOT NULL,
+        assistant_response TEXT NOT NULL,
+        timestamp TIMESTAMPTZ DEFAULT NOW(),
+        metadata JSONB
+      )
+    `);
+    await this.query(`
+      CREATE INDEX IF NOT EXISTS idx_conversations_user_session 
+      ON ${this.schema}.conversations (user_id, session_id)
+    `);
+    await this.query(`
+      CREATE TABLE IF NOT EXISTS ${this.schema}.sessions (
+        id UUID PRIMARY KEY,
+        user_id VARCHAR(255) NOT NULL,
+        started_at TIMESTAMPTZ DEFAULT NOW(),
+        ended_at TIMESTAMPTZ,
+        message_count INTEGER DEFAULT 0,
+        summary TEXT
+      )
+    `);
+    await this.query(`
+      CREATE INDEX IF NOT EXISTS idx_sessions_user 
+      ON ${this.schema}.sessions (user_id, started_at DESC)
+    `);
+    this.initialized = true;
+  }
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = void 0;
+    }
+    this.initialized = false;
+  }
+  // =========================================================================
+  // Fact Operations
+  // =========================================================================
+  async getFacts(userId, filter) {
+    await this.ensureInitialized();
+    let sql = `SELECT * FROM ${this.schema}.facts WHERE user_id = $1`;
+    const params = [userId];
+    let paramIndex = 2;
+    if (filter?.subject) {
+      sql += ` AND subject = $${paramIndex++}`;
+      params.push(filter.subject);
+    }
+    if (filter?.predicate) {
+      sql += ` AND predicate = $${paramIndex++}`;
+      params.push(filter.predicate);
+    }
+    if (filter?.predicates?.length) {
+      const placeholders = filter.predicates.map((_, i) => `$${paramIndex + i}`).join(", ");
+      sql += ` AND predicate IN (${placeholders})`;
+      params.push(...filter.predicates);
+      paramIndex += filter.predicates.length;
+    }
+    if (filter?.validOnly !== false) {
+      sql += ` AND invalidated_at IS NULL`;
+    }
+    if (filter?.orderBy) {
+      const column = this.camelToSnake(filter.orderBy);
+      const dir = filter.orderDir === "asc" ? "ASC" : "DESC";
+      sql += ` ORDER BY ${column} ${dir}`;
+    }
+    if (filter?.limit) {
+      sql += ` LIMIT $${paramIndex}`;
+      params.push(filter.limit);
+    }
+    const result = await this.query(sql, params);
+    return result.rows.map(this.rowToFact.bind(this));
+  }
+  async getFactById(userId, factId) {
+    await this.ensureInitialized();
+    const result = await this.query(
+      `SELECT * FROM ${this.schema}.facts WHERE user_id = $1 AND id = $2`,
+      [userId, factId]
+    );
+    return result.rows[0] ? this.rowToFact(result.rows[0]) : null;
+  }
+  async upsertFact(userId, fact) {
+    await this.ensureInitialized();
+    const { v4: uuidv43 } = await import('uuid');
+    const existing = await this.query(
+      `SELECT id FROM ${this.schema}.facts 
+       WHERE user_id = $1 AND subject = $2 AND predicate = $3 AND invalidated_at IS NULL`,
+      [userId, fact.subject, fact.predicate]
+    );
+    if (existing.rows[0]) {
+      const result2 = await this.query(
+        `UPDATE ${this.schema}.facts 
+         SET object = $1, confidence = $2, source = $3, updated_at = NOW(), metadata = $4
+         WHERE id = $5 RETURNING *`,
+        [
+          fact.object,
+          fact.confidence,
+          fact.source,
+          fact.metadata || null,
+          existing.rows[0].id
+        ]
+      );
+      return this.rowToFact(result2.rows[0]);
+    }
+    const id = uuidv43();
+    const result = await this.query(
+      `INSERT INTO ${this.schema}.facts 
+       (id, user_id, subject, predicate, object, confidence, source, invalidated_at, metadata)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING *`,
+      [
+        id,
+        userId,
+        fact.subject,
+        fact.predicate,
+        fact.object,
+        fact.confidence,
+        fact.source,
+        null,
+        fact.metadata || null
+      ]
+    );
+    return this.rowToFact(result.rows[0]);
+  }
+  async updateFact(userId, factId, updates) {
+    await this.ensureInitialized();
+    const setClauses = ["updated_at = NOW()"];
+    const params = [];
+    let paramIndex = 1;
+    if (updates.object !== void 0) {
+      setClauses.push(`object = $${paramIndex++}`);
+      params.push(updates.object);
+    }
+    if (updates.confidence !== void 0) {
+      setClauses.push(`confidence = $${paramIndex++}`);
+      params.push(updates.confidence);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push(`metadata = $${paramIndex++}`);
+      params.push(updates.metadata);
+    }
+    params.push(userId, factId);
+    const result = await this.query(
+      `UPDATE ${this.schema}.facts SET ${setClauses.join(", ")} 
+       WHERE user_id = $${paramIndex++} AND id = $${paramIndex} RETURNING *`,
+      params
+    );
+    if (!result.rows[0]) {
+      throw new Error(`Fact not found: ${factId}`);
+    }
+    return this.rowToFact(result.rows[0]);
+  }
+  async deleteFact(userId, factId, _reason) {
+    await this.ensureInitialized();
+    await this.query(
+      `UPDATE ${this.schema}.facts SET invalidated_at = NOW() WHERE user_id = $1 AND id = $2`,
+      [userId, factId]
+    );
+  }
+  async hardDeleteFact(userId, factId) {
+    await this.ensureInitialized();
+    await this.query(
+      `DELETE FROM ${this.schema}.facts WHERE user_id = $1 AND id = $2`,
+      [userId, factId]
+    );
+  }
+  // =========================================================================
+  // Conversation Operations
+  // =========================================================================
+  async getConversationHistory(userId, limit, sessionId) {
+    await this.ensureInitialized();
+    let sql = `SELECT * FROM ${this.schema}.conversations WHERE user_id = $1`;
+    const params = [userId];
+    if (sessionId) {
+      sql += ` AND session_id = $2`;
+      params.push(sessionId);
+    }
+    sql += ` ORDER BY timestamp DESC`;
+    if (limit) {
+      sql += ` LIMIT $${params.length + 1}`;
+      params.push(limit);
+    }
+    const result = await this.query(sql, params);
+    return result.rows.map(this.rowToConversation.bind(this));
+  }
+  async saveConversation(userId, exchange) {
+    await this.ensureInitialized();
+    const { v4: uuidv43 } = await import('uuid');
+    const id = uuidv43();
+    const result = await this.query(
+      `INSERT INTO ${this.schema}.conversations 
+       (id, user_id, session_id, user_message, assistant_response, timestamp, metadata)
+       VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *`,
+      [
+        id,
+        userId,
+        exchange.sessionId,
+        exchange.userMessage,
+        exchange.assistantResponse,
+        exchange.timestamp,
+        exchange.metadata || null
+      ]
+    );
+    await this.query(
+      `UPDATE ${this.schema}.sessions SET message_count = message_count + 1 WHERE id = $1`,
+      [exchange.sessionId]
+    );
+    return this.rowToConversation(result.rows[0]);
+  }
+  // =========================================================================
+  // Session Operations
+  // =========================================================================
+  async getSessions(userId, limit) {
+    await this.ensureInitialized();
+    let sql = `SELECT * FROM ${this.schema}.sessions WHERE user_id = $1 ORDER BY started_at DESC`;
+    const params = [userId];
+    if (limit) {
+      sql += ` LIMIT $2`;
+      params.push(limit);
+    }
+    const result = await this.query(sql, params);
+    return result.rows.map(this.rowToSession.bind(this));
+  }
+  async getSession(userId, sessionId) {
+    await this.ensureInitialized();
+    const result = await this.query(
+      `SELECT * FROM ${this.schema}.sessions WHERE user_id = $1 AND id = $2`,
+      [userId, sessionId]
+    );
+    return result.rows[0] ? this.rowToSession(result.rows[0]) : null;
+  }
+  async createSession(userId) {
+    await this.ensureInitialized();
+    const { v4: uuidv43 } = await import('uuid');
+    const id = uuidv43();
+    const result = await this.query(
+      `INSERT INTO ${this.schema}.sessions (id, user_id) VALUES ($1, $2) RETURNING *`,
+      [id, userId]
+    );
+    return this.rowToSession(result.rows[0]);
+  }
+  async endSession(userId, sessionId, summary) {
+    await this.ensureInitialized();
+    const result = await this.query(
+      `UPDATE ${this.schema}.sessions 
+       SET ended_at = NOW(), summary = COALESCE($1, summary)
+       WHERE user_id = $2 AND id = $3 RETURNING *`,
+      [summary || null, userId, sessionId]
+    );
+    if (!result.rows[0]) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return this.rowToSession(result.rows[0]);
+  }
+  // =========================================================================
+  // Helper Methods
+  // =========================================================================
+  camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  rowToFact(row) {
+    return {
+      id: row.id,
+      subject: row.subject,
+      predicate: row.predicate,
+      object: row.object,
+      confidence: row.confidence,
+      importance: row.importance ?? 5,
+      source: row.source,
+      sourceConversationId: row.source_conversation_id,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+      invalidatedAt: row.invalidated_at ? new Date(row.invalidated_at) : null,
+      accessCount: row.access_count ?? 0,
+      lastAccessedAt: row.last_accessed_at ? new Date(row.last_accessed_at) : void 0,
+      metadata: row.metadata
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  rowToConversation(row) {
+    return {
+      id: row.id,
+      userId: row.user_id,
+      sessionId: row.session_id,
+      userMessage: row.user_message,
+      assistantResponse: row.assistant_response,
+      timestamp: new Date(row.timestamp),
+      metadata: row.metadata
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  rowToSession(row) {
+    return {
+      id: row.id,
+      userId: row.user_id,
+      startedAt: new Date(row.started_at),
+      endedAt: row.ended_at ? new Date(row.ended_at) : null,
+      messageCount: row.message_count,
+      summary: row.summary
+    };
+  }
+};
+
+// src/adapters/UpstashRedisAdapter.ts
+var UpstashRedisAdapter = class extends BaseAdapter {
+  config;
+  prefix;
+  defaultTtl;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.prefix = config.prefix || "memts:";
+    this.defaultTtl = config.cacheTtl || 3600;
+  }
+  async redis(command) {
+    const response = await fetch(this.config.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(command)
+    });
+    if (!response.ok) {
+      throw new Error(`Upstash Redis error: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.result;
+  }
+  key(userId, type) {
+    return `${this.prefix}${userId}:${type}`;
+  }
+  async initialize() {
+    await this.redis(["PING"]);
+    this.initialized = true;
+  }
+  async close() {
+    this.initialized = false;
+  }
+  // =========================================================================
+  // Fact Operations
+  // =========================================================================
+  async getFacts(userId, filter) {
+    await this.ensureInitialized();
+    const data = await this.redis([
+      "HGETALL",
+      this.key(userId, "facts")
+    ]);
+    if (!data) return [];
+    let dataObj;
+    if (Array.isArray(data)) {
+      dataObj = {};
+      for (let i = 0; i < data.length; i += 2) {
+        if (data[i + 1]) {
+          dataObj[data[i]] = data[i + 1];
+        }
+      }
+    } else if (typeof data === "object") {
+      dataObj = data;
+    } else {
+      return [];
+    }
+    let facts = Object.values(dataObj).filter((v) => typeof v === "string").map((v) => JSON.parse(v)).map((f) => ({
+      ...f,
+      createdAt: new Date(f.createdAt),
+      updatedAt: new Date(f.updatedAt),
+      invalidatedAt: f.invalidatedAt ? new Date(f.invalidatedAt) : null
+    }));
+    if (filter) {
+      if (filter.subject) {
+        facts = facts.filter((f) => f.subject === filter.subject);
+      }
+      if (filter.predicate) {
+        facts = facts.filter((f) => f.predicate === filter.predicate);
+      }
+      if (filter.predicates?.length) {
+        facts = facts.filter((f) => filter.predicates.includes(f.predicate));
+      }
+      if (filter.validOnly !== false) {
+        facts = facts.filter((f) => f.invalidatedAt === null);
+      }
+      if (filter.orderBy) {
+        facts.sort((a, b) => {
+          const aVal = a[filter.orderBy];
+          const bVal = b[filter.orderBy];
+          if (aVal instanceof Date && bVal instanceof Date) {
+            return filter.orderDir === "desc" ? bVal.getTime() - aVal.getTime() : aVal.getTime() - bVal.getTime();
+          }
+          if (typeof aVal === "number" && typeof bVal === "number") {
+            return filter.orderDir === "desc" ? bVal - aVal : aVal - bVal;
+          }
+          return 0;
+        });
+      }
+      if (filter.limit) {
+        facts = facts.slice(0, filter.limit);
+      }
+    }
+    return facts;
+  }
+  async getFactById(userId, factId) {
+    await this.ensureInitialized();
+    const data = await this.redis([
+      "HGET",
+      this.key(userId, "facts"),
+      factId
+    ]);
+    if (!data) return null;
+    const fact = JSON.parse(data);
+    return {
+      ...fact,
+      createdAt: new Date(fact.createdAt),
+      updatedAt: new Date(fact.updatedAt),
+      invalidatedAt: fact.invalidatedAt ? new Date(fact.invalidatedAt) : null
+    };
+  }
+  async upsertFact(userId, fact) {
+    await this.ensureInitialized();
+    const { v4: uuidv43 } = await import('uuid');
+    const existingFacts = await this.getFacts(userId, {
+      subject: fact.subject,
+      predicate: fact.predicate,
+      validOnly: true
+    });
+    const now = /* @__PURE__ */ new Date();
+    if (existingFacts.length > 0) {
+      const existing = existingFacts[0];
+      const updated = {
+        ...existing,
+        ...fact,
+        updatedAt: now
+      };
+      await this.redis([
+        "HSET",
+        this.key(userId, "facts"),
+        existing.id,
+        JSON.stringify(updated)
+      ]);
+      return updated;
+    }
+    const newFact = {
+      ...fact,
+      id: uuidv43(),
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.redis([
+      "HSET",
+      this.key(userId, "facts"),
+      newFact.id,
+      JSON.stringify(newFact)
+    ]);
+    return newFact;
+  }
+  async updateFact(userId, factId, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getFactById(userId, factId);
+    if (!existing) {
+      throw new Error(`Fact not found: ${factId}`);
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      id: existing.id,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.redis([
+      "HSET",
+      this.key(userId, "facts"),
+      factId,
+      JSON.stringify(updated)
+    ]);
+    return updated;
+  }
+  async deleteFact(userId, factId, _reason) {
+    await this.ensureInitialized();
+    const existing = await this.getFactById(userId, factId);
+    if (existing) {
+      existing.invalidatedAt = /* @__PURE__ */ new Date();
+      await this.redis([
+        "HSET",
+        this.key(userId, "facts"),
+        factId,
+        JSON.stringify(existing)
+      ]);
+    }
+  }
+  async hardDeleteFact(userId, factId) {
+    await this.ensureInitialized();
+    await this.redis(["HDEL", this.key(userId, "facts"), factId]);
+  }
+  // =========================================================================
+  // Conversation Operations
+  // =========================================================================
+  async getConversationHistory(userId, limit, sessionId) {
+    await this.ensureInitialized();
+    const data = await this.redis([
+      "LRANGE",
+      this.key(userId, "conversations"),
+      "0",
+      "-1"
+    ]);
+    if (!data || !Array.isArray(data)) return [];
+    let conversations = data.map((v) => JSON.parse(v)).map((c) => ({
+      ...c,
+      timestamp: new Date(c.timestamp)
+    }));
+    if (sessionId) {
+      conversations = conversations.filter((c) => c.sessionId === sessionId);
+    }
+    conversations.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    if (limit) {
+      conversations = conversations.slice(0, limit);
+    }
+    return conversations;
+  }
+  async saveConversation(userId, exchange) {
+    await this.ensureInitialized();
+    const { v4: uuidv43 } = await import('uuid');
+    const newExchange = {
+      ...exchange,
+      id: uuidv43()
+    };
+    await this.redis([
+      "LPUSH",
+      this.key(userId, "conversations"),
+      JSON.stringify(newExchange)
+    ]);
+    const session = await this.getSession(userId, exchange.sessionId);
+    if (session) {
+      session.messageCount++;
+      await this.redis([
+        "HSET",
+        this.key(userId, "sessions"),
+        session.id,
+        JSON.stringify(session)
+      ]);
+    }
+    return newExchange;
+  }
+  // =========================================================================
+  // Session Operations
+  // =========================================================================
+  async getSessions(userId, limit) {
+    await this.ensureInitialized();
+    const data = await this.redis([
+      "HGETALL",
+      this.key(userId, "sessions")
+    ]);
+    if (!data) return [];
+    let dataObj;
+    if (Array.isArray(data)) {
+      dataObj = {};
+      for (let i = 0; i < data.length; i += 2) {
+        if (data[i + 1]) {
+          dataObj[data[i]] = data[i + 1];
+        }
+      }
+    } else if (typeof data === "object") {
+      dataObj = data;
+    } else {
+      return [];
+    }
+    let sessions = Object.values(dataObj).filter((v) => typeof v === "string").map((v) => JSON.parse(v)).map((s) => ({
+      ...s,
+      startedAt: new Date(s.startedAt),
+      endedAt: s.endedAt ? new Date(s.endedAt) : null
+    }));
+    sessions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+    if (limit) {
+      sessions = sessions.slice(0, limit);
+    }
+    return sessions;
+  }
+  async getSession(userId, sessionId) {
+    await this.ensureInitialized();
+    const data = await this.redis([
+      "HGET",
+      this.key(userId, "sessions"),
+      sessionId
+    ]);
+    if (!data) return null;
+    const session = JSON.parse(data);
+    return {
+      ...session,
+      startedAt: new Date(session.startedAt),
+      endedAt: session.endedAt ? new Date(session.endedAt) : null
+    };
+  }
+  async createSession(userId) {
+    await this.ensureInitialized();
+    const { v4: uuidv43 } = await import('uuid');
+    const session = {
+      id: uuidv43(),
+      userId,
+      startedAt: /* @__PURE__ */ new Date(),
+      endedAt: null,
+      messageCount: 0
+    };
+    await this.redis([
+      "HSET",
+      this.key(userId, "sessions"),
+      session.id,
+      JSON.stringify(session)
+    ]);
+    return session;
+  }
+  async endSession(userId, sessionId, summary) {
+    await this.ensureInitialized();
+    const session = await this.getSession(userId, sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    session.endedAt = /* @__PURE__ */ new Date();
+    if (summary) {
+      session.summary = summary;
+    }
+    await this.redis([
+      "HSET",
+      this.key(userId, "sessions"),
+      sessionId,
+      JSON.stringify(session)
+    ]);
+    return session;
+  }
+  // =========================================================================
+  // Utility Methods for Hot Cache
+  // =========================================================================
+  /**
+   * Set TTL on a user's data (useful for expiring cache)
+   * If no TTL is provided, uses the configured default TTL.
+   */
+  async setUserTtl(userId, ttlSeconds) {
+    const ttl = ttlSeconds ?? this.defaultTtl;
+    await this.redis(["EXPIRE", this.key(userId, "facts"), String(ttl)]);
+    await this.redis([
+      "EXPIRE",
+      this.key(userId, "conversations"),
+      String(ttl)
+    ]);
+    await this.redis(["EXPIRE", this.key(userId, "sessions"), String(ttl)]);
+  }
+  /**
+   * Clear all data for a user
+   */
+  async clearUser(userId) {
+    await this.redis(["DEL", this.key(userId, "facts")]);
+    await this.redis(["DEL", this.key(userId, "conversations")]);
+    await this.redis(["DEL", this.key(userId, "sessions")]);
+  }
+};
+
+export { BaseAdapter, InMemoryAdapter, JSONFileAdapter, MongoDBAdapter, PostgresAdapter, UpstashRedisAdapter };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map