ai-database 2.0.1 → 2.1.1

package/src/memory-provider.ts

@@ -1,1119 +0,0 @@
-/**
- * In-memory Database Provider
- *
- * Simple provider implementation for testing and development.
- * Includes concurrency control via Semaphore for rate limiting.
- */
-
-import type { DBProvider, ListOptions, SearchOptions } from './schema.js'
-
-// =============================================================================
-// Semaphore for Concurrency Control
-// =============================================================================
-
-/**
- * Simple semaphore for concurrency control
- * Used to limit parallel operations (e.g., embedding, generation)
- */
-export class Semaphore {
-  private queue: Array<() => void> = []
-  private running = 0
-
-  constructor(private concurrency: number) {}
-
-  /**
-   * Acquire a slot. Returns a release function.
-   */
-  async acquire(): Promise<() => void> {
-    if (this.running < this.concurrency) {
-      this.running++
-      return () => this.release()
-    }
-
-    return new Promise((resolve) => {
-      this.queue.push(() => {
-        this.running++
-        resolve(() => this.release())
-      })
-    })
-  }
-
-  private release(): void {
-    this.running--
-    const next = this.queue.shift()
-    if (next) next()
-  }
-
-  /**
-   * Run a function with concurrency control
-   */
-  async run<T>(fn: () => Promise<T>): Promise<T> {
-    const release = await this.acquire()
-    try {
-      return await fn()
-    } finally {
-      release()
-    }
-  }
-
-  /**
-   * Run multiple functions with concurrency control
-   */
-  async map<T, R>(items: T[], fn: (item: T) => Promise<R>): Promise<R[]> {
-    return Promise.all(items.map((item) => this.run(() => fn(item))))
-  }
-
-  get pending(): number {
-    return this.queue.length
-  }
-
-  get active(): number {
-    return this.running
-  }
-}
-
-// =============================================================================
-// Types (Actor-Event-Object-Result pattern)
-// =============================================================================
-
-/**
- * Actor metadata for events and actions
- */
-export interface ActorData {
-  name?: string
-  email?: string
-  org?: string
-  role?: string
-  [key: string]: unknown
-}
-
-/**
- * Event with Actor-Event-Object-Result pattern
- *
- * Following ActivityStreams semantics:
- * - Actor: Who did it (user, system, agent)
- * - Event: What happened (created, updated, published)
- * - Object: What it was done to
- * - Result: What was the outcome
- */
-export interface Event {
-  id: string
-  /** Actor identifier (user:id, system, agent:name) */
-  actor: string
-  /** Actor metadata */
-  actorData?: ActorData
-  /** Event type (Entity.action format) */
-  event: string
-  /** Object URL/identifier */
-  object?: string
-  /** Object data snapshot */
-  objectData?: Record<string, unknown>
-  /** Result URL/identifier */
-  result?: string
-  /** Result data */
-  resultData?: Record<string, unknown>
-  /** Additional metadata */
-  meta?: Record<string, unknown>
-  /** When the event occurred */
-  timestamp: Date
-
-  // Legacy compatibility
-  /** @deprecated Use 'event' instead */
-  type?: string
-  /** @deprecated Use 'object' instead */
-  url?: string
-  /** @deprecated Use 'objectData' instead */
-  data?: unknown
-}
-
-/**
- * Action with linguistic verb conjugations
- *
- * Uses act/action/activity pattern for semantic clarity:
- * - act: Present tense 3rd person (creates, publishes)
- * - action: Base verb form (create, publish)
- * - activity: Gerund/progressive (creating, publishing)
- */
-export interface Action {
-  id: string
-  /** Actor identifier */
-  actor: string
-  /** Actor metadata */
-  actorData?: ActorData
-  /** Present tense verb (creates, publishes) */
-  act: string
-  /** Base verb form (create, publish) */
-  action: string
-  /** Gerund form (creating, publishing) */
-  activity: string
-  /** Object being acted upon */
-  object?: string
-  /** Object data/parameters */
-  objectData?: Record<string, unknown>
-  /** Action status */
-  status: 'pending' | 'active' | 'completed' | 'failed' | 'cancelled'
-  /** Progress count */
-  progress?: number
-  /** Total items */
-  total?: number
-  /** Result data */
-  result?: Record<string, unknown>
-  /** Error message */
-  error?: string
-  /** Additional metadata */
-  meta?: Record<string, unknown>
-  /** Created timestamp */
-  createdAt: Date
-  /** Started timestamp */
-  startedAt?: Date
-  /** Completed timestamp */
-  completedAt?: Date
-
-  // Legacy compatibility
-  /** @deprecated Use 'action' instead */
-  type?: string
-  /** @deprecated Use 'objectData' instead */
-  data?: unknown
-}
-
-export interface Artifact {
-  url: string
-  type: string
-  sourceHash: string
-  content: unknown
-  metadata?: Record<string, unknown>
-  createdAt: Date
-}
-
-export interface MemoryProviderOptions {
-  /** Concurrency limit for operations (default: 10) */
-  concurrency?: number
-}
-
-// =============================================================================
-// Generate ID
-// =============================================================================
-
-function generateId(): string {
-  return crypto.randomUUID()
-}
-
-// =============================================================================
-// Verb Conjugation (Linguistic Helpers)
-// =============================================================================
-
-/**
- * Conjugate a verb to get all forms
- *
- * @example
- * ```ts
- * conjugateVerb('create')
- * // => { action: 'create', act: 'creates', activity: 'creating' }
- *
- * conjugateVerb('publish')
- * // => { action: 'publish', act: 'publishes', activity: 'publishing' }
- * ```
- */
-function conjugateVerb(verb: string): { action: string; act: string; activity: string } {
-  const base = verb.toLowerCase()
-
-  // Known verbs with pre-defined conjugations
-  const known: Record<string, { act: string; activity: string }> = {
-    create: { act: 'creates', activity: 'creating' },
-    update: { act: 'updates', activity: 'updating' },
-    delete: { act: 'deletes', activity: 'deleting' },
-    publish: { act: 'publishes', activity: 'publishing' },
-    archive: { act: 'archives', activity: 'archiving' },
-    generate: { act: 'generates', activity: 'generating' },
-    process: { act: 'processes', activity: 'processing' },
-    sync: { act: 'syncs', activity: 'syncing' },
-    import: { act: 'imports', activity: 'importing' },
-    export: { act: 'exports', activity: 'exporting' },
-    run: { act: 'runs', activity: 'running' },
-    execute: { act: 'executes', activity: 'executing' },
-    send: { act: 'sends', activity: 'sending' },
-    fetch: { act: 'fetches', activity: 'fetching' },
-    build: { act: 'builds', activity: 'building' },
-    deploy: { act: 'deploys', activity: 'deploying' },
-  }
-
-  if (known[base]) {
-    return { action: base, ...known[base] }
-  }
-
-  // Auto-conjugate unknown verbs
-  return {
-    action: base,
-    act: toPresent(base),
-    activity: toGerund(base),
-  }
-}
-
-/** Check if character is a vowel */
-function isVowel(char: string | undefined): boolean {
-  return char ? 'aeiou'.includes(char.toLowerCase()) : false
-}
-
-/** Check if we should double the final consonant */
-function shouldDoubleConsonant(verb: string): boolean {
-  if (verb.length < 2) return false
-  const last = verb[verb.length - 1]!
-  const secondLast = verb[verb.length - 2]!
-  if ('wxy'.includes(last)) return false
-  if (isVowel(last) || !isVowel(secondLast)) return false
-  // Short words (3 letters) almost always double
-  if (verb.length <= 3) return true
-  return false
-}
-
-/** Convert verb to present 3rd person (create → creates) */
-function toPresent(verb: string): string {
-  if (verb.endsWith('y') && !isVowel(verb[verb.length - 2])) {
-    return verb.slice(0, -1) + 'ies'
-  }
-  if (verb.endsWith('s') || verb.endsWith('x') || verb.endsWith('z') ||
-      verb.endsWith('ch') || verb.endsWith('sh')) {
-    return verb + 'es'
-  }
-  return verb + 's'
-}
-
-/** Convert verb to gerund (create → creating) */
-function toGerund(verb: string): string {
-  if (verb.endsWith('ie')) return verb.slice(0, -2) + 'ying'
-  if (verb.endsWith('e') && !verb.endsWith('ee')) return verb.slice(0, -1) + 'ing'
-  if (shouldDoubleConsonant(verb)) {
-    return verb + verb[verb.length - 1] + 'ing'
-  }
-  return verb + 'ing'
-}
-
-// =============================================================================
-// In-memory Provider
-// =============================================================================
-
-/**
- * In-memory storage for entities, relationships, events, actions, and artifacts
- */
-export class MemoryProvider implements DBProvider {
-  // Things: type -> id -> entity
-  private entities = new Map<string, Map<string, Record<string, unknown>>>()
-
-  // Relationships: from:relation -> Set<to>
-  private relations = new Map<string, Set<string>>()
-
-  // Events: chronological log
-  private events: Event[] = []
-  private eventHandlers = new Map<string, Array<(event: Event) => void | Promise<void>>>()
-
-  // Actions: id -> action
-  private actions = new Map<string, Action>()
-
-  // Artifacts: url:type -> artifact
-  private artifacts = new Map<string, Artifact>()
-
-  // Concurrency control
-  private semaphore: Semaphore
-
-  constructor(options: MemoryProviderOptions = {}) {
-    this.semaphore = new Semaphore(options.concurrency ?? 10)
-  }
-
-  // ===========================================================================
-  // Things (Records)
-  // ===========================================================================
-
-  private getTypeStore(type: string): Map<string, Record<string, unknown>> {
-    if (!this.entities.has(type)) {
-      this.entities.set(type, new Map())
-    }
-    return this.entities.get(type)!
-  }
-
-  async get(
-    type: string,
-    id: string
-  ): Promise<Record<string, unknown> | null> {
-    const store = this.getTypeStore(type)
-    const entity = store.get(id)
-    return entity ? { ...entity, $id: id, $type: type } : null
-  }
-
-  async list(
-    type: string,
-    options?: ListOptions
-  ): Promise<Record<string, unknown>[]> {
-    const store = this.getTypeStore(type)
-    let results: Record<string, unknown>[] = []
-
-    for (const [id, entity] of store) {
-      const full: Record<string, unknown> = { ...entity, $id: id, $type: type }
-
-      // Apply where filter
-      if (options?.where) {
-        let matches = true
-        for (const [key, value] of Object.entries(options.where)) {
-          if ((full as Record<string, unknown>)[key] !== value) {
-            matches = false
-            break
-          }
-        }
-        if (!matches) continue
-      }
-
-      results.push(full)
-    }
-
-    // Sort
-    if (options?.orderBy) {
-      const field = options.orderBy
-      const dir = options.order === 'desc' ? -1 : 1
-      results.sort((a, b) => {
-        const aVal = a[field]
-        const bVal = b[field]
-        if (aVal === undefined && bVal === undefined) return 0
-        if (aVal === undefined) return dir
-        if (bVal === undefined) return -dir
-        if ((aVal as string | number) < (bVal as string | number)) return -dir
-        if ((aVal as string | number) > (bVal as string | number)) return dir
-        return 0
-      })
-    }
-
-    // Paginate
-    if (options?.offset) {
-      results = results.slice(options.offset)
-    }
-    if (options?.limit) {
-      results = results.slice(0, options.limit)
-    }
-
-    return results
-  }
-
-  async search(
-    type: string,
-    query: string,
-    options?: SearchOptions
-  ): Promise<Record<string, unknown>[]> {
-    const all = await this.list(type, options)
-    const queryLower = query.toLowerCase()
-    const fields = options?.fields || ['$all']
-
-    const scored: Array<{ entity: Record<string, unknown>; score: number }> = []
-
-    for (const entity of all) {
-      let searchText: string
-      if (fields.includes('$all')) {
-        searchText = JSON.stringify(entity).toLowerCase()
-      } else {
-        searchText = fields
-          .map((f) => String(entity[f] || ''))
-          .join(' ')
-          .toLowerCase()
-      }
-
-      if (searchText.includes(queryLower)) {
-        const index = searchText.indexOf(queryLower)
-        const score = 1 - index / searchText.length
-        if (!options?.minScore || score >= options.minScore) {
-          scored.push({ entity, score })
-        }
-      }
-    }
-
-    scored.sort((a, b) => b.score - a.score)
-    return scored.map((s) => s.entity)
-  }
-
-  async create(
-    type: string,
-    id: string | undefined,
-    data: Record<string, unknown>
-  ): Promise<Record<string, unknown>> {
-    const store = this.getTypeStore(type)
-    const entityId = id || generateId()
-
-    if (store.has(entityId)) {
-      throw new Error(`Entity already exists: ${type}/${entityId}`)
-    }
-
-    const entity = {
-      ...data,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    }
-
-    store.set(entityId, entity)
-
-    // Emit event
-    await this.emit(`${type}.created`, { $id: entityId, $type: type, ...entity })
-
-    return { ...entity, $id: entityId, $type: type }
-  }
-
-  async update(
-    type: string,
-    id: string,
-    data: Record<string, unknown>
-  ): Promise<Record<string, unknown>> {
-    const store = this.getTypeStore(type)
-    const existing = store.get(id)
-
-    if (!existing) {
-      throw new Error(`Entity not found: ${type}/${id}`)
-    }
-
-    const updated = {
-      ...existing,
-      ...data,
-      updatedAt: new Date().toISOString(),
-    }
-
-    store.set(id, updated)
-
-    // Emit event
-    await this.emit(`${type}.updated`, { $id: id, $type: type, ...updated })
-
-    // Invalidate artifacts when data changes
-    await this.invalidateArtifacts(`${type}/${id}`)
-
-    return { ...updated, $id: id, $type: type }
-  }
-
-  async delete(type: string, id: string): Promise<boolean> {
-    const store = this.getTypeStore(type)
-
-    if (!store.has(id)) {
-      return false
-    }
-
-    store.delete(id)
-
-    // Emit event
-    await this.emit(`${type}.deleted`, { $id: id, $type: type })
-
-    // Clean up relations
-    for (const [key, targets] of this.relations) {
-      if (key.startsWith(`${type}:${id}:`)) {
-        this.relations.delete(key)
-      }
-      targets.delete(`${type}:${id}`)
-    }
-
-    // Clean up artifacts
-    await this.deleteArtifact(`${type}/${id}`)
-
-    return true
-  }
-
-  // ===========================================================================
-  // Relationships
-  // ===========================================================================
-
-  private relationKey(
-    fromType: string,
-    fromId: string,
-    relation: string
-  ): string {
-    return `${fromType}:${fromId}:${relation}`
-  }
-
-  async related(
-    type: string,
-    id: string,
-    relation: string
-  ): Promise<Record<string, unknown>[]> {
-    const key = this.relationKey(type, id, relation)
-    const targets = this.relations.get(key)
-
-    if (!targets) return []
-
-    const results: Record<string, unknown>[] = []
-    for (const target of targets) {
-      const [targetType, targetId] = target.split(':')
-      const entity = await this.get(targetType!, targetId!)
-      if (entity) {
-        results.push(entity)
-      }
-    }
-
-    return results
-  }
-
-  async relate(
-    fromType: string,
-    fromId: string,
-    relation: string,
-    toType: string,
-    toId: string
-  ): Promise<void> {
-    const key = this.relationKey(fromType, fromId, relation)
-
-    if (!this.relations.has(key)) {
-      this.relations.set(key, new Set())
-    }
-
-    this.relations.get(key)!.add(`${toType}:${toId}`)
-
-    // Emit event
-    await this.emit('Relation.created', {
-      from: `${fromType}/${fromId}`,
-      type: relation,
-      to: `${toType}/${toId}`,
-    })
-  }
-
-  async unrelate(
-    fromType: string,
-    fromId: string,
-    relation: string,
-    toType: string,
-    toId: string
-  ): Promise<void> {
-    const key = this.relationKey(fromType, fromId, relation)
-    const targets = this.relations.get(key)
-
-    if (targets) {
-      targets.delete(`${toType}:${toId}`)
-
-      // Emit event
-      await this.emit('Relation.deleted', {
-        from: `${fromType}/${fromId}`,
-        type: relation,
-        to: `${toType}/${toId}`,
-      })
-    }
-  }
-
-  // ===========================================================================
-  // Events (Actor-Event-Object-Result pattern)
-  // ===========================================================================
-
-  /**
-   * Emit an event using Actor-Event-Object-Result pattern
-   *
-   * @example
-   * ```ts
-   * // New pattern
-   * await provider.emit({
-   *   actor: 'user:john',
-   *   event: 'Post.created',
-   *   object: 'Post/hello-world',
-   *   objectData: { title: 'Hello World' },
-   * })
-   *
-   * // Legacy pattern (still supported)
-   * await provider.emit('Post.created', { title: 'Hello World' })
-   * ```
-   */
-  async emit(
-    eventOrType: string | {
-      actor?: string
-      actorData?: ActorData
-      event: string
-      object?: string
-      objectData?: Record<string, unknown>
-      result?: string
-      resultData?: Record<string, unknown>
-      meta?: Record<string, unknown>
-    },
-    data?: unknown
-  ): Promise<Event> {
-    let event: Event
-
-    if (typeof eventOrType === 'string') {
-      // Legacy pattern: emit('Post.created', { ... })
-      event = {
-        id: generateId(),
-        actor: 'system',
-        event: eventOrType,
-        objectData: data as Record<string, unknown> | undefined,
-        timestamp: new Date(),
-        // Legacy fields
-        type: eventOrType,
-        data,
-      }
-    } else {
-      // New pattern: emit({ actor, event, object, ... })
-      event = {
-        id: generateId(),
-        actor: eventOrType.actor ?? 'system',
-        actorData: eventOrType.actorData,
-        event: eventOrType.event,
-        object: eventOrType.object,
-        objectData: eventOrType.objectData,
-        result: eventOrType.result,
-        resultData: eventOrType.resultData,
-        meta: eventOrType.meta,
-        timestamp: new Date(),
-        // Legacy fields
-        type: eventOrType.event,
-      }
-    }
-
-    this.events.push(event)
-
-    // Trigger handlers (with concurrency control)
-    const handlers = this.getEventHandlers(event.event)
-    await this.semaphore.map(handlers, (handler) =>
-      Promise.resolve(handler(event))
-    )
-
-    return event
-  }
-
-  private getEventHandlers(type: string): Array<(event: Event) => void | Promise<void>> {
-    const handlers: Array<(event: Event) => void | Promise<void>> = []
-
-    for (const [pattern, patternHandlers] of this.eventHandlers) {
-      if (this.matchesPattern(type, pattern)) {
-        handlers.push(...patternHandlers)
-      }
-    }
-
-    return handlers
-  }
-
-  private matchesPattern(type: string, pattern: string): boolean {
-    if (pattern === type) return true
-    if (pattern === '*') return true
-    if (pattern.endsWith('.*')) {
-      const prefix = pattern.slice(0, -2)
-      return type.startsWith(prefix + '.')
-    }
-    if (pattern.startsWith('*.')) {
-      const suffix = pattern.slice(2)
-      return type.endsWith('.' + suffix)
-    }
-    return false
-  }
-
-  on(pattern: string, handler: (event: Event) => void | Promise<void>): () => void {
-    if (!this.eventHandlers.has(pattern)) {
-      this.eventHandlers.set(pattern, [])
-    }
-    this.eventHandlers.get(pattern)!.push(handler)
-
-    // Return unsubscribe function
-    return () => {
-      const handlers = this.eventHandlers.get(pattern)
-      if (handlers) {
-        const index = handlers.indexOf(handler)
-        if (index !== -1) handlers.splice(index, 1)
-      }
-    }
-  }
-
-  async listEvents(options?: {
-    event?: string
-    actor?: string
-    object?: string
-    since?: Date
-    until?: Date
-    limit?: number
-    /** @deprecated Use 'event' instead */
-    type?: string
-  }): Promise<Event[]> {
-    let results = [...this.events]
-
-    // Filter by event pattern
-    const eventPattern = options?.event ?? options?.type
-    if (eventPattern) {
-      results = results.filter((e) => this.matchesPattern(e.event, eventPattern))
-    }
-    if (options?.actor) {
-      results = results.filter((e) => e.actor === options.actor)
-    }
-    if (options?.object) {
-      results = results.filter((e) => e.object === options.object)
-    }
-    if (options?.since) {
-      results = results.filter((e) => e.timestamp >= options.since!)
-    }
-    if (options?.until) {
-      results = results.filter((e) => e.timestamp <= options.until!)
-    }
-    if (options?.limit) {
-      results = results.slice(-options.limit)
-    }
-
-    return results
-  }
-
-  async replayEvents(options: {
-    event?: string
-    actor?: string
-    since?: Date
-    handler: (event: Event) => void | Promise<void>
-    /** @deprecated Use 'event' instead */
-    type?: string
-  }): Promise<void> {
-    const events = await this.listEvents({
-      event: options.event ?? options.type,
-      actor: options.actor,
-      since: options.since,
-    })
-
-    for (const event of events) {
-      await this.semaphore.run(() => Promise.resolve(options.handler(event)))
-    }
-  }
-
-  // ===========================================================================
-  // Actions (Linguistic Verb Pattern)
-  // ===========================================================================
-
-  /**
-   * Create an action with automatic verb conjugation
-   *
-   * @example
-   * ```ts
-   * // New pattern with verb conjugation
-   * const action = await provider.createAction({
-   *   actor: 'system',
-   *   action: 'generate',  // auto-conjugates to act='generates', activity='generating'
-   *   object: 'Post',
-   *   objectData: { count: 100 },
-   *   total: 100,
-   * })
-   *
-   * // Legacy pattern (still supported)
-   * const action = await provider.createAction({
-   *   type: 'generate',
-   *   data: { count: 100 },
-   *   total: 100,
-   * })
-   * ```
-   */
-  async createAction(data: {
-    actor?: string
-    actorData?: ActorData
-    action?: string
-    object?: string
-    objectData?: Record<string, unknown>
-    total?: number
-    meta?: Record<string, unknown>
-    // Legacy
-    type?: string
-    data?: unknown
-  }): Promise<Action> {
-    // Get base verb from action or legacy type
-    const baseVerb = data.action ?? data.type ?? 'process'
-
-    // Auto-conjugate verb forms
-    const conjugated = conjugateVerb(baseVerb)
-
-    const action: Action = {
-      id: generateId(),
-      actor: data.actor ?? 'system',
-      actorData: data.actorData,
-      act: conjugated.act,
-      action: conjugated.action,
-      activity: conjugated.activity,
-      object: data.object,
-      objectData: data.objectData ?? (data.data as Record<string, unknown> | undefined),
-      status: 'pending',
-      progress: 0,
-      total: data.total,
-      meta: data.meta,
-      createdAt: new Date(),
-      // Legacy fields
-      type: baseVerb,
-      data: data.data,
-    }
-
-    this.actions.set(action.id, action)
-
-    await this.emit({
-      actor: action.actor,
-      actorData: action.actorData,
-      event: 'Action.created',
-      object: action.id,
-      objectData: { action: action.action, object: action.object },
-    })
-
-    return action
-  }
-
-  async getAction(id: string): Promise<Action | null> {
-    return this.actions.get(id) ?? null
-  }
-
-  async updateAction(
-    id: string,
-    updates: Partial<Pick<Action, 'status' | 'progress' | 'result' | 'error'>>
-  ): Promise<Action> {
-    const action = this.actions.get(id)
-    if (!action) {
-      throw new Error(`Action not found: ${id}`)
-    }
-
-    Object.assign(action, updates)
-
-    if (updates.status === 'active' && !action.startedAt) {
-      action.startedAt = new Date()
-      await this.emit({
-        actor: action.actor,
-        event: 'Action.started',
-        object: action.id,
-        objectData: { action: action.action, activity: action.activity },
-      })
-    }
-
-    if (updates.status === 'completed') {
-      action.completedAt = new Date()
-      await this.emit({
-        actor: action.actor,
-        event: 'Action.completed',
-        object: action.id,
-        objectData: { action: action.action },
-        result: action.object,
-        resultData: action.result,
-      })
-    }
-
-    if (updates.status === 'failed') {
-      action.completedAt = new Date()
-      await this.emit({
-        actor: action.actor,
-        event: 'Action.failed',
-        object: action.id,
-        objectData: { action: action.action, error: action.error },
-      })
-    }
-
-    if (updates.status === 'cancelled') {
-      action.completedAt = new Date()
-      await this.emit({
-        actor: action.actor,
-        event: 'Action.cancelled',
-        object: action.id,
-        objectData: { action: action.action },
-      })
-    }
-
-    return action
-  }
-
-  async listActions(options?: {
-    status?: Action['status']
-    action?: string
-    actor?: string
-    object?: string
-    since?: Date
-    until?: Date
-    limit?: number
-    /** @deprecated Use 'action' instead */
-    type?: string
-  }): Promise<Action[]> {
-    let results = Array.from(this.actions.values())
-
-    if (options?.status) {
-      results = results.filter((a) => a.status === options.status)
-    }
-    // Filter by action or legacy type
-    const actionFilter = options?.action ?? options?.type
-    if (actionFilter) {
-      results = results.filter((a) => a.action === actionFilter)
-    }
-    if (options?.actor) {
-      results = results.filter((a) => a.actor === options.actor)
-    }
-    if (options?.object) {
-      results = results.filter((a) => a.object === options.object)
-    }
-    if (options?.since) {
-      results = results.filter((a) => a.createdAt >= options.since!)
-    }
-    if (options?.until) {
-      results = results.filter((a) => a.createdAt <= options.until!)
-    }
-    if (options?.limit) {
-      results = results.slice(0, options.limit)
-    }
-
-    return results
-  }
-
-  async retryAction(id: string): Promise<Action> {
-    const action = this.actions.get(id)
-    if (!action) {
-      throw new Error(`Action not found: ${id}`)
-    }
-    if (action.status !== 'failed') {
-      throw new Error(`Can only retry failed actions: ${id}`)
-    }
-
-    action.status = 'pending'
-    action.error = undefined
-    action.startedAt = undefined
-    action.completedAt = undefined
-
-    await this.emit({
-      actor: action.actor,
-      event: 'Action.retried',
-      object: action.id,
-      objectData: { action: action.action },
-    })
-
-    return action
-  }
-
-  async cancelAction(id: string): Promise<void> {
-    const action = this.actions.get(id)
-    if (!action) {
-      throw new Error(`Action not found: ${id}`)
-    }
-    if (action.status === 'completed' || action.status === 'failed' || action.status === 'cancelled') {
-      throw new Error(`Cannot cancel finished action: ${id}`)
-    }
-
-    action.status = 'cancelled'
-    action.completedAt = new Date()
-
-    await this.emit({
-      actor: action.actor,
-      event: 'Action.cancelled',
-      object: action.id,
-      objectData: { action: action.action },
-    })
-  }
-
-  // ===========================================================================
-  // Artifacts
-  // ===========================================================================
-
-  private artifactKey(url: string, type: string): string {
-    return `${url}:${type}`
-  }
-
-  async getArtifact(url: string, type: string): Promise<Artifact | null> {
-    return this.artifacts.get(this.artifactKey(url, type)) ?? null
-  }
-
-  async setArtifact(
-    url: string,
-    type: string,
-    data: { content: unknown; sourceHash: string; metadata?: Record<string, unknown> }
-  ): Promise<void> {
-    const artifact: Artifact = {
-      url,
-      type,
-      sourceHash: data.sourceHash,
-      content: data.content,
-      metadata: data.metadata,
-      createdAt: new Date(),
-    }
-
-    this.artifacts.set(this.artifactKey(url, type), artifact)
-  }
-
-  async deleteArtifact(url: string, type?: string): Promise<void> {
-    if (type) {
-      this.artifacts.delete(this.artifactKey(url, type))
-    } else {
-      // Delete all artifacts for this URL
-      for (const key of this.artifacts.keys()) {
-        if (key.startsWith(`${url}:`)) {
-          this.artifacts.delete(key)
-        }
-      }
-    }
-  }
-
-  private async invalidateArtifacts(url: string): Promise<void> {
-    // Keep embedding artifact but mark others for regeneration
-    for (const [key, artifact] of this.artifacts) {
-      if (key.startsWith(`${url}:`) && artifact.type !== 'embedding') {
-        this.artifacts.delete(key)
-      }
-    }
-  }
-
-  async listArtifacts(url: string): Promise<Artifact[]> {
-    const results: Artifact[] = []
-    for (const [key, artifact] of this.artifacts) {
-      if (key.startsWith(`${url}:`)) {
-        results.push(artifact)
-      }
-    }
-    return results
-  }
-
-  // ===========================================================================
-  // Utilities
-  // ===========================================================================
-
-  /**
-   * Run an operation with concurrency control
-   */
-  async withConcurrency<T>(fn: () => Promise<T>): Promise<T> {
-    return this.semaphore.run(fn)
-  }
-
-  /**
-   * Run multiple operations with concurrency control
-   */
-  async mapWithConcurrency<T, R>(items: T[], fn: (item: T) => Promise<R>): Promise<R[]> {
-    return this.semaphore.map(items, fn)
-  }
-
-  /**
-   * Clear all data (useful for testing)
-   */
-  clear(): void {
-    this.entities.clear()
-    this.relations.clear()
-    this.events.length = 0
-    this.actions.clear()
-    this.artifacts.clear()
-    this.eventHandlers.clear()
-  }
-
-  /**
-   * Get stats
-   */
-  stats(): {
-    entities: number
-    relations: number
-    events: number
-    actions: { pending: number; active: number; completed: number; failed: number; cancelled: number }
-    artifacts: number
-    concurrency: { active: number; pending: number }
-  } {
-    let entityCount = 0
-    for (const store of this.entities.values()) {
-      entityCount += store.size
-    }
-
-    let relationCount = 0
-    for (const targets of this.relations.values()) {
-      relationCount += targets.size
-    }
-
-    const actionStats = { pending: 0, active: 0, completed: 0, failed: 0, cancelled: 0 }
-    for (const action of this.actions.values()) {
-      actionStats[action.status]++
-    }
-
-    return {
-      entities: entityCount,
-      relations: relationCount,
-      events: this.events.length,
-      actions: actionStats,
-      artifacts: this.artifacts.size,
-      concurrency: {
-        active: this.semaphore.active,
-        pending: this.semaphore.pending,
-      },
-    }
-  }
-}
-
-/**
- * Create an in-memory provider
- */
-export function createMemoryProvider(options?: MemoryProviderOptions): MemoryProvider {
-  return new MemoryProvider(options)
-}