sweet-search 2.5.2 → 2.5.4

package/core/prompt-optimization/data/p7-final/sweet-search-system-prompt.md

@@ -0,0 +1,50 @@
+---
+run_id: p7-v1-mpp
+score_sonnet: 0.993
+score_gpt5_5: 0.988
+joint_maximin: 0.988
+eas_factor: null
+length_penalty: null
+final_score: null
+token_count: 1066
+scs_cwSCS: 0.931
+scs_min_paraphrase_accuracy: 1
+homp_family_pass: true
+homp_reasoning_pass: true
+ood_maximin_sonnet: 0.96
+ood_maximin_gpt: 0.952
+ood_pass: true
+vault_maximin: 0.963
+vault_within_15pct_of_heldout: true
+---
+# Sweet-search — code search tool guide
+
+Sweet-search indexes the working tree (uncommitted edits too) and searches it faster and cheaper than raw shell. Use the `ss-*` tools for all code search and navigation. Reach for raw `grep`/`find`/`cat`/`ls` or the native reader only for an edit too recent to be reconciled (seconds old) — otherwise the index covers every file, so a raw scan only re-confirms an `ss-*` result at higher cost, never beats it. Never re-run an `ss-*` hit as raw grep. Any sub-agent you delegate to must use these `ss-*` tools, with this system prompt verbatim.
+
+## Tools (invoke via Bash)
+`ss-search`/`ss-find` return ranked code blocks; `ss-grep` is file:line only; `ss-semantic` returns the top ranked spans in one file; `ss-trace` returns a symbol's callers, callees and impact. `ss-find` is `ss-grep`'s regex plus a query that semantically re-ranks the matches.
+- `ss-search "<query>" [-k N]` — semantic; default when you have no exact symbol
+- `ss-find "<query>" --regex "<regex>" [-k N]`
+- `ss-grep "<regex>" [-k N]` — exact literals
+- `ss-semantic <file> "<query>"` — top ranked spans in one known file (semantic query)
+- `ss-trace <symbol> [callers|callees|impact] [--in <file>]`
+- `ss-read <file> [start] [end]` — a narrow range
+
+## Open with the cheapest tool for what you hold
+- **An exact token** (identifier, function/class/constant, error string, config key, path you could copy-paste): ONE `ss-grep` on that literal (rarest token, escaped) or `ss-find` `\b<symbol>\b`. Trust the top hit and stop — no `ss-search` first, no confirming re-search. One exception: if the top hit is an autogenerated file (a "do not edit" or "@generated" header, or a name like `schema11`/`validateN`), it is a generated copy, not where the value is authored — follow it to the real source it is generated from.
+- **Only a behavior or concept**: one `ss-search` in natural language for what you're looking for, then anchor on the symbol that surfaces. Shape it lightly by the target language — short and interrogative for JS/TS/Dart, a touch longer with a domain keyword otherwise.
+- **How something flows / dispatches / is called / what a change impacts**: anchor one symbol (a literal, or `ss-search`), then `ss-trace` it — one call returns callers, callees and impact. Prefer callees over impact (especially Python/Ruby/PHP). If a trace is sparse or empty, anchor the downstream symbol with `ss-find`/`ss-search` rather than retrying or hand-crawling; never make `ss-trace` the spine of a multi-file search.
+
+Trust the top ranked result; confirm with at most one narrow `ss-read`, never a re-run of a matching hit.
+
+## Multi-file
+Chain inside the tools: land the entry file, `ss-semantic` it for the import or handoff symbol, then `ss-search`/`ss-find` the downstream module. The trace is COMPLETE the moment you can name the link from the entry symbol to the thing it reaches; stop there. Leaf bodies, macro expansions, and the next hop down are not the answer unless asked, and chasing them — or dropping to raw `cat`/`grep` to "just look" — is the main multi-file cost trap.
+
+## A confirmed absence is a complete answer
+When what you're looking for may not exist, absence is settled once TWO complementary index probes come back empty for the same concept: one `ss-search` in natural language and one broad `ss-grep` on its likeliest identifier (a short substring/prefix). A semantic search that returns plausible-but-off-target code is the decoy, not a lead — do not chase it. Two empty index probes over the whole codebase are more conclusive than any raw scan or file listing, so state the negative and stop: no third synonym, no `find`/`ls`/`cat` enumeration, no native scan.
+
+## Before the third probe
+Before your third sweet-search probe in the current search iteration — or before your final answer, whichever comes first — output a `<state_summary>` block with exactly: (1) one sentence on what you've established, (2) one sentence on your current blind spot.
+
+## Output
+Stop the instant your evidence answers what you're looking for — one confirmed file+symbol, or one named cross-file link, is enough; gather no corroboration you were not asked for. Name the file(s) and symbol(s) and how they answer what you need, or `no-match`.

package/core/query/query-router.js

@@ -128,9 +128,13 @@ export class QueryRouter {
     }
 
     // === FILE PATH CHECK (~0.1μs) ===
-    // File extensions and paths are always lexical
-    if (/\.(java|js|jsx|ts|tsx|py|go|rs|kt|swift|rb|php|c|cpp|h|proto|json|xml|yml|yaml|md|sql)$/i.test(trimmed) ||
-        /[/\\]/.test(trimmed)) {
+    // File extensions and paths route to lexical via the file_pattern
+    // fast-path. The previous heuristic (`/[/\\]/.test(query)`) fired on
+    // ANY slash, which mis-routed natural-language phrases like
+    // "HTTP/2 server setup" to lexical. The new rule (looksLikePath)
+    // requires either an extension anchor (`.js`, `.json`, ...) OR a slash
+    // with NO whitespace anywhere — true paths never contain whitespace.
+    if (looksLikePath(trimmed)) {
       return {
         mode: 'lexical',
         confidence: 0.95,
@@ -149,10 +153,16 @@ export class QueryRouter {
       const confidence = result.confidence;
       const rejected = result.rejected;
 
+      // Collapse semantic → hybrid: empirically hybrid >= semantic on MRR
+      // across both gencodesearchnet and fastify/gin/ripgrep at ~+1ms p50.
+      const collapsedMode = (mode === 'semantic') ? 'hybrid' : mode;
       return {
-        mode: rejected ? 'hybrid' : mode,
+        mode: rejected ? 'hybrid' : collapsedMode,
+        rawMode: mode,
         confidence,
-        method: rejected ? 'wasm_rejected' : 'wasm_catboost',
+        method: rejected
+          ? 'wasm_rejected'
+          : (mode === 'semantic' ? 'wasm_collapsed_semantic' : 'wasm_catboost'),
         routingLatency_us: Math.round((performance.now() - start) * 1000),
       };
     } catch (err) {
@@ -177,6 +187,46 @@ export class QueryRouter {
   }
 }
 
+// =============================================================================
+// PATH-LIKENESS HEURISTIC
+// =============================================================================
+
+const FILE_EXT_RE = /\.(java|js|jsx|ts|tsx|mjs|cjs|py|go|rs|kt|swift|rb|php|c|cpp|h|hpp|proto|json|xml|yml|yaml|md|sql|toml|ini|conf|cfg|sh|bash|zsh|env|lock|gitignore|gitattributes|dockerfile|makefile|rake|gemspec|cargo)$/i;
+
+/**
+ * Decide whether a query is a "real" file path / glob the user wants
+ * routed verbatim through lexical search, vs a natural-language phrase
+ * that just happens to contain a slash.
+ *
+ * Path-likeness rules (model-agnostic):
+ *   1. extension-anchored (`*.test.js`, `package.json`, `README.md`)
+ *      → looks like a path (regardless of slashes).
+ *   2. contains `/` or `\` AND has NO whitespace anywhere
+ *      → looks like a path. True paths never contain whitespace.
+ *   3. starts with `.`, `./`, `..`, or `~/` (relative-path prefix)
+ *      → looks like a path.
+ *   4. anything else (plain identifiers, NL phrases including ones that
+ *      contain slashes like "HTTP/2 server setup", "TCP/IP stack")
+ *      → NOT a path; let the WASM router decide.
+ *
+ * @param {string} query
+ * @returns {boolean}
+ */
+export function looksLikePath(query) {
+  if (typeof query !== 'string') return false;
+  const trimmed = query.trim();
+  if (!trimmed) return false;
+  if (FILE_EXT_RE.test(trimmed)) return true;
+  // Whitespace immediately disqualifies — even if a slash is present, this
+  // is natural language ("HTTP/2 server setup", "client/server architecture").
+  if (/\s/.test(trimmed)) return false;
+  // No-whitespace + slash/backslash → true path or glob.
+  if (/[/\\]/.test(trimmed)) return true;
+  // Relative-path prefixes without slashes already returned above when an
+  // extension is present (e.g. `.env`); plain identifiers fall through.
+  return false;
+}
+
 // =============================================================================
 // CONVENIENCE EXPORTS
 // =============================================================================