@revealui/ai 0.1.0

package/dist/memory/stores/procedural-memory.js

@@ -0,0 +1,152 @@
+/**
+ * Procedural Memory
+ *
+ * Stores and executes named workflows for AI agents.
+ * Workflows are sequences of typed steps that can be run
+ * sequentially or in parallel.
+ *
+ * @example
+ * ```typescript
+ * const mem = new ProceduralMemory()
+ *
+ * mem.register('onboard-user', [
+ *   { id: 'welcome', type: 'action', label: 'Send welcome email',
+ *     execute: async (ctx) => { ... } },
+ *   { id: 'create-profile', type: 'action', label: 'Init profile',
+ *     execute: async (ctx) => { ... } },
+ * ])
+ *
+ * const result = await mem.execute('onboard-user', { userId: 'u1' })
+ * ```
+ */
+// =============================================================================
+// ProceduralMemory
+// =============================================================================
+/**
+ * Procedural Memory stores named workflow definitions and executes them
+ * against a shared context object.
+ */
+export class ProceduralMemory {
+    workflows = new Map();
+    /**
+     * Register a new workflow.
+     * If a workflow with the same name already exists it is overwritten.
+     */
+    register(name, steps, description) {
+        this.workflows.set(name, { name, description, steps, createdAt: Date.now() });
+    }
+    /**
+     * Unregister a workflow by name.
+     */
+    unregister(name) {
+        this.workflows.delete(name);
+    }
+    /**
+     * Check whether a workflow is registered.
+     */
+    has(name) {
+        return this.workflows.has(name);
+    }
+    /**
+     * List all registered workflow names.
+     */
+    listWorkflows() {
+        return Array.from(this.workflows.keys());
+    }
+    /**
+     * Get the definition for a registered workflow.
+     */
+    getDefinition(name) {
+        return this.workflows.get(name);
+    }
+    /**
+     * Execute a workflow by name.
+     *
+     * Steps marked `parallel: true` are executed concurrently with the
+     * immediately following step(s). All other steps run sequentially.
+     *
+     * @param name    - Registered workflow name
+     * @param context - Initial context object passed to each step
+     * @throws {Error} If the workflow is not registered
+     */
+    async execute(name, context = {}) {
+        const workflow = this.workflows.get(name);
+        if (!workflow) {
+            throw new Error(`Workflow "${name}" is not registered`);
+        }
+        const stepResults = [];
+        const startTime = Date.now();
+        // Group steps into sequential "batches". Consecutive steps that have
+        // parallel:true are collected into one batch and run with Promise.all.
+        const batches = buildBatches(workflow.steps);
+        for (const batch of batches) {
+            if (batch.length === 1) {
+                // Sequential step
+                // biome-ignore lint/style/noNonNullAssertion: batch[0] is guaranteed by batch.length === 1 check above
+                const step = batch[0];
+                try {
+                    const result = await step.execute(context);
+                    stepResults.push({ id: step.id, status: 'ok', result });
+                }
+                catch (err) {
+                    stepResults.push({
+                        id: step.id,
+                        status: 'error',
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            else {
+                // Parallel batch
+                const settled = await Promise.allSettled(batch.map((s) => s.execute(context)));
+                for (let i = 0; i < batch.length; i++) {
+                    // biome-ignore lint/style/noNonNullAssertion: i is bounded by batch.length, so settled[i] and batch[i] are always defined
+                    const outcome = settled[i];
+                    // biome-ignore lint/style/noNonNullAssertion: i is bounded by batch.length, so batch[i] is always defined
+                    const batchStep = batch[i];
+                    if (outcome.status === 'fulfilled') {
+                        const { value } = outcome;
+                        stepResults.push({ id: batchStep.id, status: 'ok', result: value });
+                    }
+                    else {
+                        const { reason } = outcome;
+                        stepResults.push({
+                            id: batchStep.id,
+                            status: 'error',
+                            error: reason instanceof Error ? reason.message : String(reason),
+                        });
+                    }
+                }
+            }
+        }
+        const success = stepResults.every((r) => r.status === 'ok');
+        return {
+            workflow: name,
+            success,
+            steps: stepResults,
+            durationMs: Date.now() - startTime,
+        };
+    }
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+/**
+ * Group steps into sequential batches.
+ * A step with `parallel: true` is placed in the same batch as the next step.
+ */
+function buildBatches(steps) {
+    const batches = [];
+    let current = [];
+    for (const step of steps) {
+        current.push(step);
+        if (!step.parallel) {
+            batches.push(current);
+            current = [];
+        }
+    }
+    if (current.length > 0) {
+        batches.push(current);
+    }
+    return batches;
+}

package/dist/memory/stores/semantic-memory.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Semantic Memory
+ *
+ * Knowledge base with vector similarity search for AI agents.
+ * Stores content with optional embeddings and supports semantic
+ * retrieval via cosine similarity ranking.
+ *
+ * Designed to work standalone (in-memory) for testing and
+ * with a vector store (Supabase pgvector) in production.
+ */
+export interface SemanticEntry {
+    key: string;
+    content: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+    storedAt: number;
+    expiresAt?: number;
+}
+export interface SemanticSearchResult {
+    key: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SemanticMemoryOptions {
+    /** Maximum number of entries to retain. Oldest are evicted first. */
+    maxEntries?: number;
+    /** Default TTL in milliseconds. Entries expire after this duration. */
+    ttlMs?: number;
+}
+/**
+ * Semantic Memory for knowledge-base storage and retrieval.
+ *
+ * Provides cosine-similarity search over stored entries.
+ * When embeddings are not provided, falls back to keyword matching.
+ *
+ * @example
+ * ```typescript
+ * const memory = new SemanticMemory({ maxEntries: 1000, ttlMs: 24 * 60 * 60 * 1000 })
+ *
+ * await memory.store('pref:theme', 'User prefers dark mode', [0.1, 0.9, 0.3])
+ *
+ * const results = await memory.search([0.1, 0.9, 0.3], 3)
+ * // results[0].content === 'User prefers dark mode'
+ *
+ * await memory.delete('pref:theme')
+ * ```
+ */
+export declare class SemanticMemory {
+    private entries;
+    private readonly maxEntries;
+    private readonly ttlMs;
+    constructor(options?: SemanticMemoryOptions);
+    /**
+     * Store a content entry with an optional embedding vector.
+     *
+     * If the store is at capacity, the oldest entry is evicted first.
+     */
+    store(key: string, content: string, embedding?: number[], metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Retrieve an entry by exact key.
+     */
+    get(key: string): Promise<SemanticEntry | null>;
+    /**
+     * Delete an entry by key.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Search for the top-K most similar entries to a query embedding.
+     *
+     * Uses cosine similarity when both the query and entry have embeddings.
+     * Falls back to returning all non-expired entries ordered by recency when
+     * embeddings are absent.
+     *
+     * @param queryEmbedding - Query vector
+     * @param topK           - Maximum number of results to return (default 5)
+     */
+    search(queryEmbedding: number[], topK?: number): Promise<SemanticSearchResult[]>;
+    /**
+     * Return all non-expired entries.
+     */
+    list(): SemanticEntry[];
+    /**
+     * Number of stored entries (excluding expired ones).
+     */
+    get size(): number;
+    /**
+     * Remove all expired entries from the store.
+     */
+    private evictExpired;
+}
+//# sourceMappingURL=semantic-memory.d.ts.map

package/dist/memory/stores/semantic-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-memory.d.ts","sourceRoot":"","sources":["../../../src/memory/stores/semantic-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;gBAE9B,OAAO,GAAE,qBAA0B;IAK/C;;;;OAIG;IACG,KAAK,CACT,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,EAAE,EACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;IAyBhB;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAUrD;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC;;;;;;;;;OASG;IACG,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,EAAE,IAAI,SAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAejF;;OAEG;IACH,IAAI,IAAI,aAAa,EAAE;IAKvB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED;;OAEG;IACH,OAAO,CAAC,YAAY;CAQrB"}

package/dist/memory/stores/semantic-memory.js

@@ -0,0 +1,155 @@
+/**
+ * Semantic Memory
+ *
+ * Knowledge base with vector similarity search for AI agents.
+ * Stores content with optional embeddings and supports semantic
+ * retrieval via cosine similarity ranking.
+ *
+ * Designed to work standalone (in-memory) for testing and
+ * with a vector store (Supabase pgvector) in production.
+ */
+import { validateContext } from '../utils/validation.js';
+// =============================================================================
+// SemanticMemory
+// =============================================================================
+/**
+ * Semantic Memory for knowledge-base storage and retrieval.
+ *
+ * Provides cosine-similarity search over stored entries.
+ * When embeddings are not provided, falls back to keyword matching.
+ *
+ * @example
+ * ```typescript
+ * const memory = new SemanticMemory({ maxEntries: 1000, ttlMs: 24 * 60 * 60 * 1000 })
+ *
+ * await memory.store('pref:theme', 'User prefers dark mode', [0.1, 0.9, 0.3])
+ *
+ * const results = await memory.search([0.1, 0.9, 0.3], 3)
+ * // results[0].content === 'User prefers dark mode'
+ *
+ * await memory.delete('pref:theme')
+ * ```
+ */
+export class SemanticMemory {
+    entries = new Map();
+    maxEntries;
+    ttlMs;
+    constructor(options = {}) {
+        this.maxEntries = options.maxEntries ?? 10_000;
+        this.ttlMs = options.ttlMs;
+    }
+    /**
+     * Store a content entry with an optional embedding vector.
+     *
+     * If the store is at capacity, the oldest entry is evicted first.
+     */
+    async store(key, content, embedding, metadata) {
+        if (metadata) {
+            validateContext(metadata);
+        }
+        // Evict oldest if at capacity (and not overwriting an existing key)
+        if (!this.entries.has(key) && this.entries.size >= this.maxEntries) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest !== undefined) {
+                this.entries.delete(oldest);
+            }
+        }
+        const entry = {
+            key,
+            content,
+            embedding,
+            metadata,
+            storedAt: Date.now(),
+            expiresAt: this.ttlMs !== undefined ? Date.now() + this.ttlMs : undefined,
+        };
+        this.entries.set(key, entry);
+    }
+    /**
+     * Retrieve an entry by exact key.
+     */
+    async get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return null;
+        if (entry.expiresAt !== undefined && entry.expiresAt < Date.now()) {
+            this.entries.delete(key);
+            return null;
+        }
+        return entry;
+    }
+    /**
+     * Delete an entry by key.
+     */
+    async delete(key) {
+        this.entries.delete(key);
+    }
+    /**
+     * Search for the top-K most similar entries to a query embedding.
+     *
+     * Uses cosine similarity when both the query and entry have embeddings.
+     * Falls back to returning all non-expired entries ordered by recency when
+     * embeddings are absent.
+     *
+     * @param queryEmbedding - Query vector
+     * @param topK           - Maximum number of results to return (default 5)
+     */
+    async search(queryEmbedding, topK = 5) {
+        this.evictExpired();
+        const results = [];
+        for (const entry of this.entries.values()) {
+            const score = entry.embedding !== undefined ? cosineSimilarity(queryEmbedding, entry.embedding) : 0; // No embedding → score 0 (will appear last)
+            results.push({ key: entry.key, content: entry.content, score, metadata: entry.metadata });
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, topK);
+    }
+    /**
+     * Return all non-expired entries.
+     */
+    list() {
+        this.evictExpired();
+        return Array.from(this.entries.values());
+    }
+    /**
+     * Number of stored entries (excluding expired ones).
+     */
+    get size() {
+        this.evictExpired();
+        return this.entries.size;
+    }
+    /**
+     * Remove all expired entries from the store.
+     */
+    evictExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.entries.entries()) {
+            if (entry.expiresAt !== undefined && entry.expiresAt < now) {
+                this.entries.delete(key);
+            }
+        }
+    }
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+/**
+ * Cosine similarity between two equal-length vectors.
+ * Returns a value in [-1, 1]. Returns 0 for zero-magnitude vectors.
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        // biome-ignore lint/style/noNonNullAssertion: i is bounded by a.length, and b has same length (checked above)
+        const ai = a[i];
+        // biome-ignore lint/style/noNonNullAssertion: i is bounded by a.length === b.length (checked above)
+        const bi = b[i];
+        dot += ai * bi;
+        magA += ai * ai;
+        magB += bi * bi;
+    }
+    const denom = Math.sqrt(magA) * Math.sqrt(magB);
+    return denom === 0 ? 0 : dot / denom;
+}

package/dist/memory/stores/working-memory.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Working Memory
+ *
+ * Short-term, session-scoped memory for AI agents.
+ * Uses CRDTs for conflict-free state management across distributed nodes.
+ *
+ * - Context: LWWRegister for single-valued state (last writer wins)
+ * - Active Agents: ORSet for collection of active agent configurations
+ * - Session State: LWWRegister for session metadata
+ */
+import type { AgentDefinition } from '@revealui/contracts/agents';
+import { type LWWRegisterData } from '../crdt/lww-register.js';
+import { type ORSetData } from '../crdt/or-set.js';
+import type { CRDTPersistence } from '../persistence/crdt-persistence.js';
+export interface SessionState {
+    status: 'active' | 'paused' | 'completed';
+    focus?: {
+        siteId?: string;
+        pageId?: string;
+        blockId?: string;
+        selection?: string[];
+    };
+    currentTask?: {
+        id: string;
+        description: string;
+        status: 'pending' | 'running' | 'completed' | 'failed';
+        progress?: number;
+    };
+}
+export interface WorkingMemoryData {
+    sessionId: string;
+    nodeId: string;
+    context: LWWRegisterData<Record<string, unknown>>;
+    sessionState: LWWRegisterData<SessionState>;
+    activeAgents: ORSetData<AgentDefinition>;
+}
+/**
+ * Working Memory for session-scoped agent state.
+ *
+ * @example
+ * ```typescript
+ * const memory = new WorkingMemory('session-123', 'node-abc')
+ * await memory.load()
+ *
+ * memory.setContext({ userId: 'user-1', theme: 'dark' })
+ * const agentTag = memory.addAgent(agentConfig)
+ * memory.updateSessionState({ status: 'active' })
+ *
+ * await memory.save()
+ * ```
+ */
+export declare class WorkingMemory {
+    private context;
+    private sessionState;
+    private activeAgents;
+    private sessionId;
+    private nodeId;
+    private persistence?;
+    /**
+     * Creates a new WorkingMemory instance.
+     *
+     * @param sessionId - Unique session identifier
+     * @param nodeId - Unique node identifier (for CRDT operations)
+     * @param persistence - Optional persistence adapter
+     */
+    constructor(sessionId: string, nodeId: string, persistence?: CRDTPersistence);
+    /**
+     * Sets the entire context object.
+     *
+     * @param context - Context data to set
+     */
+    /**
+     * Sets the entire context object.
+     *
+     * **Performance Note**: This replaces the entire context. For partial updates,
+     * use `updateContext()` or `setContextValue()`.
+     *
+     * **Validation**: The context is validated by LWWRegister (which clones values),
+     * but for additional security, consider validating before calling this method.
+     *
+     * @param context - The complete context object
+     */
+    setContext(context: Record<string, unknown>): void;
+    /**
+     * Gets the current context.
+     *
+     * @returns Current context object
+     */
+    getContext(): Record<string, unknown>;
+    /**
+     * Updates context with partial data.
+     * Merges with existing context.
+     *
+     * @param updates - Partial context updates
+     */
+    updateContext(updates: Partial<Record<string, unknown>>): void;
+    /**
+     * Gets a specific context value.
+     *
+     * @param key - Context key
+     * @returns Context value or undefined
+     */
+    /**
+     * Gets a specific context value by key.
+     *
+     * **Immutability Guarantee**: Returns a deep clone of object/array values to prevent external mutations.
+     * Primitives (strings, numbers, booleans, null) are returned as-is.
+     *
+     * @param key - The context key to retrieve
+     * @returns The context value (cloned if object/array, direct reference if primitive)
+     */
+    getContextValue(key: string): unknown;
+    /**
+     * Sets a specific context value.
+     *
+     * **Performance Note**: This method clones the entire context object to update
+     * a single key. For multiple updates, use `updateContext()` instead.
+     *
+     * @param key - Context key
+     * @param value - Context value
+     */
+    setContextValue(key: string, value: unknown): void;
+    /**
+     * Adds an agent to the active agents set.
+     *
+     * @param agent - Agent configuration
+     * @returns Unique tag for this agent addition
+     */
+    addAgent(agent: AgentDefinition): string;
+    /**
+     * Removes an agent by tag.
+     *
+     * @param tag - Tag returned from addAgent
+     * @returns true if agent was removed
+     */
+    removeAgent(tag: string): boolean;
+    /**
+     * Removes an agent by ID (removes all instances).
+     *
+     * @param agentId - Agent ID to remove
+     * @returns Number of instances removed
+     */
+    removeAgentById(agentId: string): number;
+    /**
+     * Gets all active agents.
+     *
+     * @returns Array of active agent configurations
+     */
+    getActiveAgents(): AgentDefinition[];
+    /**
+     * Checks if an agent is active.
+     *
+     * @param agentId - Agent ID to check
+     * @returns true if agent is active
+     */
+    hasAgent(agentId: string): boolean;
+    /**
+     * Updates session state with partial data.
+     *
+     * @param state - Partial session state
+     */
+    updateSessionState(state: Partial<SessionState>): void;
+    /**
+     * Gets the current session state.
+     *
+     * @returns Current session state
+     */
+    getSessionState(): SessionState;
+    /**
+     * Merges another WorkingMemory into this one.
+     * Uses CRDT merge operations for conflict resolution.
+     *
+     * @param other - WorkingMemory to merge
+     * @returns New merged WorkingMemory
+     */
+    merge(other: WorkingMemory): WorkingMemory;
+    /**
+     * Loads state from database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    load(): Promise<void>;
+    /**
+     * Saves state to database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    save(): Promise<void>;
+    /**
+     * Serializes WorkingMemory to plain object.
+     *
+     * @returns Serialized data
+     */
+    toData(): WorkingMemoryData;
+    /**
+     * Deserializes WorkingMemory from plain object.
+     *
+     * @param data - Serialized data
+     * @param persistence - Optional persistence adapter
+     * @returns New WorkingMemory instance
+     */
+    static fromData(data: WorkingMemoryData, persistence?: CRDTPersistence): WorkingMemory;
+    /**
+     * Creates a copy of this WorkingMemory.
+     *
+     * @returns New WorkingMemory with same state
+     */
+    clone(): WorkingMemory;
+    /**
+     * Gets the session ID.
+     */
+    getSessionId(): string;
+    /**
+     * Gets the node ID.
+     */
+    getNodeId(): string;
+    /**
+     * Gets the context register's timestamp.
+     * Used for proper CRDT merge semantics.
+     *
+     * @returns Timestamp of the last context update
+     */
+    getContextTimestamp(): number;
+}
+//# sourceMappingURL=working-memory.d.ts.map

package/dist/memory/stores/working-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"working-memory.d.ts","sourceRoot":"","sources":["../../../src/memory/stores/working-memory.ts"],"names":[],"mappings":"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"}