aether-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1071 @@
+// src/retrieval/strategies/semantic.strategy.ts
+var SemanticStrategy = class {
+  type = "semantic";
+  async retrieve(query, context, options) {
+    const queryEmbedding = await context.embeddings.embed(query);
+    const filters = {};
+    if (options.actor) {
+      filters["actor"] = options.actor;
+    }
+    if (options.contextFilters) {
+      Object.assign(filters, options.contextFilters);
+    }
+    const results = await context.storage.searchByVector(queryEmbedding, {
+      limit: options.limit ?? 10,
+      threshold: options.threshold ?? 0.5,
+      filters: Object.keys(filters).length > 0 ? filters : void 0
+    });
+    return results;
+  }
+};
+
+// src/retrieval/strategies/temporal.strategy.ts
+var TemporalStrategy = class {
+  type = "temporal";
+  /** Decay rate for recency scoring (higher = faster decay) */
+  decayRate;
+  constructor(decayRate = 1e-4) {
+    this.decayRate = decayRate;
+  }
+  async retrieve(_query, context, options) {
+    if (!options.actor) {
+      return [];
+    }
+    const events = await context.storage.queryByActor(options.actor, {
+      limit: options.limit ?? 20,
+      order: "desc"
+      // Most recent first
+    });
+    const now = Date.now();
+    const scored = events.map((event) => {
+      const eventTime = new Date(event.timestamp).getTime();
+      const age = now - eventTime;
+      const score = Math.exp(-this.decayRate * age);
+      return { ...event, score };
+    });
+    return scored;
+  }
+};
+
+// src/retrieval/strategies/relational.strategy.ts
+var DEFAULT_ENTITY_PATTERNS = [
+  { key: "cartId", pattern: /cart[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "orderId", pattern: /order[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "userId", pattern: /user[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "productId", pattern: /product[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "sessionId", pattern: /session[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "transactionId", pattern: /transaction[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "customerId", pattern: /customer[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "invoiceId", pattern: /invoice[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "ticketId", pattern: /ticket[_\s-]?id[:\s=]+["']?(\w+)["']?/i },
+  { key: "email", pattern: /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/i }
+];
+var PatternEntityExtractor = class {
+  patterns;
+  constructor(patterns) {
+    this.patterns = patterns ?? DEFAULT_ENTITY_PATTERNS;
+  }
+  /**
+   * Add a new pattern.
+   */
+  addPattern(key, pattern) {
+    this.patterns.push({ key, pattern });
+  }
+  /**
+   * Add multiple patterns at once.
+   */
+  addPatterns(patterns) {
+    this.patterns.push(...patterns);
+  }
+  /**
+   * Remove a pattern by key.
+   */
+  removePattern(key) {
+    this.patterns = this.patterns.filter((p) => p.key !== key);
+  }
+  /**
+   * Clear all patterns.
+   */
+  clearPatterns() {
+    this.patterns = [];
+  }
+  /**
+   * Get current patterns.
+   */
+  getPatterns() {
+    return [...this.patterns];
+  }
+  extract(query) {
+    const extracted = {};
+    for (const { key, pattern } of this.patterns) {
+      const match = query.match(pattern);
+      if (match?.[1]) {
+        extracted[key] = match[1];
+      }
+    }
+    return extracted;
+  }
+};
+var CompositeEntityExtractor = class {
+  extractors;
+  constructor(extractors = []) {
+    this.extractors = extractors;
+  }
+  addExtractor(extractor) {
+    this.extractors.push(extractor);
+  }
+  async extract(query) {
+    const results = {};
+    for (const extractor of this.extractors) {
+      const extracted = await extractor.extract(query);
+      Object.assign(results, extracted);
+    }
+    return results;
+  }
+};
+var RelationalStrategy = class {
+  type = "relational";
+  entityExtractor;
+  constructor(config) {
+    if (config?.entityExtractor) {
+      this.entityExtractor = config.entityExtractor;
+    } else {
+      let patterns;
+      if (config?.patterns) {
+        if (config.includeDefaultPatterns) {
+          patterns = [...DEFAULT_ENTITY_PATTERNS, ...config.patterns];
+        } else {
+          patterns = config.patterns;
+        }
+      } else {
+        patterns = DEFAULT_ENTITY_PATTERNS;
+      }
+      this.entityExtractor = new PatternEntityExtractor(patterns);
+    }
+  }
+  /**
+   * Get the entity extractor (for testing or modification).
+   */
+  getEntityExtractor() {
+    return this.entityExtractor;
+  }
+  async retrieve(query, context, options) {
+    const filters = await this.buildFilters(query, options.contextFilters);
+    if (Object.keys(filters).length === 0) {
+      return [];
+    }
+    const events = await context.storage.queryByContext(filters, {
+      limit: options.limit ?? 20
+    });
+    const totalFilters = Object.keys(filters).length;
+    const scored = events.map((event) => {
+      let matchCount = 0;
+      for (const [key, value] of Object.entries(filters)) {
+        if (event.context[key] === value) {
+          matchCount++;
+        }
+      }
+      const score = matchCount / totalFilters;
+      return { ...event, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored;
+  }
+  /**
+   * Build filters from explicit context filters or by extracting entities from query.
+   */
+  async buildFilters(query, contextFilters) {
+    if (contextFilters && Object.keys(contextFilters).length > 0) {
+      return contextFilters;
+    }
+    return this.entityExtractor.extract(query);
+  }
+};
+
+// src/retrieval/strategies/hybrid.strategy.ts
+var DEFAULT_WEIGHTS = {
+  semantic: 0.5,
+  temporal: 0.3,
+  relational: 0.2
+};
+var HybridStrategy = class {
+  type = "hybrid";
+  semanticStrategy;
+  temporalStrategy;
+  relationalStrategy;
+  weights;
+  constructor(weights) {
+    this.semanticStrategy = new SemanticStrategy();
+    this.temporalStrategy = new TemporalStrategy();
+    this.relationalStrategy = new RelationalStrategy();
+    this.weights = { ...DEFAULT_WEIGHTS, ...weights };
+    const total = this.weights.semantic + this.weights.temporal + this.weights.relational;
+    if (total > 0) {
+      this.weights.semantic /= total;
+      this.weights.temporal /= total;
+      this.weights.relational /= total;
+    }
+  }
+  async retrieve(query, context, options) {
+    const [semanticResults, temporalResults, relationalResults] = await Promise.all([
+      this.semanticStrategy.retrieve(query, context, options),
+      // Only run temporal if actor is specified
+      options.actor ? this.temporalStrategy.retrieve(query, context, options) : Promise.resolve([]),
+      this.relationalStrategy.retrieve(query, context, options)
+    ]);
+    const combinedMap = /* @__PURE__ */ new Map();
+    for (const event of semanticResults) {
+      const weightedScore = event.score * this.weights.semantic;
+      combinedMap.set(event.id, { ...event, score: weightedScore });
+    }
+    for (const event of temporalResults) {
+      const weightedScore = event.score * this.weights.temporal;
+      const existing = combinedMap.get(event.id);
+      if (existing) {
+        existing.score += weightedScore;
+      } else {
+        combinedMap.set(event.id, { ...event, score: weightedScore });
+      }
+    }
+    for (const event of relationalResults) {
+      const weightedScore = event.score * this.weights.relational;
+      const existing = combinedMap.get(event.id);
+      if (existing) {
+        existing.score += weightedScore;
+      } else {
+        combinedMap.set(event.id, { ...event, score: weightedScore });
+      }
+    }
+    const results = Array.from(combinedMap.values()).sort((a, b) => b.score - a.score).slice(0, options.limit ?? 10);
+    return results;
+  }
+};
+
+// src/retrieval/retrieval-engine.ts
+var RetrievalEngine = class {
+  storage;
+  embeddings;
+  config;
+  strategies;
+  constructor(storage, embeddings, config = {}) {
+    this.storage = storage;
+    this.embeddings = embeddings;
+    this.config = {
+      defaultLimit: config.defaultLimit ?? 10,
+      defaultType: config.defaultType ?? "hybrid",
+      hybridWeights: config.hybridWeights ?? {
+        semantic: 0.5,
+        temporal: 0.3,
+        relational: 0.2
+      },
+      ...config
+    };
+    this.strategies = /* @__PURE__ */ new Map();
+    this.strategies.set("semantic", new SemanticStrategy());
+    this.strategies.set("temporal", new TemporalStrategy());
+    this.strategies.set("relational", new RelationalStrategy());
+    this.strategies.set("hybrid", new HybridStrategy(this.config.hybridWeights));
+  }
+  /**
+   * Retrieve relevant memories based on a query.
+   * @param query The search query
+   * @param options Retrieval options
+   * @returns Array of relevant memory events
+   */
+  async retrieve(query, options = {}) {
+    const type = options.retrievalType ?? this.config.defaultType ?? "hybrid";
+    const limit = options.limit ?? this.config.defaultLimit ?? 10;
+    const strategy = this.strategies.get(type);
+    if (!strategy) {
+      throw new Error(`Unknown retrieval type: ${type}`);
+    }
+    const context = {
+      storage: this.storage,
+      embeddings: this.embeddings
+    };
+    const mergedOptions = {
+      ...options,
+      limit
+    };
+    const results = await strategy.retrieve(query, context, mergedOptions);
+    if (this.config.reranker?.enabled) {
+      return this.rerank(query, results, this.config.reranker.topK ?? limit);
+    }
+    if (!options.includeEmbeddings) {
+      return results.map(({ score: _, embedding: __, ...event }) => event);
+    }
+    return results.map(({ score: _, ...event }) => event);
+  }
+  /**
+   * Get a specific retrieval strategy.
+   */
+  getStrategy(type) {
+    return this.strategies.get(type);
+  }
+  /**
+   * Register a custom retrieval strategy.
+   */
+  registerStrategy(type, strategy) {
+    this.strategies.set(type, strategy);
+  }
+  /**
+   * Rerank results (placeholder - can be extended with cross-encoder models).
+   */
+  async rerank(_query, results, topK) {
+    return results.sort((a, b) => b.score - a.score).slice(0, topK).map(({ score: _, ...event }) => event);
+  }
+};
+
+// src/utils/id-generator.ts
+import { ulid } from "ulid";
+function generateId() {
+  return ulid();
+}
+function getTimestampFromId(id) {
+  const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+  const TIME_LEN = 10;
+  let time = 0;
+  for (let i = 0; i < TIME_LEN; i++) {
+    const char = id.charAt(i).toUpperCase();
+    const index = ENCODING.indexOf(char);
+    if (index === -1) {
+      throw new Error(`Invalid ULID character: ${char}`);
+    }
+    time = time * 32 + index;
+  }
+  return time;
+}
+
+// src/aether.ts
+var Aether = class {
+  storage;
+  embeddings;
+  retrieval;
+  config;
+  listeners = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+    this.storage = config.storage.adapter;
+    this.embeddings = config.embeddings.provider;
+    this.retrieval = new RetrievalEngine(this.storage, this.embeddings, config.retrieval);
+  }
+  /**
+   * Initialize the memory system.
+   * Called automatically on first operation if not called explicitly.
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await this.storage.initialize();
+    this.initialized = true;
+  }
+  async add(contentOrEvent, context) {
+    await this.initialize();
+    const input = typeof contentOrEvent === "string" ? { content: contentOrEvent, context } : contentOrEvent;
+    const embedding = await this.embeddings.embed(input.content);
+    const event = {
+      id: generateId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: input.actor ?? "unknown",
+      action: input.action ?? this.inferAction(input.content),
+      content: input.content,
+      context: input.context ?? {},
+      embedding,
+      relations: input.relations
+    };
+    const stored = await this.storage.store(event);
+    this.notifyListeners(stored);
+    return stored;
+  }
+  /**
+   * Add multiple memory events in a batch.
+   * More efficient than calling add() multiple times.
+   */
+  async addBatch(events) {
+    await this.initialize();
+    const contents = events.map((e) => e.content);
+    const embeddings = await this.embeddings.embedBatch(contents);
+    const fullEvents = events.map((input, i) => ({
+      id: generateId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: input.actor ?? "unknown",
+      action: input.action ?? this.inferAction(input.content),
+      content: input.content,
+      context: input.context ?? {},
+      embedding: embeddings[i],
+      relations: input.relations
+    }));
+    const stored = await this.storage.storeBatch(fullEvents);
+    for (const event of stored) {
+      this.notifyListeners(event);
+    }
+    return stored;
+  }
+  /**
+   * Retrieve relevant memories based on a query.
+   * Uses multi-modal retrieval (semantic, temporal, relational).
+   *
+   * @example Basic retrieval
+   * ```typescript
+   * const memories = await aether.retrieve('What products did the user view?');
+   * ```
+   *
+   * @example With options
+   * ```typescript
+   * const memories = await aether.retrieve('recent actions', {
+   *   actor: 'user123',
+   *   retrievalType: 'temporal',
+   *   limit: 10
+   * });
+   * ```
+   */
+  async retrieve(query, options) {
+    await this.initialize();
+    return this.retrieval.retrieve(query, options);
+  }
+  /**
+   * Get the history of events for a specific actor.
+   * Events are returned in reverse chronological order (most recent first).
+   */
+  async getHistory(actor, limit) {
+    await this.initialize();
+    return this.storage.queryByActor(actor, {
+      limit: limit ?? 20,
+      order: "desc"
+    });
+  }
+  /**
+   * Get a specific event by ID.
+   */
+  async get(id) {
+    await this.initialize();
+    return this.storage.getById(id);
+  }
+  /**
+   * Delete a specific event by ID.
+   */
+  async delete(id) {
+    await this.initialize();
+    return this.storage.delete(id);
+  }
+  /**
+   * Advanced multi-modal search with fine-grained control.
+   */
+  async search(options) {
+    await this.initialize();
+    const retrievalOptions = {
+      limit: options.limit ?? 10,
+      retrievalType: "hybrid"
+    };
+    const query = options.semantic?.query ?? "";
+    if (options.temporal?.actor) {
+      retrievalOptions.actor = options.temporal.actor;
+    }
+    if (options.relational?.contextKeys && options.relational?.values) {
+      retrievalOptions.contextFilters = {};
+      for (let i = 0; i < options.relational.contextKeys.length; i++) {
+        const key = options.relational.contextKeys[i];
+        const value = options.relational.values[i];
+        if (key !== void 0) {
+          retrievalOptions.contextFilters[key] = value;
+        }
+      }
+    }
+    return this.retrieval.retrieve(query, retrievalOptions);
+  }
+  /**
+   * Get events related to a specific event.
+   * Follows the relations defined on the event.
+   */
+  async getRelated(eventId, depth = 1) {
+    await this.initialize();
+    const visited = /* @__PURE__ */ new Set();
+    const related = [];
+    const traverse = async (id, currentDepth) => {
+      if (currentDepth > depth || visited.has(id)) return;
+      visited.add(id);
+      const event = await this.storage.getById(id);
+      if (!event) return;
+      if (id !== eventId) {
+        related.push(event);
+      }
+      if (event.relations) {
+        for (const relation of event.relations) {
+          await traverse(relation.targetEventId, currentDepth + 1);
+        }
+      }
+    };
+    await traverse(eventId, 0);
+    return related;
+  }
+  /**
+   * Subscribe to new memory events.
+   * Returns an unsubscribe function.
+   */
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  /**
+   * Get statistics about the memory store.
+   */
+  async stats() {
+    await this.initialize();
+    const actors = await this.storage.getActors();
+    const count = await this.storage.count();
+    let oldestEvent;
+    let newestEvent;
+    if (count > 0 && actors.length > 0) {
+      const allEvents = await this.storage.queryByActor(actors[0], { limit: 1, order: "asc" });
+      if (allEvents.length > 0) {
+        oldestEvent = allEvents[0].timestamp;
+      }
+      const recentEvents = await this.storage.queryByActor(actors[0], { limit: 1, order: "desc" });
+      if (recentEvents.length > 0) {
+        newestEvent = recentEvents[0].timestamp;
+      }
+    }
+    return {
+      totalEvents: count,
+      uniqueActors: actors.length,
+      oldestEvent,
+      newestEvent,
+      storageAdapter: this.storage.name,
+      embeddingProvider: this.embeddings.name
+    };
+  }
+  /**
+   * Close the memory system and release resources.
+   */
+  async close() {
+    await this.storage.close();
+    this.listeners.clear();
+    this.initialized = false;
+  }
+  /**
+   * Clear all stored memories.
+   * Use with caution!
+   */
+  async clear() {
+    await this.initialize();
+    await this.storage.clear();
+  }
+  /**
+   * Infer an action type from content.
+   */
+  inferAction(content) {
+    const lowerContent = content.toLowerCase();
+    const actionPatterns = [
+      [/\b(clicked|click|pressed|tapped)\b/, "click"],
+      [/\b(viewed|view|looked|saw|opened)\b/, "view"],
+      [/\b(searched|search|queried|query)\b/, "search"],
+      [/\b(purchased|bought|ordered|paid)\b/, "purchase"],
+      [/\b(added|add)\b.*\b(cart|basket)\b/, "add_to_cart"],
+      [/\b(removed|remove)\b.*\b(cart|basket)\b/, "remove_from_cart"],
+      [/\b(selected|chose|picked)\b/, "select"],
+      [/\b(submitted|submit|sent|send)\b/, "submit"],
+      [/\b(logged|login|signed)\s*(in|on)\b/, "login"],
+      [/\b(logged|signed)\s*(out|off)\b/, "logout"],
+      [/\b(created|create|made|new)\b/, "create"],
+      [/\b(updated|update|changed|modified)\b/, "update"],
+      [/\b(deleted|delete|removed)\b/, "delete"],
+      [/\b(said|asked|responded|replied|wrote)\b/, "message"]
+    ];
+    for (const [pattern, action] of actionPatterns) {
+      if (pattern.test(lowerContent)) {
+        return action;
+      }
+    }
+    return "event";
+  }
+  /**
+   * Notify all listeners of a new event.
+   */
+  notifyListeners(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error("Error in event listener:", error);
+      }
+    }
+  }
+};
+
+// src/utils/math.ts
+function dotProduct(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+function magnitude(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    sum += v[i] * v[i];
+  }
+  return Math.sqrt(sum);
+}
+function normalize(v) {
+  const mag = magnitude(v);
+  if (mag === 0) {
+    return v.map(() => 0);
+  }
+  return v.map((x) => x / mag);
+}
+function cosineSimilarity(a, b) {
+  const dot = dotProduct(a, b);
+  const magA = magnitude(a);
+  const magB = magnitude(b);
+  if (magA === 0 || magB === 0) {
+    return 0;
+  }
+  return dot / (magA * magB);
+}
+function euclideanDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i] - b[i];
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+
+// src/storage/in-memory.adapter.ts
+var InMemoryStorageAdapter = class {
+  name = "in-memory";
+  /** Primary storage: id -> event */
+  events = /* @__PURE__ */ new Map();
+  /** Actor index: actor -> Set<event ids> */
+  actorIndex = /* @__PURE__ */ new Map();
+  /** Context index: context key -> value -> Set<event ids> */
+  contextIndex = /* @__PURE__ */ new Map();
+  /** Timestamp index: sorted list of [timestamp, id] for range queries */
+  timestampIndex = [];
+  async initialize() {
+  }
+  async store(event) {
+    this.events.set(event.id, event);
+    if (!this.actorIndex.has(event.actor)) {
+      this.actorIndex.set(event.actor, /* @__PURE__ */ new Set());
+    }
+    this.actorIndex.get(event.actor).add(event.id);
+    for (const [key, value] of Object.entries(event.context)) {
+      if (!this.contextIndex.has(key)) {
+        this.contextIndex.set(key, /* @__PURE__ */ new Map());
+      }
+      const valueMap = this.contextIndex.get(key);
+      if (!valueMap.has(value)) {
+        valueMap.set(value, /* @__PURE__ */ new Set());
+      }
+      valueMap.get(value).add(event.id);
+    }
+    const ts = new Date(event.timestamp).getTime();
+    const insertIdx = this.binarySearchInsert(ts);
+    this.timestampIndex.splice(insertIdx, 0, { timestamp: ts, id: event.id });
+    return event;
+  }
+  async storeBatch(events) {
+    const results = [];
+    for (const event of events) {
+      results.push(await this.store(event));
+    }
+    return results;
+  }
+  async getById(id) {
+    return this.events.get(id) ?? null;
+  }
+  async getByIds(ids) {
+    const results = [];
+    for (const id of ids) {
+      const event = this.events.get(id);
+      if (event) {
+        results.push(event);
+      }
+    }
+    return results;
+  }
+  async queryByActor(actor, options) {
+    const eventIds = this.actorIndex.get(actor);
+    if (!eventIds || eventIds.size === 0) {
+      return [];
+    }
+    let events = [];
+    for (const id of eventIds) {
+      const event = this.events.get(id);
+      if (event) {
+        events.push(event);
+      }
+    }
+    const order = options?.order ?? "desc";
+    events.sort((a, b) => {
+      const timeA = new Date(a.timestamp).getTime();
+      const timeB = new Date(b.timestamp).getTime();
+      return order === "asc" ? timeA - timeB : timeB - timeA;
+    });
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? events.length;
+    return events.slice(offset, offset + limit);
+  }
+  async queryByContext(filters, options) {
+    const filterEntries = Object.entries(filters);
+    if (filterEntries.length === 0) {
+      return [];
+    }
+    let matchingIds = null;
+    for (const [key, value] of filterEntries) {
+      const keyIndex = this.contextIndex.get(key);
+      if (!keyIndex) {
+        return [];
+      }
+      const valueIds = keyIndex.get(value);
+      if (!valueIds) {
+        return [];
+      }
+      if (matchingIds === null) {
+        matchingIds = new Set(valueIds);
+      } else {
+        const newSet = /* @__PURE__ */ new Set();
+        for (const id of matchingIds) {
+          if (valueIds.has(id)) {
+            newSet.add(id);
+          }
+        }
+        matchingIds = newSet;
+      }
+      if (matchingIds.size === 0) {
+        return [];
+      }
+    }
+    if (!matchingIds) {
+      return [];
+    }
+    const events = [];
+    for (const id of matchingIds) {
+      const event = this.events.get(id);
+      if (event) {
+        events.push(event);
+      }
+    }
+    events.sort((a, b) => {
+      return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+    });
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? events.length;
+    return events.slice(offset, offset + limit);
+  }
+  async queryByTimeRange(range, options) {
+    const startTs = new Date(range.start).getTime();
+    const endTs = new Date(range.end).getTime();
+    let left = 0;
+    let right = this.timestampIndex.length;
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2);
+      if (this.timestampIndex[mid].timestamp < startTs) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    const events = [];
+    for (let i = left; i < this.timestampIndex.length; i++) {
+      const entry = this.timestampIndex[i];
+      if (entry.timestamp > endTs) {
+        break;
+      }
+      const event = this.events.get(entry.id);
+      if (event) {
+        events.push(event);
+      }
+    }
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? events.length;
+    return events.slice(offset, offset + limit);
+  }
+  async searchByVector(vector, options) {
+    const results = [];
+    const threshold = options?.threshold ?? 0;
+    for (const event of this.events.values()) {
+      if (!event.embedding) {
+        continue;
+      }
+      if (options?.filters) {
+        let matches = true;
+        for (const [key, value] of Object.entries(options.filters)) {
+          if (event.context[key] !== value) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) {
+          continue;
+        }
+      }
+      const score = cosineSimilarity(vector, event.embedding);
+      if (score >= threshold) {
+        results.push({ ...event, score });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    const limit = options?.limit ?? results.length;
+    return results.slice(0, limit);
+  }
+  async delete(id) {
+    const event = this.events.get(id);
+    if (!event) {
+      return false;
+    }
+    this.events.delete(id);
+    const actorIds = this.actorIndex.get(event.actor);
+    if (actorIds) {
+      actorIds.delete(id);
+      if (actorIds.size === 0) {
+        this.actorIndex.delete(event.actor);
+      }
+    }
+    for (const [key, value] of Object.entries(event.context)) {
+      const keyIndex = this.contextIndex.get(key);
+      if (keyIndex) {
+        const valueIds = keyIndex.get(value);
+        if (valueIds) {
+          valueIds.delete(id);
+          if (valueIds.size === 0) {
+            keyIndex.delete(value);
+          }
+        }
+        if (keyIndex.size === 0) {
+          this.contextIndex.delete(key);
+        }
+      }
+    }
+    const ts = new Date(event.timestamp).getTime();
+    const idx = this.timestampIndex.findIndex((e) => e.id === id && e.timestamp === ts);
+    if (idx !== -1) {
+      this.timestampIndex.splice(idx, 1);
+    }
+    return true;
+  }
+  async deleteBatch(ids) {
+    let count = 0;
+    for (const id of ids) {
+      if (await this.delete(id)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async clear() {
+    this.events.clear();
+    this.actorIndex.clear();
+    this.contextIndex.clear();
+    this.timestampIndex = [];
+  }
+  async count(filters) {
+    if (!filters || Object.keys(filters).length === 0) {
+      return this.events.size;
+    }
+    const events = await this.queryByContext(filters);
+    return events.length;
+  }
+  async getActors() {
+    return Array.from(this.actorIndex.keys());
+  }
+  async close() {
+    await this.clear();
+  }
+  /**
+   * Binary search to find insertion point for a timestamp.
+   */
+  binarySearchInsert(timestamp) {
+    let left = 0;
+    let right = this.timestampIndex.length;
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2);
+      if (this.timestampIndex[mid].timestamp < timestamp) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    return left;
+  }
+};
+
+// src/embeddings/mock.provider.ts
+var MockEmbeddingProvider = class {
+  name = "mock";
+  dimensions;
+  constructor(dimensions = 384) {
+    this.dimensions = dimensions;
+  }
+  async embed(text) {
+    return this.hashToVector(text);
+  }
+  async embedBatch(texts) {
+    return texts.map((t) => this.hashToVector(t));
+  }
+  similarity(a, b) {
+    return cosineSimilarity(a, b);
+  }
+  /**
+   * Generate a deterministic vector from text hash.
+   * Same text always produces the same vector.
+   */
+  hashToVector(text) {
+    const hash = this.simpleHash(text);
+    const vector = [];
+    let seed = hash;
+    for (let i = 0; i < this.dimensions; i++) {
+      seed = seed * 1103515245 + 12345 & 2147483647;
+      vector.push(seed / 2147483647 * 2 - 1);
+    }
+    return normalize(vector);
+  }
+  /**
+   * Simple string hash function.
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+};
+
+// src/embeddings/voyage.provider.ts
+var MODEL_DIMENSIONS = {
+  "voyage-3": 1024,
+  "voyage-3-lite": 512,
+  "voyage-code-3": 1024,
+  "voyage-finance-2": 1024,
+  "voyage-law-2": 1024,
+  "voyage-code-2": 1536,
+  "voyage-2": 1024,
+  "voyage-large-2": 1536,
+  "voyage-large-2-instruct": 1024
+};
+var VoyageProvider = class {
+  name = "voyage";
+  dimensions;
+  apiKey;
+  model;
+  baseUrl;
+  batchSize;
+  timeout;
+  maxRetries;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("VoyageAI API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? "voyage-2";
+    this.baseUrl = config.baseUrl ?? "https://api.voyageai.com/v1";
+    this.batchSize = config.batchSize ?? 128;
+    this.timeout = config.timeout ?? 3e4;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.dimensions = MODEL_DIMENSIONS[this.model] ?? 1024;
+  }
+  async embed(text) {
+    const results = await this.embedBatch([text]);
+    return results[0];
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) {
+      return [];
+    }
+    const results = [];
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      const batch = texts.slice(i, i + this.batchSize);
+      const batchResults = await this.embedWithRetry(batch);
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  similarity(a, b) {
+    return cosineSimilarity(a, b);
+  }
+  /**
+   * Embed a batch of texts with retry logic.
+   */
+  async embedWithRetry(texts) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        return await this.callApi(texts);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof Error && error.message.includes("4")) {
+          throw error;
+        }
+        const delay = Math.pow(2, attempt) * 1e3;
+        await this.sleep(delay);
+      }
+    }
+    throw lastError ?? new Error("Failed to embed texts");
+  }
+  /**
+   * Call the VoyageAI API.
+   */
+  async callApi(texts) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          input: texts,
+          model: this.model
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`VoyageAI API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      const sorted = data.data.sort((a, b) => a.index - b.index);
+      return sorted.map((item) => item.embedding);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+export {
+  Aether,
+  CompositeEntityExtractor,
+  DEFAULT_ENTITY_PATTERNS,
+  HybridStrategy,
+  InMemoryStorageAdapter,
+  MockEmbeddingProvider,
+  PatternEntityExtractor,
+  RelationalStrategy,
+  RetrievalEngine,
+  SemanticStrategy,
+  TemporalStrategy,
+  VoyageProvider,
+  cosineSimilarity,
+  euclideanDistance,
+  generateId,
+  getTimestampFromId,
+  normalize
+};
+//# sourceMappingURL=index.js.map