@steno-ai/engine 0.1.10 → 0.1.12

package/src/retrieval/search.ts

@@ -3,7 +3,7 @@ import type { EmbeddingAdapter } from '../adapters/embedding.js';
 import type { CacheAdapter } from '../adapters/cache.js';
 import type { LLMAdapter } from '../adapters/llm.js';
 import type { SearchOptions, SearchResponse, FusionWeights, Candidate } from './types.js';
-import { DEFAULT_FUSION_WEIGHTS } from './types.js';
+import { DEFAULT_FUSION_WEIGHTS, CODEBASE_FUSION_WEIGHTS } from './types.js';
 import { compoundSearchSignal } from './compound-search.js';
 import { graphSearch } from './graph-traversal.js';
 import { matchTriggers } from './trigger-matcher.js';
@@ -37,7 +37,10 @@ export async function search(
 ): Promise<SearchResponse> {
   const startTime = Date.now();
   const limit = Math.min(options.limit ?? 10, 100);
-  const weights = options.weights ?? config.defaultWeights ?? DEFAULT_FUSION_WEIGHTS;
+  // Use codebase-optimized weights when the scope is 'codebase' (unless explicitly overridden)
+  const isCodebaseScope = options.scope === 'codebase';
+  const defaultWeightsForScope = isCodebaseScope ? CODEBASE_FUSION_WEIGHTS : DEFAULT_FUSION_WEIGHTS;
+  const weights = options.weights ?? config.defaultWeights ?? defaultWeightsForScope;
   const fetchMultiplier = 3; // fetch 3x limit from each signal for better fusion
 
   // Wrap embedding with cache if available
@@ -45,97 +48,111 @@ export async function search(
     ? new CachedEmbeddingAdapter(config.embedding, config.cache)
     : config.embedding;
 
-  // 1. Run all signals in PARALLEL — ONE compound search (not multiple)
-  //    Multi-query expansion adds latency (3× embedding calls). Instead:
-  //    - Single compound search with original query (vector + keyword in 1 DB call)
-  //    - Graph search with original query
-  //    - Trigger matching
-  //    All parallel = single round trip time.
+  // Fast mode: vector + keyword only, no graph, no triggers, no reranking
+  // Target: <300ms (embedding API ~150ms + DB ~100ms)
+  const isFast = options.fast === true;
+
+  // 1. Run retrieval signals
   const t0 = Date.now();
 
   const tCompound = Date.now();
   const compoundPromise = compoundSearchSignal(config.storage, effectiveEmbedding, options.query, options.tenantId, options.scope, options.scopeId, limit * fetchMultiplier).catch(() => ({ vectorCandidates: [] as Candidate[], keywordCandidates: [] as Candidate[] }));
-  const tGraph = Date.now();
-  const graphPromise = graphSearch(config.storage, effectiveEmbedding, options.query, options.tenantId, options.scope, options.scopeId, limit * fetchMultiplier, { maxDepth: config.graphMaxDepth, maxEntities: config.graphMaxEntities, asOf: options.temporalFilter?.asOf }).catch(() => [] as Candidate[]);
-  const tTrigger = Date.now();
-  const triggerPromise = matchTriggers(config.storage, effectiveEmbedding, options.query, options.tenantId, options.scope, options.scopeId).catch(() => ({ candidates: [] as Candidate[], triggersMatched: [] as string[] }));
-
-  const [compoundResult, graphSettled, triggerSettled] = await Promise.all([
-    compoundPromise.then(r => { console.error(`[steno-search] compound: ${Date.now() - tCompound}ms (vec=${r.vectorCandidates.length}, kw=${r.keywordCandidates.length})`); return r; }),
-    graphPromise.then(r => { console.error(`[steno-search] graph: ${Date.now() - tGraph}ms (${Array.isArray(r) ? r.length : 0} candidates)`); return r; }),
-    triggerPromise.then(r => { console.error(`[steno-search] trigger: ${Date.now() - tTrigger}ms`); return r; }),
-  ]);
-  console.error(`[steno-search] Signals total: ${Date.now() - t0}ms`);
+
+  let graphPromise: Promise<Candidate[]> | null = null;
+  let triggerPromise: Promise<{ candidates: Candidate[]; triggersMatched: string[] }> | null = null;
+
+  if (!isFast) {
+    const tGraph = Date.now();
+    graphPromise = graphSearch(config.storage, effectiveEmbedding, options.query, options.tenantId, options.scope, options.scopeId, limit * fetchMultiplier, { maxDepth: config.graphMaxDepth, maxEntities: config.graphMaxEntities, asOf: options.temporalFilter?.asOf })
+      .then(r => { console.error(`[steno-search] graph: ${Date.now() - tGraph}ms (${Array.isArray(r) ? r.length : 0} candidates)`); return r; })
+      .catch(() => [] as Candidate[]);
+    const tTrigger = Date.now();
+    triggerPromise = matchTriggers(config.storage, effectiveEmbedding, options.query, options.tenantId, options.scope, options.scopeId)
+      .then(r => { console.error(`[steno-search] trigger: ${Date.now() - tTrigger}ms`); return r; })
+      .catch(() => ({ candidates: [] as Candidate[], triggersMatched: [] as string[] }));
+  }
+
+  const compoundResult = await compoundPromise.then(r => { console.error(`[steno-search] compound: ${Date.now() - tCompound}ms (vec=${r.vectorCandidates.length}, kw=${r.keywordCandidates.length})`); return r; });
 
   const vectorCandidates = compoundResult.vectorCandidates;
   const keywordCandidates = compoundResult.keywordCandidates;
-  const graphCandidates = Array.isArray(graphSettled) ? graphSettled : [];
-  const triggerResult = triggerSettled;
-  const triggersMatched = triggerResult.triggersMatched;
 
-  // 2. Triple-tier pre-fusion reranking — rerank each stream INDEPENDENTLY
-  //    Only rerank when there are enough candidates to justify the embedding cost
-  //    before fusion, like Hydra DB's triple-tier architecture.
+  let graphCandidates: Candidate[] = [];
+  let triggersMatched: string[] = [];
+  let triggerCandidates: Candidate[] = [];
+
+  if (!isFast && graphPromise && triggerPromise) {
+    const [graphSettled, triggerSettled] = await Promise.all([graphPromise, triggerPromise]);
+    graphCandidates = Array.isArray(graphSettled) ? graphSettled : [];
+    triggersMatched = triggerSettled.triggersMatched;
+    triggerCandidates = triggerSettled.candidates;
+  }
+
+  console.error(`[steno-search] Signals total: ${Date.now() - t0}ms${isFast ? ' (fast mode)' : ''}`);
+
+  // 2. Pre-fusion reranking — skip entirely in fast mode
   const t1 = Date.now();
 
-  // Batch-embed query + all unique candidate contents in ONE call
-  const allPreRerankCandidates = [...vectorCandidates, ...graphCandidates];
-  let queryEmbedding: number[] | null = null;
-  const candidateEmbeddings = new Map<string, number[]>();
-
-  // Only rerank if we have >10 candidates — for small sets the original order is fine
-  if (allPreRerankCandidates.length > 10) {
-    try {
-      const uniqueTexts = new Map<string, string>();
-      for (const c of allPreRerankCandidates) {
-        if (!uniqueTexts.has(c.fact.id)) uniqueTexts.set(c.fact.id, c.fact.content);
-      }
-      const textsToEmbed = [options.query, ...uniqueTexts.values()];
-      const embeddings = await effectiveEmbedding.embedBatch(textsToEmbed);
-      queryEmbedding = embeddings[0]!;
-      let idx = 1;
-      for (const [factId] of uniqueTexts) {
-        candidateEmbeddings.set(factId, embeddings[idx++]!);
+  if (!isFast) {
+    // Batch-embed query + all unique candidate contents in ONE call
+    const allPreRerankCandidates = [...vectorCandidates, ...graphCandidates];
+    let queryEmbedding: number[] | null = null;
+    const candidateEmbeddings = new Map<string, number[]>();
+
+    // Only rerank if we have >10 candidates — for small sets the original order is fine
+    if (allPreRerankCandidates.length > 10) {
+      try {
+        const uniqueTexts = new Map<string, string>();
+        for (const c of allPreRerankCandidates) {
+          if (!uniqueTexts.has(c.fact.id)) uniqueTexts.set(c.fact.id, c.fact.content);
+        }
+        const textsToEmbed = [options.query, ...uniqueTexts.values()];
+        const embeddings = await effectiveEmbedding.embedBatch(textsToEmbed);
+        queryEmbedding = embeddings[0]!;
+        let idx = 1;
+        for (const [factId] of uniqueTexts) {
+          candidateEmbeddings.set(factId, embeddings[idx++]!);
+        }
+      } catch {
+        // Reranking fails silently — proceed without it
       }
-    } catch {
-      // Reranking fails silently — proceed without it
     }
-  }
 
-  // Rerank vector candidates
-  if (queryEmbedding && vectorCandidates.length > 1) {
-    const RERANK_W = 0.4;
-    for (const c of vectorCandidates) {
-      const factEmb = candidateEmbeddings.get(c.fact.id);
-      if (factEmb) {
-        const sim = cosineSim(queryEmbedding, factEmb);
-        c.vectorScore = c.vectorScore * (1 - RERANK_W) + sim * RERANK_W;
+    // Rerank vector candidates
+    if (queryEmbedding && vectorCandidates.length > 1) {
+      const RERANK_W = 0.4;
+      for (const c of vectorCandidates) {
+        const factEmb = candidateEmbeddings.get(c.fact.id);
+        if (factEmb) {
+          const sim = cosineSim(queryEmbedding, factEmb);
+          c.vectorScore = c.vectorScore * (1 - RERANK_W) + sim * RERANK_W;
+        }
       }
+      vectorCandidates.sort((a, b) => b.vectorScore - a.vectorScore);
     }
-    vectorCandidates.sort((a, b) => b.vectorScore - a.vectorScore);
-  }
 
-  // Rerank graph candidates
-  if (queryEmbedding && graphCandidates.length > 1) {
-    const RERANK_W = 0.4;
-    for (const c of graphCandidates) {
-      const factEmb = candidateEmbeddings.get(c.fact.id);
-      if (factEmb) {
-        const sim = cosineSim(queryEmbedding, factEmb);
-        c.graphScore = c.graphScore * (1 - RERANK_W) + sim * RERANK_W;
+    // Rerank graph candidates
+    if (queryEmbedding && graphCandidates.length > 1) {
+      const RERANK_W = 0.4;
+      for (const c of graphCandidates) {
+        const factEmb = candidateEmbeddings.get(c.fact.id);
+        if (factEmb) {
+          const sim = cosineSim(queryEmbedding, factEmb);
+          c.graphScore = c.graphScore * (1 - RERANK_W) + sim * RERANK_W;
+        }
       }
+      graphCandidates.sort((a, b) => b.graphScore - a.graphScore);
     }
-    graphCandidates.sort((a, b) => b.graphScore - a.graphScore);
   }
   // Keyword candidates skip reranking — FTS scores shouldn't be overridden by embeddings
-  console.error(`[steno-search] Pre-fusion rerank: ${Date.now() - t1}ms`);
+  console.error(`[steno-search] Pre-fusion rerank: ${Date.now() - t1}ms${isFast ? ' (skipped)' : ''}`);
 
   // 3. Merge all pre-reranked streams
   const allCandidates: Candidate[] = [
     ...vectorCandidates,
     ...keywordCandidates,
     ...graphCandidates,
-    ...triggerResult.candidates,
+    ...triggerCandidates,
   ];
 
   if (allCandidates.length === 0) {

package/src/retrieval/types.ts

@@ -14,6 +14,7 @@ export interface SearchOptions {
   };
   weights?: FusionWeights;     // override default fusion weights
   tokenBudget?: number;        // max estimated tokens for results (rough: chars/4). Trims lowest-scored results to fit.
+  fast?: boolean;              // skip graph traversal + reranking for <300ms latency
 }
 
 /** Configurable fusion weights (should sum to 1.0 — normalized if not) */
@@ -80,3 +81,14 @@ export const DEFAULT_FUSION_WEIGHTS: FusionWeights = {
   salience: 0.10,
   temporal: 0.20,
 };
+
+/** Fusion weights optimized for codebase queries — heavier on graph + keyword,
+ *  no temporal bias (code architecture is not time-sensitive) */
+export const CODEBASE_FUSION_WEIGHTS: FusionWeights = {
+  vector: 0.30,
+  keyword: 0.25,
+  graph: 0.25,
+  recency: 0.10,
+  salience: 0.10,
+  temporal: 0.00,
+};