@psiclawops/hypermem 0.1.0

package/dist/vector-store.js

@@ -0,0 +1,498 @@
+/**
+ * HyperMem Vector Store — Semantic Search via sqlite-vec
+ *
+ * Provides embedding-backed KNN search over facts, knowledge, episodes,
+ * and session registry entries. Uses Ollama (local) for embeddings,
+ * sqlite-vec for vector indexing, and coexists with existing FTS5.
+ *
+ * Architecture:
+ *   - One vec0 virtual table per indexed content type
+ *   - Embeddings generated via local Ollama (nomic-embed-text, 768d)
+ *   - Vectors stored alongside content in the same agent DB
+ *   - Embedding cache to avoid redundant API calls
+ *   - Batch embedding support for bulk indexing
+ */
+import { createHash } from 'node:crypto';
+const DEFAULT_EMBEDDING_CONFIG = {
+    ollamaUrl: 'http://localhost:11434',
+    model: 'nomic-embed-text',
+    dimensions: 768,
+    timeout: 10000,
+    batchSize: 32,
+};
+/**
+ * Generate embeddings via Ollama API.
+ * Supports single and batch embedding.
+ */
+export async function generateEmbeddings(texts, config = DEFAULT_EMBEDDING_CONFIG) {
+    if (texts.length === 0)
+        return [];
+    const results = [];
+    // Ollama /api/embed supports batch via `input` array
+    for (let i = 0; i < texts.length; i += config.batchSize) {
+        const batch = texts.slice(i, i + config.batchSize);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), config.timeout);
+        try {
+            const response = await fetch(`${config.ollamaUrl}/api/embed`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: config.model,
+                    input: batch,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama embedding failed: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            for (const embedding of data.embeddings) {
+                if (embedding.length !== config.dimensions) {
+                    throw new Error(`Embedding dimension mismatch: expected ${config.dimensions}, got ${embedding.length}`);
+                }
+                results.push(new Float32Array(embedding));
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    return results;
+}
+/**
+ * Serialize a Float32Array to Uint8Array for sqlite-vec binding.
+ */
+function vecToBytes(vec) {
+    return new Uint8Array(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+/**
+ * VectorStore — manages vector indexes in an agent's vector database.
+ *
+ * The vector DB (vectors.db) stores vec0 virtual tables and the index map.
+ * Source content (facts, knowledge, episodes) lives in the library DB.
+ * The VectorStore needs both: vectorDb for indexes, libraryDb for content.
+ */
+export class VectorStore {
+    db; // vectors.db
+    libraryDb; // library.db for source content
+    config;
+    constructor(db, config, libraryDb) {
+        this.db = db;
+        this.libraryDb = libraryDb || null;
+        this.config = { ...DEFAULT_EMBEDDING_CONFIG, ...config };
+    }
+    /**
+     * Create vector index tables if they don't exist.
+     * Safe to call multiple times (idempotent).
+     */
+    ensureTables() {
+        const dim = this.config.dimensions;
+        // Vector index for facts
+        this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_facts
+      USING vec0(embedding float[${dim}])
+    `);
+        // Vector index for knowledge
+        this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_knowledge
+      USING vec0(embedding float[${dim}])
+    `);
+        // Vector index for episodes
+        this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_episodes
+      USING vec0(embedding float[${dim}])
+    `);
+        // Vector index for session registry (library DB)
+        // This is created separately via ensureSessionRegistryTable()
+        // Mapping table: links vec rowids to source table rows
+        // Using a single mapping table for all vec tables
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS vec_index_map (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_table TEXT NOT NULL,
+        source_id INTEGER NOT NULL,
+        vec_table TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        indexed_at TEXT NOT NULL,
+        UNIQUE(source_table, source_id)
+      )
+    `);
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_vec_map_source ON vec_index_map(source_table, source_id)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_vec_map_vec ON vec_index_map(vec_table, id)');
+    }
+    /**
+     * Index a single content item. Generates embedding and stores in vec table.
+     * Skips if content hasn't changed (based on hash).
+     */
+    /** Allowlisted source tables for vector indexing. Prevents SQL injection via table name interpolation. */
+    static ALLOWED_SOURCE_TABLES = new Set(['facts', 'knowledge', 'episodes', 'sessions']);
+    validateSourceTable(sourceTable) {
+        if (!VectorStore.ALLOWED_SOURCE_TABLES.has(sourceTable)) {
+            throw new Error(`Invalid sourceTable: "${sourceTable}". Must be one of: ${[...VectorStore.ALLOWED_SOURCE_TABLES].join(', ')}`);
+        }
+    }
+    async indexItem(sourceTable, sourceId, content, domain) {
+        this.validateSourceTable(sourceTable);
+        const vecTable = `vec_${sourceTable}`;
+        const contentHash = simpleHash(content);
+        // Check if already indexed with same content
+        const existing = this.db
+            .prepare('SELECT id, content_hash FROM vec_index_map WHERE source_table = ? AND source_id = ?')
+            .get(sourceTable, sourceId);
+        if (existing && existing.content_hash === contentHash) {
+            return false; // Already indexed, content unchanged
+        }
+        // Generate embedding
+        const [embedding] = await generateEmbeddings([content], this.config);
+        const bytes = vecToBytes(embedding);
+        if (existing) {
+            // Update: delete old vector, insert new
+            this.db.prepare(`DELETE FROM ${vecTable} WHERE rowid = CAST(? AS INTEGER)`).run(existing.id);
+            this.db.prepare(`INSERT INTO ${vecTable}(rowid, embedding) VALUES (CAST(? AS INTEGER), ?)`).run(existing.id, bytes);
+            this.db
+                .prepare('UPDATE vec_index_map SET content_hash = ?, indexed_at = ? WHERE id = ?')
+                .run(contentHash, new Date().toISOString(), existing.id);
+        }
+        else {
+            // Insert new mapping row first to get the rowid
+            const mapResult = this.db
+                .prepare('INSERT INTO vec_index_map (source_table, source_id, vec_table, content_hash, indexed_at) VALUES (?, ?, ?, ?, ?)')
+                .run(sourceTable, sourceId, vecTable, contentHash, new Date().toISOString());
+            const mapRowId = Number(mapResult.lastInsertRowid);
+            // Insert vector with matching rowid
+            this.db.prepare(`INSERT INTO ${vecTable}(rowid, embedding) VALUES (CAST(? AS INTEGER), ?)`).run(mapRowId, bytes);
+        }
+        return true;
+    }
+    /**
+     * Batch index multiple items. More efficient than individual calls.
+     */
+    async indexBatch(items) {
+        let indexed = 0;
+        let skipped = 0;
+        // Validate all source tables before processing any items
+        for (const item of items) {
+            this.validateSourceTable(item.sourceTable);
+        }
+        // Filter out already-indexed items
+        const toIndex = [];
+        for (const item of items) {
+            const contentHash = simpleHash(item.content);
+            const existing = this.db
+                .prepare('SELECT content_hash FROM vec_index_map WHERE source_table = ? AND source_id = ?')
+                .get(item.sourceTable, item.sourceId);
+            if (existing && existing.content_hash === contentHash) {
+                skipped++;
+            }
+            else {
+                toIndex.push(item);
+            }
+        }
+        if (toIndex.length === 0)
+            return { indexed, skipped };
+        // Batch generate embeddings
+        const texts = toIndex.map(item => item.content);
+        const embeddings = await generateEmbeddings(texts, this.config);
+        // Insert in a transaction
+        this.db.exec('BEGIN');
+        try {
+            for (let i = 0; i < toIndex.length; i++) {
+                const item = toIndex[i];
+                const embedding = embeddings[i];
+                const vecTable = `vec_${item.sourceTable}`;
+                const contentHash = simpleHash(item.content);
+                const bytes = vecToBytes(embedding);
+                // Check for existing mapping (might need update vs insert)
+                const existing = this.db
+                    .prepare('SELECT id FROM vec_index_map WHERE source_table = ? AND source_id = ?')
+                    .get(item.sourceTable, item.sourceId);
+                if (existing) {
+                    this.db.prepare(`DELETE FROM ${vecTable} WHERE rowid = CAST(? AS INTEGER)`).run(existing.id);
+                    this.db.prepare(`INSERT INTO ${vecTable}(rowid, embedding) VALUES (CAST(? AS INTEGER), ?)`).run(existing.id, bytes);
+                    this.db
+                        .prepare('UPDATE vec_index_map SET content_hash = ?, indexed_at = ? WHERE id = ?')
+                        .run(contentHash, new Date().toISOString(), existing.id);
+                }
+                else {
+                    const mapResult = this.db
+                        .prepare('INSERT INTO vec_index_map (source_table, source_id, vec_table, content_hash, indexed_at) VALUES (?, ?, ?, ?, ?)')
+                        .run(item.sourceTable, item.sourceId, vecTable, contentHash, new Date().toISOString());
+                    const mapRowId = Number(mapResult.lastInsertRowid);
+                    this.db.prepare(`INSERT INTO ${vecTable}(rowid, embedding) VALUES (CAST(? AS INTEGER), ?)`).run(mapRowId, bytes);
+                }
+                indexed++;
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (err) {
+            this.db.exec('ROLLBACK');
+            throw err;
+        }
+        return { indexed, skipped };
+    }
+    /**
+     * Semantic KNN search across one or all vector tables.
+     */
+    async search(query, opts) {
+        const limit = opts?.limit || 10;
+        const tables = opts?.tables || ['facts', 'knowledge', 'episodes'];
+        // Validate all table names before any SQL construction
+        for (const table of tables) {
+            this.validateSourceTable(table);
+        }
+        // Generate query embedding
+        const [queryEmbedding] = await generateEmbeddings([query], this.config);
+        const queryBytes = vecToBytes(queryEmbedding);
+        const results = [];
+        for (const table of tables) {
+            const vecTable = `vec_${table}`;
+            // Check if the vec table exists
+            const tableExists = this.db
+                .prepare("SELECT count(*) as cnt FROM sqlite_master WHERE type='table' AND name=?")
+                .get(vecTable);
+            if (!tableExists || tableExists.cnt === 0)
+                continue;
+            // KNN query
+            const rows = this.db
+                .prepare(`SELECT rowid, distance 
+           FROM ${vecTable} 
+           WHERE embedding MATCH ? 
+           ORDER BY distance 
+           LIMIT ?`)
+                .all(queryBytes, limit);
+            for (const row of rows) {
+                if (opts?.maxDistance !== undefined && row.distance > opts.maxDistance)
+                    continue;
+                // Look up source from mapping table
+                const mapping = this.db
+                    .prepare('SELECT source_table, source_id FROM vec_index_map WHERE id = ?')
+                    .get(row.rowid);
+                if (!mapping)
+                    continue;
+                // Fetch actual content from source table
+                const sourceContent = this.getSourceContent(mapping.source_table, mapping.source_id);
+                if (!sourceContent)
+                    continue;
+                results.push({
+                    rowid: row.rowid,
+                    distance: row.distance,
+                    sourceTable: mapping.source_table,
+                    sourceId: mapping.source_id,
+                    content: sourceContent.content,
+                    domain: sourceContent.domain,
+                    agentId: sourceContent.agentId,
+                    metadata: sourceContent.metadata,
+                });
+            }
+        }
+        // Sort all results by distance (cross-table)
+        results.sort((a, b) => a.distance - b.distance);
+        return results.slice(0, limit);
+    }
+    /**
+     * Get content from a source table by id.
+     */
+    getSourceContent(table, id) {
+        // Source content lives in the library DB (facts, knowledge, episodes)
+        // or in the vector DB itself (if old schema). Try library first.
+        const sourceDb = this.libraryDb || this.db;
+        switch (table) {
+            case 'facts': {
+                const row = sourceDb
+                    .prepare('SELECT content, domain, agent_id FROM facts WHERE id = ?')
+                    .get(id);
+                return row ? { content: row.content, domain: row.domain, agentId: row.agent_id } : null;
+            }
+            case 'knowledge': {
+                const row = sourceDb
+                    .prepare('SELECT content, domain, agent_id, key FROM knowledge WHERE id = ?')
+                    .get(id);
+                return row
+                    ? { content: row.content, domain: row.domain, agentId: row.agent_id, metadata: row.key }
+                    : null;
+            }
+            case 'episodes': {
+                const row = sourceDb
+                    .prepare('SELECT summary, event_type, agent_id, participants FROM episodes WHERE id = ?')
+                    .get(id);
+                return row
+                    ? {
+                        content: row.summary,
+                        domain: row.event_type,
+                        agentId: row.agent_id,
+                        metadata: row.participants,
+                    }
+                    : null;
+            }
+            default:
+                return null;
+        }
+    }
+    /**
+     * Index all un-indexed content in the agent's database.
+     * Called by the background indexer.
+     */
+    async indexAll(agentId) {
+        const items = [];
+        const sourceDb = this.libraryDb || this.db;
+        // Count already-indexed items for accurate skip reporting
+        const alreadyIndexed = this.db
+            .prepare('SELECT COUNT(*) as cnt FROM vec_index_map')
+            .get().cnt;
+        // Get IDs already indexed (in vector DB)
+        const indexedFacts = new Set(this.db.prepare("SELECT source_id FROM vec_index_map WHERE source_table = 'facts'")
+            .all().map(r => r.source_id));
+        const indexedKnowledge = new Set(this.db.prepare("SELECT source_id FROM vec_index_map WHERE source_table = 'knowledge'")
+            .all().map(r => r.source_id));
+        const indexedEpisodes = new Set(this.db.prepare("SELECT source_id FROM vec_index_map WHERE source_table = 'episodes'")
+            .all().map(r => r.source_id));
+        // Collect un-indexed facts from library DB
+        const facts = sourceDb
+            .prepare('SELECT id, content, domain FROM facts WHERE agent_id = ? AND superseded_by IS NULL')
+            .all(agentId);
+        for (const f of facts) {
+            if (!indexedFacts.has(f.id)) {
+                items.push({ sourceTable: 'facts', sourceId: f.id, content: f.content });
+            }
+        }
+        // Collect un-indexed knowledge from library DB
+        const knowledge = sourceDb
+            .prepare('SELECT id, content, domain, key FROM knowledge WHERE agent_id = ? AND superseded_by IS NULL')
+            .all(agentId);
+        for (const k of knowledge) {
+            if (!indexedKnowledge.has(k.id)) {
+                items.push({
+                    sourceTable: 'knowledge',
+                    sourceId: k.id,
+                    content: `${k.key}: ${k.content}`,
+                });
+            }
+        }
+        // Collect un-indexed episodes from library DB
+        const episodes = sourceDb
+            .prepare('SELECT id, summary, event_type FROM episodes WHERE agent_id = ?')
+            .all(agentId);
+        for (const e of episodes) {
+            if (!indexedEpisodes.has(e.id)) {
+                items.push({ sourceTable: 'episodes', sourceId: e.id, content: e.summary });
+            }
+        }
+        if (items.length === 0) {
+            return { indexed: 0, skipped: alreadyIndexed };
+        }
+        const result = await this.indexBatch(items);
+        return { indexed: result.indexed, skipped: result.skipped + alreadyIndexed };
+    }
+    /**
+     * Remove vector index entries for deleted source rows.
+     */
+    pruneOrphans() {
+        let pruned = 0;
+        const sourceDb = this.libraryDb || this.db;
+        for (const table of ['facts', 'knowledge', 'episodes']) {
+            // Get all indexed IDs for this table
+            const indexed = this.db
+                .prepare('SELECT id, vec_table, source_id FROM vec_index_map WHERE source_table = ?')
+                .all(table);
+            for (const entry of indexed) {
+                // Check if source still exists in library DB
+                const exists = sourceDb
+                    .prepare(`SELECT 1 FROM ${table} WHERE id = ?`)
+                    .get(entry.source_id);
+                if (!exists) {
+                    this.db.prepare(`DELETE FROM ${entry.vec_table} WHERE rowid = CAST(? AS INTEGER)`).run(entry.id);
+                    this.db.prepare('DELETE FROM vec_index_map WHERE id = ?').run(entry.id);
+                    pruned++;
+                }
+            }
+        }
+        return pruned;
+    }
+    /**
+     * Tombstone vector entries for superseded facts and knowledge.
+     *
+     * When fact A is superseded by fact B (facts.superseded_by = B.id), the old
+     * vector for A should not surface in semantic recall. Without this, recalled
+     * context can include contradicted/outdated facts alongside their replacements.
+     *
+     * Strategy: find all indexed facts/knowledge with superseded_by IS NOT NULL
+     * and delete their vec_index_map entries + vec table rows. The source row
+     * stays in library.db (audit trail) but disappears from recall.
+     *
+     * @returns Number of vector entries tombstoned.
+     */
+    tombstoneSuperseded() {
+        const sourceDb = this.libraryDb || this.db;
+        let tombstoned = 0;
+        for (const table of ['facts', 'knowledge']) {
+            // Find all indexed entries whose source row has been superseded
+            const indexed = this.db
+                .prepare('SELECT vim.id, vim.vec_table, vim.source_id FROM vec_index_map vim WHERE vim.source_table = ?')
+                .all(table);
+            for (const entry of indexed) {
+                const row = sourceDb
+                    .prepare(`SELECT superseded_by FROM ${table} WHERE id = ?`)
+                    .get(entry.source_id);
+                if (row?.superseded_by != null) {
+                    // Remove from vector table
+                    this.db.prepare(`DELETE FROM ${entry.vec_table} WHERE rowid = CAST(? AS INTEGER)`).run(entry.id);
+                    // Remove from index map
+                    this.db.prepare('DELETE FROM vec_index_map WHERE id = ?').run(entry.id);
+                    tombstoned++;
+                }
+            }
+        }
+        if (tombstoned > 0) {
+            console.log(`[hypermem-vector] tombstoneSuperseded: removed ${tombstoned} stale vector entries`);
+        }
+        return tombstoned;
+    }
+    /**
+     * Get index statistics.
+     */
+    getStats() {
+        const breakdown = {};
+        let total = 0;
+        for (const table of ['facts', 'knowledge', 'episodes']) {
+            const count = this.db
+                .prepare('SELECT COUNT(*) as cnt FROM vec_index_map WHERE source_table = ?')
+                .get(table);
+            breakdown[table] = count.cnt;
+            total += count.cnt;
+        }
+        const lastIndexed = this.db
+            .prepare('SELECT MAX(indexed_at) as last_at FROM vec_index_map')
+            .get();
+        return {
+            totalVectors: total,
+            tableBreakdown: breakdown,
+            lastIndexedAt: lastIndexed.last_at,
+        };
+    }
+}
+/**
+ * SHA-256 content hash for change detection and deduplication.
+ * Replaces the prior 32-bit rolling hash which had collision risk on large corpora.
+ */
+function simpleHash(str) {
+    return createHash('sha256').update(str).digest('hex').slice(0, 16);
+}
+/**
+ * Create vector tables in a library database for session registry search.
+ */
+export function ensureSessionVecTable(db, dimensions = 768) {
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_sessions
+    USING vec0(embedding float[${dimensions}])
+  `);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS vec_session_map (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL UNIQUE,
+      content_hash TEXT NOT NULL,
+      indexed_at TEXT NOT NULL
+    )
+  `);
+}
+//# sourceMappingURL=vector-store.js.map

package/dist/work-store.d.ts

@@ -0,0 +1,112 @@
+/**
+ * HyperMem Work Item Store
+ *
+ * Fleet kanban board in SQL. Replaces WORKQUEUE.md.
+ * Lives in the central library DB.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export type WorkStatus = 'incoming' | 'active' | 'blocked' | 'review' | 'completed' | 'cancelled';
+export interface WorkItem {
+    id: string;
+    title: string;
+    description: string | null;
+    status: WorkStatus;
+    priority: number;
+    agentId: string | null;
+    createdBy: string;
+    domain: string | null;
+    parentId: string | null;
+    blockedBy: string | null;
+    sessionKey: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    dueAt: string | null;
+    metadata: Record<string, unknown> | null;
+}
+export interface WorkEvent {
+    id: number;
+    workItemId: string;
+    eventType: string;
+    oldStatus: string | null;
+    newStatus: string | null;
+    agentId: string | null;
+    comment: string | null;
+    createdAt: string;
+}
+export declare class WorkStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    /**
+     * Create a new work item.
+     */
+    create(data: {
+        title: string;
+        description?: string;
+        priority?: number;
+        agentId?: string;
+        createdBy: string;
+        domain?: string;
+        parentId?: string;
+        dueAt?: string;
+        metadata?: Record<string, unknown>;
+    }): WorkItem;
+    /**
+     * Update the status of a work item.
+     */
+    updateStatus(id: string, newStatus: WorkStatus, agentId?: string, comment?: string): WorkItem | null;
+    /**
+     * Assign a work item to an agent.
+     */
+    assign(id: string, agentId: string, assignedBy?: string): WorkItem | null;
+    /**
+     * Block a work item.
+     */
+    block(id: string, blockedBy: string, agentId?: string, reason?: string): WorkItem | null;
+    /**
+     * Get a work item by ID.
+     */
+    getItem(id: string): WorkItem | null;
+    /**
+     * Get active work for an agent.
+     */
+    getAgentWork(agentId: string, status?: WorkStatus): WorkItem[];
+    /**
+     * Get the fleet kanban — all active work grouped by status.
+     */
+    getKanban(opts?: {
+        domain?: string;
+        agentId?: string;
+    }): WorkItem[];
+    /**
+     * Get blocked items across the fleet.
+     */
+    getBlocked(): WorkItem[];
+    /**
+     * Get completion stats for the fleet.
+     */
+    getStats(opts?: {
+        agentId?: string;
+        since?: string;
+    }): {
+        total: number;
+        incoming: number;
+        active: number;
+        blocked: number;
+        review: number;
+        completed: number;
+        cancelled: number;
+        avgDurationHours: number | null;
+    };
+    /**
+     * Get events for a work item.
+     */
+    getEvents(workItemId: string, limit?: number): WorkEvent[];
+    /**
+     * Search work items.
+     */
+    search(query: string, limit?: number): WorkItem[];
+    private recordEvent;
+}
+//# sourceMappingURL=work-store.d.ts.map

package/dist/work-store.d.ts.map

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