@lov3kaizen/agentsea-memory 0.5.1

package/dist/index.js

@@ -0,0 +1,742 @@
+import {
+  Debugger,
+  Exporter,
+  Inspector,
+  Timeline,
+  createDebugger,
+  createExporter,
+  createInspector,
+  createTimeline
+} from "./chunk-YI7RPDEV.js";
+import {
+  Compressor,
+  Consolidator,
+  Extractor,
+  Forgetter,
+  Summarizer,
+  createCompressor,
+  createConsolidator,
+  createExtractor,
+  createForgetter,
+  createSummarizer
+} from "./chunk-XD2CQGSD.js";
+import {
+  HybridRetrieval,
+  PipelineBuilder,
+  RetrievalPipeline,
+  SemanticRetrieval,
+  TemporalRetrieval,
+  TimeWindows,
+  createHybridRetrieval,
+  createPipelineBuilder,
+  createRetrievalPipeline,
+  createSemanticRetrieval,
+  createTemporalRetrieval
+} from "./chunk-M44NB53O.js";
+import {
+  AccessControl,
+  NamespaceManager,
+  SharedMemory,
+  createAccessControl,
+  createNamespaceManager,
+  createSharedMemory
+} from "./chunk-MQDWBPZU.js";
+import {
+  InMemoryStore,
+  PostgresStore,
+  RedisStore,
+  SQLiteStore,
+  createInMemoryStore,
+  createPostgresStore,
+  createRedisStore,
+  createSQLiteStore
+} from "./chunk-GACX3FPR.js";
+import {
+  EpisodicMemory,
+  HierarchicalMemory,
+  LongTermMemory,
+  SemanticMemory,
+  WorkingMemory,
+  createEpisodicMemory,
+  createHierarchicalMemory,
+  createLongTermMemory,
+  createSemanticMemory,
+  createWorkingMemory
+} from "./chunk-TPC7MYWK.js";
+
+// src/core/MemoryManager.ts
+import { EventEmitter } from "eventemitter3";
+import { nanoid } from "nanoid";
+var MemoryManager = class extends EventEmitter {
+  store;
+  embedding;
+  retrieval;
+  defaultNamespace;
+  autoEmbed;
+  importanceCalculator;
+  constructor(config) {
+    super();
+    this.store = config.store;
+    this.embedding = config.embedding;
+    this.retrieval = config.retrieval;
+    this.defaultNamespace = config.defaultNamespace ?? "default";
+    this.autoEmbed = config.autoEmbed ?? true;
+    this.importanceCalculator = config.importanceCalculator ?? this.defaultImportanceCalculator;
+  }
+  /**
+   * Add a memory
+   */
+  async add(input) {
+    const now = Date.now();
+    const importance = input.importance ?? this.importanceCalculator(input.content, input.type ?? "context", {
+      source: input.metadata?.source ?? "explicit",
+      confidence: input.metadata?.confidence ?? 1,
+      namespace: input.metadata?.namespace ?? this.defaultNamespace,
+      ...input.metadata
+    });
+    let embedding;
+    if (this.embedding && this.autoEmbed) {
+      embedding = await this.embedding.embed(input.content);
+    }
+    const entry = {
+      id: nanoid(),
+      content: input.content,
+      embedding,
+      type: input.type ?? "context",
+      importance,
+      metadata: {
+        source: "explicit",
+        confidence: 1,
+        namespace: this.defaultNamespace,
+        ...input.metadata
+      },
+      timestamp: now,
+      expiresAt: input.expiresAt,
+      parentId: input.parentId,
+      accessCount: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    const id = await this.store.add(entry);
+    this.emit("memory:added", {
+      type: "memory:added",
+      memoryId: id,
+      memory: entry,
+      timestamp: now
+    });
+    return id;
+  }
+  /**
+   * Add multiple memories
+   */
+  async addBatch(inputs) {
+    const ids = [];
+    if (this.embedding && this.autoEmbed && inputs.length > 1) {
+      const contents = inputs.map((i) => i.content);
+      const embeddings = await this.embedding.embedBatch(contents);
+      for (let i = 0; i < inputs.length; i++) {
+        const id = await this.addWithEmbedding(inputs[i], embeddings[i]);
+        ids.push(id);
+      }
+    } else {
+      for (const input of inputs) {
+        const id = await this.add(input);
+        ids.push(id);
+      }
+    }
+    return ids;
+  }
+  /**
+   * Add memory with pre-computed embedding
+   */
+  async addWithEmbedding(input, embedding) {
+    const now = Date.now();
+    const importance = input.importance ?? this.importanceCalculator(input.content, input.type ?? "context", {
+      source: input.metadata?.source ?? "explicit",
+      confidence: input.metadata?.confidence ?? 1,
+      namespace: input.metadata?.namespace ?? this.defaultNamespace,
+      ...input.metadata
+    });
+    const entry = {
+      id: nanoid(),
+      content: input.content,
+      embedding,
+      type: input.type ?? "context",
+      importance,
+      metadata: {
+        source: "explicit",
+        confidence: 1,
+        namespace: this.defaultNamespace,
+        ...input.metadata
+      },
+      timestamp: now,
+      expiresAt: input.expiresAt,
+      parentId: input.parentId,
+      accessCount: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    const id = await this.store.add(entry);
+    this.emit("memory:added", {
+      type: "memory:added",
+      memoryId: id,
+      memory: entry,
+      timestamp: now
+    });
+    return id;
+  }
+  /**
+   * Get a memory by ID
+   */
+  async get(id) {
+    const entry = await this.store.get(id);
+    if (entry) {
+      await this.store.update(id, {});
+    }
+    return entry;
+  }
+  /**
+   * Update a memory
+   */
+  async update(id, updates) {
+    const existing = await this.store.get(id);
+    if (!existing) {
+      return false;
+    }
+    if (updates.content && this.embedding && this.autoEmbed) {
+      const embedding = await this.embedding.embed(updates.content);
+      updates.embedding = embedding;
+    }
+    const success = await this.store.update(id, updates);
+    if (success) {
+      const updated = await this.store.get(id);
+      this.emit("memory:updated", {
+        type: "memory:updated",
+        memoryId: id,
+        memory: updated ?? void 0,
+        timestamp: Date.now()
+      });
+    }
+    return success;
+  }
+  /**
+   * Delete a memory
+   */
+  async delete(id) {
+    const success = await this.store.delete(id);
+    if (success) {
+      this.emit("memory:deleted", {
+        type: "memory:deleted",
+        memoryId: id,
+        timestamp: Date.now()
+      });
+    }
+    return success;
+  }
+  /**
+   * Retrieve relevant memories using semantic search
+   */
+  async retrieve(query, options = {}) {
+    if (!this.embedding) {
+      throw new Error("Embedding provider required for semantic retrieval");
+    }
+    let results;
+    if (this.retrieval) {
+      results = await this.retrieval.retrieve(
+        query,
+        this.store,
+        this.embedding,
+        options
+      );
+    } else {
+      const queryEmbedding = await this.embedding.embed(query);
+      results = await this.store.search(queryEmbedding, {
+        topK: options.limit ?? 10,
+        minScore: options.minScore ?? 0.5,
+        filter: {
+          userId: options.userId,
+          agentId: options.agentId,
+          conversationId: options.conversationId,
+          namespace: options.namespace ?? this.defaultNamespace,
+          types: options.types
+        },
+        namespace: options.namespace ?? this.defaultNamespace
+      });
+    }
+    this.emit("memory:retrieved", {
+      type: "memory:retrieved",
+      metadata: { query, count: results.length },
+      timestamp: Date.now()
+    });
+    return results;
+  }
+  /**
+   * Search memories with filters (non-semantic)
+   */
+  search(options) {
+    const queryOptions = {
+      ...options,
+      namespace: options.namespace ?? this.defaultNamespace
+    };
+    return this.store.query(queryOptions);
+  }
+  /**
+   * Query memories (alias for search)
+   */
+  query(options) {
+    return this.search(options);
+  }
+  /**
+   * Clear memories
+   */
+  clear(options) {
+    return this.store.clear({
+      namespace: options?.namespace ?? this.defaultNamespace,
+      userId: options?.userId
+    });
+  }
+  /**
+   * Get memory count
+   */
+  count(options) {
+    return this.store.count({
+      ...options,
+      namespace: options?.namespace ?? this.defaultNamespace
+    });
+  }
+  /**
+   * Get memory statistics
+   */
+  async getStats() {
+    const result = await this.store.query({ limit: 1e5 });
+    const entries = result.entries;
+    const byType = {
+      fact: 0,
+      preference: 0,
+      event: 0,
+      context: 0,
+      summary: 0,
+      entity: 0,
+      relation: 0,
+      conversation: 0,
+      custom: 0
+    };
+    const byNamespace = {};
+    let totalImportance = 0;
+    let embeddedCount = 0;
+    let oldestTimestamp = Infinity;
+    let newestTimestamp = 0;
+    let totalSize = 0;
+    for (const entry of entries) {
+      byType[entry.type] = (byType[entry.type] ?? 0) + 1;
+      const ns = entry.metadata.namespace ?? "default";
+      byNamespace[ns] = (byNamespace[ns] ?? 0) + 1;
+      totalImportance += entry.importance;
+      if (entry.embedding) {
+        embeddedCount++;
+      }
+      if (entry.timestamp < oldestTimestamp) {
+        oldestTimestamp = entry.timestamp;
+      }
+      if (entry.timestamp > newestTimestamp) {
+        newestTimestamp = entry.timestamp;
+      }
+      totalSize += JSON.stringify(entry).length;
+    }
+    return {
+      totalCount: entries.length,
+      byType,
+      byNamespace,
+      sizeBytes: totalSize,
+      oldestTimestamp: oldestTimestamp === Infinity ? 0 : oldestTimestamp,
+      newestTimestamp,
+      averageImportance: entries.length > 0 ? totalImportance / entries.length : 0,
+      embeddedCount
+    };
+  }
+  /**
+   * Set embedding provider
+   */
+  setEmbedding(embedding) {
+    this.embedding = embedding;
+  }
+  /**
+   * Set retrieval strategy
+   */
+  setRetrieval(retrieval) {
+    this.retrieval = retrieval;
+  }
+  /**
+   * Set importance calculator
+   */
+  setImportanceCalculator(calculator) {
+    this.importanceCalculator = calculator;
+  }
+  /**
+   * Get the underlying store
+   */
+  getStore() {
+    return this.store;
+  }
+  /**
+   * Close the memory manager
+   */
+  async close() {
+    if (this.store.close) {
+      await this.store.close();
+    }
+  }
+  /**
+   * Default importance calculator
+   */
+  defaultImportanceCalculator = (_content, type, metadata) => {
+    let importance = 0.5;
+    switch (type) {
+      case "fact":
+      case "preference":
+        importance = 0.8;
+        break;
+      case "event":
+        importance = 0.6;
+        break;
+      case "summary":
+        importance = 0.7;
+        break;
+      case "context":
+        importance = 0.5;
+        break;
+      case "entity":
+      case "relation":
+        importance = 0.7;
+        break;
+      default:
+        importance = 0.5;
+    }
+    if (metadata.confidence !== void 0) {
+      importance *= 0.5 + 0.5 * metadata.confidence;
+    }
+    if (metadata.source === "explicit") {
+      importance *= 1.1;
+    }
+    return Math.min(importance, 1);
+  };
+};
+function createMemoryManager(config) {
+  return new MemoryManager(config);
+}
+
+// src/integrations/AgentMemory.ts
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
+var AgentMemory = class extends EventEmitter2 {
+  agentId;
+  namespace;
+  workingMemorySize;
+  store;
+  manager;
+  working;
+  episodic;
+  semantic;
+  conversationHistory = [];
+  constructor(config) {
+    super();
+    this.agentId = config.agentId;
+    this.namespace = config.namespace ?? "default";
+    this.workingMemorySize = config.workingMemorySize ?? 20;
+    this.store = config.store;
+    this.manager = new MemoryManager({
+      store: config.store,
+      defaultNamespace: this.namespace
+    });
+    this.working = new WorkingMemory(config.store, {
+      maxSize: this.workingMemorySize
+    });
+    this.episodic = new EpisodicMemory(config.store);
+    this.semantic = new SemanticMemory(config.store);
+    this.setupEventForwarding();
+  }
+  /**
+   * Remember information
+   */
+  async remember(content, options) {
+    const entryId = await this.manager.add({
+      content,
+      type: options?.type ?? "context",
+      importance: options?.importance ?? 0.5,
+      metadata: {
+        source: "explicit",
+        confidence: 1,
+        ...options?.metadata,
+        agentId: this.agentId,
+        tags: options?.tags
+      }
+    });
+    const entry = await this.manager.get(entryId);
+    if (entry) {
+      await this.working.add(entry);
+      this.emit("memoryAdded", entry);
+    }
+    return entryId;
+  }
+  /**
+   * Recall information
+   */
+  async recall(query, options) {
+    this.working.setQuery(query);
+    const results = await this.manager.retrieve(query, {
+      limit: options?.limit ?? 10,
+      minScore: options?.minScore ?? 0.5
+    });
+    const entries = results.map((r) => r.entry);
+    let combined = entries;
+    if (options?.includeContext !== false) {
+      const workingContext = this.working.getFocused(5);
+      const workingIds = new Set(workingContext.map((e) => e.id));
+      combined = [
+        ...workingContext,
+        ...entries.filter((e) => !workingIds.has(e.id))
+      ];
+    }
+    this.emit("memoryRetrieved", combined, query);
+    return combined;
+  }
+  /**
+   * Learn a fact
+   */
+  async learnFact(content, options) {
+    const fact = await this.semantic.learnFact(content, {
+      agentId: this.agentId,
+      confidence: options?.confidence ?? 0.8,
+      source: options?.source
+    });
+    this.emit("memoryAdded", fact);
+    return fact.id;
+  }
+  /**
+   * Record an event/experience
+   */
+  async recordEvent(content, options) {
+    const entry = {
+      id: `event-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+      content,
+      type: "event",
+      importance: options?.importance ?? 0.5,
+      metadata: {
+        source: "explicit",
+        confidence: 1,
+        agentId: this.agentId,
+        namespace: this.namespace,
+        participants: options?.participants,
+        location: options?.location
+      },
+      timestamp: Date.now(),
+      accessCount: 0,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.episodic.recordEvent(entry);
+    this.emit("memoryAdded", entry);
+    return entry.id;
+  }
+  /**
+   * Add a conversation turn
+   */
+  async addConversationTurn(turn) {
+    const fullTurn = {
+      ...turn,
+      timestamp: turn.timestamp ?? Date.now()
+    };
+    this.conversationHistory.push(fullTurn);
+    if (turn.content.length > 20) {
+      await this.remember(`[${turn.role}]: ${turn.content}`, {
+        type: "context",
+        importance: turn.role === "user" ? 0.7 : 0.5,
+        metadata: {
+          conversationTurn: true,
+          role: turn.role,
+          ...turn.metadata
+        }
+      });
+    }
+    this.emit("conversationUpdated", fullTurn);
+  }
+  /**
+   * Get recent conversation
+   */
+  getRecentConversation(turns = 10) {
+    return this.conversationHistory.slice(-turns);
+  }
+  /**
+   * Format conversation for LLM context
+   */
+  formatConversationForContext(turns = 10) {
+    return this.getRecentConversation(turns).map((turn) => `${turn.role}: ${turn.content}`).join("\n");
+  }
+  /**
+   * Get working memory context
+   */
+  getWorkingContext() {
+    return this.working.getContext();
+  }
+  /**
+   * Clear working memory
+   */
+  clearWorkingMemory() {
+    this.working.clear();
+  }
+  /**
+   * Clear conversation history
+   */
+  clearConversation() {
+    this.conversationHistory = [];
+  }
+  /**
+   * Forget a specific memory
+   */
+  async forget(id) {
+    return Promise.resolve(this.manager.delete(id));
+  }
+  /**
+   * Update a memory
+   */
+  update(id, updates) {
+    return Promise.resolve(this.manager.update(id, updates));
+  }
+  /**
+   * Search by semantic similarity
+   */
+  async searchSimilar(text, options) {
+    return this.manager.retrieve(text, {
+      limit: options?.topK ?? 10,
+      minScore: options?.minScore
+    });
+  }
+  /**
+   * Get memory by ID
+   */
+  get(id) {
+    return Promise.resolve(this.manager.get(id));
+  }
+  /**
+   * Get agent statistics
+   */
+  async getStats() {
+    const stats = await this.manager.getStats();
+    const semanticStats = this.semantic.getStats();
+    const currentEpisode = this.episodic.getCurrentEpisode();
+    return {
+      totalMemories: stats.byType ? Object.values(stats.byType).reduce((a, b) => a + b, 0) : 0,
+      workingMemorySize: this.working.size,
+      conversationLength: this.conversationHistory.length,
+      currentEpisode: currentEpisode ? { eventCount: currentEpisode.events.length } : null,
+      factCount: semanticStats.conceptCount
+    };
+  }
+  /**
+   * Consolidate memories
+   */
+  async consolidate() {
+    return Promise.resolve(this.working.consolidate(this.store));
+  }
+  /**
+   * Get related concepts
+   */
+  getRelatedConcepts(conceptId, depth = 1) {
+    return Promise.resolve(
+      this.semantic.getRelatedConcepts(conceptId, void 0, depth)
+    );
+  }
+  /**
+   * Export agent memory
+   */
+  async export() {
+    return {
+      agentId: this.agentId,
+      namespace: this.namespace,
+      conversationHistory: [...this.conversationHistory],
+      workingContext: this.working.getContext(),
+      stats: await this.getStats(),
+      exportedAt: Date.now()
+    };
+  }
+  /**
+   * Set up event forwarding
+   */
+  setupEventForwarding() {
+    this.working.on("contextUpdate", (context) => {
+      this.emit("contextUpdated", context);
+    });
+  }
+  /**
+   * Access underlying components
+   */
+  get components() {
+    return {
+      manager: this.manager,
+      working: this.working,
+      episodic: this.episodic,
+      semantic: this.semantic
+    };
+  }
+};
+function createAgentMemory(config) {
+  return new AgentMemory(config);
+}
+export {
+  AccessControl,
+  AgentMemory,
+  Compressor,
+  Consolidator,
+  Debugger,
+  EpisodicMemory,
+  Exporter,
+  Extractor,
+  Forgetter,
+  HierarchicalMemory,
+  HybridRetrieval,
+  InMemoryStore,
+  Inspector,
+  LongTermMemory,
+  MemoryManager,
+  NamespaceManager,
+  PipelineBuilder,
+  PostgresStore,
+  RedisStore,
+  RetrievalPipeline,
+  SQLiteStore,
+  SemanticMemory,
+  SemanticRetrieval,
+  SharedMemory,
+  Summarizer,
+  TemporalRetrieval,
+  TimeWindows,
+  Timeline,
+  WorkingMemory,
+  createAccessControl,
+  createAgentMemory,
+  createCompressor,
+  createConsolidator,
+  createDebugger,
+  createEpisodicMemory,
+  createExporter,
+  createExtractor,
+  createForgetter,
+  createHierarchicalMemory,
+  createHybridRetrieval,
+  createInMemoryStore,
+  createInspector,
+  createLongTermMemory,
+  createMemoryManager,
+  createNamespaceManager,
+  createPipelineBuilder,
+  createPostgresStore,
+  createRedisStore,
+  createRetrievalPipeline,
+  createSQLiteStore,
+  createSemanticMemory,
+  createSemanticRetrieval,
+  createSharedMemory,
+  createSummarizer,
+  createTemporalRetrieval,
+  createTimeline,
+  createWorkingMemory
+};