@elizaos/plugin-localdb 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/node/index.node.js

@@ -1,43 +1,1170 @@
+// index.node.ts
+import { join as join2 } from "node:path";
+import {
+  logger as logger2
+} from "@elizaos/core";
+
+// adapter.ts
+import {
+  DatabaseAdapter,
+  logger
+} from "@elizaos/core";
+
+// hnsw.ts
+function cosineDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.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 1;
+  return 1 - dotProduct / magnitude;
+}
+
+class SimpleHNSW {
+  nodes = new Map;
+  entryPoint = null;
+  maxLevel = 0;
+  dimension = 0;
+  config;
+  saveCallback;
+  loadCallback;
+  constructor(saveCallback, loadCallback) {
+    this.config = {
+      M: 16,
+      efConstruction: 200,
+      efSearch: 50,
+      mL: 1 / Math.log(16)
+    };
+    this.saveCallback = saveCallback;
+    this.loadCallback = loadCallback;
+  }
+  async init(dimension) {
+    this.dimension = dimension;
+    if (this.loadCallback) {
+      const index = await this.loadCallback();
+      if (index && index.dimension === dimension) {
+        this.deserialize(index);
+      }
+    }
+  }
+  getRandomLevel() {
+    let level = 0;
+    while (Math.random() < Math.exp(-level * this.config.mL) && level < 16) {
+      level++;
+    }
+    return level;
+  }
+  async add(id, vector) {
+    if (vector.length !== this.dimension) {
+      throw new Error(`Vector dimension mismatch: expected ${this.dimension}, got ${vector.length}`);
+    }
+    if (this.nodes.has(id)) {
+      const existing = this.nodes.get(id);
+      if (existing) {
+        existing.vector = vector;
+      }
+      return;
+    }
+    const level = this.getRandomLevel();
+    const newNode = {
+      id,
+      vector,
+      level,
+      neighbors: new Map
+    };
+    for (let l = 0;l <= level; l++) {
+      newNode.neighbors.set(l, new Set);
+    }
+    if (this.entryPoint === null) {
+      this.entryPoint = id;
+      this.maxLevel = level;
+      this.nodes.set(id, newNode);
+      return;
+    }
+    let currentNode = this.entryPoint;
+    for (let l = this.maxLevel;l > level; l--) {
+      currentNode = this.searchLayer(vector, currentNode, 1, l)[0]?.id ?? currentNode;
+    }
+    for (let l = Math.min(level, this.maxLevel);l >= 0; l--) {
+      const neighbors = this.searchLayer(vector, currentNode, this.config.efConstruction, l);
+      const M = this.config.M;
+      const selectedNeighbors = neighbors.slice(0, M);
+      for (const neighbor of selectedNeighbors) {
+        newNode.neighbors.get(l)?.add(neighbor.id);
+        const neighborNode = this.nodes.get(neighbor.id);
+        if (neighborNode) {
+          let neighborSet = neighborNode.neighbors.get(l);
+          if (!neighborSet) {
+            neighborSet = new Set;
+            neighborNode.neighbors.set(l, neighborSet);
+          }
+          neighborSet.add(id);
+          if (neighborSet.size > M) {
+            const toKeep = this.selectBestNeighbors(neighborNode.vector, neighborSet, M, l);
+            neighborNode.neighbors.set(l, new Set(toKeep.map((n) => n.id)));
+          }
+        }
+      }
+      if (neighbors.length > 0) {
+        currentNode = neighbors[0].id;
+      }
+    }
+    this.nodes.set(id, newNode);
+    if (level > this.maxLevel) {
+      this.maxLevel = level;
+      this.entryPoint = id;
+    }
+  }
+  searchLayer(query, entryId, ef, level) {
+    const visited = new Set([entryId]);
+    const entryNode = this.nodes.get(entryId);
+    if (!entryNode)
+      return [];
+    const entryDist = cosineDistance(query, entryNode.vector);
+    const candidates = [
+      { id: entryId, distance: entryDist }
+    ];
+    const results = [{ id: entryId, distance: entryDist }];
+    while (candidates.length > 0) {
+      candidates.sort((a, b) => a.distance - b.distance);
+      const current = candidates.shift();
+      if (!current)
+        break;
+      results.sort((a, b) => b.distance - a.distance);
+      const furthestResult = results[0];
+      if (current.distance > furthestResult.distance) {
+        break;
+      }
+      const currentNode = this.nodes.get(current.id);
+      if (!currentNode)
+        continue;
+      const neighbors = currentNode.neighbors.get(level);
+      if (!neighbors)
+        continue;
+      for (const neighborId of neighbors) {
+        if (visited.has(neighborId))
+          continue;
+        visited.add(neighborId);
+        const neighborNode = this.nodes.get(neighborId);
+        if (!neighborNode)
+          continue;
+        const dist = cosineDistance(query, neighborNode.vector);
+        if (results.length < ef || dist < furthestResult.distance) {
+          candidates.push({ id: neighborId, distance: dist });
+          results.push({ id: neighborId, distance: dist });
+          if (results.length > ef) {
+            results.sort((a, b) => b.distance - a.distance);
+            results.pop();
+          }
+        }
+      }
+    }
+    results.sort((a, b) => a.distance - b.distance);
+    return results;
+  }
+  selectBestNeighbors(nodeVector, neighborIds, M, _level) {
+    const neighbors = [];
+    for (const id of neighborIds) {
+      const node = this.nodes.get(id);
+      if (node) {
+        neighbors.push({
+          id,
+          distance: cosineDistance(nodeVector, node.vector)
+        });
+      }
+    }
+    neighbors.sort((a, b) => a.distance - b.distance);
+    return neighbors.slice(0, M);
+  }
+  async remove(id) {
+    const node = this.nodes.get(id);
+    if (!node)
+      return;
+    for (const [level, neighbors] of node.neighbors) {
+      for (const neighborId of neighbors) {
+        const neighborNode = this.nodes.get(neighborId);
+        if (neighborNode) {
+          neighborNode.neighbors.get(level)?.delete(id);
+        }
+      }
+    }
+    this.nodes.delete(id);
+    if (this.entryPoint === id) {
+      if (this.nodes.size === 0) {
+        this.entryPoint = null;
+        this.maxLevel = 0;
+      } else {
+        let maxLevel = 0;
+        let newEntry = null;
+        for (const [nodeId, n] of this.nodes) {
+          if (n.level >= maxLevel) {
+            maxLevel = n.level;
+            newEntry = nodeId;
+          }
+        }
+        this.entryPoint = newEntry;
+        this.maxLevel = maxLevel;
+      }
+    }
+  }
+  async search(query, k, threshold = 0.5) {
+    if (this.entryPoint === null || this.nodes.size === 0) {
+      return [];
+    }
+    if (query.length !== this.dimension) {
+      throw new Error(`Query dimension mismatch: expected ${this.dimension}, got ${query.length}`);
+    }
+    let currentNode = this.entryPoint;
+    for (let l = this.maxLevel;l > 0; l--) {
+      const closest = this.searchLayer(query, currentNode, 1, l);
+      if (closest.length > 0) {
+        currentNode = closest[0].id;
+      }
+    }
+    const results = this.searchLayer(query, currentNode, Math.max(k, this.config.efSearch), 0);
+    return results.slice(0, k).filter((r) => 1 - r.distance >= threshold).map((r) => ({
+      id: r.id,
+      distance: r.distance,
+      similarity: 1 - r.distance
+    }));
+  }
+  async save() {
+    if (this.saveCallback) {
+      await this.saveCallback();
+    }
+  }
+  async load() {
+    if (this.loadCallback) {
+      const index = await this.loadCallback();
+      if (index) {
+        this.deserialize(index);
+      }
+    }
+  }
+  serialize() {
+    const nodes = {};
+    for (const [id, node] of this.nodes) {
+      const neighbors = {};
+      for (const [level, set] of node.neighbors) {
+        neighbors[level] = Array.from(set);
+      }
+      nodes[id] = {
+        id: node.id,
+        vector: node.vector,
+        level: node.level,
+        neighbors
+      };
+    }
+    return {
+      dimension: this.dimension,
+      config: this.config,
+      nodes,
+      entryPoint: this.entryPoint,
+      maxLevel: this.maxLevel
+    };
+  }
+  deserialize(index) {
+    this.dimension = index.dimension;
+    this.config = index.config;
+    this.entryPoint = index.entryPoint;
+    this.maxLevel = index.maxLevel;
+    this.nodes.clear();
+    for (const [id, serialized] of Object.entries(index.nodes)) {
+      const neighbors = new Map;
+      for (const [level, ids] of Object.entries(serialized.neighbors)) {
+        neighbors.set(Number(level), new Set(ids));
+      }
+      this.nodes.set(id, {
+        id: serialized.id,
+        vector: serialized.vector,
+        level: serialized.level,
+        neighbors
+      });
+    }
+  }
+  getIndex() {
+    return this.serialize();
+  }
+  size() {
+    return this.nodes.size;
+  }
+}
+
+// types.ts
+var COLLECTIONS = {
+  AGENTS: "agents",
+  ENTITIES: "entities",
+  MEMORIES: "memories",
+  ROOMS: "rooms",
+  WORLDS: "worlds",
+  COMPONENTS: "components",
+  RELATIONSHIPS: "relationships",
+  PARTICIPANTS: "participants",
+  TASKS: "tasks",
+  CACHE: "cache",
+  LOGS: "logs",
+  EMBEDDINGS: "embeddings",
+  PAIRING_REQUESTS: "pairing_requests",
+  PAIRING_ALLOWLIST: "pairing_allowlist"
+};
+
+// adapter.ts
+function toMemory(stored) {
+  return {
+    id: stored.id,
+    entityId: stored.entityId,
+    agentId: stored.agentId,
+    createdAt: stored.createdAt,
+    content: stored.content,
+    embedding: stored.embedding,
+    roomId: stored.roomId,
+    worldId: stored.worldId,
+    unique: stored.unique,
+    similarity: stored.similarity,
+    metadata: stored.metadata
+  };
+}
+function toMemories(stored) {
+  return stored.map(toMemory);
+}
+
+class LocalDatabaseAdapter extends DatabaseAdapter {
+  storage;
+  vectorIndex;
+  embeddingDimension = 384;
+  ready = false;
+  agentId;
+  constructor(storage, agentId) {
+    super();
+    this.storage = storage;
+    this.agentId = agentId;
+    this.vectorIndex = new SimpleHNSW(async () => {
+      const index = this.vectorIndex.getIndex();
+      await this.storage.saveRaw("vectors/hnsw_index.json", JSON.stringify(index));
+    }, async () => {
+      const data = await this.storage.loadRaw("vectors/hnsw_index.json");
+      if (data) {
+        try {
+          return JSON.parse(data);
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    });
+  }
+  async initialize() {
+    await this.init();
+  }
+  async init() {
+    await this.storage.init();
+    await this.vectorIndex.init(this.embeddingDimension);
+    this.ready = true;
+    logger.info({ src: "plugin:localdb" }, "Local database initialized");
+  }
+  async runPluginMigrations(_plugins, _options) {
+    logger.debug({ src: "plugin:localdb" }, "Plugin migrations not needed for JSON storage");
+  }
+  async isReady() {
+    return this.ready && await this.storage.isReady();
+  }
+  async close() {
+    await this.vectorIndex.save();
+    await this.storage.close();
+    this.ready = false;
+    logger.info({ src: "plugin:localdb" }, "Local database closed");
+  }
+  async getConnection() {
+    return this.storage;
+  }
+  async getAgent(agentId) {
+    return this.storage.get(COLLECTIONS.AGENTS, agentId);
+  }
+  async getAgents() {
+    return this.storage.getAll(COLLECTIONS.AGENTS);
+  }
+  async createAgent(agent) {
+    if (!agent.id)
+      return false;
+    await this.storage.set(COLLECTIONS.AGENTS, agent.id, agent);
+    return true;
+  }
+  async updateAgent(agentId, agent) {
+    const existing = await this.getAgent(agentId);
+    if (!existing)
+      return false;
+    await this.storage.set(COLLECTIONS.AGENTS, agentId, {
+      ...existing,
+      ...agent
+    });
+    return true;
+  }
+  async deleteAgent(agentId) {
+    return this.storage.delete(COLLECTIONS.AGENTS, agentId);
+  }
+  async ensureEmbeddingDimension(dimension) {
+    if (this.embeddingDimension !== dimension) {
+      this.embeddingDimension = dimension;
+      await this.vectorIndex.init(dimension);
+    }
+  }
+  async getEntitiesByIds(entityIds) {
+    const entities = [];
+    for (const id of entityIds) {
+      const entity = await this.storage.get(COLLECTIONS.ENTITIES, id);
+      if (entity)
+        entities.push(entity);
+    }
+    return entities.length > 0 ? entities : null;
+  }
+  async getEntitiesForRoom(roomId, includeComponents = false) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
+    const entityIds = participants.map((p) => p.entityId);
+    const entities = [];
+    for (const entityId of entityIds) {
+      const entity = await this.storage.get(COLLECTIONS.ENTITIES, entityId);
+      if (entity) {
+        if (includeComponents) {
+          const components = await this.getComponents(entityId);
+          entity.components = components;
+        }
+        entities.push(entity);
+      }
+    }
+    return entities;
+  }
+  async createEntities(entities) {
+    for (const entity of entities) {
+      if (!entity.id)
+        continue;
+      await this.storage.set(COLLECTIONS.ENTITIES, entity.id, entity);
+    }
+    return true;
+  }
+  async updateEntity(entity) {
+    if (!entity.id)
+      return;
+    await this.storage.set(COLLECTIONS.ENTITIES, entity.id, entity);
+  }
+  async getComponent(entityId, type, worldId, sourceEntityId) {
+    const components = await this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => c.entityId === entityId && c.type === type && (worldId === undefined || c.worldId === worldId) && (sourceEntityId === undefined || c.sourceEntityId === sourceEntityId));
+    return components[0] ?? null;
+  }
+  async getComponents(entityId, worldId, sourceEntityId) {
+    return this.storage.getWhere(COLLECTIONS.COMPONENTS, (c) => c.entityId === entityId && (worldId === undefined || c.worldId === worldId) && (sourceEntityId === undefined || c.sourceEntityId === sourceEntityId));
+  }
+  async createComponent(component) {
+    if (!component.id)
+      return false;
+    await this.storage.set(COLLECTIONS.COMPONENTS, component.id, component);
+    return true;
+  }
+  async updateComponent(component) {
+    if (!component.id)
+      return;
+    await this.storage.set(COLLECTIONS.COMPONENTS, component.id, component);
+  }
+  async deleteComponent(componentId) {
+    await this.storage.delete(COLLECTIONS.COMPONENTS, componentId);
+  }
+  async getMemories(params) {
+    let memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => {
+      if (params.entityId && m.entityId !== params.entityId)
+        return false;
+      if (params.agentId && m.agentId !== params.agentId)
+        return false;
+      if (params.roomId && m.roomId !== params.roomId)
+        return false;
+      if (params.worldId && m.worldId !== params.worldId)
+        return false;
+      if (params.tableName && m.metadata?.type !== params.tableName)
+        return false;
+      if (params.start && m.createdAt && m.createdAt < params.start)
+        return false;
+      if (params.end && m.createdAt && m.createdAt > params.end)
+        return false;
+      if (params.unique && !m.unique)
+        return false;
+      return true;
+    });
+    memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    if (params.offset) {
+      memories = memories.slice(params.offset);
+    }
+    if (params.count) {
+      memories = memories.slice(0, params.count);
+    }
+    return toMemories(memories);
+  }
+  async getMemoriesByRoomIds(params) {
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => params.roomIds.includes(m.roomId) && (params.tableName ? m.metadata?.type === params.tableName : true));
+    memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    if (params.limit) {
+      return toMemories(memories.slice(0, params.limit));
+    }
+    return toMemories(memories);
+  }
+  async getMemoryById(id) {
+    return this.storage.get(COLLECTIONS.MEMORIES, id);
+  }
+  async getMemoriesByIds(memoryIds, tableName) {
+    const memories = [];
+    for (const id of memoryIds) {
+      const memory = await this.storage.get(COLLECTIONS.MEMORIES, id);
+      if (memory) {
+        if (tableName && memory.metadata?.type !== tableName)
+          continue;
+        memories.push(toMemory(memory));
+      }
+    }
+    return memories;
+  }
+  async getCachedEmbeddings(params) {
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => m.metadata?.type === params.query_table_name);
+    const results = [];
+    for (const memory of memories) {
+      if (!memory.embedding)
+        continue;
+      const memoryRecord = memory;
+      const fieldValue = memoryRecord[params.query_field_name];
+      const content = String(fieldValue ?? "");
+      const score = this.simpleStringScore(params.query_input, content);
+      if (score <= params.query_threshold) {
+        results.push({
+          embedding: memory.embedding,
+          levenshtein_score: score
+        });
+      }
+    }
+    return results.slice(0, params.query_match_count);
+  }
+  simpleStringScore(a, b) {
+    if (a === b)
+      return 0;
+    const aLower = a.toLowerCase();
+    const bLower = b.toLowerCase();
+    if (aLower === bLower)
+      return 0.1;
+    if (aLower.includes(bLower) || bLower.includes(aLower))
+      return 0.3;
+    return 1;
+  }
+  async log(params) {
+    const id = crypto.randomUUID();
+    const log = {
+      id,
+      entityId: params.entityId,
+      roomId: params.roomId,
+      body: params.body,
+      type: params.type,
+      createdAt: new Date
+    };
+    await this.storage.set(COLLECTIONS.LOGS, id, log);
+  }
+  async getLogs(params) {
+    let logs = await this.storage.getWhere(COLLECTIONS.LOGS, (l) => {
+      if (params.entityId && l.entityId !== params.entityId)
+        return false;
+      if (params.roomId && l.roomId !== params.roomId)
+        return false;
+      if (params.type && l.type !== params.type)
+        return false;
+      return true;
+    });
+    logs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (params.offset) {
+      logs = logs.slice(params.offset);
+    }
+    if (params.count) {
+      logs = logs.slice(0, params.count);
+    }
+    return logs;
+  }
+  async deleteLog(logId) {
+    await this.storage.delete(COLLECTIONS.LOGS, logId);
+  }
+  async searchMemories(params) {
+    const threshold = params.match_threshold ?? 0.5;
+    const count = params.count ?? 10;
+    const results = await this.vectorIndex.search(params.embedding, count * 2, threshold);
+    const memories = [];
+    for (const result of results) {
+      const memory = await this.storage.get(COLLECTIONS.MEMORIES, result.id);
+      if (!memory)
+        continue;
+      if (params.tableName && memory.metadata?.type !== params.tableName)
+        continue;
+      if (params.roomId && memory.roomId !== params.roomId)
+        continue;
+      if (params.worldId && memory.worldId !== params.worldId)
+        continue;
+      if (params.entityId && memory.entityId !== params.entityId)
+        continue;
+      if (params.unique && !memory.unique)
+        continue;
+      memories.push({
+        ...toMemory(memory),
+        similarity: result.similarity
+      });
+    }
+    return memories.slice(0, count);
+  }
+  async createMemory(memory, tableName, unique = false) {
+    const id = memory.id ?? crypto.randomUUID();
+    const now = Date.now();
+    const storedMemory = {
+      ...memory,
+      id,
+      agentId: memory.agentId ?? this.agentId,
+      unique: unique || memory.unique,
+      createdAt: memory.createdAt ?? now,
+      metadata: {
+        ...memory.metadata,
+        type: tableName
+      }
+    };
+    await this.storage.set(COLLECTIONS.MEMORIES, id, storedMemory);
+    if (memory.embedding && memory.embedding.length > 0) {
+      await this.vectorIndex.add(id, memory.embedding);
+      await this.vectorIndex.save();
+    }
+    return id;
+  }
+  async updateMemory(memory) {
+    const existing = await this.getMemoryById(memory.id);
+    if (!existing)
+      return false;
+    const updated = {
+      ...existing,
+      ...memory,
+      metadata: {
+        ...existing.metadata,
+        ...memory.metadata
+      }
+    };
+    await this.storage.set(COLLECTIONS.MEMORIES, memory.id, updated);
+    if (memory.embedding && memory.embedding.length > 0) {
+      await this.vectorIndex.add(memory.id, memory.embedding);
+      await this.vectorIndex.save();
+    }
+    return true;
+  }
+  async deleteMemory(memoryId) {
+    await this.storage.delete(COLLECTIONS.MEMORIES, memoryId);
+    await this.vectorIndex.remove(memoryId);
+    await this.vectorIndex.save();
+  }
+  async deleteManyMemories(memoryIds) {
+    for (const id of memoryIds) {
+      await this.deleteMemory(id);
+    }
+  }
+  async deleteAllMemories(roomId, tableName) {
+    const memories = await this.getMemories({ roomId, tableName });
+    await this.deleteManyMemories(memories.map((m) => m.id).filter((id) => id !== undefined));
+  }
+  async countMemories(roomId, unique = false, tableName) {
+    return this.storage.count(COLLECTIONS.MEMORIES, (memory) => {
+      if (memory.roomId !== roomId)
+        return false;
+      if (unique && !memory.unique)
+        return false;
+      if (tableName && memory.metadata?.type !== tableName)
+        return false;
+      return true;
+    });
+  }
+  async getMemoriesByWorldId(params) {
+    const memories = await this.storage.getWhere(COLLECTIONS.MEMORIES, (m) => m.worldId === params.worldId && (params.tableName ? m.metadata?.type === params.tableName : true));
+    memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    if (params.count) {
+      return toMemories(memories.slice(0, params.count));
+    }
+    return toMemories(memories);
+  }
+  async createWorld(world) {
+    const id = world.id ?? crypto.randomUUID();
+    await this.storage.set(COLLECTIONS.WORLDS, id, { ...world, id });
+    return id;
+  }
+  async getWorld(id) {
+    return this.storage.get(COLLECTIONS.WORLDS, id);
+  }
+  async removeWorld(id) {
+    await this.storage.delete(COLLECTIONS.WORLDS, id);
+  }
+  async getAllWorlds() {
+    return this.storage.getAll(COLLECTIONS.WORLDS);
+  }
+  async updateWorld(world) {
+    if (!world.id)
+      return;
+    await this.storage.set(COLLECTIONS.WORLDS, world.id, world);
+  }
+  async getRoomsByIds(roomIds) {
+    const rooms = [];
+    for (const id of roomIds) {
+      const room = await this.storage.get(COLLECTIONS.ROOMS, id);
+      if (room)
+        rooms.push(room);
+    }
+    return rooms.length > 0 ? rooms : null;
+  }
+  async createRooms(rooms) {
+    const ids = [];
+    for (const room of rooms) {
+      const id = room.id ?? crypto.randomUUID();
+      await this.storage.set(COLLECTIONS.ROOMS, id, { ...room, id });
+      ids.push(id);
+    }
+    return ids;
+  }
+  async deleteRoom(roomId) {
+    await this.storage.delete(COLLECTIONS.ROOMS, roomId);
+    await this.storage.deleteWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
+    await this.storage.deleteWhere(COLLECTIONS.MEMORIES, (m) => m.roomId === roomId);
+  }
+  async deleteRoomsByWorldId(worldId) {
+    const rooms = await this.getRoomsByWorld(worldId);
+    for (const room of rooms) {
+      if (room.id) {
+        await this.deleteRoom(room.id);
+      }
+    }
+  }
+  async updateRoom(room) {
+    if (!room.id)
+      return;
+    await this.storage.set(COLLECTIONS.ROOMS, room.id, room);
+  }
+  async getRoomsForParticipant(entityId) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId);
+    return participants.map((p) => p.roomId);
+  }
+  async getRoomsForParticipants(userIds) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => userIds.includes(p.entityId));
+    return [...new Set(participants.map((p) => p.roomId))];
+  }
+  async getRoomsByWorld(worldId) {
+    return this.storage.getWhere(COLLECTIONS.ROOMS, (r) => r.worldId === worldId);
+  }
+  async removeParticipant(entityId, roomId) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId && p.roomId === roomId);
+    if (participants.length === 0)
+      return false;
+    for (const p of participants) {
+      if (p.id) {
+        await this.storage.delete(COLLECTIONS.PARTICIPANTS, p.id);
+      }
+    }
+    return true;
+  }
+  async getParticipantsForEntity(entityId) {
+    const stored = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.entityId === entityId);
+    const participants = [];
+    for (const p of stored) {
+      const entity = await this.storage.get(COLLECTIONS.ENTITIES, p.entityId);
+      if (entity) {
+        participants.push({
+          id: p.id,
+          entity
+        });
+      }
+    }
+    return participants;
+  }
+  async getParticipantsForRoom(roomId) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId);
+    return participants.map((p) => p.entityId);
+  }
+  async isRoomParticipant(roomId, entityId) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
+    return participants.length > 0;
+  }
+  async addParticipantsRoom(entityIds, roomId) {
+    for (const entityId of entityIds) {
+      const exists = await this.isRoomParticipant(roomId, entityId);
+      if (!exists) {
+        const id = crypto.randomUUID();
+        const participant = {
+          id,
+          entityId,
+          roomId
+        };
+        await this.storage.set(COLLECTIONS.PARTICIPANTS, id, participant);
+      }
+    }
+    return true;
+  }
+  async getParticipantUserState(roomId, entityId) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
+    if (participants.length === 0)
+      return null;
+    const state = participants[0].userState;
+    if (state === "FOLLOWED" || state === "MUTED")
+      return state;
+    return null;
+  }
+  async setParticipantUserState(roomId, entityId, state) {
+    const participants = await this.storage.getWhere(COLLECTIONS.PARTICIPANTS, (p) => p.roomId === roomId && p.entityId === entityId);
+    for (const p of participants) {
+      if (p.id) {
+        await this.storage.set(COLLECTIONS.PARTICIPANTS, p.id, {
+          ...p,
+          userState: state
+        });
+      }
+    }
+  }
+  async createRelationship(params) {
+    const id = crypto.randomUUID();
+    const relationship = {
+      id,
+      sourceEntityId: params.sourceEntityId,
+      targetEntityId: params.targetEntityId,
+      agentId: this.agentId,
+      tags: params.tags ?? [],
+      metadata: params.metadata ?? {},
+      createdAt: new Date().toISOString()
+    };
+    await this.storage.set(COLLECTIONS.RELATIONSHIPS, id, relationship);
+    return true;
+  }
+  async getRelationship(params) {
+    const relationships = await this.storage.getWhere(COLLECTIONS.RELATIONSHIPS, (r2) => r2.sourceEntityId === params.sourceEntityId && r2.targetEntityId === params.targetEntityId);
+    if (relationships.length === 0)
+      return null;
+    const r = relationships[0];
+    return {
+      id: r.id,
+      sourceEntityId: r.sourceEntityId,
+      targetEntityId: r.targetEntityId,
+      agentId: r.agentId ?? this.agentId,
+      tags: r.tags ?? [],
+      metadata: r.metadata ?? {},
+      createdAt: r.createdAt
+    };
+  }
+  async getRelationships(params) {
+    const stored = await this.storage.getWhere(COLLECTIONS.RELATIONSHIPS, (r) => {
+      const isInvolved = r.sourceEntityId === params.entityId || r.targetEntityId === params.entityId;
+      if (!isInvolved)
+        return false;
+      if (params.tags && params.tags.length > 0) {
+        return params.tags.some((tag) => r.tags?.includes(tag));
+      }
+      return true;
+    });
+    return stored.map((r) => ({
+      id: r.id,
+      sourceEntityId: r.sourceEntityId,
+      targetEntityId: r.targetEntityId,
+      agentId: r.agentId ?? this.agentId,
+      tags: r.tags ?? [],
+      metadata: r.metadata ?? {},
+      createdAt: r.createdAt
+    }));
+  }
+  async updateRelationship(relationship) {
+    const existing = await this.getRelationship({
+      sourceEntityId: relationship.sourceEntityId,
+      targetEntityId: relationship.targetEntityId
+    });
+    if (!existing || !existing.id)
+      return;
+    const stored = {
+      id: existing.id,
+      sourceEntityId: relationship.sourceEntityId,
+      targetEntityId: relationship.targetEntityId,
+      agentId: relationship.agentId,
+      tags: relationship.tags ?? existing.tags ?? [],
+      metadata: { ...existing.metadata ?? {}, ...relationship.metadata ?? {} },
+      createdAt: existing.createdAt ?? new Date().toISOString()
+    };
+    await this.storage.set(COLLECTIONS.RELATIONSHIPS, existing.id, stored);
+  }
+  async getCache(key) {
+    const cached = await this.storage.get(COLLECTIONS.CACHE, key);
+    if (!cached)
+      return;
+    if (cached.expiresAt && Date.now() > cached.expiresAt) {
+      await this.deleteCache(key);
+      return;
+    }
+    return cached.value;
+  }
+  async setCache(key, value) {
+    await this.storage.set(COLLECTIONS.CACHE, key, { value });
+    return true;
+  }
+  async deleteCache(key) {
+    return this.storage.delete(COLLECTIONS.CACHE, key);
+  }
+  async createTask(task) {
+    const id = task.id ?? crypto.randomUUID();
+    await this.storage.set(COLLECTIONS.TASKS, id, { ...task, id });
+    return id;
+  }
+  async getTasks(params) {
+    return this.storage.getWhere(COLLECTIONS.TASKS, (t) => {
+      if (params.roomId && t.roomId !== params.roomId)
+        return false;
+      if (params.entityId && t.entityId !== params.entityId)
+        return false;
+      if (params.tags && params.tags.length > 0) {
+        if (!t.tags?.some((tag) => params.tags?.includes(tag)))
+          return false;
+      }
+      return true;
+    });
+  }
+  async getTask(id) {
+    return this.storage.get(COLLECTIONS.TASKS, id);
+  }
+  async getTasksByName(name) {
+    return this.storage.getWhere(COLLECTIONS.TASKS, (t) => t.name === name);
+  }
+  async updateTask(id, task) {
+    const existing = await this.getTask(id);
+    if (!existing)
+      return;
+    await this.storage.set(COLLECTIONS.TASKS, id, { ...existing, ...task });
+  }
+  async deleteTask(id) {
+    await this.storage.delete(COLLECTIONS.TASKS, id);
+  }
+  async getPairingRequests(channel, agentId) {
+    return this.storage.getWhere(COLLECTIONS.PAIRING_REQUESTS, (r) => r.channel === channel && r.agentId === agentId);
+  }
+  async createPairingRequest(request) {
+    const id = request.id ?? crypto.randomUUID();
+    await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, id, { ...request, id });
+    return id;
+  }
+  async updatePairingRequest(request) {
+    const existing = await this.storage.get(COLLECTIONS.PAIRING_REQUESTS, request.id);
+    if (existing) {
+      await this.storage.set(COLLECTIONS.PAIRING_REQUESTS, request.id, {
+        ...existing,
+        ...request
+      });
+    }
+  }
+  async deletePairingRequest(id) {
+    await this.storage.delete(COLLECTIONS.PAIRING_REQUESTS, id);
+  }
+  async getPairingAllowlist(channel, agentId) {
+    return this.storage.getWhere(COLLECTIONS.PAIRING_ALLOWLIST, (e) => e.channel === channel && e.agentId === agentId);
+  }
+  async createPairingAllowlistEntry(entry) {
+    const id = entry.id ?? crypto.randomUUID();
+    await this.storage.set(COLLECTIONS.PAIRING_ALLOWLIST, id, { ...entry, id });
+    return id;
+  }
+  async deletePairingAllowlistEntry(id) {
+    await this.storage.delete(COLLECTIONS.PAIRING_ALLOWLIST, id);
+  }
+}
+
+// storage-node.ts
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { logger, } from "@elizaos/core";
-import { LocalDatabaseAdapter } from "./adapter";
-import { NodeStorage } from "./storage-node";
-const GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-localdb/global-singletons");
-const globalSymbols = globalThis;
-if (!globalSymbols[GLOBAL_SINGLETONS]) {
-    globalSymbols[GLOBAL_SINGLETONS] = {};
-}
-const globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
-export function createDatabaseAdapter(config, agentId) {
-    const dataDir = config.dataDir ?? join(process.cwd(), "data");
-    if (!globalSingletons.storageManager) {
-        globalSingletons.storageManager = new NodeStorage(dataDir);
-    }
-    return new LocalDatabaseAdapter(globalSingletons.storageManager, agentId);
-}
-export const plugin = {
-    name: "@elizaos/plugin-localdb",
-    description: "Simple JSON-based local database storage for elizaOS",
-    async init(_config, runtime) {
-        logger.info({ src: "plugin:localdb" }, "Initializing local database plugin");
-        const runtimeWithAdapter = runtime;
-        const hasAdapter = runtimeWithAdapter.adapter !== undefined ||
-            runtimeWithAdapter.databaseAdapter !== undefined ||
-            (runtimeWithAdapter.hasDatabaseAdapter?.() ?? false);
-        if (hasAdapter) {
-            logger.debug({ src: "plugin:localdb" }, "Database adapter already exists, skipping initialization");
-            return;
+
+class NodeStorage {
+  dataDir;
+  ready = false;
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+  }
+  async init() {
+    if (!existsSync(this.dataDir)) {
+      await mkdir(this.dataDir, { recursive: true });
+    }
+    this.ready = true;
+  }
+  async close() {
+    this.ready = false;
+  }
+  async isReady() {
+    return this.ready;
+  }
+  getCollectionDir(collection) {
+    return join(this.dataDir, collection);
+  }
+  getFilePath(collection, id) {
+    const safeId = id.replace(/[^a-zA-Z0-9-_]/g, "_");
+    return join(this.getCollectionDir(collection), `${safeId}.json`);
+  }
+  async get(collection, id) {
+    const filePath = this.getFilePath(collection, id);
+    try {
+      if (!existsSync(filePath)) {
+        return null;
+      }
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async getAll(collection) {
+    const collectionDir = this.getCollectionDir(collection);
+    try {
+      if (!existsSync(collectionDir)) {
+        return [];
+      }
+      const files = await readdir(collectionDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json"))
+          continue;
+        try {
+          const content = await readFile(join(collectionDir, file), "utf-8");
+          items.push(JSON.parse(content));
+        } catch {}
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async getWhere(collection, predicate) {
+    const all = await this.getAll(collection);
+    return all.filter(predicate);
+  }
+  async set(collection, id, data) {
+    const collectionDir = this.getCollectionDir(collection);
+    if (!existsSync(collectionDir)) {
+      await mkdir(collectionDir, { recursive: true });
+    }
+    const filePath = this.getFilePath(collection, id);
+    await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+  async delete(collection, id) {
+    const filePath = this.getFilePath(collection, id);
+    try {
+      if (!existsSync(filePath)) {
+        return false;
+      }
+      await rm(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async deleteMany(collection, ids) {
+    await Promise.all(ids.map((id) => this.delete(collection, id)));
+  }
+  async deleteWhere(collection, predicate) {
+    const collectionDir = this.getCollectionDir(collection);
+    try {
+      if (!existsSync(collectionDir)) {
+        return;
+      }
+      const files = await readdir(collectionDir);
+      for (const file of files) {
+        if (!file.endsWith(".json"))
+          continue;
+        try {
+          const filePath = join(collectionDir, file);
+          const content = await readFile(filePath, "utf-8");
+          const item = JSON.parse(content);
+          if (predicate(item)) {
+            await rm(filePath);
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+  async count(collection, predicate) {
+    if (!predicate) {
+      const collectionDir = this.getCollectionDir(collection);
+      try {
+        if (!existsSync(collectionDir)) {
+          return 0;
         }
-        const dataDir = runtime.getSetting("LOCALDB_DATA_DIR");
-        const adapter = createDatabaseAdapter({ dataDir }, runtime.agentId);
-        await adapter.init();
-        runtime.registerDatabaseAdapter(adapter);
-        logger.success({ src: "plugin:localdb" }, "Local database adapter registered successfully");
-    },
+        const files = await readdir(collectionDir);
+        return files.filter((f) => f.endsWith(".json")).length;
+      } catch {
+        return 0;
+      }
+    }
+    const items = await this.getAll(collection);
+    return items.filter(predicate).length;
+  }
+  async saveRaw(filename, data) {
+    const filePath = join(this.dataDir, filename);
+    const dir = join(this.dataDir, filename.split("/").slice(0, -1).join("/"));
+    if (dir && dir !== this.dataDir && !existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(filePath, data, "utf-8");
+  }
+  async loadRaw(filename) {
+    const filePath = join(this.dataDir, filename);
+    try {
+      if (!existsSync(filePath)) {
+        return null;
+      }
+      return await readFile(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+}
+
+// index.node.ts
+var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-localdb/global-singletons");
+var globalSymbols = globalThis;
+if (!globalSymbols[GLOBAL_SINGLETONS]) {
+  globalSymbols[GLOBAL_SINGLETONS] = {};
+}
+var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
+function createDatabaseAdapter(config, agentId) {
+  const dataDir = config.dataDir ?? join2(process.cwd(), "data");
+  if (!globalSingletons.storageManager) {
+    globalSingletons.storageManager = new NodeStorage(dataDir);
+  }
+  return new LocalDatabaseAdapter(globalSingletons.storageManager, agentId);
+}
+var plugin = {
+  name: "@elizaos/plugin-localdb",
+  description: "Simple JSON-based local database storage for elizaOS",
+  async init(_config, runtime) {
+    logger2.info({ src: "plugin:localdb" }, "Initializing local database plugin");
+    const runtimeWithAdapter = runtime;
+    const hasAdapter = runtimeWithAdapter.adapter !== undefined || runtimeWithAdapter.databaseAdapter !== undefined || (runtimeWithAdapter.hasDatabaseAdapter?.() ?? false);
+    if (hasAdapter) {
+      logger2.debug({ src: "plugin:localdb" }, "Database adapter already exists, skipping initialization");
+      return;
+    }
+    const dataDir = runtime.getSetting("LOCALDB_DATA_DIR");
+    const adapter = createDatabaseAdapter({ dataDir }, runtime.agentId);
+    await adapter.init();
+    runtime.registerDatabaseAdapter(adapter);
+    logger2.success({ src: "plugin:localdb" }, "Local database adapter registered successfully");
+  }
+};
+var index_node_default = plugin;
+export {
+  plugin,
+  index_node_default as default,
+  createDatabaseAdapter,
+  SimpleHNSW,
+  NodeStorage,
+  LocalDatabaseAdapter,
+  COLLECTIONS
 };
-export { LocalDatabaseAdapter } from "./adapter";
-export { SimpleHNSW } from "./hnsw";
-export { NodeStorage } from "./storage-node";
-export * from "./types";
-export default plugin;
-//# sourceMappingURL=index.node.js.map
+
+//# debugId=619C0E91079B9F5364756E2164756E21
+//# sourceMappingURL=index.node.js.map