sweet-search 2.5.12 → 2.5.13

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

@@ -0,0 +1,148 @@
+// Pure argument-parsing helpers for the ss-* CLI wrappers.
+//
+// Extracted from _ss-helpers.mjs so they can be unit-tested without triggering
+// the CLI's top-level IIFE (which runs on import). NOTHING here touches
+// process.* or the filesystem — every function is a pure transform over an
+// args array (some mutate the array in place, by design, and return a value).
+
+// --- value-flag parsers (mutate `args`, returning the consumed value) --------
+
+export function parseFlag(args, name, fallback) {
+  const i = args.indexOf(name);
+  if (i === -1) return fallback;
+  const v = args[i + 1];
+  args.splice(i, 2);
+  return v;
+}
+
+export function parseShortFlag(args, names, fallback) {
+  for (const n of names) {
+    const i = args.indexOf(n);
+    if (i !== -1) { const v = args[i + 1]; args.splice(i, 2); return v; }
+  }
+  return fallback;
+}
+
+// Boolean (value-less) flag: remove every occurrence, return whether any present.
+export function parseBoolFlag(args, names) {
+  let present = false;
+  for (const n of names) {
+    let i;
+    while ((i = args.indexOf(n)) !== -1) { args.splice(i, 1); present = true; }
+  }
+  return present;
+}
+
+// --- pattern construction ----------------------------------------------------
+
+export function escapeRegex(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Translate the grep-family pattern flags into a single regex — no engine change
+// needed. `-F` escapes the pattern so metacharacters are literal; `-w` wraps it
+// in word boundaries; `-i` prepends the `(?i)` inline flag the planner already
+// honours end-to-end (hasCaseInsensitiveRegexFlag → ripgrep prefilter + Rust
+// gram+grep). Order matters: escape (literal) → word-wrap → case flag.
+export function buildGrepPattern(pattern, { ignoreCase = false, wordBound = false, fixedString = false } = {}) {
+  if (!pattern) return pattern;
+  let p = fixedString ? escapeRegex(pattern) : pattern;
+  if (wordBound) p = `\\b(?:${p})\\b`;
+  if (ignoreCase && !/^\(\?[a-z-]*i[a-z-]*[:)]/.test(p)) p = `(?i)${p}`;
+  return p;
+}
+
+// --- inert flags (always true for ss-*, safe to accept as no-ops) ------------
+// These never change which lines match: we always print file:line, always
+// search the whole index, never colourise. Stripping them lets reflexive grep
+// muscle-memory pass without a wasted call — UNLIKE semantic flags (-w/-F/-v/
+// -C…), which we either implement or reject, never silently drop.
+export const INERT_FLAGS = new Set([
+  '-n', '--line-number', '-H', '--with-filename', '--no-filename',
+  '-r', '-R', '--recursive', '--color', '--colour',
+]);
+
+export function stripInertFlags(args) {
+  for (let i = args.length - 1; i >= 0; i--) {
+    const a = args[i];
+    if (typeof a === 'string' && (INERT_FLAGS.has(a) || /^--colou?r=/.test(a))) {
+      args.splice(i, 1);
+    }
+  }
+}
+
+// --- normalisation: make agent-typed forms canonical before parsing ----------
+// Short flags that consume a following value, and value-less boolean shorts.
+// Used to split attached/bundled forms (-k5, -iw, -iwk5) the way getopt would,
+// so they parse instead of being mistaken for an unknown flag or the pattern.
+export const VALUE_SHORTS = new Set(['k']);
+export const BOOL_SHORTS = new Set(['i', 'w', 'F']);
+
+export function normalizeArgs(args) {
+  const out = [];
+  let positionalOnly = false;
+  for (const tok of args) {
+    if (positionalOnly || typeof tok !== 'string') { out.push(tok); continue; }
+    if (tok === '--') { out.push(tok); positionalOnly = true; continue; }
+
+    // --name=value  →  --name value
+    let m = /^(--[A-Za-z][\w-]*)=(.*)$/.exec(tok);
+    if (m) { out.push(m[1], m[2]); continue; }
+
+    // attached short value or boolean bundle:  -k5, -iw, -iwk5
+    m = /^-([A-Za-z])(.+)$/.exec(tok);
+    if (m) {
+      const first = m[1];
+      if (VALUE_SHORTS.has(first)) { out.push('-' + first, m[2]); continue; } // -k5 → -k 5
+      if (BOOL_SHORTS.has(first)) {
+        const chars = tok.slice(1);
+        const expanded = [];
+        let i = 0, ok = true;
+        while (i < chars.length) {
+          const ch = chars[i];
+          if (BOOL_SHORTS.has(ch)) { expanded.push('-' + ch); i++; }
+          else if (VALUE_SHORTS.has(ch)) {                 // value short ends the bundle
+            const val = chars.slice(i + 1);
+            expanded.push('-' + ch);
+            if (val) expanded.push(val);
+            i = chars.length;
+          } else { ok = false; break; }                    // unknown char → leave token intact
+        }
+        if (ok) { out.push(...expanded); continue; }
+      }
+    }
+    out.push(tok);
+  }
+  return out;
+}
+
+// A token that looks like a real CLI option, as opposed to a regex/query that
+// merely begins with '-' (e.g. `-?\d+`, `-->`). Narrow on purpose: single short
+// letter, pure-letter bundle, or GNU long flag. Anything containing regex
+// metacharacters falls through and is treated as the positional pattern, so a
+// dash-leading pattern works WITHOUT the agent needing to know about `--`.
+export function looksLikeOption(tok) {
+  if (typeof tok !== 'string' || tok === '-' || tok === '--') return false;
+  return /^-[A-Za-z]$/.test(tok)            // -i
+    || /^-[A-Za-z]{2,}$/.test(tok)          // -iw  (pure-letter bundle)
+    || /^--[A-Za-z][\w-]*$/.test(tok);      // --ignore-case
+}
+
+// After known flags are consumed, resolve the positional pattern. `--` ends
+// option parsing (everything after is positional). Any remaining option-shaped
+// token is an unsupported flag → reported, not silently dropped and not
+// mistaken for the pattern. Returns { pattern, unknownFlag }; the caller decides
+// how to surface the error (kept side-effect-free for testability).
+export function extractPositional(args) {
+  const sep = args.indexOf('--');
+  if (sep !== -1) {
+    const before = args.slice(0, sep);
+    const after = args.slice(sep + 1);
+    const bad = before.find(looksLikeOption);
+    if (bad) return { pattern: undefined, unknownFlag: bad };
+    return { pattern: after[0], unknownFlag: null };
+  }
+  const bad = args.find(looksLikeOption);
+  if (bad) return { pattern: undefined, unknownFlag: bad };
+  return { pattern: args[0], unknownFlag: null };
+}

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

@@ -13,6 +13,10 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import {
+  parseFlag, parseShortFlag, parseBoolFlag,
+  buildGrepPattern, stripInertFlags, normalizeArgs, extractPositional,
+} from './_ss-argparse.mjs';
 
 // 8-char SHA1 prefix is enough for grouping identical queries across
 // benchmark runs without bloating artifacts.
@@ -40,19 +44,18 @@ process.env.SWEET_SEARCH_PROJECT_ROOT = PROJECT_ROOT;
 const subcommand = process.argv[2];
 const rest = process.argv.slice(3);
 
-function parseFlag(args, name, fallback) {
-  const i = args.indexOf(name);
-  if (i === -1) return fallback;
-  const v = args[i + 1];
-  args.splice(i, 2);
-  return v;
-}
-function parseShortFlag(args, names, fallback) {
-  for (const n of names) {
-    const i = args.indexOf(n);
-    if (i !== -1) { const v = args[i + 1]; args.splice(i, 2); return v; }
+// Pure arg-parsing helpers (parseFlag/parseShortFlag/parseBoolFlag/
+// buildGrepPattern/stripInertFlags/normalizeArgs/extractPositional) live in
+// ./_ss-argparse.mjs so they can be unit-tested without this file's top-level
+// IIFE firing. resolvePositional wraps the side-effect-free extractPositional
+// with the CLI's loud-error exit.
+function resolvePositional(args, usage) {
+  const { pattern, unknownFlag } = extractPositional(args);
+  if (unknownFlag) {
+    process.stderr.write(`[ss] unrecognised option "${unknownFlag}"\n${usage}\n`);
+    process.exit(2);
   }
-  return fallback;
+  return pattern;
 }
 
 async function getSweetSearch() {
@@ -79,11 +82,17 @@ async function ensureWarmServerReady({ timeoutMs = 60000, intervalMs = 500 } = {
 
 // --- subcommands ----------------------------------------------------------
 
-async function cmdGrep(args) {
+const GREP_USAGE = 'Usage: ss-grep <regex> [-i|--ignore-case] [-w|--word-regexp] [-F|--fixed-strings] [-k N]';
+async function cmdGrep(rawArgs) {
+  const args = normalizeArgs(rawArgs);
+  const ignoreCase = parseBoolFlag(args, ['-i', '--ignore-case']);
+  const wordBound = parseBoolFlag(args, ['-w', '--word-regexp']);
+  const fixedString = parseBoolFlag(args, ['-F', '--fixed-strings']);
   const k = +parseShortFlag(args, ['-k', '--top'], 20);
-  const regex = args[0];
+  stripInertFlags(args);
+  const regex = buildGrepPattern(resolvePositional(args, GREP_USAGE), { ignoreCase, wordBound, fixedString });
   if (!regex) {
-    process.stderr.write('Usage: ss-grep <regex> [-k N]\n');
+    process.stderr.write(GREP_USAGE + '\n');
     process.exit(2);
   }
   const s = await getSweetSearch();
@@ -109,27 +118,34 @@ async function cmdGrep(args) {
   process.exit(0);
 }
 
-async function cmdFind(args) {
+async function cmdFind(rawArgs) {
+  const args = normalizeArgs(rawArgs);
   // ColGrep pattern search with token-budgeted agent packaging — returns the
   // FULL useful answer (ranked code blocks + confidence + sufficiency), the same
   // agent packaging ss-search emits. ss-grep is the short/locator counterpart, so
   // ss-find defaults to the full answer: it saves the follow-up read entirely.
   // (Mirrors the agent-in-the-loop H2H adapter eval/agent-eval/tools/
   // pattern-agent-tools.js, which calls search(...,{format:'agent'}).)
+  const FIND_USAGE = 'Usage: ss-find "<query>" --regex "<regex>" [-i|--ignore-case] [-w|--word-regexp] [-F|--fixed-strings] [--full|--xl] [-k N]';
   let format = 'agent';
   if (args.includes('--full')) { format = 'agent_full'; args.splice(args.indexOf('--full'), 1); }
   if (args.includes('--xl'))   { format = 'agent_full_xl'; args.splice(args.indexOf('--xl'), 1); }
+  const ignoreCase = parseBoolFlag(args, ['-i', '--ignore-case']);
+  const wordBound = parseBoolFlag(args, ['-w', '--word-regexp']);
+  const fixedString = parseBoolFlag(args, ['-F', '--fixed-strings']);
   const k = +parseShortFlag(args, ['-k', '--top'], 6);
   const regex = parseFlag(args, '--regex', '');
-  const query = args[0];
+  stripInertFlags(args);
+  const query = resolvePositional(args, FIND_USAGE);
   if (!query) {
-    process.stderr.write('Usage: ss-find "<query>" --regex "<regex>" [--full|--xl] [-k N]\n');
+    process.stderr.write(FIND_USAGE + '\n');
     process.exit(2);
   }
   // Budget-sweep experiment hook: lets the bench pin the response token budget
   // per-process without changing the agent-visible tool surface.
   const envFindBudget = Number(process.env.SS_SMOKE_FIND_BUDGET || '') || null;
-  const effectiveRegex = regex || '';
+  // Pattern flags apply to the regex candidate generator; the NL query is untouched.
+  const effectiveRegex = buildGrepPattern(regex || '', { ignoreCase, wordBound, fixedString });
   const s = await getSweetSearch();
   if (!s.hasLateInteractionIndex) {
     process.stderr.write(`[ss-find] no late-interaction index — falling back to ss-grep\n`);

package/eval/agent-read-workflows/bin/ss-find

@@ -5,7 +5,7 @@
 # Use for behavioural / semantic questions where lexical alone won't pinpoint the
 # chunk. (ss-grep is the short file:line locator.)
 #
-# Usage:  ss-find "<query>" --regex "<regex>" [--full|--xl] [-k N]
+# Usage:  ss-find "<query>" --regex "<regex>" [-i|--ignore-case] [--full|--xl] [-k N]
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 TMPERR=$(mktemp)
 node "$DIR/_ss-helpers.mjs" find "$@" 2>"$TMPERR"

package/eval/agent-read-workflows/bin/ss-grep

@@ -2,7 +2,7 @@
 # ss-grep: indexed bare grep (gram-prefiltered) over the cwd's Sweet Search index.
 # Compact agent-friendly output: file:line  matchText
 #
-# Usage:  ss-grep <regex> [-k N]
+# Usage:  ss-grep <regex> [-i|--ignore-case] [-k N]
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 TMPERR=$(mktemp)
 node "$DIR/_ss-helpers.mjs" grep "$@" 2>"$TMPERR"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.5.12",
+  "version": "2.5.13",
   "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",
@@ -76,6 +76,7 @@
     "eval/agent-read-workflows/bin/ss-trace",
     "eval/agent-read-workflows/bin/ss-read",
     "eval/agent-read-workflows/bin/_ss-helpers.mjs",
+    "eval/agent-read-workflows/bin/_ss-argparse.mjs",
     "crates/wasm-router/pkg/",
     "LICENSE",
     "NOTICE"
@@ -164,12 +165,12 @@
   },
   "optionalDependencies": {
     "usearch": "^2.21.4",
-    "@sweet-search/native-darwin-arm64": "2.5.12",
-    "@sweet-search/native-darwin-x64": "2.5.12",
-    "@sweet-search/native-linux-arm64-gnu": "2.5.12",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.5.12",
-    "@sweet-search/native-linux-x64-gnu": "2.5.12",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.5.12"
+    "@sweet-search/native-darwin-arm64": "2.5.13",
+    "@sweet-search/native-darwin-x64": "2.5.13",
+    "@sweet-search/native-linux-arm64-gnu": "2.5.13",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.5.13",
+    "@sweet-search/native-linux-x64-gnu": "2.5.13",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.5.13"
   },
   "engines": {
     "node": ">=18.0.0"