sweet-search 2.6.16 → 2.7.0

package/core/search/session-daemon-prewarm.mjs

@@ -27,6 +27,7 @@ import {
   readFileSync,
   readdirSync,
   openSync,
+  appendFileSync,
   writeSync,
   closeSync,
   unlinkSync,
@@ -36,6 +37,8 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { launchMaintainer } from '../indexing/maintainer-launcher.mjs';
 import { projectSocketPath, projectPidFile } from './server-identity.js';
+import { sendAgentSpanOperation } from './agent-span-client.js';
+import { validAgentSessionId } from './agent-span-ledger.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -48,10 +51,33 @@ const LOCK_PATH = process.env.SWEET_SEARCH_PREWARM_LOCK || '/tmp/sweet-search-pr
 const SOCKET_PROBE_TIMEOUT_MS = Number(process.env.SWEET_SEARCH_PREWARM_PROBE_MS ?? 300);
 
 const verbose = !!process.env.SWEET_SEARCH_PREWARM_VERBOSE;
+const hookMode = process.argv.includes('--agent-session-drop')
+  ? 'drop'
+  : (process.argv.includes('--agent-session-hook') ? 'session-start' : null);
 const log = (msg) => {
   if (verbose) process.stderr.write(`[sweet-search prewarm] ${msg}\n`);
 };
 
+function readHookPayload() {
+  if (!hookMode) return null;
+  try {
+    const raw = readFileSync(0, 'utf8');
+    if (!raw || Buffer.byteLength(raw) > 64 * 1024) return null;
+    const payload = JSON.parse(raw);
+    return payload && typeof payload === 'object' ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+function persistClaudeSessionId(sessionId) {
+  const envFile = process.env.CLAUDE_ENV_FILE;
+  if (!envFile || !validAgentSessionId(sessionId)) return;
+  const shellQuoted = `'${sessionId.replace(/'/g, `'"'"'`)}'`;
+  try { appendFileSync(envFile, `export SWEET_SEARCH_SESSION_ID=${shellQuoted}\n`, 'utf8'); }
+  catch (err) { log(`session env non-fatal: ${err?.message || err}`); }
+}
+
 function pageCacheSweepEnabled() {
   const v = String(process.env.SWEET_SEARCH_PREWARM_PAGE_CACHE || '').trim().toLowerCase();
   return v !== '0' && v !== 'false' && v !== 'off' && v !== 'no';
@@ -184,6 +210,16 @@ async function daemonHealthy() {
   return socketResponsive(SOCKET_PATH, SOCKET_PROBE_TIMEOUT_MS);
 }
 
+async function waitForResponsiveSocket(timeoutMs = SOCKET_PROBE_TIMEOUT_MS) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  do {
+    if (await socketResponsive(SOCKET_PATH, Math.min(100, timeoutMs))) return true;
+    if (Date.now() >= deadline) break;
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  } while (Date.now() < deadline);
+  return false;
+}
+
 /**
  * Acquire an exclusive lock so only one concurrent SessionStart spawns a
  * daemon. Returns the file descriptor on success, null on failure. Handles
@@ -268,6 +304,34 @@ if (process.env.SWEET_SEARCH_PAGE_CACHE_SWEEP === '1') {
   process.exit(0);
 }
 
+const hookPayload = readHookPayload();
+const hookSessionId = validAgentSessionId(hookPayload?.session_id)
+  ? hookPayload.session_id
+  : null;
+
+if (hookMode === 'drop') {
+  if (hookSessionId) {
+    await sendAgentSpanOperation({ operation: 'drop', sessionId: hookSessionId }, { timeoutMs: 750 });
+  }
+  process.exit(0);
+}
+
+if (hookMode === 'session-start' && hookSessionId) {
+  persistClaudeSessionId(hookSessionId);
+}
+
+const resetRequested = hookMode === 'session-start'
+  && hookSessionId
+  && (hookPayload?.source === 'clear' || hookPayload?.source === 'compact');
+let resetComplete = false;
+if (resetRequested) {
+  const response = await sendAgentSpanOperation(
+    { operation: 'reset', sessionId: hookSessionId },
+    { timeoutMs: 750 },
+  );
+  resetComplete = response?.ok === true;
+}
+
 // The search server and the index maintainer are independent: a stuck/already
 // running server must not stop the maintainer from starting, and vice versa.
 // Each is isolated in its own try so one failing never blocks the other.
@@ -283,6 +347,17 @@ try {
   log(`server prewarm non-fatal: ${err?.message || err}`);
 }
 
+if (resetRequested && !resetComplete) {
+  // A compact/clear can race a daemon cold start. The first attempt happens
+  // before unrelated prewarm work; this is the single bounded retry after the
+  // server has had a chance to bind its socket.
+  await waitForResponsiveSocket(SOCKET_PROBE_TIMEOUT_MS);
+  await sendAgentSpanOperation(
+    { operation: 'reset', sessionId: hookSessionId },
+    { timeoutMs: 750 },
+  );
+}
+
 try {
   // Delegate to the shared launcher (core/indexing/maintainer-launcher.mjs).
   // The hook is a best-effort convenience layer; the durable guarantee lives in

package/core/search/sweet-search.js

@@ -706,7 +706,12 @@ export class SweetSearch {
         results = grepResult.results;
         Object.assign(stats, grepResult.stats);
         stats.total_ms = grepResult.stats.total_ms ?? (Date.now() - start);
-        return { results, stats };
+        return {
+          results,
+          stats,
+          ...(grepResult.fileSummary ? { fileSummary: grepResult.fileSummary } : {}),
+          ...(grepResult.familyManifest ? { familyManifest: grepResult.familyManifest } : {}),
+        };
       }
       case 'pattern': {
         const patternResult = await this.patternSearch(query, routing, options);
@@ -881,6 +886,7 @@ export class SweetSearch {
         locationMap: null,
         projectRoot: this.projectRoot,
         ablations: options.ablations,
+        _isAgentFormat: true,
       });
       __ptEnd('packageForAgent', __t_pkg);
       // Preserve the underlying retrieval stats so callers can inspect both layers

package/core/search/unread-symbol-ranking.js

@@ -0,0 +1,90 @@
+/**
+ * Agent-only relevance ordering for the ss-read unread-symbol trailer.
+ *
+ * The caller supplies symbols already loaded from the selected file's index.
+ * This module only reallocates the existing five display slots; it performs no
+ * I/O and never changes the total symbol count represented by "+N more".
+ */
+
+import { containsToken, informativeSubtokens } from './query-sufficiency.js';
+
+function normalizeEvidence(queryEvidence) {
+  const anchors = Array.isArray(queryEvidence?.anchors)
+    ? queryEvidence.anchors.filter((value) => typeof value === 'string' && value.length >= 3)
+    : [];
+  const subtokens = new Set(
+    Array.isArray(queryEvidence?.subtokens)
+      ? queryEvidence.subtokens.filter((value) => typeof value === 'string' && value.length >= 3)
+      : [],
+  );
+  return { anchors, subtokens };
+}
+
+function relevance(symbol, evidence) {
+  const name = String(symbol?.symbol || '');
+  const lower = name.toLowerCase();
+  let exactAnchor = 0;
+  let containedAnchor = 0;
+
+  for (const anchor of evidence.anchors) {
+    const anchorLower = anchor.toLowerCase();
+    if (lower === anchorLower) {
+      exactAnchor = Math.max(exactAnchor, anchor.length);
+      continue;
+    }
+    const caseSensitive = /[A-Z]/.test(anchor);
+    if (containsToken(name, anchor, { caseSensitive }) || lower.includes(anchorLower)) {
+      containedAnchor = Math.max(containedAnchor, anchor.length);
+    }
+  }
+
+  const symbolTerms = informativeSubtokens(name);
+  let subtokenMatches = 0;
+  for (const term of evidence.subtokens) {
+    if (symbolTerms.has(term)) subtokenMatches++;
+  }
+
+  return {
+    matched: exactAnchor > 0 || containedAnchor > 0 || subtokenMatches > 0,
+    exactAnchor,
+    containedAnchor,
+    subtokenMatches,
+  };
+}
+
+/**
+ * Select the fixed-size unread-symbol trailer list by query relevance.
+ * Stable position order is preserved for ties and when no symbol matches.
+ */
+export function selectUnreadSymbols(symbols, queryEvidence, maxSymbols = 5) {
+  const candidates = Array.isArray(symbols) ? symbols : [];
+  const limit = Math.max(0, maxSymbols | 0);
+  if (candidates.length <= limit) {
+    return { symbols: candidates.slice(), moreCount: 0 };
+  }
+
+  const evidence = normalizeEvidence(queryEvidence);
+  if (evidence.anchors.length === 0 && evidence.subtokens.size === 0) {
+    return {
+      symbols: candidates.slice(0, limit),
+      moreCount: candidates.length - limit,
+    };
+  }
+
+  const ranked = candidates.map((symbol, index) => ({
+    symbol,
+    index,
+    ...relevance(symbol, evidence),
+  }));
+  ranked.sort((a, b) =>
+    Number(b.matched) - Number(a.matched)
+    || b.exactAnchor - a.exactAnchor
+    || b.containedAnchor - a.containedAnchor
+    || b.subtokenMatches - a.subtokenMatches
+    || a.index - b.index);
+
+  return {
+    symbols: ranked.slice(0, limit).map((entry) => entry.symbol),
+    moreCount: candidates.length - limit,
+  };
+}