@jackchen_me/open-multi-agent 0.2.0 → 1.0.1

package/src/memory/store.ts

@@ -1,124 +0,0 @@
-/**
- * @fileoverview In-memory implementation of {@link MemoryStore}.
- *
- * All data lives in a plain `Map` and is never persisted to disk. This is the
- * default store used by {@link SharedMemory} and is suitable for testing and
- * single-process use-cases. Swap it for a Redis or SQLite-backed implementation
- * in production by satisfying the same {@link MemoryStore} interface.
- */
-
-import type { MemoryEntry, MemoryStore } from '../types.js'
-
-// ---------------------------------------------------------------------------
-// InMemoryStore
-// ---------------------------------------------------------------------------
-
-/**
- * Synchronous-under-the-hood key/value store that exposes an `async` surface
- * so implementations can be swapped for async-native backends without changing
- * callers.
- *
- * All keys are treated as opaque strings. Values are always strings; structured
- * data must be serialised by the caller (e.g. `JSON.stringify`).
- *
- * @example
- * ```ts
- * const store = new InMemoryStore()
- * await store.set('config', JSON.stringify({ model: 'claude-opus-4-6' }))
- * const entry = await store.get('config')
- * ```
- */
-export class InMemoryStore implements MemoryStore {
-  private readonly data = new Map<string, MemoryEntry>()
-
-  // ---------------------------------------------------------------------------
-  // MemoryStore interface
-  // ---------------------------------------------------------------------------
-
-  /** Returns the entry for `key`, or `null` if not present. */
-  async get(key: string): Promise<MemoryEntry | null> {
-    return this.data.get(key) ?? null
-  }
-
-  /**
-   * Upserts `key` with `value` and optional `metadata`.
-   *
-   * If the key already exists its `createdAt` is **preserved** so callers can
-   * detect when a value was first written.
-   */
-  async set(
-    key: string,
-    value: string,
-    metadata?: Record<string, unknown>,
-  ): Promise<void> {
-    const existing = this.data.get(key)
-    const entry: MemoryEntry = {
-      key,
-      value,
-      metadata: metadata !== undefined ? { ...metadata } : undefined,
-      createdAt: existing?.createdAt ?? new Date(),
-    }
-    this.data.set(key, entry)
-  }
-
-  /** Returns a snapshot of all entries in insertion order. */
-  async list(): Promise<MemoryEntry[]> {
-    return Array.from(this.data.values())
-  }
-
-  /**
-   * Removes the entry for `key`.
-   * Deleting a non-existent key is a no-op.
-   */
-  async delete(key: string): Promise<void> {
-    this.data.delete(key)
-  }
-
-  /** Removes **all** entries from the store. */
-  async clear(): Promise<void> {
-    this.data.clear()
-  }
-
-  // ---------------------------------------------------------------------------
-  // Extensions beyond the base MemoryStore interface
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Returns entries whose `key` starts with `query` **or** whose `value`
-   * contains `query` (case-insensitive substring match).
-   *
-   * This is a simple linear scan; it is not suitable for very large stores
-   * without an index layer on top.
-   *
-   * @example
-   * ```ts
-   * // Find all entries related to "research"
-   * const hits = await store.search('research')
-   * ```
-   */
-  async search(query: string): Promise<MemoryEntry[]> {
-    if (query.length === 0) {
-      return this.list()
-    }
-    const lower = query.toLowerCase()
-    return Array.from(this.data.values()).filter(
-      (entry) =>
-        entry.key.toLowerCase().includes(lower) ||
-        entry.value.toLowerCase().includes(lower),
-    )
-  }
-
-  // ---------------------------------------------------------------------------
-  // Convenience helpers (not part of MemoryStore)
-  // ---------------------------------------------------------------------------
-
-  /** Returns the number of entries currently held in the store. */
-  get size(): number {
-    return this.data.size
-  }
-
-  /** Returns `true` if `key` exists in the store. */
-  has(key: string): boolean {
-    return this.data.has(key)
-  }
-}