@sochdb/sochdb 0.4.0 → 0.4.1

package/dist/cjs/semantic-cache.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Semantic Cache for LLM responses
+ *
+ * Cache LLM responses with similarity-based retrieval for cost savings.
+ * Uses database prefix scanning to store and retrieve cached responses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticCache = void 0;
+/**
+ * Calculate cosine similarity between two vectors
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have same length');
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0) {
+        return 0;
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+/**
+ * Semantic Cache with vector similarity matching
+ *
+ * @example
+ * ```typescript
+ * const cache = new SemanticCache(db, 'llm_responses');
+ *
+ * // Store response
+ * await cache.put(
+ *   'What is Python?',
+ *   'Python is a high-level programming language...',
+ *   embedding,
+ *   3600  // TTL in seconds
+ * );
+ *
+ * // Check cache
+ * const hit = await cache.get(queryEmbedding, 0.85);
+ * if (hit) {
+ *   console.log(`Cache HIT: ${hit.value} (similarity: ${hit.score})`);
+ * }
+ * ```
+ */
+class SemanticCache {
+    constructor(db, cacheName) {
+        this.hits = 0;
+        this.misses = 0;
+        this.db = db;
+        this.cacheName = cacheName;
+        this.prefix = Buffer.from(`cache:${cacheName}:`);
+    }
+    /**
+     * Store a cached response
+     */
+    async put(key, value, embedding, ttlSeconds = 0, metadata) {
+        const entry = {
+            key,
+            value,
+            embedding,
+            timestamp: Date.now(),
+            ttl: ttlSeconds > 0 ? ttlSeconds : undefined,
+            metadata,
+        };
+        const entryKey = Buffer.concat([
+            this.prefix,
+            Buffer.from(key),
+        ]);
+        await this.db.put(entryKey, Buffer.from(JSON.stringify(entry)));
+    }
+    /**
+     * Retrieve cached response by similarity
+     *
+     * @param queryEmbedding - Query embedding vector
+     * @param threshold - Minimum cosine similarity (0-1)
+     * @returns Best matching cache entry or null
+     */
+    async get(queryEmbedding, threshold = 0.85) {
+        const now = Date.now();
+        let bestMatch = null;
+        let bestScore = threshold;
+        // Scan all cache entries with this prefix
+        try {
+            for await (const [_, valueBuffer] of this.db.scanPrefix(this.prefix)) {
+                const entry = JSON.parse(valueBuffer.toString());
+                // Check TTL expiration
+                if (entry.ttl && entry.timestamp) {
+                    const expiresAt = entry.timestamp + entry.ttl * 1000;
+                    if (now > expiresAt) {
+                        continue; // Skip expired entries
+                    }
+                }
+                // Calculate similarity
+                const score = cosineSimilarity(queryEmbedding, entry.embedding);
+                // Update best match
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestMatch = { ...entry, score };
+                }
+            }
+        }
+        catch (error) {
+            // If scan fails, return null
+            this.misses++;
+            return null;
+        }
+        if (bestMatch) {
+            this.hits++;
+        }
+        else {
+            this.misses++;
+        }
+        return bestMatch;
+    }
+    /**
+     * Delete a specific cache entry
+     */
+    async delete(key) {
+        const entryKey = Buffer.concat([
+            this.prefix,
+            Buffer.from(key),
+        ]);
+        await this.db.delete(entryKey);
+    }
+    /**
+     * Clear all entries in this cache
+     */
+    async clear() {
+        let deleted = 0;
+        try {
+            const toDelete = [];
+            for await (const [key] of this.db.scanPrefix(this.prefix)) {
+                toDelete.push(key);
+            }
+            for (const key of toDelete) {
+                await this.db.delete(key);
+                deleted++;
+            }
+        }
+        catch (error) {
+            // If operation fails, return count so far
+            return deleted;
+        }
+        // Reset stats
+        this.hits = 0;
+        this.misses = 0;
+        return deleted;
+    }
+    /**
+     * Get cache statistics
+     */
+    async stats() {
+        const now = Date.now();
+        let count = 0;
+        let memoryUsage = 0;
+        try {
+            for await (const [key, value] of this.db.scanPrefix(this.prefix)) {
+                const entry = JSON.parse(value.toString());
+                // Skip expired entries
+                if (entry.ttl && entry.timestamp) {
+                    const expiresAt = entry.timestamp + entry.ttl * 1000;
+                    if (now > expiresAt) {
+                        continue;
+                    }
+                }
+                count++;
+                memoryUsage += key.length + value.length;
+            }
+        }
+        catch (error) {
+            // Return partial stats if operation fails
+        }
+        const total = this.hits + this.misses;
+        const hitRate = total > 0 ? this.hits / total : 0;
+        return {
+            count,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate,
+            memoryUsage,
+        };
+    }
+    /**
+     * Purge expired entries
+     */
+    async purgeExpired() {
+        const now = Date.now();
+        let purged = 0;
+        try {
+            const toDelete = [];
+            for await (const [key, value] of this.db.scanPrefix(this.prefix)) {
+                const entry = JSON.parse(value.toString());
+                if (entry.ttl && entry.timestamp) {
+                    const expiresAt = entry.timestamp + entry.ttl * 1000;
+                    if (now > expiresAt) {
+                        toDelete.push(key);
+                    }
+                }
+            }
+            for (const key of toDelete) {
+                await this.db.delete(key);
+                purged++;
+            }
+        }
+        catch (error) {
+            // Return count so far
+            return purged;
+        }
+        return purged;
+    }
+}
+exports.SemanticCache = SemanticCache;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semantic-cache.js","sourceRoot":"","sources":["../../src/semantic-cache.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAIH;;GAEG;AACH,SAAS,gBAAgB,CAAC,CAAW,EAAE,CAAW;IAChD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,UAAU,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1B,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACrB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,UAAU,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAC5D,CAAC;AAuBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,aAAa;IAOxB,YAAY,EAAoB,EAAE,SAAiB;QAH3C,SAAI,GAAG,CAAC,CAAC;QACT,WAAM,GAAG,CAAC,CAAC;QAGjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CACP,GAAW,EACX,KAAa,EACb,SAAmB,EACnB,UAAU,GAAG,CAAC,EACd,QAA8B;QAE9B,MAAM,KAAK,GAAe;YACxB,GAAG;YACH,KAAK;YACL,SAAS;YACT,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,GAAG,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;YAC5C,QAAQ;SACT,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC;YAC7B,IAAI,CAAC,MAAM;YACX,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;SACjB,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,GAAG,CACP,cAAwB,EACxB,SAAS,GAAG,IAAI;QAEhB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,SAAS,GAAoB,IAAI,CAAC;QACtC,IAAI,SAAS,GAAG,SAAS,CAAC;QAE1B,0CAA0C;QAC1C,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACrE,MAAM,KAAK,GAAe,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAE7D,uBAAuB;gBACvB,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;oBACjC,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC;oBACrD,IAAI,GAAG,GAAG,SAAS,EAAE,CAAC;wBACpB,SAAS,CAAC,uBAAuB;oBACnC,CAAC;gBACH,CAAC;gBAED,uBAAuB;gBACvB,MAAM,KAAK,GAAG,gBAAgB,CAAC,cAAc,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;gBAEhE,oBAAoB;gBACpB,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;oBACtB,SAAS,GAAG,KAAK,CAAC;oBAClB,SAAS,GAAG,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC;gBAClC,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,6BAA6B;YAC7B,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,GAAW;QACtB,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC;YAC7B,IAAI,CAAC,MAAM;YACX,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;SACjB,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,OAAO,GAAG,CAAC,CAAC;QAEhB,IAAI,CAAC;YACH,MAAM,QAAQ,GAAa,EAAE,CAAC;YAC9B,IAAI,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC1D,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrB,CAAC;YAED,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAC3B,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC1B,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,0CAA0C;YAC1C,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,cAAc;QACd,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAEhB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,WAAW,GAAG,CAAC,CAAC;QAEpB,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjE,MAAM,KAAK,GAAe,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAEvD,uBAAuB;gBACvB,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;oBACjC,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC;oBACrD,IAAI,GAAG,GAAG,SAAS,EAAE,CAAC;wBACpB,SAAS;oBACX,CAAC;gBACH,CAAC;gBAED,KAAK,EAAE,CAAC;gBACR,WAAW,IAAI,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;YAC3C,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,0CAA0C;QAC5C,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;QACtC,MAAM,OAAO,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAElD,OAAO;YACL,KAAK;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,OAAO;YACP,WAAW;SACZ,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY;QAChB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,IAAI,CAAC;YACH,MAAM,QAAQ,GAAa,EAAE,CAAC;YAE9B,IAAI,KAAK,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjE,MAAM,KAAK,GAAe,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAEvD,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;oBACjC,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC;oBACrD,IAAI,GAAG,GAAG,SAAS,EAAE,CAAC;wBACpB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACrB,CAAC;gBACH,CAAC;YACH,CAAC;YAED,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAC3B,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC1B,MAAM,EAAE,CAAC;YACX,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sBAAsB;YACtB,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA1MD,sCA0MC","sourcesContent":["/**\n * Semantic Cache for LLM responses\n * \n * Cache LLM responses with similarity-based retrieval for cost savings.\n * Uses database prefix scanning to store and retrieve cached responses.\n */\n\nimport { EmbeddedDatabase } from './embedded';\n\n/**\n * Calculate cosine similarity between two vectors\n */\nfunction cosineSimilarity(a: number[], b: number[]): number {\n  if (a.length !== b.length) {\n    throw new Error('Vectors must have same length');\n  }\n\n  let dotProduct = 0;\n  let normA = 0;\n  let normB = 0;\n\n  for (let i = 0; i < a.length; i++) {\n    dotProduct += a[i] * b[i];\n    normA += a[i] * a[i];\n    normB += b[i] * b[i];\n  }\n\n  if (normA === 0 || normB === 0) {\n    return 0;\n  }\n\n  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));\n}\n\nexport interface CacheEntry {\n  key: string;\n  value: string;\n  embedding: number[];\n  timestamp: number;\n  ttl?: number;\n  metadata?: Record<string, any>;\n}\n\nexport interface CacheHit extends CacheEntry {\n  score: number;\n}\n\nexport interface CacheStats {\n  count: number;\n  hits: number;\n  misses: number;\n  hitRate: number;\n  memoryUsage: number;\n}\n\n/**\n * Semantic Cache with vector similarity matching\n * \n * @example\n * ```typescript\n * const cache = new SemanticCache(db, 'llm_responses');\n * \n * // Store response\n * await cache.put(\n *   'What is Python?',\n *   'Python is a high-level programming language...',\n *   embedding,\n *   3600  // TTL in seconds\n * );\n * \n * // Check cache\n * const hit = await cache.get(queryEmbedding, 0.85);\n * if (hit) {\n *   console.log(`Cache HIT: ${hit.value} (similarity: ${hit.score})`);\n * }\n * ```\n */\nexport class SemanticCache {\n  private db: EmbeddedDatabase;\n  private cacheName: string;\n  private prefix: Buffer;\n  private hits = 0;\n  private misses = 0;\n\n  constructor(db: EmbeddedDatabase, cacheName: string) {\n    this.db = db;\n    this.cacheName = cacheName;\n    this.prefix = Buffer.from(`cache:${cacheName}:`);\n  }\n\n  /**\n   * Store a cached response\n   */\n  async put(\n    key: string,\n    value: string,\n    embedding: number[],\n    ttlSeconds = 0,\n    metadata?: Record<string, any>\n  ): Promise<void> {\n    const entry: CacheEntry = {\n      key,\n      value,\n      embedding,\n      timestamp: Date.now(),\n      ttl: ttlSeconds > 0 ? ttlSeconds : undefined,\n      metadata,\n    };\n\n    const entryKey = Buffer.concat([\n      this.prefix,\n      Buffer.from(key),\n    ]);\n\n    await this.db.put(entryKey, Buffer.from(JSON.stringify(entry)));\n  }\n\n  /**\n   * Retrieve cached response by similarity\n   * \n   * @param queryEmbedding - Query embedding vector\n   * @param threshold - Minimum cosine similarity (0-1)\n   * @returns Best matching cache entry or null\n   */\n  async get(\n    queryEmbedding: number[],\n    threshold = 0.85\n  ): Promise<CacheHit | null> {\n    const now = Date.now();\n    let bestMatch: CacheHit | null = null;\n    let bestScore = threshold;\n\n    // Scan all cache entries with this prefix\n    try {\n      for await (const [_, valueBuffer] of this.db.scanPrefix(this.prefix)) {\n        const entry: CacheEntry = JSON.parse(valueBuffer.toString());\n\n        // Check TTL expiration\n        if (entry.ttl && entry.timestamp) {\n          const expiresAt = entry.timestamp + entry.ttl * 1000;\n          if (now > expiresAt) {\n            continue; // Skip expired entries\n          }\n        }\n\n        // Calculate similarity\n        const score = cosineSimilarity(queryEmbedding, entry.embedding);\n\n        // Update best match\n        if (score > bestScore) {\n          bestScore = score;\n          bestMatch = { ...entry, score };\n        }\n      }\n    } catch (error) {\n      // If scan fails, return null\n      this.misses++;\n      return null;\n    }\n\n    if (bestMatch) {\n      this.hits++;\n    } else {\n      this.misses++;\n    }\n\n    return bestMatch;\n  }\n\n  /**\n   * Delete a specific cache entry\n   */\n  async delete(key: string): Promise<void> {\n    const entryKey = Buffer.concat([\n      this.prefix,\n      Buffer.from(key),\n    ]);\n    await this.db.delete(entryKey);\n  }\n\n  /**\n   * Clear all entries in this cache\n   */\n  async clear(): Promise<number> {\n    let deleted = 0;\n\n    try {\n      const toDelete: Buffer[] = [];\n      for await (const [key] of this.db.scanPrefix(this.prefix)) {\n        toDelete.push(key);\n      }\n\n      for (const key of toDelete) {\n        await this.db.delete(key);\n        deleted++;\n      }\n    } catch (error) {\n      // If operation fails, return count so far\n      return deleted;\n    }\n\n    // Reset stats\n    this.hits = 0;\n    this.misses = 0;\n\n    return deleted;\n  }\n\n  /**\n   * Get cache statistics\n   */\n  async stats(): Promise<CacheStats> {\n    const now = Date.now();\n    let count = 0;\n    let memoryUsage = 0;\n\n    try {\n      for await (const [key, value] of this.db.scanPrefix(this.prefix)) {\n        const entry: CacheEntry = JSON.parse(value.toString());\n        \n        // Skip expired entries\n        if (entry.ttl && entry.timestamp) {\n          const expiresAt = entry.timestamp + entry.ttl * 1000;\n          if (now > expiresAt) {\n            continue;\n          }\n        }\n\n        count++;\n        memoryUsage += key.length + value.length;\n      }\n    } catch (error) {\n      // Return partial stats if operation fails\n    }\n\n    const total = this.hits + this.misses;\n    const hitRate = total > 0 ? this.hits / total : 0;\n\n    return {\n      count,\n      hits: this.hits,\n      misses: this.misses,\n      hitRate,\n      memoryUsage,\n    };\n  }\n\n  /**\n   * Purge expired entries\n   */\n  async purgeExpired(): Promise<number> {\n    const now = Date.now();\n    let purged = 0;\n\n    try {\n      const toDelete: Buffer[] = [];\n\n      for await (const [key, value] of this.db.scanPrefix(this.prefix)) {\n        const entry: CacheEntry = JSON.parse(value.toString());\n        \n        if (entry.ttl && entry.timestamp) {\n          const expiresAt = entry.timestamp + entry.ttl * 1000;\n          if (now > expiresAt) {\n            toDelete.push(key);\n          }\n        }\n      }\n\n      for (const key of toDelete) {\n        await this.db.delete(key);\n        purged++;\n      }\n    } catch (error) {\n      // Return count so far\n      return purged;\n    }\n\n    return purged;\n  }\n}\n"]}

package/dist/esm/context-builder.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Context Query Builder for LLM Context Assembly
+ *
+ * Token-aware context assembly with priority-based truncation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextQueryBuilder = exports.TruncationStrategy = exports.ContextOutputFormat = void 0;
+exports.createContextBuilder = createContextBuilder;
+var ContextOutputFormat;
+(function (ContextOutputFormat) {
+    ContextOutputFormat["TOON"] = "toon";
+    ContextOutputFormat["JSON"] = "json";
+    ContextOutputFormat["MARKDOWN"] = "markdown";
+})(ContextOutputFormat || (exports.ContextOutputFormat = ContextOutputFormat = {}));
+var TruncationStrategy;
+(function (TruncationStrategy) {
+    TruncationStrategy["TAIL_DROP"] = "tail_drop";
+    TruncationStrategy["HEAD_DROP"] = "head_drop";
+    TruncationStrategy["PROPORTIONAL"] = "proportional";
+})(TruncationStrategy || (exports.TruncationStrategy = TruncationStrategy = {}));
+/**
+ * Context Query Builder for assembling LLM context
+ */
+class ContextQueryBuilder {
+    sessionId;
+    tokenBudget = 4096;
+    format = ContextOutputFormat.TOON;
+    truncation = TruncationStrategy.TAIL_DROP;
+    sections = [];
+    currentSection;
+    /**
+     * Set session ID for context
+     */
+    forSession(sessionId) {
+        this.sessionId = sessionId;
+        return this;
+    }
+    /**
+     * Set token budget
+     */
+    withBudget(tokens) {
+        this.tokenBudget = tokens;
+        return this;
+    }
+    /**
+     * Set output format
+     */
+    setFormat(format) {
+        this.format = format;
+        return this;
+    }
+    /**
+     * Set truncation strategy
+     */
+    setTruncation(strategy) {
+        this.truncation = strategy;
+        return this;
+    }
+    /**
+     * Add literal text section
+     */
+    literal(name, priority, text) {
+        const tokenCount = this.estimateTokens(text);
+        this.sections.push({
+            name,
+            priority,
+            content: text,
+            tokenCount,
+        });
+        return this;
+    }
+    /**
+     * Start a new section
+     */
+    section(name, priority) {
+        this.currentSection = {
+            name,
+            priority,
+            content: '',
+            tokenCount: 0,
+        };
+        return this;
+    }
+    /**
+     * Add content to current section
+     */
+    get(path) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `GET ${path}\n`;
+        return this;
+    }
+    /**
+     * Add last N records query
+     */
+    last(n, table) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `LAST ${n} FROM ${table}\n`;
+        return this;
+    }
+    /**
+     * Add where equals condition
+     */
+    whereEq(field, value) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `WHERE ${field} = ${JSON.stringify(value)}\n`;
+        return this;
+    }
+    /**
+     * Add vector search
+     */
+    search(collection, embedding, k) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `SEARCH ${collection} WITH ${embedding} LIMIT ${k}\n`;
+        return this;
+    }
+    /**
+     * Add SQL query
+     */
+    sql(query) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `SQL: ${query}\n`;
+        return this;
+    }
+    /**
+     * Finish current section
+     */
+    done() {
+        if (this.currentSection) {
+            this.currentSection.tokenCount = this.estimateTokens(this.currentSection.content);
+            this.sections.push(this.currentSection);
+            this.currentSection = undefined;
+        }
+        return this;
+    }
+    /**
+     * Execute and build context
+     */
+    execute() {
+        // Finish any pending section
+        if (this.currentSection) {
+            this.done();
+        }
+        // Sort sections by priority (lower = higher priority)
+        const sortedSections = [...this.sections].sort((a, b) => a.priority - b.priority);
+        // Calculate total tokens
+        let totalTokens = sortedSections.reduce((sum, s) => sum + s.tokenCount, 0);
+        // Truncate if needed
+        const truncatedSections = [];
+        const includedSections = [];
+        if (totalTokens <= this.tokenBudget) {
+            // No truncation needed
+            for (const section of sortedSections) {
+                includedSections.push(section);
+                truncatedSections.push({
+                    name: section.name,
+                    tokenCount: section.tokenCount,
+                    truncated: false,
+                });
+            }
+        }
+        else {
+            // Apply truncation strategy
+            let remainingBudget = this.tokenBudget;
+            if (this.truncation === TruncationStrategy.TAIL_DROP) {
+                // Include sections in priority order until budget exhausted
+                for (const section of sortedSections) {
+                    if (section.tokenCount <= remainingBudget) {
+                        includedSections.push(section);
+                        remainingBudget -= section.tokenCount;
+                        truncatedSections.push({
+                            name: section.name,
+                            tokenCount: section.tokenCount,
+                            truncated: false,
+                        });
+                    }
+                    else {
+                        truncatedSections.push({
+                            name: section.name,
+                            tokenCount: 0,
+                            truncated: true,
+                        });
+                    }
+                }
+            }
+            else if (this.truncation === TruncationStrategy.PROPORTIONAL) {
+                // Proportionally reduce all sections
+                const ratio = this.tokenBudget / totalTokens;
+                for (const section of sortedSections) {
+                    const allocatedTokens = Math.floor(section.tokenCount * ratio);
+                    const truncatedContent = this.truncateText(section.content, allocatedTokens);
+                    includedSections.push({
+                        ...section,
+                        content: truncatedContent,
+                        tokenCount: allocatedTokens,
+                    });
+                    truncatedSections.push({
+                        name: section.name,
+                        tokenCount: allocatedTokens,
+                        truncated: allocatedTokens < section.tokenCount,
+                    });
+                }
+            }
+        }
+        // Build final context based on format
+        let text = '';
+        let actualTokens = 0;
+        if (this.format === ContextOutputFormat.TOON) {
+            text = this.buildToonFormat(includedSections);
+        }
+        else if (this.format === ContextOutputFormat.JSON) {
+            text = this.buildJsonFormat(includedSections);
+        }
+        else {
+            text = this.buildMarkdownFormat(includedSections);
+        }
+        actualTokens = this.estimateTokens(text);
+        return {
+            text,
+            tokenCount: actualTokens,
+            sections: truncatedSections,
+        };
+    }
+    // Helper methods
+    estimateTokens(text) {
+        // Rough estimate: ~4 characters per token for English
+        return Math.ceil(text.length / 4);
+    }
+    truncateText(text, maxTokens) {
+        const maxChars = maxTokens * 4;
+        if (text.length <= maxChars) {
+            return text;
+        }
+        return text.substring(0, maxChars) + '...';
+    }
+    buildToonFormat(sections) {
+        const lines = [];
+        for (const section of sections) {
+            lines.push(`[${section.name}]`);
+            lines.push(section.content);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    buildJsonFormat(sections) {
+        const obj = {};
+        for (const section of sections) {
+            obj[section.name] = section.content;
+        }
+        return JSON.stringify(obj, null, 2);
+    }
+    buildMarkdownFormat(sections) {
+        const lines = [];
+        for (const section of sections) {
+            lines.push(`## ${section.name}`);
+            lines.push('');
+            lines.push(section.content);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+exports.ContextQueryBuilder = ContextQueryBuilder;
+/**
+ * Create a context query builder
+ */
+function createContextBuilder() {
+    return new ContextQueryBuilder();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-builder.js","sourceRoot":"","sources":["../../src/context-builder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Context Query Builder for LLM Context Assembly\n * \n * Token-aware context assembly with priority-based truncation.\n */\n\nexport enum ContextOutputFormat {\n  TOON = 'toon',\n  JSON = 'json',\n  MARKDOWN = 'markdown',\n}\n\nexport enum TruncationStrategy {\n  TAIL_DROP = 'tail_drop',       // Drop from end\n  HEAD_DROP = 'head_drop',       // Drop from beginning\n  PROPORTIONAL = 'proportional', // Proportional across sections\n}\n\ninterface Section {\n  name: string;\n  priority: number;\n  content: string;\n  tokenCount: number;\n}\n\nexport interface ContextResult {\n  text: string;\n  tokenCount: number;\n  sections: Array<{ name: string; tokenCount: number; truncated: boolean }>;\n}\n\n/**\n * Context Query Builder for assembling LLM context\n */\nexport class ContextQueryBuilder {\n  private sessionId?: string;\n  private tokenBudget: number = 4096;\n  private format: ContextOutputFormat = ContextOutputFormat.TOON;\n  private truncation: TruncationStrategy = TruncationStrategy.TAIL_DROP;\n  private sections: Section[] = [];\n  private currentSection?: Section;\n\n  /**\n   * Set session ID for context\n   */\n  forSession(sessionId: string): this {\n    this.sessionId = sessionId;\n    return this;\n  }\n\n  /**\n   * Set token budget\n   */\n  withBudget(tokens: number): this {\n    this.tokenBudget = tokens;\n    return this;\n  }\n\n  /**\n   * Set output format\n   */\n  setFormat(format: ContextOutputFormat): this {\n    this.format = format;\n    return this;\n  }\n\n  /**\n   * Set truncation strategy\n   */\n  setTruncation(strategy: TruncationStrategy): this {\n    this.truncation = strategy;\n    return this;\n  }\n\n  /**\n   * Add literal text section\n   */\n  literal(name: string, priority: number, text: string): this {\n    const tokenCount = this.estimateTokens(text);\n    this.sections.push({\n      name,\n      priority,\n      content: text,\n      tokenCount,\n    });\n    return this;\n  }\n\n  /**\n   * Start a new section\n   */\n  section(name: string, priority: number): this {\n    this.currentSection = {\n      name,\n      priority,\n      content: '',\n      tokenCount: 0,\n    };\n    return this;\n  }\n\n  /**\n   * Add content to current section\n   */\n  get(path: string): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `GET ${path}\\n`;\n    return this;\n  }\n\n  /**\n   * Add last N records query\n   */\n  last(n: number, table: string): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `LAST ${n} FROM ${table}\\n`;\n    return this;\n  }\n\n  /**\n   * Add where equals condition\n   */\n  whereEq(field: string, value: any): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `WHERE ${field} = ${JSON.stringify(value)}\\n`;\n    return this;\n  }\n\n  /**\n   * Add vector search\n   */\n  search(collection: string, embedding: string, k: number): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `SEARCH ${collection} WITH ${embedding} LIMIT ${k}\\n`;\n    return this;\n  }\n\n  /**\n   * Add SQL query\n   */\n  sql(query: string): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `SQL: ${query}\\n`;\n    return this;\n  }\n\n  /**\n   * Finish current section\n   */\n  done(): this {\n    if (this.currentSection) {\n      this.currentSection.tokenCount = this.estimateTokens(this.currentSection.content);\n      this.sections.push(this.currentSection);\n      this.currentSection = undefined;\n    }\n    return this;\n  }\n\n  /**\n   * Execute and build context\n   */\n  execute(): ContextResult {\n    // Finish any pending section\n    if (this.currentSection) {\n      this.done();\n    }\n\n    // Sort sections by priority (lower = higher priority)\n    const sortedSections = [...this.sections].sort((a, b) => a.priority - b.priority);\n\n    // Calculate total tokens\n    let totalTokens = sortedSections.reduce((sum, s) => sum + s.tokenCount, 0);\n\n    // Truncate if needed\n    const truncatedSections: Array<{ name: string; tokenCount: number; truncated: boolean }> = [];\n    const includedSections: Section[] = [];\n\n    if (totalTokens <= this.tokenBudget) {\n      // No truncation needed\n      for (const section of sortedSections) {\n        includedSections.push(section);\n        truncatedSections.push({\n          name: section.name,\n          tokenCount: section.tokenCount,\n          truncated: false,\n        });\n      }\n    } else {\n      // Apply truncation strategy\n      let remainingBudget = this.tokenBudget;\n\n      if (this.truncation === TruncationStrategy.TAIL_DROP) {\n        // Include sections in priority order until budget exhausted\n        for (const section of sortedSections) {\n          if (section.tokenCount <= remainingBudget) {\n            includedSections.push(section);\n            remainingBudget -= section.tokenCount;\n            truncatedSections.push({\n              name: section.name,\n              tokenCount: section.tokenCount,\n              truncated: false,\n            });\n          } else {\n            truncatedSections.push({\n              name: section.name,\n              tokenCount: 0,\n              truncated: true,\n            });\n          }\n        }\n      } else if (this.truncation === TruncationStrategy.PROPORTIONAL) {\n        // Proportionally reduce all sections\n        const ratio = this.tokenBudget / totalTokens;\n        for (const section of sortedSections) {\n          const allocatedTokens = Math.floor(section.tokenCount * ratio);\n          const truncatedContent = this.truncateText(section.content, allocatedTokens);\n          includedSections.push({\n            ...section,\n            content: truncatedContent,\n            tokenCount: allocatedTokens,\n          });\n          truncatedSections.push({\n            name: section.name,\n            tokenCount: allocatedTokens,\n            truncated: allocatedTokens < section.tokenCount,\n          });\n        }\n      }\n    }\n\n    // Build final context based on format\n    let text = '';\n    let actualTokens = 0;\n\n    if (this.format === ContextOutputFormat.TOON) {\n      text = this.buildToonFormat(includedSections);\n    } else if (this.format === ContextOutputFormat.JSON) {\n      text = this.buildJsonFormat(includedSections);\n    } else {\n      text = this.buildMarkdownFormat(includedSections);\n    }\n\n    actualTokens = this.estimateTokens(text);\n\n    return {\n      text,\n      tokenCount: actualTokens,\n      sections: truncatedSections,\n    };\n  }\n\n  // Helper methods\n  private estimateTokens(text: string): number {\n    // Rough estimate: ~4 characters per token for English\n    return Math.ceil(text.length / 4);\n  }\n\n  private truncateText(text: string, maxTokens: number): string {\n    const maxChars = maxTokens * 4;\n    if (text.length <= maxChars) {\n      return text;\n    }\n    return text.substring(0, maxChars) + '...';\n  }\n\n  private buildToonFormat(sections: Section[]): string {\n    const lines: string[] = [];\n    \n    for (const section of sections) {\n      lines.push(`[${section.name}]`);\n      lines.push(section.content);\n      lines.push('');\n    }\n    \n    return lines.join('\\n');\n  }\n\n  private buildJsonFormat(sections: Section[]): string {\n    const obj: Record<string, string> = {};\n    \n    for (const section of sections) {\n      obj[section.name] = section.content;\n    }\n    \n    return JSON.stringify(obj, null, 2);\n  }\n\n  private buildMarkdownFormat(sections: Section[]): string {\n    const lines: string[] = [];\n    \n    for (const section of sections) {\n      lines.push(`## ${section.name}`);\n      lines.push('');\n      lines.push(section.content);\n      lines.push('');\n    }\n    \n    return lines.join('\\n');\n  }\n}\n\n/**\n * Create a context query builder\n */\nexport function createContextBuilder(): ContextQueryBuilder {\n  return new ContextQueryBuilder();\n}\n"]}