@lov3kaizen/agentsea-memory 0.5.1

package/dist/chunk-TPC7MYWK.js

@@ -0,0 +1,1495 @@
+// src/structures/WorkingMemory.ts
+import { EventEmitter } from "eventemitter3";
+var WorkingMemory = class extends EventEmitter {
+  store;
+  config;
+  contextWindow = [];
+  attentionBuffer = /* @__PURE__ */ new Map();
+  currentQuery = "";
+  constructor(store, config = {}) {
+    super();
+    this.store = store;
+    this.config = {
+      maxItems: config.maxItems ?? 20,
+      maxSize: config.maxSize ?? 20,
+      ttl: config.ttl ?? 3e5,
+      // 5 minutes default
+      importance: config.importance ?? "recency",
+      onEvict: config.onEvict ?? (() => {
+      }),
+      attentionWindow: config.attentionWindow ?? 5,
+      decayRate: config.decayRate ?? 0.1,
+      relevanceThreshold: config.relevanceThreshold ?? 0.3,
+      autoEvict: config.autoEvict ?? true
+    };
+  }
+  /**
+   * Add an entry to working memory
+   */
+  async add(entry) {
+    const existingIdx = this.contextWindow.findIndex((e) => e.id === entry.id);
+    if (existingIdx !== -1) {
+      this.contextWindow.splice(existingIdx, 1);
+    }
+    this.contextWindow.unshift(entry);
+    this.attentionBuffer.set(entry.id, 1);
+    if (this.contextWindow.length > this.config.maxSize) {
+      await this.evictLowestAttention();
+    }
+    this.emit("contextUpdate", this.contextWindow);
+  }
+  /**
+   * Get all entries in working memory
+   */
+  getContext() {
+    return [...this.contextWindow];
+  }
+  /**
+   * Get entries with attention scores
+   */
+  getContextWithAttention() {
+    return this.contextWindow.map((entry, index) => {
+      const recency = 1 - index / this.config.maxSize;
+      const attention = this.attentionBuffer.get(entry.id) ?? 0;
+      const relevance = this.calculateRelevance(entry);
+      const importance = entry.importance;
+      const total = recency * 0.3 + attention * 0.3 + relevance * 0.25 + importance * 0.15;
+      return {
+        entry,
+        relevance,
+        recency,
+        importance,
+        total
+      };
+    });
+  }
+  /**
+   * Update attention for an entry (e.g., when referenced)
+   */
+  attend(id) {
+    const current = this.attentionBuffer.get(id) ?? 0;
+    const newScore = Math.min(current + 0.2, 1);
+    this.attentionBuffer.set(id, newScore);
+    const entry = this.contextWindow.find((e) => e.id === id);
+    if (entry) {
+      this.emit("attention", entry, newScore);
+    }
+  }
+  /**
+   * Set the current query/context for relevance calculation
+   */
+  setQuery(query) {
+    this.currentQuery = query;
+  }
+  /**
+   * Decay attention scores
+   */
+  decay() {
+    for (const [id, score] of this.attentionBuffer) {
+      const newScore = score * (1 - this.config.decayRate);
+      if (newScore < 0.01) {
+        this.attentionBuffer.delete(id);
+      } else {
+        this.attentionBuffer.set(id, newScore);
+      }
+    }
+  }
+  /**
+   * Get the most attended entries
+   */
+  getFocused(limit = 5) {
+    const scored = this.getContextWithAttention();
+    scored.sort((a, b) => b.total - a.total);
+    return scored.slice(0, limit).map((s) => s.entry);
+  }
+  /**
+   * Clear working memory
+   */
+  clear() {
+    const evicted = [...this.contextWindow];
+    this.contextWindow = [];
+    this.attentionBuffer.clear();
+    this.emit("overflow", evicted);
+    this.emit("contextUpdate", []);
+  }
+  /**
+   * Remove a specific entry
+   */
+  remove(id) {
+    const idx = this.contextWindow.findIndex((e) => e.id === id);
+    if (idx === -1) return false;
+    this.contextWindow.splice(idx, 1);
+    this.attentionBuffer.delete(id);
+    this.emit("contextUpdate", this.contextWindow);
+    return true;
+  }
+  /**
+   * Get current size
+   */
+  get size() {
+    return this.contextWindow.length;
+  }
+  /**
+   * Check if at capacity
+   */
+  get isFull() {
+    return this.contextWindow.length >= this.config.maxSize;
+  }
+  /**
+   * Consolidate important items to long-term storage
+   */
+  async consolidate(targetStore) {
+    const scored = this.getContextWithAttention();
+    const toConsolidate = scored.filter(
+      (s) => s.total > this.config.relevanceThreshold
+    );
+    let count = 0;
+    for (const { entry } of toConsolidate) {
+      await targetStore.add(entry);
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Load context from store
+   */
+  async loadFromStore(options) {
+    const { entries } = await this.store.query({
+      namespace: options?.namespace,
+      userId: options?.userId,
+      conversationId: options?.conversationId,
+      limit: options?.limit ?? this.config.maxSize
+    });
+    this.contextWindow = entries;
+    this.attentionBuffer.clear();
+    for (const entry of entries) {
+      this.attentionBuffer.set(entry.id, 0.5);
+    }
+    this.emit("contextUpdate", this.contextWindow);
+  }
+  /**
+   * Calculate relevance to current query
+   */
+  calculateRelevance(entry) {
+    if (!this.currentQuery) return 0.5;
+    const queryWords = this.currentQuery.toLowerCase().split(/\s+/);
+    const contentWords = entry.content.toLowerCase();
+    let matches = 0;
+    for (const word of queryWords) {
+      if (word.length > 2 && contentWords.includes(word)) {
+        matches++;
+      }
+    }
+    return queryWords.length > 0 ? matches / queryWords.length : 0;
+  }
+  /**
+   * Evict entry with lowest attention
+   */
+  async evictLowestAttention() {
+    const scored = this.getContextWithAttention();
+    scored.sort((a, b) => a.total - b.total);
+    const toEvict = scored[0];
+    if (toEvict) {
+      const idx = this.contextWindow.findIndex(
+        (e) => e.id === toEvict.entry.id
+      );
+      if (idx !== -1) {
+        const evicted = this.contextWindow.splice(idx, 1);
+        this.attentionBuffer.delete(toEvict.entry.id);
+        this.emit("overflow", evicted);
+      }
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Get summary of working memory state
+   */
+  getSummary() {
+    const types = {};
+    let totalAttention = 0;
+    for (const entry of this.contextWindow) {
+      types[entry.type] = (types[entry.type] ?? 0) + 1;
+      totalAttention += this.attentionBuffer.get(entry.id) ?? 0;
+    }
+    return {
+      size: this.contextWindow.length,
+      maxSize: this.config.maxSize,
+      avgAttention: this.contextWindow.length > 0 ? totalAttention / this.contextWindow.length : 0,
+      topTypes: types
+    };
+  }
+};
+function createWorkingMemory(store, config) {
+  return new WorkingMemory(store, config);
+}
+
+// src/structures/EpisodicMemory.ts
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
+var EpisodicMemory = class extends EventEmitter2 {
+  store;
+  config;
+  episodes = /* @__PURE__ */ new Map();
+  currentEpisode = null;
+  episodeTimeout = null;
+  constructor(store, config = {}) {
+    super();
+    this.store = store;
+    this.config = {
+      store: config.store ?? store,
+      consolidateAfter: config.consolidateAfter ?? 24 * 60 * 60 * 1e3,
+      // 24 hours
+      summarizeThreshold: config.summarizeThreshold ?? 10,
+      retentionDays: config.retentionDays ?? 90,
+      maxEpisodeLength: config.maxEpisodeLength ?? 50,
+      episodeTimeout: config.episodeTimeout ?? 30 * 60 * 1e3,
+      // 30 minutes
+      autoSummarize: config.autoSummarize ?? true,
+      minEventsForEpisode: config.minEventsForEpisode ?? 3,
+      emotionTracking: config.emotionTracking ?? false
+    };
+  }
+  /**
+   * Record an event
+   */
+  async recordEvent(entry) {
+    const eventEntry = {
+      ...entry,
+      type: "event"
+    };
+    await this.store.add(eventEntry);
+    let episode = this.currentEpisode;
+    if (!episode) {
+      episode = this.startEpisode();
+    }
+    episode.events.push(eventEntry);
+    this.resetEpisodeTimeout();
+    if (episode.events.length >= this.config.maxEpisodeLength) {
+      await this.endCurrentEpisode();
+    }
+    this.emit("eventAdded", eventEntry, episode);
+    return episode;
+  }
+  /**
+   * Start a new episode
+   */
+  startEpisode(metadata) {
+    if (this.currentEpisode) {
+      void this.endCurrentEpisode();
+    }
+    const episode = {
+      id: this.generateId(),
+      startTime: Date.now(),
+      events: [],
+      metadata: metadata ?? {}
+    };
+    this.currentEpisode = episode;
+    this.episodes.set(episode.id, episode);
+    this.emit("episodeStart", episode);
+    return episode;
+  }
+  /**
+   * End the current episode
+   */
+  async endCurrentEpisode() {
+    if (!this.currentEpisode) return null;
+    const episode = this.currentEpisode;
+    episode.endTime = Date.now();
+    if (this.config.autoSummarize && episode.events.length >= this.config.minEventsForEpisode) {
+      episode.summary = this.generateEpisodeSummary(episode);
+    }
+    if (episode.summary) {
+      await this.store.add({
+        id: `episode-summary-${episode.id}`,
+        content: episode.summary,
+        type: "summary",
+        importance: this.calculateEpisodeImportance(episode),
+        metadata: {
+          source: "system",
+          confidence: 0.9,
+          episodeId: episode.id,
+          eventCount: episode.events.length,
+          duration: episode.endTime - episode.startTime,
+          ...episode.metadata
+        },
+        timestamp: episode.startTime,
+        accessCount: 0,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      });
+    }
+    this.currentEpisode = null;
+    if (this.episodeTimeout) {
+      clearTimeout(this.episodeTimeout);
+      this.episodeTimeout = null;
+    }
+    this.emit("episodeEnd", episode);
+    return episode;
+  }
+  /**
+   * Recall events from a time period
+   */
+  async recall(options) {
+    const { entries } = await this.store.query({
+      types: ["event"],
+      startTime: options.startTime,
+      endTime: options.endTime,
+      conversationId: options.conversationId,
+      userId: options.userId,
+      limit: options.limit ?? 50
+    });
+    return entries;
+  }
+  /**
+   * Search episodes by content
+   */
+  async searchEpisodes(query, limit = 10) {
+    const { entries } = await this.store.query({
+      query,
+      types: ["summary"],
+      limit
+    });
+    const results = [];
+    for (const entry of entries) {
+      const episodeId = entry.metadata.episodeId;
+      if (episodeId && this.episodes.has(episodeId)) {
+        results.push(this.episodes.get(episodeId));
+      }
+    }
+    return results;
+  }
+  /**
+   * Get episode by ID
+   */
+  getEpisode(id) {
+    return this.episodes.get(id);
+  }
+  /**
+   * Get current episode
+   */
+  getCurrentEpisode() {
+    return this.currentEpisode;
+  }
+  /**
+   * Get all episodes in a time range
+   */
+  getEpisodesByTimeRange(startTime, endTime) {
+    return Array.from(this.episodes.values()).filter(
+      (ep) => ep.startTime >= startTime && (ep.endTime ?? Date.now()) <= endTime
+    );
+  }
+  /**
+   * Get recent episodes
+   */
+  getRecentEpisodes(limit = 5) {
+    const sorted = Array.from(this.episodes.values()).sort(
+      (a, b) => b.startTime - a.startTime
+    );
+    return sorted.slice(0, limit);
+  }
+  /**
+   * Find similar episodes
+   */
+  async findSimilarEpisodes(episode, embedFn, limit = 5) {
+    if (!episode.summary) return [];
+    const embedding = await embedFn(episode.summary);
+    const results = await this.store.search(embedding, {
+      topK: limit + 1
+      // +1 to potentially exclude self
+    });
+    const similar = [];
+    for (const result of results) {
+      const episodeId = result.entry.metadata.episodeId;
+      if (episodeId && episodeId !== episode.id && this.episodes.has(episodeId)) {
+        similar.push({
+          episode: this.episodes.get(episodeId),
+          similarity: result.score
+        });
+      }
+    }
+    return Promise.resolve(similar.slice(0, limit));
+  }
+  /**
+   * Merge related episodes
+   */
+  mergeEpisodes(episodeIds, newTitle) {
+    const episodes = episodeIds.map((id) => this.episodes.get(id)).filter((ep) => ep !== void 0);
+    if (episodes.length < 2) return null;
+    episodes.sort((a, b) => a.startTime - b.startTime);
+    const merged = {
+      id: this.generateId(),
+      title: newTitle ?? `Merged episode (${episodes.length} episodes)`,
+      startTime: episodes[0].startTime,
+      endTime: episodes[episodes.length - 1].endTime,
+      events: episodes.flatMap((ep) => ep.events),
+      metadata: {
+        mergedFrom: episodeIds
+      }
+    };
+    merged.summary = this.generateEpisodeSummary(merged);
+    this.episodes.set(merged.id, merged);
+    return merged;
+  }
+  /**
+   * Reset episode timeout
+   */
+  resetEpisodeTimeout() {
+    if (this.episodeTimeout) {
+      clearTimeout(this.episodeTimeout);
+    }
+    this.episodeTimeout = setTimeout(() => {
+      void this.endCurrentEpisode();
+    }, this.config.episodeTimeout);
+  }
+  /**
+   * Generate episode summary
+   */
+  generateEpisodeSummary(episode) {
+    const eventSummaries = episode.events.slice(0, 10).map((e) => e.content.slice(0, 100)).join("; ");
+    const duration = episode.endTime ? Math.round((episode.endTime - episode.startTime) / 6e4) : "ongoing";
+    return `Episode with ${episode.events.length} events over ${duration} minutes: ${eventSummaries}`;
+  }
+  /**
+   * Calculate episode importance
+   */
+  calculateEpisodeImportance(episode) {
+    if (episode.events.length === 0) return 0;
+    const avgImportance = episode.events.reduce((sum, e) => sum + e.importance, 0) / episode.events.length;
+    const lengthBonus = Math.min(episode.events.length / 20, 0.2);
+    return Math.min(avgImportance + lengthBonus, 1);
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `ep-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const totalEvents = Array.from(this.episodes.values()).reduce(
+      (sum, ep) => sum + ep.events.length,
+      0
+    );
+    return {
+      totalEpisodes: this.episodes.size,
+      currentEpisodeSize: this.currentEpisode?.events.length ?? 0,
+      totalEvents,
+      avgEventsPerEpisode: this.episodes.size > 0 ? totalEvents / this.episodes.size : 0
+    };
+  }
+};
+function createEpisodicMemory(store, config) {
+  return new EpisodicMemory(store, config);
+}
+
+// src/structures/SemanticMemory.ts
+import { EventEmitter as EventEmitter3 } from "eventemitter3";
+var SemanticMemory = class extends EventEmitter3 {
+  store;
+  config;
+  concepts = /* @__PURE__ */ new Map();
+  relationships = /* @__PURE__ */ new Map();
+  conceptIndex = /* @__PURE__ */ new Map();
+  // category -> concept IDs
+  constructor(store, config = {}) {
+    super();
+    this.store = store;
+    this.config = {
+      store: config.store ?? store,
+      extractEntities: config.extractEntities ?? true,
+      extractRelations: config.extractRelations ?? true,
+      deduplication: config.deduplication ?? true,
+      deduplicationThreshold: config.deduplicationThreshold ?? 0.9,
+      maxConcepts: config.maxConcepts ?? 1e4,
+      enableInference: config.enableInference ?? true,
+      conflictResolution: config.conflictResolution ?? "newest",
+      minConfidence: config.minConfidence ?? 0.5
+    };
+  }
+  /**
+   * Learn a new fact
+   */
+  async learnFact(content, metadata) {
+    const fact = {
+      id: this.generateId("fact"),
+      content,
+      type: "fact",
+      importance: metadata?.importance ?? 0.5,
+      metadata: {
+        source: "explicit",
+        confidence: metadata?.confidence ?? 0.8,
+        ...metadata,
+        verified: metadata?.verified ?? false
+      },
+      timestamp: Date.now(),
+      accessCount: 0,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.store.add(fact);
+    this.emit("factLearned", fact);
+    return fact;
+  }
+  /**
+   * Add or update a concept
+   */
+  addConcept(concept) {
+    const existing = Array.from(this.concepts.values()).find(
+      (c) => c.name.toLowerCase() === concept.name.toLowerCase()
+    );
+    if (existing) {
+      const updated = {
+        ...existing,
+        ...concept,
+        id: existing.id,
+        createdAt: existing.createdAt,
+        updatedAt: Date.now()
+      };
+      this.concepts.set(existing.id, updated);
+      this.emit("conceptUpdated", updated);
+      return updated;
+    }
+    const newConcept = {
+      ...concept,
+      id: this.generateId("concept"),
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this.concepts.set(newConcept.id, newConcept);
+    if (newConcept.category) {
+      if (!this.conceptIndex.has(newConcept.category)) {
+        this.conceptIndex.set(newConcept.category, /* @__PURE__ */ new Set());
+      }
+      this.conceptIndex.get(newConcept.category).add(newConcept.id);
+    }
+    this.emit("conceptAdded", newConcept);
+    return newConcept;
+  }
+  /**
+   * Create a relationship between concepts
+   */
+  addRelationship(sourceId, targetId, type, metadata) {
+    const source = this.concepts.get(sourceId);
+    const target = this.concepts.get(targetId);
+    if (!source || !target) {
+      return null;
+    }
+    const existing = Array.from(this.relationships.values()).find(
+      (r) => r.sourceId === sourceId && r.targetId === targetId && r.type === type
+    );
+    if (existing) {
+      existing.weight = Math.min(existing.weight + 0.1, 1);
+      return existing;
+    }
+    const relationship = {
+      id: this.generateId("rel"),
+      sourceId,
+      targetId,
+      type,
+      weight: metadata?.weight ?? 0.5,
+      metadata: metadata ?? {},
+      createdAt: Date.now()
+    };
+    this.relationships.set(relationship.id, relationship);
+    this.emit("relationshipAdded", relationship);
+    return relationship;
+  }
+  /**
+   * Get a concept by ID or name
+   */
+  getConcept(idOrName) {
+    const byId = this.concepts.get(idOrName);
+    if (byId) return byId;
+    return Array.from(this.concepts.values()).find(
+      (c) => c.name.toLowerCase() === idOrName.toLowerCase()
+    );
+  }
+  /**
+   * Get concepts by category
+   */
+  getConceptsByCategory(category) {
+    const ids = this.conceptIndex.get(category);
+    if (!ids) return [];
+    return Array.from(ids).map((id) => this.concepts.get(id)).filter((c) => c !== void 0);
+  }
+  /**
+   * Get relationships for a concept
+   */
+  getRelationships(conceptId, direction = "both") {
+    return Array.from(this.relationships.values()).filter((r) => {
+      if (direction === "outgoing") return r.sourceId === conceptId;
+      if (direction === "incoming") return r.targetId === conceptId;
+      return r.sourceId === conceptId || r.targetId === conceptId;
+    });
+  }
+  /**
+   * Get related concepts
+   */
+  getRelatedConcepts(conceptId, relationshipType, maxDepth = 1) {
+    const results = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ id: conceptId, path: [], distance: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current.id) || current.distance > maxDepth) continue;
+      visited.add(current.id);
+      const relationships = this.getRelationships(current.id);
+      for (const rel of relationships) {
+        if (relationshipType && rel.type !== relationshipType) continue;
+        const relatedId = rel.sourceId === current.id ? rel.targetId : rel.sourceId;
+        if (relatedId === conceptId) continue;
+        const concept = this.concepts.get(relatedId);
+        if (!concept) continue;
+        const newPath = [...current.path, rel];
+        const existing = results.get(relatedId);
+        if (!existing || newPath.length < existing.path.length) {
+          results.set(relatedId, {
+            concept,
+            path: newPath,
+            distance: current.distance + 1
+          });
+          if (current.distance + 1 < maxDepth) {
+            queue.push({
+              id: relatedId,
+              path: newPath,
+              distance: current.distance + 1
+            });
+          }
+        }
+      }
+    }
+    return Array.from(results.values()).sort((a, b) => a.distance - b.distance);
+  }
+  /**
+   * Query facts
+   */
+  async queryFacts(query, limit = 10) {
+    const { entries } = await this.store.query({
+      query,
+      types: ["fact"],
+      limit
+    });
+    return entries;
+  }
+  /**
+   * Search facts by embedding
+   */
+  async searchFacts(embedding, options) {
+    const results = await this.store.search(embedding, {
+      topK: options?.topK ?? 10,
+      minScore: options?.minScore ?? this.config.minConfidence
+    });
+    return results.filter((r) => r.entry.type === "fact");
+  }
+  /**
+   * Find path between two concepts
+   */
+  findPath(sourceId, targetId, maxDepth = 5) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [
+      { id: sourceId, path: [] }
+    ];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current.id) || current.path.length >= maxDepth) continue;
+      visited.add(current.id);
+      const relationships = this.getRelationships(current.id);
+      for (const rel of relationships) {
+        const nextId = rel.sourceId === current.id ? rel.targetId : rel.sourceId;
+        const newPath = [...current.path, rel];
+        if (nextId === targetId) {
+          return newPath;
+        }
+        queue.push({ id: nextId, path: newPath });
+      }
+    }
+    return null;
+  }
+  /**
+   * Infer new relationships based on existing ones
+   */
+  inferRelationships() {
+    if (!this.config.enableInference) return [];
+    const inferred = [];
+    const transitiveTypes = ["is_a", "part_of", "related_to"];
+    for (const rel1 of this.relationships.values()) {
+      if (!transitiveTypes.includes(rel1.type)) continue;
+      for (const rel2 of this.relationships.values()) {
+        if (rel1.id === rel2.id) continue;
+        if (rel1.type !== rel2.type) continue;
+        if (rel1.targetId !== rel2.sourceId) continue;
+        const exists = Array.from(this.relationships.values()).some(
+          (r) => r.sourceId === rel1.sourceId && r.targetId === rel2.targetId && r.type === rel1.type
+        );
+        if (!exists) {
+          const newRel = this.addRelationship(
+            rel1.sourceId,
+            rel2.targetId,
+            rel1.type,
+            {
+              inferred: true,
+              weight: rel1.weight * rel2.weight * 0.8
+            }
+          );
+          if (newRel) {
+            inferred.push(newRel);
+          }
+        }
+      }
+    }
+    return inferred;
+  }
+  /**
+   * Get conflicting facts
+   */
+  async findConflicts(fact) {
+    const { entries } = await this.store.query({
+      query: fact.content,
+      types: ["fact"],
+      limit: 20
+    });
+    return entries.filter((e) => {
+      if (e.id === fact.id) return false;
+      const contentLower = e.content.toLowerCase();
+      const factLower = fact.content.toLowerCase();
+      const negationPatterns = ["not ", "isn't", "aren't", "never", "false"];
+      const hasNegation = negationPatterns.some(
+        (p) => contentLower.includes(p) && !factLower.includes(p) || !contentLower.includes(p) && factLower.includes(p)
+      );
+      return hasNegation;
+    });
+  }
+  /**
+   * Resolve conflict between facts
+   */
+  resolveConflict(fact1, fact2) {
+    switch (this.config.conflictResolution) {
+      case "newest":
+        return fact1.timestamp > fact2.timestamp ? fact1 : fact2;
+      case "highest-confidence": {
+        const conf1 = fact1.metadata.confidence ?? 0.5;
+        const conf2 = fact2.metadata.confidence ?? 0.5;
+        return conf1 > conf2 ? fact1 : fact2;
+      }
+      case "merge":
+        return {
+          ...fact1,
+          content: `${fact1.content} (Note: conflicting fact exists: ${fact2.content})`,
+          metadata: {
+            ...fact1.metadata,
+            hasConflict: true,
+            conflictingFactId: fact2.id
+          }
+        };
+      default:
+        return fact1;
+    }
+  }
+  /**
+   * Export knowledge graph
+   */
+  exportGraph() {
+    return {
+      concepts: Array.from(this.concepts.values()),
+      relationships: Array.from(this.relationships.values())
+    };
+  }
+  /**
+   * Import knowledge graph
+   */
+  importGraph(data) {
+    for (const concept of data.concepts) {
+      this.concepts.set(concept.id, concept);
+      if (concept.category) {
+        if (!this.conceptIndex.has(concept.category)) {
+          this.conceptIndex.set(concept.category, /* @__PURE__ */ new Set());
+        }
+        this.conceptIndex.get(concept.category).add(concept.id);
+      }
+    }
+    for (const relationship of data.relationships) {
+      this.relationships.set(relationship.id, relationship);
+    }
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      conceptCount: this.concepts.size,
+      relationshipCount: this.relationships.size,
+      categoryCount: this.conceptIndex.size,
+      avgRelationshipsPerConcept: this.concepts.size > 0 ? this.relationships.size / this.concepts.size : 0
+    };
+  }
+};
+function createSemanticMemory(store, config) {
+  return new SemanticMemory(store, config);
+}
+
+// src/structures/LongTermMemory.ts
+import { EventEmitter as EventEmitter4 } from "eventemitter3";
+var LongTermMemory = class extends EventEmitter4 {
+  store;
+  config;
+  consolidatedMemories = /* @__PURE__ */ new Map();
+  constructor(store, config = {}) {
+    super();
+    this.store = store;
+    this.config = {
+      store: config.store ?? store,
+      indexing: config.indexing ?? "hybrid",
+      compression: config.compression ?? true,
+      compressionThreshold: config.compressionThreshold ?? 1e3,
+      consolidationThreshold: config.consolidationThreshold ?? 100,
+      compressionRatio: config.compressionRatio ?? 5,
+      minImportance: config.minImportance ?? 0.3,
+      retentionPeriod: config.retentionPeriod ?? 365 * 24 * 60 * 60 * 1e3,
+      // 1 year
+      autoConsolidate: config.autoConsolidate ?? true,
+      maxStorageSize: config.maxStorageSize ?? 1e5
+    };
+  }
+  /**
+   * Store a memory in long-term storage
+   */
+  async store_memory(entry) {
+    if (entry.importance < this.config.minImportance) {
+      return entry.id;
+    }
+    const entryWithExpiry = {
+      ...entry,
+      expiresAt: entry.expiresAt ?? Date.now() + this.config.retentionPeriod
+    };
+    await this.store.add(entryWithExpiry);
+    if (this.config.autoConsolidate) {
+      const count = await this.store.count();
+      if (count >= this.config.consolidationThreshold) {
+        await this.consolidateOldMemories();
+      }
+    }
+    return entry.id;
+  }
+  /**
+   * Retrieve memories by similarity
+   */
+  async retrieve(embedding, options) {
+    const results = await this.store.search(embedding, {
+      topK: options?.topK ?? 10,
+      minScore: options?.minScore ?? 0.5
+    });
+    this.emit(
+      "retrieved",
+      results.map((r) => r.entry)
+    );
+    return results;
+  }
+  /**
+   * Query long-term memories
+   */
+  async query(options) {
+    const { entries } = await this.store.query({
+      ...options,
+      types: options.types,
+      minImportance: options.minImportance ?? this.config.minImportance,
+      limit: options.limit ?? 100
+    });
+    return entries;
+  }
+  /**
+   * Consolidate old memories into summaries
+   */
+  async consolidateOldMemories(options) {
+    const olderThan = options?.olderThan ?? Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const { entries } = await this.store.query({
+      endTime: olderThan,
+      limit: 1e3
+    });
+    if (entries.length < this.config.compressionRatio) {
+      return [];
+    }
+    const groups = this.groupMemories(entries, options?.groupBy ?? "day");
+    const consolidated = [];
+    for (const [key, groupEntries] of groups) {
+      if (groupEntries.length < 2) continue;
+      const summary = options?.summarizeFn ? await options.summarizeFn(groupEntries) : this.generateSimpleSummary(groupEntries);
+      const consolidatedMemory = {
+        id: this.generateId(),
+        summary,
+        sourceIds: groupEntries.map((e) => e.id),
+        sourceCount: groupEntries.length,
+        avgImportance: groupEntries.reduce((sum, e) => sum + e.importance, 0) / groupEntries.length,
+        timeRange: {
+          start: Math.min(...groupEntries.map((e) => e.timestamp)),
+          end: Math.max(...groupEntries.map((e) => e.timestamp))
+        },
+        metadata: {
+          groupKey: key
+        },
+        createdAt: Date.now()
+      };
+      await this.store.add({
+        id: consolidatedMemory.id,
+        content: consolidatedMemory.summary,
+        type: "summary",
+        importance: consolidatedMemory.avgImportance,
+        metadata: {
+          source: "system",
+          confidence: 0.85,
+          consolidated: true,
+          sourceCount: consolidatedMemory.sourceCount,
+          ...consolidatedMemory.metadata
+        },
+        timestamp: consolidatedMemory.timeRange.start,
+        accessCount: 0,
+        createdAt: consolidatedMemory.createdAt,
+        updatedAt: consolidatedMemory.createdAt
+      });
+      this.consolidatedMemories.set(consolidatedMemory.id, consolidatedMemory);
+      for (const entry of groupEntries) {
+        await this.store.delete(entry.id);
+      }
+      consolidated.push(consolidatedMemory);
+      this.emit("consolidated", consolidatedMemory, groupEntries);
+    }
+    return consolidated;
+  }
+  /**
+   * Prune low-importance memories
+   */
+  async prune(options) {
+    const { entries } = await this.store.query({
+      limit: 1e4
+    });
+    const now = Date.now();
+    const maxAge = options?.maxAge ?? this.config.retentionPeriod;
+    const maxImportance = options?.maxImportance ?? this.config.minImportance;
+    const toPrune = entries.filter((entry) => {
+      const age = now - entry.timestamp;
+      const isOld = age > maxAge;
+      const isLowImportance = entry.importance < maxImportance;
+      const isLowAccess = entry.accessCount < 2;
+      return isOld || isLowImportance && isLowAccess;
+    });
+    const limit = options?.maxCount ?? toPrune.length;
+    const pruneList = toPrune.slice(0, limit);
+    for (const entry of pruneList) {
+      await this.store.delete(entry.id);
+    }
+    this.emit("pruned", pruneList);
+    return pruneList.length;
+  }
+  /**
+   * Reinforce a memory (increase importance)
+   */
+  async reinforce(id, amount = 0.1) {
+    const entry = await this.store.get(id);
+    if (!entry) return false;
+    const newImportance = Math.min(entry.importance + amount, 1);
+    return this.store.update(id, {
+      importance: newImportance,
+      expiresAt: Date.now() + this.config.retentionPeriod
+      // Reset expiration
+    });
+  }
+  /**
+   * Get consolidated memory by ID
+   */
+  getConsolidated(id) {
+    return this.consolidatedMemories.get(id);
+  }
+  /**
+   * Get all consolidated memories
+   */
+  getAllConsolidated() {
+    return Array.from(this.consolidatedMemories.values());
+  }
+  /**
+   * Expand a consolidated memory to show original summaries
+   */
+  expandConsolidated(id) {
+    const consolidated = this.consolidatedMemories.get(id);
+    if (!consolidated) return null;
+    return [
+      {
+        id: consolidated.id,
+        content: consolidated.summary,
+        type: "summary",
+        importance: consolidated.avgImportance,
+        metadata: {
+          source: "system",
+          confidence: 0.85,
+          expanded: true,
+          sourceCount: consolidated.sourceCount
+        },
+        timestamp: consolidated.timeRange.start,
+        accessCount: 0,
+        createdAt: consolidated.createdAt,
+        updatedAt: consolidated.createdAt
+      }
+    ];
+  }
+  /**
+   * Group memories by time or topic
+   */
+  groupMemories(entries, groupBy) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      let key;
+      switch (groupBy) {
+        case "day":
+          key = new Date(entry.timestamp).toISOString().split("T")[0];
+          break;
+        case "week": {
+          const date = new Date(entry.timestamp);
+          const weekStart = new Date(date);
+          weekStart.setDate(date.getDate() - date.getDay());
+          key = weekStart.toISOString().split("T")[0];
+          break;
+        }
+        case "topic":
+          key = String(entry.metadata.topic ?? entry.type);
+          break;
+        default:
+          key = "default";
+      }
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key).push(entry);
+    }
+    return groups;
+  }
+  /**
+   * Generate simple summary from entries
+   */
+  generateSimpleSummary(entries) {
+    const types = new Set(entries.map((e) => e.type));
+    const snippets = entries.slice(0, 5).map((e) => e.content.slice(0, 50)).join("; ");
+    return `Consolidated ${entries.length} memories (${Array.from(types).join(", ")}): ${snippets}...`;
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `ltm-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+  /**
+   * Get statistics
+   */
+  async getStats() {
+    const count = await this.store.count();
+    const { entries } = await this.store.query({ limit: 1e3 });
+    const avgImportance = entries.length > 0 ? entries.reduce((sum, e) => sum + e.importance, 0) / entries.length : 0;
+    const timestamps = entries.map((e) => e.timestamp);
+    return {
+      totalMemories: count,
+      consolidatedCount: this.consolidatedMemories.size,
+      avgImportance,
+      oldestMemory: timestamps.length > 0 ? Math.min(...timestamps) : null,
+      newestMemory: timestamps.length > 0 ? Math.max(...timestamps) : null
+    };
+  }
+};
+function createLongTermMemory(store, config) {
+  return new LongTermMemory(store, config);
+}
+
+// src/structures/HierarchicalMemory.ts
+import { EventEmitter as EventEmitter5 } from "eventemitter3";
+var HierarchicalMemory = class extends EventEmitter5 {
+  workingMemory;
+  episodicMemory;
+  semanticMemory;
+  longTermMemory;
+  config;
+  embedFn;
+  constructor(stores, config = {}) {
+    super();
+    this.config = {
+      working: config.working ?? {},
+      episodic: config.episodic ?? {},
+      semantic: config.semantic ?? {},
+      longTerm: config.longTerm ?? {},
+      routing: config.routing ?? {},
+      routingStrategy: config.routingStrategy ?? "auto",
+      consolidationInterval: config.consolidationInterval ?? 60 * 60 * 1e3,
+      // 1 hour
+      workingMemorySize: config.workingMemorySize ?? 20,
+      promotionThreshold: config.promotionThreshold ?? 0.7
+    };
+    this.workingMemory = new WorkingMemory(stores.working, {
+      maxSize: this.config.workingMemorySize
+    });
+    this.episodicMemory = new EpisodicMemory(stores.episodic);
+    this.semanticMemory = new SemanticMemory(stores.semantic);
+    this.longTermMemory = new LongTermMemory(stores.longterm);
+    this.setupEventHandlers();
+  }
+  /**
+   * Set embedding function for semantic search
+   */
+  setEmbeddingFunction(fn) {
+    this.embedFn = fn;
+  }
+  /**
+   * Add a memory entry with automatic routing
+   */
+  async add(entry) {
+    const layer = this.route(entry);
+    switch (layer) {
+      case "working":
+        await this.workingMemory.add(entry);
+        break;
+      case "episodic":
+        await this.episodicMemory.recordEvent(entry);
+        break;
+      case "semantic":
+        await this.semanticMemory.learnFact(entry.content, entry.metadata);
+        break;
+      case "longterm":
+        await this.longTermMemory.store_memory(entry);
+        break;
+    }
+    this.emit("routed", entry, layer);
+    return layer;
+  }
+  /**
+   * Add to a specific layer
+   */
+  async addToLayer(entry, layer) {
+    switch (layer) {
+      case "working":
+        await this.workingMemory.add(entry);
+        break;
+      case "episodic":
+        await this.episodicMemory.recordEvent(entry);
+        break;
+      case "semantic":
+        await this.semanticMemory.learnFact(entry.content, entry.metadata);
+        break;
+      case "longterm":
+        await this.longTermMemory.store_memory(entry);
+        break;
+    }
+    this.emit("routed", entry, layer);
+  }
+  /**
+   * Search across all memory layers
+   */
+  async search(query, options) {
+    const layers = options?.layers ?? [
+      "working",
+      "episodic",
+      "semantic",
+      "longterm"
+    ];
+    const topK = options?.topK ?? 10;
+    const minScore = options?.minScore ?? 0.3;
+    const results = [];
+    let embedding;
+    if (this.embedFn) {
+      embedding = await this.embedFn(query);
+    }
+    for (const layer of layers) {
+      const layerResults = await this.searchLayer(layer, query, embedding, {
+        topK,
+        minScore
+      });
+      results.push(...layerResults);
+    }
+    results.sort((a, b) => b.score - a.score);
+    const seen = /* @__PURE__ */ new Set();
+    const deduplicated = results.filter((r) => {
+      if (seen.has(r.entry.id)) return false;
+      seen.add(r.entry.id);
+      return true;
+    });
+    this.emit(
+      "retrieved",
+      deduplicated.map((r) => r.entry),
+      layers
+    );
+    return deduplicated.slice(0, topK);
+  }
+  /**
+   * Search a specific layer
+   */
+  async searchLayer(layer, query, embedding, options) {
+    const topK = options?.topK ?? 10;
+    switch (layer) {
+      case "working": {
+        const context = this.workingMemory.getContextWithAttention();
+        return context.filter(
+          (c) => c.entry.content.toLowerCase().includes(query.toLowerCase())
+        ).map((c) => ({
+          entry: c.entry,
+          score: c.total,
+          layer: "working"
+        })).slice(0, topK);
+      }
+      case "episodic": {
+        const episodes = await this.episodicMemory.recall({ limit: topK * 2 });
+        return episodes.filter((e) => e.content.toLowerCase().includes(query.toLowerCase())).map((entry) => ({
+          entry,
+          score: this.calculateTextScore(query, entry.content),
+          layer: "episodic"
+        })).slice(0, topK);
+      }
+      case "semantic": {
+        const facts = await this.semanticMemory.queryFacts(query, topK);
+        return facts.map((entry) => ({
+          entry,
+          score: this.calculateTextScore(query, entry.content),
+          layer: "semantic"
+        }));
+      }
+      case "longterm": {
+        if (embedding) {
+          const results = await this.longTermMemory.retrieve(embedding, {
+            topK
+          });
+          return results.map((r) => ({
+            entry: r.entry,
+            score: r.score,
+            layer: "longterm"
+          }));
+        }
+        const entries = await this.longTermMemory.query({ query, limit: topK });
+        return entries.map((entry) => ({
+          entry,
+          score: this.calculateTextScore(query, entry.content),
+          layer: "longterm"
+        }));
+      }
+      default:
+        return [];
+    }
+  }
+  /**
+   * Get context from working memory
+   */
+  getWorkingContext() {
+    return this.workingMemory.getContext();
+  }
+  /**
+   * Promote a memory to a higher layer
+   */
+  async promote(entryId, from, to) {
+    let entry = null;
+    switch (from) {
+      case "working":
+        entry = this.workingMemory.getContext().find((e) => e.id === entryId) ?? null;
+        break;
+      case "episodic": {
+        const events = await this.episodicMemory.recall({ limit: 1e3 });
+        entry = events.find((e) => e.id === entryId) ?? null;
+        break;
+      }
+    }
+    if (!entry) return false;
+    await this.addToLayer(entry, to);
+    this.emit("promoted", entry, from, to);
+    return true;
+  }
+  /**
+   * Consolidate memories from one layer to another
+   */
+  async consolidate(from, to) {
+    let count = 0;
+    switch (from) {
+      case "working":
+        if (to === "episodic" || to === "longterm") {
+          const context = this.workingMemory.getContext();
+          const important = context.filter(
+            (e) => e.importance >= this.config.promotionThreshold
+          );
+          for (const entry of important) {
+            await this.addToLayer(entry, to);
+            count++;
+          }
+        }
+        break;
+      case "episodic":
+        if (to === "longterm") {
+          const episodes = this.episodicMemory.getRecentEpisodes(10);
+          for (const episode of episodes) {
+            if (episode.summary) {
+              await this.longTermMemory.store_memory({
+                id: `consolidated-${episode.id}`,
+                content: episode.summary,
+                type: "summary",
+                importance: 0.7,
+                metadata: {
+                  source: "system",
+                  confidence: 0.85,
+                  sourceEpisodeId: episode.id,
+                  eventCount: episode.events.length
+                },
+                timestamp: episode.startTime,
+                accessCount: 0,
+                createdAt: Date.now(),
+                updatedAt: Date.now()
+              });
+              count++;
+            }
+          }
+        }
+        break;
+    }
+    if (count > 0) {
+      this.emit("consolidated", from, to, count);
+    }
+    return count;
+  }
+  /**
+   * Route a memory entry to the appropriate layer
+   */
+  route(entry) {
+    if (this.config.routingStrategy === "manual") {
+      return entry.metadata.targetLayer ?? "working";
+    }
+    const decision = this.makeRoutingDecision(entry);
+    return decision.layer;
+  }
+  /**
+   * Make routing decision
+   */
+  makeRoutingDecision(entry) {
+    if (entry.type === "event") {
+      return {
+        layer: "episodic",
+        confidence: 0.9,
+        reason: "Event type maps to episodic memory"
+      };
+    }
+    if (entry.type === "fact") {
+      return {
+        layer: "semantic",
+        confidence: 0.9,
+        reason: "Fact type maps to semantic memory"
+      };
+    }
+    if (entry.importance >= 0.8) {
+      return {
+        layer: "longterm",
+        confidence: 0.8,
+        reason: "High importance memory"
+      };
+    }
+    if (entry.type === "context") {
+      return {
+        layer: "working",
+        confidence: 0.9,
+        reason: "Context type maps to working memory"
+      };
+    }
+    if (entry.type === "summary") {
+      return {
+        layer: "longterm",
+        confidence: 0.8,
+        reason: "Summary type maps to long-term memory"
+      };
+    }
+    return {
+      layer: "working",
+      confidence: 0.6,
+      reason: "Default routing to working memory"
+    };
+  }
+  /**
+   * Calculate text similarity score
+   */
+  calculateTextScore(query, content) {
+    const queryWords = query.toLowerCase().split(/\s+/);
+    const contentLower = content.toLowerCase();
+    let matches = 0;
+    for (const word of queryWords) {
+      if (word.length > 2 && contentLower.includes(word)) {
+        matches++;
+      }
+    }
+    return queryWords.length > 0 ? matches / queryWords.length : 0;
+  }
+  /**
+   * Set up event handlers between layers
+   */
+  setupEventHandlers() {
+    this.workingMemory.on("overflow", (evicted) => {
+      void (async () => {
+        for (const entry of evicted) {
+          if (entry.importance >= this.config.promotionThreshold) {
+            await this.longTermMemory.store_memory(entry);
+          }
+        }
+      })();
+    });
+    this.episodicMemory.on("episodeEnd", (episode) => {
+      void (async () => {
+        if (episode.summary && episode.events.length >= 5) {
+          await this.longTermMemory.store_memory({
+            id: `episode-${episode.id}`,
+            content: episode.summary,
+            type: "summary",
+            importance: 0.6,
+            metadata: {
+              source: "system",
+              confidence: 0.8,
+              episodeId: episode.id,
+              eventCount: episode.events.length
+            },
+            timestamp: episode.startTime,
+            accessCount: 0,
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+          });
+        }
+      })();
+    });
+  }
+  /**
+   * Get statistics for all layers
+   */
+  async getStats() {
+    return {
+      working: this.workingMemory.getSummary(),
+      episodic: this.episodicMemory.getStats(),
+      semantic: this.semanticMemory.getStats(),
+      longterm: await this.longTermMemory.getStats()
+    };
+  }
+  /**
+   * Access individual memory layers
+   */
+  get layers() {
+    return {
+      working: this.workingMemory,
+      episodic: this.episodicMemory,
+      semantic: this.semanticMemory,
+      longterm: this.longTermMemory
+    };
+  }
+};
+function createHierarchicalMemory(stores, config) {
+  return new HierarchicalMemory(stores, config);
+}
+
+export {
+  WorkingMemory,
+  createWorkingMemory,
+  EpisodicMemory,
+  createEpisodicMemory,
+  SemanticMemory,
+  createSemanticMemory,
+  LongTermMemory,
+  createLongTermMemory,
+  HierarchicalMemory,
+  createHierarchicalMemory
+};