sweet-search 2.6.8 → 2.6.9

package/core/search/search-boost.js

@@ -201,6 +201,18 @@ function envFloat(name, fallback, min = 0, max = 1) {
   return Number.isFinite(parsed) && parsed >= min && parsed <= max ? parsed : fallback;
 }
 
+// Query-term derivation is pure in `query`; memoize the last query so the
+// per-result map in applyPostFusionBoosts doesn't re-split identical input.
+let _lastIdTermsQuery = null;
+let _lastIdTerms = null;
+function identifierTermsForQuery(query) {
+  if (query !== _lastIdTermsQuery) {
+    _lastIdTermsQuery = query;
+    _lastIdTerms = new Set(splitIdentifierTerms(query));
+  }
+  return _lastIdTerms;
+}
+
 function splitIdentifierTerms(value) {
   return String(value || '')
     .replace(/_[0-9a-f]{8}(?=\.[^.]+$|$)/gi, '')
@@ -233,7 +245,7 @@ export function computeIdentifierAgreementBoost(result, query) {
   const weight = envFloat('SWEET_SEARCH_IDENTIFIER_AGREEMENT_BOOST', 0.40, 0, 1);
   if (weight === 0) return 1.0;
 
-  const queryTerms = new Set(splitIdentifierTerms(query));
+  const queryTerms = identifierTermsForQuery(query);
   if (queryTerms.size === 0) return 1.0;
 
   const fileName = (result.file || result.path || result.metadata?.file || '')
@@ -290,22 +302,22 @@ export function computeDefinitionBoost(result, queryLower, queryTokens) {
 /**
  * Compute syntax boost (PHASE_1_FIXES helper)
  */
+const DEFINITION_SIGNATURE_PATTERNS = [
+  /\b(?:public|private|protected)?\s*(?:abstract|final)?\s*class\s+(\w+)/,
+  /\b(?:public|private|protected)?\s*interface\s+(\w+)/,
+  /\b(?:public|private|protected)?\s*enum\s+(\w+)/,
+  /\bclass\s+(\w+)/,
+  /\bfunction\s+(\w+)/,
+  /\bexport\s+(?:default\s+)?(?:class|function)\s+(\w+)/,
+  /\binterface\s+(\w+)/,
+  /\btype\s+(\w+)\s*=/,
+];
+
 export function computeSyntaxBoost(result, queryTokens) {
   const signature = (result.signature || '').toLowerCase();
   if (!signature) return 1.0;
 
-  const definitionPatterns = [
-    /\b(?:public|private|protected)?\s*(?:abstract|final)?\s*class\s+(\w+)/,
-    /\b(?:public|private|protected)?\s*interface\s+(\w+)/,
-    /\b(?:public|private|protected)?\s*enum\s+(\w+)/,
-    /\bclass\s+(\w+)/,
-    /\bfunction\s+(\w+)/,
-    /\bexport\s+(?:default\s+)?(?:class|function)\s+(\w+)/,
-    /\binterface\s+(\w+)/,
-    /\btype\s+(\w+)\s*=/,
-  ];
-
-  for (const pattern of definitionPatterns) {
+  for (const pattern of DEFINITION_SIGNATURE_PATTERNS) {
     const match = signature.match(pattern);
     if (match && match[1]) {
       const definedName = match[1].toLowerCase();

package/core/search/search-fusion.js

@@ -109,20 +109,24 @@ export function quantileNormalize(scores, lowQuantile = 0.05, highQuantile = 0.9
 export function convexCombination(lexicalResults, semanticResults, routeType = 'mixed', options = {}) {
   const alpha = options.alpha ?? ROUTE_ALPHAS[routeType] ?? 0.5;
 
-  // Build score maps
+  // Build score + result maps in one key derivation per result
   const lexicalScoreMap = new Map();
   const semanticScoreMap = new Map();
+  const lexResultMap = new Map();
+  const semResultMap = new Map();
   const allKeys = new Set();
 
   for (const r of lexicalResults) {
     const key = this.getResultKey(r);
     lexicalScoreMap.set(key, r.score);
+    lexResultMap.set(key, r);
     allKeys.add(key);
   }
 
   for (const r of semanticResults) {
     const key = this.getResultKey(r);
     semanticScoreMap.set(key, r.score);
+    semResultMap.set(key, r);
     allKeys.add(key);
   }
 
@@ -148,8 +152,6 @@ export function convexCombination(lexicalResults, semanticResults, routeType = '
 
   // Compute CC scores
   const ccResults = [];
-  const lexResultMap = new Map(lexicalResults.map(r => [this.getResultKey(r), r]));
-  const semResultMap = new Map(semanticResults.map(r => [this.getResultKey(r), r]));
 
   for (const key of allKeys) {
     const lexScore = lexicalScoreMap.get(key);
@@ -253,7 +255,10 @@ export function rrfFusion(lexicalResults, semanticResults, k = 60) {
   });
 
   return [...results.values()]
-    .map(r => ({ ...r, score: scores.get(this.getResultKey(r)), ccScore: scores.get(this.getResultKey(r)) }))
+    .map(r => {
+      const score = scores.get(this.getResultKey(r));
+      return { ...r, score, ccScore: score };
+    })
     .sort((a, b) => b.score - a.score);
 }
 
@@ -310,7 +315,10 @@ export function robustCCFusion(lexicalResults, semanticResults, routeType = 'mix
 
   return {
     results: [...results.values()]
-      .map(r => ({ ...r, score: combinedScores.get(this.getResultKey(r)), ccScore: combinedScores.get(this.getResultKey(r)), alpha }))
+      .map(r => {
+        const score = combinedScores.get(this.getResultKey(r));
+        return { ...r, score, ccScore: score, alpha };
+      })
       .sort((a, b) => b.score - a.score),
     method: 'cc_robust',
     fallbackReason: null,

package/core/search/search-read-semantic.js

@@ -155,8 +155,7 @@ function _lateInteractionIndexPath(projectRoot, manifest) {
   return path.join(_stateDirForProject(root), path.basename(DB_PATHS.lateInteraction));
 }
 
-function _sourceStaleness(projectRoot, filePathRel) {
-  const manifest = _readReconcileManifest(projectRoot);
+function _sourceStaleness(projectRoot, filePathRel, manifest = _readReconcileManifest(projectRoot)) {
   const publishedMs = Date.parse(manifest?.publishedAt || '');
   if (!Number.isFinite(publishedMs)) return null;
   try {
@@ -178,9 +177,8 @@ function _sourceStaleness(projectRoot, filePathRel) {
 }
 
 const _repos = new Map();
-function _getRepo(projectRoot) {
+function _getRepo(projectRoot, manifest = _readReconcileManifest(projectRoot)) {
   const key = _projectKey(projectRoot);
-  const manifest = _readReconcileManifest(projectRoot);
   const dbPath = _codebasePathForProject(projectRoot, manifest);
   const baseDbPath = _defaultCodebasePathForProject(projectRoot);
   let entry = _repos.get(key);
@@ -202,9 +200,8 @@ let _liIndex = null;
 let _liInitPromise = null;
 let _liProjectKey = null;
 let _liManifestEpoch = null;
-async function _getLateInteractionIndex(projectRoot) {
+async function _getLateInteractionIndex(projectRoot, manifest = _readReconcileManifest(projectRoot)) {
   const projectKey = _projectKey(projectRoot);
-  const manifest = _readReconcileManifest(projectRoot);
   const manifestEpoch = Number.isInteger(manifest?.epoch) ? manifest.epoch : null;
   const samePin = _liProjectKey === projectKey && _liManifestEpoch === manifestEpoch;
   if (_liIndex !== null && samePin) return _liIndex || null;
@@ -331,8 +328,8 @@ function _escapeRegex(s) {
 // Candidate enumeration — load chunk metadata + per-chunk on-disk text slice
 // ---------------------------------------------------------------------------
 
-async function _loadFileChunks(filePathRel, projectRoot) {
-  const repo = _getRepo(projectRoot);
+async function _loadFileChunks(filePathRel, projectRoot, manifest = _readReconcileManifest(projectRoot)) {
+  const repo = _getRepo(projectRoot, manifest);
   if (!repo) return { chunks: [], language: null };
   const rows = repo.getChunksByFilePath(filePathRel);
   if (rows.length === 0) return { chunks: [], language: null };
@@ -445,9 +442,9 @@ function _scoreSymbol(chunks, queryTerms, queryRaw) {
   return scores;
 }
 
-async function _scoreLateInteraction(chunks, query, projectRoot, lateInteractionIndexOverride = null) {
+async function _scoreLateInteraction(chunks, query, projectRoot, lateInteractionIndexOverride = null, manifest = undefined) {
   if (chunks.length === 0) return { scores: new Map(), ran: false };
-  const liIndex = lateInteractionIndexOverride || await _getLateInteractionIndex(projectRoot);
+  const liIndex = lateInteractionIndexOverride || await _getLateInteractionIndex(projectRoot, manifest);
   if (!liIndex) return { scores: new Map(), ran: false };
 
   // Only score chunks whose IDs actually appear in the LI index. Use the
@@ -636,7 +633,10 @@ async function _readSemanticUnpinned(req) {
   const projectRoot = req.projectRoot || process.cwd();
   _ensurePersistedLiModelApplied(projectRoot);
   const filePathRel = _projectRelative(req.path, projectRoot);
-  const staleness = _sourceStaleness(projectRoot, filePathRel);
+  // One manifest read per request — _sourceStaleness/_getRepo/_getLateInteractionIndex
+  // each re-read the same file otherwise (it cannot change mid-request usefully).
+  const reconcileManifest = _readReconcileManifest(projectRoot);
+  const staleness = _sourceStaleness(projectRoot, filePathRel, reconcileManifest);
 
   const topK = req.topK ?? DEFAULTS.topK;
   const threshold = req.threshold ?? DEFAULTS.threshold;
@@ -646,7 +646,7 @@ async function _readSemanticUnpinned(req) {
   const verbose = !!req.verbose;
 
   const tLoad0 = performance.now();
-  const { chunks, language, totalLines, fileText } = await _loadFileChunks(filePathRel, projectRoot);
+  const { chunks, language, totalLines, fileText } = await _loadFileChunks(filePathRel, projectRoot, reconcileManifest);
   const tLoad1 = performance.now();
 
   // No chunks at all → fall back to plain read so the caller still gets
@@ -692,6 +692,7 @@ async function _readSemanticUnpinned(req) {
     req.query,
     projectRoot,
     req._lateInteractionIndex || null,
+    reconcileManifest,
   );
   const tLi1 = performance.now();
 

package/core/search/search-server.js

@@ -37,6 +37,8 @@ export const SEARCH_SERVER_MAX_URL_LENGTH = 16_384;
 export const SEARCH_SERVER_MAX_QUERY_LENGTH = 2_000;
 export const SEARCH_SERVER_MAX_READ_PATH_LENGTH = 8_192;
 
+const AGENT_FORMATS = new Set(['agent', 'agent_preview', 'agent_full', 'agent_full_xl']);
+
 function canonicalProjectRoot(root) {
   const resolved = path.resolve(root || process.cwd());
   try {
@@ -686,7 +688,6 @@ export async function startServer() {
 
       // Agent mode: context packaging (ColGrep agent format)
       const rawFormat = url.searchParams.get('format');
-      const AGENT_FORMATS = new Set(['agent', 'agent_preview', 'agent_full', 'agent_full_xl']);
       const agentFormat = AGENT_FORMATS.has(rawFormat) ? rawFormat : undefined;
       const tokenBudget = url.searchParams.has('budget')
         ? parseInt(url.searchParams.get('budget'), 10)

package/core/vector-store/binary-hnsw-index.js

@@ -236,6 +236,11 @@ export class BinaryHNSWIndex {
 
     // Pre-allocated visited list (generation-stamped, reused across searches)
     this._visitedList = new VisitedList(this.maxElements);
+    // Pooled search heaps — searchLayer/searchLayerQuery are synchronous and
+    // never re-entered, so one pair (auto-growing) serves all calls. Same
+    // single-flight contract as _visitedList.
+    this._candHeap = new TypedMinHeap(64);
+    this._resHeap = new TypedMaxHeap(64);
 
     // Asymmetric binary quantization calibration data
     this.centroid = null;       // Float32Array — dataset centroid
@@ -652,11 +657,13 @@ export class BinaryHNSWIndex {
     const startDist = hammingDistance(this.vectors[startNode].binary, targetBinary);
 
     // candidates = min-heap (explore closest first)
-    const candidates = new TypedMinHeap(ef * 4);
+    const candidates = this._candHeap;
+    candidates.clear();
     candidates.insert(startNode, startDist);
 
     // results = max-heap of size ef (peek furthest, replaceMax when closer found)
-    const results = new TypedMaxHeap(ef + 1);
+    const results = this._resHeap;
+    results.clear();
     results.insert(startNode, startDist);
 
     while (candidates.size > 0) {
@@ -894,8 +901,10 @@ export class BinaryHNSWIndex {
     visited.mark(startNode);
 
     const startDist = hammingDistance(this.vectors[startNode].binary, queryBinary);
-    const candidates = new TypedMinHeap(ef * 4);
-    const results = new TypedMaxHeap(ef + 1);
+    const candidates = this._candHeap;
+    candidates.clear();
+    const results = this._resHeap;
+    results.clear();
     candidates.insert(startNode, startDist);
     results.insert(startNode, startDist);
 

package/core/vector-store/float-vector-store.js

@@ -117,12 +117,16 @@ export class FloatVectorStore {
     const idsPath = binPath.replace(/\.bin$/, '.ids.json');
     if (!existsSync(idsPath)) return false;
 
-    // Read binary
+    // Read binary. Large reads return an unpooled Buffer that owns its whole
+    // ArrayBuffer — adopt it directly; only pooled (offset/short) buffers need
+    // the defensive copy.
     const fileBuffer = await readFile(binPath);
-    this.buffer = fileBuffer.buffer.slice(
-      fileBuffer.byteOffset,
-      fileBuffer.byteOffset + fileBuffer.byteLength
-    );
+    this.buffer = (fileBuffer.byteOffset === 0 && fileBuffer.byteLength === fileBuffer.buffer.byteLength)
+      ? fileBuffer.buffer
+      : fileBuffer.buffer.slice(
+        fileBuffer.byteOffset,
+        fileBuffer.byteOffset + fileBuffer.byteLength
+      );
 
     // Parse header
     const header = new DataView(this.buffer, 0, HEADER_SIZE);

package/eval/agent-read-workflows/bin/_ss-helpers.mjs

@@ -19,6 +19,17 @@ import {
   parseLineRange, looksLikeOption,
 } from './_ss-argparse.mjs';
 
+// Diagnostic-log isolation (agent-facing tools). The Sweet Search engine emits
+// model/index load banners via console.log → stdout ("LateInteraction: Loaded…",
+// "BinaryHNSW: Loaded…", "Warming up embedding…", "✓ Vocabulary loaded…"). When the
+// engine runs IN-PROCESS in this wrapper, that stdout IS the agent's tool result, so a
+// cold start crowds out the actual hits and the agent falls back to native tools
+// (diagnosed root cause of the sweet≈native tie). The wrappers emit REAL results only
+// via process.stdout.write, so redirect every console.log to stderr; the ss-* shell
+// wrapper's `2>` suppresses it on success → the agent sees clean results, warm or cold.
+// (Production search/grep/find already avoid this: the daemon is spawned stdio:'ignore'.)
+console.log = (...args) => process.stderr.write(args.map(a => (typeof a === 'string' ? a : String(a))).join(' ') + '\n');
+
 // 8-char SHA1 prefix is enough for grouping identical queries across
 // benchmark runs without bloating artifacts.
 function shortQueryHash(q) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.6.8",
+  "version": "2.6.9",
   "description": "Sweet Search - SOTA Hybrid Code Search Engine with WASM CatBoost Query Router, Semantic/Lexical/Structural Search, and Multilingual Support",
   "type": "module",
   "main": "core/search/sweet-search.js",
@@ -167,13 +167,13 @@
     "vitest": "^4.0.16"
   },
   "optionalDependencies": {
-    "@sweet-search/native-darwin-arm64": "2.6.8",
-    "@sweet-search/native-darwin-x64": "2.6.8",
-    "@sweet-search/native-linux-arm64-gnu": "2.6.8",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.8",
-    "@sweet-search/native-linux-x64-gnu": "2.6.8",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.8",
-    "@sweet-search/bg-priority": "2.6.8"
+    "@sweet-search/native-darwin-arm64": "2.6.9",
+    "@sweet-search/native-darwin-x64": "2.6.9",
+    "@sweet-search/native-linux-arm64-gnu": "2.6.9",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.9",
+    "@sweet-search/native-linux-x64-gnu": "2.6.9",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.9",
+    "@sweet-search/bg-priority": "2.6.9"
   },
   "engines": {
     "node": ">=18.0.0"