kiro-memory 1.9.0 → 2.1.0

package/plugin/dist/services/search/index.js

@@ -22,13 +22,13 @@ __export(Search_exports, {
   searchObservationsLIKE: () => searchObservationsLIKE,
   searchSummariesFiltered: () => searchSummariesFiltered
 });
-import { existsSync as existsSync3, statSync } from "fs";
+import { existsSync as existsSync2, statSync } from "fs";
 function escapeLikePattern(input) {
   return input.replace(/[%_\\]/g, "\\$&");
 }
 function sanitizeFTS5Query(query) {
   const trimmed = query.length > 1e4 ? query.substring(0, 1e4) : query;
-  const terms = trimmed.replace(/[""]/g, "").split(/\s+/).filter((t) => t.length > 0).slice(0, 100).map((t) => `"${t}"`);
+  const terms = trimmed.replace(/[""\u0022]/g, "").split(/\s+/).filter((t) => t.length > 0).slice(0, 100).map((t) => `"${t}"`);
   return terms.join(" ");
 }
 function searchObservationsFTS(db, query, filters = {}) {
@@ -193,26 +193,38 @@ function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
   return [...before, ...self, ...after];
 }
 function getProjectStats(db, project) {
-  const obsStmt = db.query("SELECT COUNT(*) as count FROM observations WHERE project = ?");
-  const sumStmt = db.query("SELECT COUNT(*) as count FROM summaries WHERE project = ?");
-  const sesStmt = db.query("SELECT COUNT(*) as count FROM sessions WHERE project = ?");
-  const prmStmt = db.query("SELECT COUNT(*) as count FROM prompts WHERE project = ?");
-  const discoveryStmt = db.query(
-    "SELECT COALESCE(SUM(discovery_tokens), 0) as total FROM observations WHERE project = ?"
-  );
-  const discoveryTokens = discoveryStmt.get(project)?.total || 0;
-  const readStmt = db.query(
-    `SELECT COALESCE(SUM(
-      CAST((LENGTH(COALESCE(title, '')) + LENGTH(COALESCE(narrative, ''))) / 4 AS INTEGER)
-    ), 0) as total FROM observations WHERE project = ?`
-  );
-  const readTokens = readStmt.get(project)?.total || 0;
+  const sql = `
+    WITH
+      obs_stats AS (
+        SELECT
+          COUNT(*) as count,
+          COALESCE(SUM(discovery_tokens), 0) as discovery_tokens,
+          COALESCE(SUM(
+            CAST((LENGTH(COALESCE(title, '')) + LENGTH(COALESCE(narrative, ''))) / 4 AS INTEGER)
+          ), 0) as read_tokens
+        FROM observations WHERE project = ?
+      ),
+      sum_count AS (SELECT COUNT(*) as count FROM summaries WHERE project = ?),
+      ses_count AS (SELECT COUNT(*) as count FROM sessions WHERE project = ?),
+      prm_count AS (SELECT COUNT(*) as count FROM prompts WHERE project = ?)
+    SELECT
+      obs_stats.count as observations,
+      obs_stats.discovery_tokens,
+      obs_stats.read_tokens,
+      sum_count.count as summaries,
+      ses_count.count as sessions,
+      prm_count.count as prompts
+    FROM obs_stats, sum_count, ses_count, prm_count
+  `;
+  const row = db.query(sql).get(project, project, project, project);
+  const discoveryTokens = row?.discovery_tokens || 0;
+  const readTokens = row?.read_tokens || 0;
   const savings = Math.max(0, discoveryTokens - readTokens);
   return {
-    observations: obsStmt.get(project)?.count || 0,
-    summaries: sumStmt.get(project)?.count || 0,
-    sessions: sesStmt.get(project)?.count || 0,
-    prompts: prmStmt.get(project)?.count || 0,
+    observations: row?.observations || 0,
+    summaries: row?.summaries || 0,
+    sessions: row?.sessions || 0,
+    prompts: row?.prompts || 0,
     tokenEconomics: { discoveryTokens, readTokens, savings }
   };
 }
@@ -230,7 +242,7 @@ function getStaleObservations(db, project) {
     let isStale = false;
     for (const filepath of files) {
       try {
-        if (!existsSync3(filepath)) continue;
+        if (!existsSync2(filepath)) continue;
         const stat = statSync(filepath);
         if (stat.mtimeMs > obs.created_at_epoch) {
           isStale = true;
@@ -346,9 +358,25 @@ function consolidateObservations(db, project, options = {}) {
     ORDER BY cnt DESC
   `).all(project, minGroupSize);
   if (groups.length === 0) return { merged: 0, removed: 0 };
-  let totalMerged = 0;
-  let totalRemoved = 0;
+  if (options.dryRun) {
+    let totalMerged = 0;
+    let totalRemoved = 0;
+    for (const group of groups) {
+      const obsIds = group.ids.split(",").map(Number);
+      const placeholders = obsIds.map(() => "?").join(",");
+      const count = db.query(
+        `SELECT COUNT(*) as cnt FROM observations WHERE id IN (${placeholders})`
+      ).get(...obsIds)?.cnt || 0;
+      if (count >= minGroupSize) {
+        totalMerged += 1;
+        totalRemoved += count - 1;
+      }
+    }
+    return { merged: totalMerged, removed: totalRemoved };
+  }
   const runConsolidation = db.transaction(() => {
+    let merged = 0;
+    let removed = 0;
     for (const group of groups) {
       const obsIds = group.ids.split(",").map(Number);
       const placeholders = obsIds.map(() => "?").join(",");
@@ -356,11 +384,6 @@ function consolidateObservations(db, project, options = {}) {
         `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`
       ).all(...obsIds);
       if (observations.length < minGroupSize) continue;
-      if (options.dryRun) {
-        totalMerged += 1;
-        totalRemoved += observations.length - 1;
-        continue;
-      }
       const keeper = observations[0];
       const others = observations.slice(1);
       const uniqueTexts = /* @__PURE__ */ new Set();
@@ -373,18 +396,18 @@ function consolidateObservations(db, project, options = {}) {
       const consolidatedText = Array.from(uniqueTexts).join("\n---\n").substring(0, 1e5);
       db.run(
         "UPDATE observations SET text = ?, title = ? WHERE id = ?",
-        [consolidatedText, `[consolidato x${observations.length}] ${keeper.title}`, keeper.id]
+        [consolidatedText, `[consolidated x${observations.length}] ${keeper.title}`, keeper.id]
       );
       const removeIds = others.map((o) => o.id);
       const removePlaceholders = removeIds.map(() => "?").join(",");
       db.run(`DELETE FROM observations WHERE id IN (${removePlaceholders})`, removeIds);
       db.run(`DELETE FROM observation_embeddings WHERE observation_id IN (${removePlaceholders})`, removeIds);
-      totalMerged += 1;
-      totalRemoved += removeIds.length;
+      merged += 1;
+      removed += removeIds.length;
     }
+    return { merged, removed };
   });
-  runConsolidation();
-  return { merged: totalMerged, removed: totalRemoved };
+  return runConsolidation();
 }
 var init_Observations = __esm({
   "src/services/sqlite/Observations.ts"() {
@@ -392,12 +415,6 @@ var init_Observations = __esm({
   }
 });
 
-// src/services/search/ChromaManager.ts
-import { ChromaClient } from "chromadb";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-
 // src/utils/logger.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
 import { join } from "path";
@@ -617,135 +634,6 @@ ${data.stack}` : ` ${data.message}`;
 };
 var logger = new Logger();
 
-// src/services/search/ChromaManager.ts
-var VECTOR_DB_DIR = join2(homedir2(), ".contextkit", "vector-db");
-var ChromaManager = class {
-  client;
-  collection = null;
-  isAvailable = false;
-  constructor() {
-    if (!existsSync2(VECTOR_DB_DIR)) {
-      mkdirSync2(VECTOR_DB_DIR, { recursive: true });
-    }
-    this.client = new ChromaClient({
-      path: process.env.CHROMADB_URL || "http://localhost:8000"
-    });
-  }
-  /**
-   * Initialize ChromaDB connection and collection
-   */
-  async initialize() {
-    try {
-      await this.client.heartbeat();
-      this.collection = await this.client.getOrCreateCollection({
-        name: "kiro-memory-observations",
-        metadata: { description: "Kiro Memory observation embeddings" }
-      });
-      this.isAvailable = true;
-      logger.info("CHROMA", "ChromaDB initialized successfully");
-      return true;
-    } catch (error) {
-      logger.warn("CHROMA", "ChromaDB not available, falling back to SQLite search", {}, error);
-      this.isAvailable = false;
-      return false;
-    }
-  }
-  /**
-   * Add observation embedding to ChromaDB
-   */
-  async addObservation(id, content, metadata) {
-    if (!this.isAvailable || !this.collection) {
-      logger.debug("CHROMA", "ChromaDB not available, skipping embedding");
-      return;
-    }
-    try {
-      await this.collection.add({
-        ids: [id],
-        documents: [content],
-        metadatas: [metadata]
-      });
-      logger.debug("CHROMA", `Added observation ${id} to vector DB`);
-    } catch (error) {
-      logger.error("CHROMA", `Failed to add observation ${id}`, {}, error);
-    }
-  }
-  /**
-   * Search observations by semantic similarity
-   */
-  async search(query, options = {}) {
-    if (!this.isAvailable || !this.collection) {
-      logger.debug("CHROMA", "ChromaDB not available, returning empty results");
-      return [];
-    }
-    try {
-      const where = options.project ? { project: options.project } : void 0;
-      const results = await this.collection.query({
-        queryTexts: [query],
-        nResults: options.limit || 10,
-        where
-      });
-      const hits = [];
-      if (results.ids && results.ids[0]) {
-        for (let i = 0; i < results.ids[0].length; i++) {
-          hits.push({
-            id: results.ids[0][i],
-            content: results.documents?.[0]?.[i] || "",
-            metadata: results.metadatas?.[0]?.[i] || {},
-            distance: results.distances?.[0]?.[i] || 0
-          });
-        }
-      }
-      logger.debug("CHROMA", `Search returned ${hits.length} results`);
-      return hits;
-    } catch (error) {
-      logger.error("CHROMA", "Search failed", {}, error);
-      return [];
-    }
-  }
-  /**
-   * Delete observation from ChromaDB
-   */
-  async deleteObservation(id) {
-    if (!this.isAvailable || !this.collection) {
-      return;
-    }
-    try {
-      await this.collection.delete({ ids: [id] });
-      logger.debug("CHROMA", `Deleted observation ${id}`);
-    } catch (error) {
-      logger.error("CHROMA", `Failed to delete observation ${id}`, {}, error);
-    }
-  }
-  /**
-   * Check if ChromaDB is available
-   */
-  isChromaAvailable() {
-    return this.isAvailable;
-  }
-  /**
-   * Get collection stats
-   */
-  async getStats() {
-    if (!this.isAvailable || !this.collection) {
-      return { count: 0 };
-    }
-    try {
-      const count = await this.collection.count();
-      return { count };
-    } catch (error) {
-      logger.error("CHROMA", "Failed to get stats", {}, error);
-      return { count: 0 };
-    }
-  }
-};
-var chromaManager = null;
-function getChromaManager() {
-  if (!chromaManager) {
-    chromaManager = new ChromaManager();
-  }
-  return chromaManager;
-}
-
 // src/services/search/EmbeddingService.ts
 var EmbeddingService = class {
   provider = null;
@@ -753,8 +641,8 @@ var EmbeddingService = class {
   initialized = false;
   initializing = null;
   /**
-   * Inizializza il servizio di embedding.
-   * Tenta fastembed, poi @huggingface/transformers, poi fallback a null.
+   * Initialize the embedding service.
+   * Tries fastembed, then @huggingface/transformers, then fallback to null.
    */
   async initialize() {
     if (this.initialized) return this.provider !== null;
@@ -775,11 +663,11 @@ var EmbeddingService = class {
         });
         this.provider = "fastembed";
         this.initialized = true;
-        logger.info("EMBEDDING", "Inizializzato con fastembed (BGE-small-en-v1.5)");
+        logger.info("EMBEDDING", "Initialized with fastembed (BGE-small-en-v1.5)");
         return true;
       }
     } catch (error) {
-      logger.debug("EMBEDDING", `fastembed non disponibile: ${error}`);
+      logger.debug("EMBEDDING", `fastembed not available: ${error}`);
     }
     try {
       const transformers = await import("@huggingface/transformers");
@@ -790,20 +678,20 @@ var EmbeddingService = class {
         });
         this.provider = "transformers";
         this.initialized = true;
-        logger.info("EMBEDDING", "Inizializzato con @huggingface/transformers (all-MiniLM-L6-v2)");
+        logger.info("EMBEDDING", "Initialized with @huggingface/transformers (all-MiniLM-L6-v2)");
         return true;
       }
     } catch (error) {
-      logger.debug("EMBEDDING", `@huggingface/transformers non disponibile: ${error}`);
+      logger.debug("EMBEDDING", `@huggingface/transformers not available: ${error}`);
     }
     this.provider = null;
     this.initialized = true;
-    logger.warn("EMBEDDING", "Nessun provider embedding disponibile, ricerca semantica disabilitata");
+    logger.warn("EMBEDDING", "No embedding provider available, semantic search disabled");
     return false;
   }
   /**
-   * Genera embedding per un singolo testo.
-   * Ritorna Float32Array con 384 dimensioni, o null se non disponibile.
+   * Generate embedding for a single text.
+   * Returns Float32Array with 384 dimensions, or null if not available.
    */
   async embed(text) {
     if (!this.initialized) await this.initialize();
@@ -816,46 +704,111 @@ var EmbeddingService = class {
         return await this._embedTransformers(truncated);
       }
     } catch (error) {
-      logger.error("EMBEDDING", `Errore generazione embedding: ${error}`);
+      logger.error("EMBEDDING", `Error generating embedding: ${error}`);
     }
     return null;
   }
   /**
-   * Genera embeddings in batch.
+   * Generate embeddings in batch.
+   * Uses native batch support when available (fastembed, transformers),
+   * falls back to serial processing on batch failure.
    */
   async embedBatch(texts) {
     if (!this.initialized) await this.initialize();
     if (!this.provider || !this.model) return texts.map(() => null);
-    const results = [];
-    for (const text of texts) {
-      try {
-        const embedding = await this.embed(text);
-        results.push(embedding);
-      } catch {
-        results.push(null);
+    if (texts.length === 0) return [];
+    const truncated = texts.map((t) => t.substring(0, 2e3));
+    try {
+      if (this.provider === "fastembed") {
+        return await this._embedBatchFastembed(truncated);
+      } else if (this.provider === "transformers") {
+        return await this._embedBatchTransformers(truncated);
       }
+    } catch (error) {
+      logger.warn("EMBEDDING", `Batch embedding failed, falling back to serial: ${error}`);
     }
-    return results;
+    return this._embedBatchSerial(truncated);
   }
   /**
-   * Verifica se il servizio è disponibile.
+   * Check if the service is available.
    */
   isAvailable() {
     return this.initialized && this.provider !== null;
   }
   /**
-   * Nome del provider attivo.
+   * Name of the active provider.
    */
   getProvider() {
     return this.provider;
   }
   /**
-   * Dimensioni del vettore embedding.
+   * Embedding vector dimensions.
    */
   getDimensions() {
     return 384;
   }
-  // --- Provider specifici ---
+  // --- Batch implementations ---
+  /**
+   * Native batch embedding with fastembed.
+   * FlagEmbedding.embed() accepts string[] and returns an async iterable of batches.
+   */
+  async _embedBatchFastembed(texts) {
+    const results = [];
+    const embeddings = this.model.embed(texts, texts.length);
+    for await (const batch of embeddings) {
+      if (batch) {
+        for (const vec of batch) {
+          results.push(vec instanceof Float32Array ? vec : new Float32Array(vec));
+        }
+      }
+    }
+    while (results.length < texts.length) {
+      results.push(null);
+    }
+    return results;
+  }
+  /**
+   * Batch embedding with @huggingface/transformers pipeline.
+   * The pipeline accepts string[] and returns a Tensor with shape [N, dims].
+   */
+  async _embedBatchTransformers(texts) {
+    const output = await this.model(texts, {
+      pooling: "mean",
+      normalize: true
+    });
+    if (!output?.data) {
+      return texts.map(() => null);
+    }
+    const dims = this.getDimensions();
+    const data = output.data instanceof Float32Array ? output.data : new Float32Array(output.data);
+    const results = [];
+    for (let i = 0; i < texts.length; i++) {
+      const offset = i * dims;
+      if (offset + dims <= data.length) {
+        results.push(data.slice(offset, offset + dims));
+      } else {
+        results.push(null);
+      }
+    }
+    return results;
+  }
+  /**
+   * Serial fallback: embed texts one at a time.
+   * Used when native batch fails.
+   */
+  async _embedBatchSerial(texts) {
+    const results = [];
+    for (const text of texts) {
+      try {
+        const embedding = await this.embed(text);
+        results.push(embedding);
+      } catch {
+        results.push(null);
+      }
+    }
+    return results;
+  }
+  // --- Single-text provider implementations ---
   async _embedFastembed(text) {
     const embeddings = this.model.embed([text], 1);
     for await (const batch of embeddings) {
@@ -886,17 +839,21 @@ function getEmbeddingService() {
 }
 
 // src/services/search/VectorSearch.ts
+var DEFAULT_MAX_CANDIDATES = 2e3;
 function cosineSimilarity(a, b) {
-  if (a.length !== b.length) return 0;
+  const len = a.length;
+  if (len !== b.length) return 0;
   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];
+  for (let i = 0; i < len; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    dotProduct += ai * bi;
+    normA += ai * ai;
+    normB += bi * bi;
   }
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  const denominator = Math.sqrt(normA * normB);
   if (denominator === 0) return 0;
   return dotProduct / denominator;
 }
@@ -909,23 +866,36 @@ function bufferToFloat32(buf) {
 }
 var VectorSearch = class {
   /**
-   * Ricerca semantica: calcola cosine similarity tra query e tutti gli embeddings.
+   * Semantic search with SQL pre-filtering for scalability.
+   *
+   * 2-phase strategy:
+   * 1. SQL pre-filters by project + sorts by recency (loads max N candidates)
+   * 2. JS computes cosine similarity only on filtered candidates
+   *
+   * With 50k observations and maxCandidates=2000, loads only ~4% of data.
    */
   async search(db, queryEmbedding, options = {}) {
     const limit = options.limit || 10;
     const threshold = options.threshold || 0.3;
+    const maxCandidates = options.maxCandidates || DEFAULT_MAX_CANDIDATES;
     try {
-      let sql = `
+      const conditions = [];
+      const params = [];
+      if (options.project) {
+        conditions.push("o.project = ?");
+        params.push(options.project);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sql = `
         SELECT e.observation_id, e.embedding,
                o.title, o.text, o.type, o.project, o.created_at, o.created_at_epoch
         FROM observation_embeddings e
         JOIN observations o ON o.id = e.observation_id
+        ${whereClause}
+        ORDER BY o.created_at_epoch DESC
+        LIMIT ?
       `;
-      const params = [];
-      if (options.project) {
-        sql += " WHERE o.project = ?";
-        params.push(options.project);
-      }
+      params.push(maxCandidates);
       const rows = db.query(sql).all(...params);
       const scored = [];
       for (const row of rows) {
@@ -946,14 +916,15 @@ var VectorSearch = class {
         }
       }
       scored.sort((a, b) => b.similarity - a.similarity);
+      logger.debug("VECTOR", `Search: ${rows.length} candidates \u2192 ${scored.length} above threshold \u2192 ${Math.min(scored.length, limit)} results`);
       return scored.slice(0, limit);
     } catch (error) {
-      logger.error("VECTOR", `Errore ricerca vettoriale: ${error}`);
+      logger.error("VECTOR", `Vector search error: ${error}`);
       return [];
     }
   }
   /**
-   * Salva embedding per un'osservazione.
+   * Store embedding for an observation.
    */
   async storeEmbedding(db, observationId, embedding, model) {
     try {
@@ -969,18 +940,18 @@ var VectorSearch = class {
         embedding.length,
         (/* @__PURE__ */ new Date()).toISOString()
       );
-      logger.debug("VECTOR", `Embedding salvato per osservazione ${observationId}`);
+      logger.debug("VECTOR", `Embedding saved for observation ${observationId}`);
     } catch (error) {
-      logger.error("VECTOR", `Errore salvataggio embedding: ${error}`);
+      logger.error("VECTOR", `Error saving embedding: ${error}`);
     }
   }
   /**
-   * Genera embeddings per osservazioni che non li hanno ancora.
+   * Generate embeddings for observations that don't have them yet.
    */
   async backfillEmbeddings(db, batchSize = 50) {
     const embeddingService2 = getEmbeddingService();
     if (!await embeddingService2.initialize()) {
-      logger.warn("VECTOR", "Embedding service non disponibile, backfill saltato");
+      logger.warn("VECTOR", "Embedding service not available, backfill skipped");
       return 0;
     }
     const rows = db.query(`
@@ -1006,11 +977,11 @@ var VectorSearch = class {
         count++;
       }
     }
-    logger.info("VECTOR", `Backfill completato: ${count}/${rows.length} embeddings generati`);
+    logger.info("VECTOR", `Backfill completed: ${count}/${rows.length} embeddings generated`);
     return count;
   }
   /**
-   * Statistiche sugli embeddings.
+   * Embedding statistics.
    */
   getStats(db) {
     try {
@@ -1098,21 +1069,21 @@ function estimateTokens(text) {
 var HybridSearch = class {
   embeddingInitialized = false;
   /**
-   * Inizializza il servizio di embedding (lazy, non bloccante)
+   * Initialize the embedding service (lazy, non-blocking)
    */
   async initialize() {
     try {
       const embeddingService2 = getEmbeddingService();
       await embeddingService2.initialize();
       this.embeddingInitialized = embeddingService2.isAvailable();
-      logger.info("SEARCH", `HybridSearch inizializzato (embedding: ${this.embeddingInitialized ? "attivo" : "disattivato"})`);
+      logger.info("SEARCH", `HybridSearch initialized (embedding: ${this.embeddingInitialized ? "active" : "disabled"})`);
     } catch (error) {
-      logger.warn("SEARCH", "Inizializzazione embedding fallita, uso solo FTS5", {}, error);
+      logger.warn("SEARCH", "Embedding initialization failed, using only FTS5", {}, error);
       this.embeddingInitialized = false;
     }
   }
   /**
-   * Ricerca ibrida con scoring a 4 segnali
+   * Hybrid search with 4-signal scoring
    */
   async search(db, query, options = {}) {
     const limit = options.limit || 10;
@@ -1128,7 +1099,7 @@ var HybridSearch = class {
           const vectorResults = await vectorSearch2.search(db, queryEmbedding, {
             project: options.project,
             limit: limit * 2,
-            // Prendiamo piu risultati per il ranking
+            // Fetch more results for ranking
             threshold: 0.3
           });
           for (const hit of vectorResults) {
@@ -1145,10 +1116,10 @@ var HybridSearch = class {
               source: "vector"
             });
           }
-          logger.debug("SEARCH", `Vector search: ${vectorResults.length} risultati`);
+          logger.debug("SEARCH", `Vector search: ${vectorResults.length} results`);
         }
       } catch (error) {
-        logger.warn("SEARCH", "Ricerca vettoriale fallita, uso solo keyword", {}, error);
+        logger.warn("SEARCH", "Vector search failed, using only keyword", {}, error);
       }
     }
     try {
@@ -1178,9 +1149,9 @@ var HybridSearch = class {
           });
         }
       }
-      logger.debug("SEARCH", `Keyword search: ${keywordResults.length} risultati`);
+      logger.debug("SEARCH", `Keyword search: ${keywordResults.length} results`);
     } catch (error) {
-      logger.error("SEARCH", "Ricerca keyword fallita", {}, error);
+      logger.error("SEARCH", "Keyword search failed", {}, error);
     }
     if (rawItems.size === 0) return [];
     const allFTS5Ranks = Array.from(rawItems.values()).filter((item) => item.fts5Rank !== null).map((item) => item.fts5Rank);
@@ -1233,14 +1204,12 @@ function getHybridSearch() {
 }
 export {
   CONTEXT_WEIGHTS,
-  ChromaManager,
   HybridSearch,
   KNOWLEDGE_TYPE_BOOST,
   SEARCH_WEIGHTS,
   accessRecencyScore,
   computeCompositeScore,
   estimateTokens,
-  getChromaManager,
   getHybridSearch,
   knowledgeTypeBoost,
   normalizeFTS5Rank,