@spikedpunch/mast 0.1.0

package/dist/search/declex.js

@@ -0,0 +1,242 @@
+/**
+ * Ranker D — the declaration-exact ranker: a match against `chunks.symbol_name`
+ * (full-name or final-dot-segment), case-insensitive, deterministically
+ * ordered.
+ *
+ * Ported from `eval/declex-ranker.mjs`, the Q1/DECLEX-measured construction
+ * (IMPLEMENTATION_PLAN.md § "Q1/DECLEX — the declaration-exact ranker" +
+ * AMENDMENT 1, commit dd10796; Stage 6 of the productization plan). PRIMARY
+ * ARM ONLY — this file intentionally does NOT port the escape variant
+ * (`escape`/`escapeCap` options, `escapeEligibleTerms`/
+ * `lowercaseTokenMatchCounts` diagnostics) or `classifyTargetReach`
+ * (instrument-analysis machinery, not product). The escape variant was
+ * measured harmful off-stratum (M2 decision memo) and is barred from
+ * shipping without a fresh pre-registration.
+ *
+ * Ranker D queries the `chunks` table DIRECTLY (not `chunk_fts`/
+ * `identifier_fts`): `chunk_fts.symbol_name` is stored UNINDEXED
+ * (`src/graph/db.ts`) — not reachable via FTS5 MATCH — and the registered
+ * match rule ("equals the chunk's own symbol_name OR its final dot-segment")
+ * is a structural string comparison, not a full-text match, so a direct SQL
+ * predicate against `chunks.symbol_name` is the correct primitive.
+ */
+import { sql } from 'kysely';
+import { compileScopeMatcher } from './scope.js';
+/**
+ * Ranker D's candidate pool multiplier — 4x the caller's own `limit`, the
+ * SAME convention as ranker I (`eval/idfuse-ranker.mjs`, AMENDMENT 1 F8) and
+ * the pre-Stage-7 vector search helper: the caller multiplies by 4 and passes
+ * the already-multiplied limit directly; `searchRankerD` applies no further
+ * internal multiplication.
+ */
+export const RANKER_D_POOL_MULTIPLIER = 4;
+// ---------------------------------------------------------------------------
+// Term derivation + eligibility gate (pure, no DB)
+// ---------------------------------------------------------------------------
+/** Raw token split — identical character class to ranker I's own derivation
+ * (`eval/idfuse-ranker.mjs`); no camelCase split, no lowercasing. `Class.method`
+ * splits into two independent terms (the dot is not in the character class). */
+export function deriveRankerDTerms(query) {
+    return query.match(/[A-Za-z0-9_$]+/g) ?? [];
+}
+const DIGIT_ADJACENT_LETTER = /[0-9][A-Za-z]|[A-Za-z][0-9]/;
+/**
+ * Symbol-shaped eligibility predicate for ranker D's PRIMARY arm — reproduces
+ * `isSymbolShapedTerm` (`eval/idfuse-ranker.mjs`) MINUS the dead
+ * `term.includes('.')` clause (registration: "the implementation also tests
+ * term.includes('.'), but the upstream split character class
+ * `/[A-Za-z0-9_$]+/` never includes `.` in any surviving token ... Ranker D's
+ * eligibility gate reproduces this predicate but drops the dead clause rather
+ * than reimplementing dead code"). A term qualifies if it contains an
+ * uppercase letter, an underscore, a dollar sign, or a digit adjacent to a
+ * letter.
+ */
+export function isEligiblePrimaryTerm(term) {
+    return (/[A-Z]/.test(term) ||
+        term.includes('_') ||
+        term.includes('$') ||
+        DIGIT_ADJACENT_LETTER.test(term));
+}
+/** Ranker D's PRIMARY-arm eligible terms: raw split, filtered to symbol-shaped. */
+export function deriveEligiblePrimaryTerms(query) {
+    return deriveRankerDTerms(query).filter(isEligiblePrimaryTerm);
+}
+// ---------------------------------------------------------------------------
+// SQL match primitive — direct predicate against `chunks.symbol_name`
+// ---------------------------------------------------------------------------
+/** Escape `\`, `%`, `_` for a SQLite LIKE pattern (registration's segment
+ * match is a STRUCTURAL suffix-after-dot comparison; a raw token containing
+ * `_` — a legal, even common, eligible character per the split regex — would
+ * otherwise be silently reinterpreted as a single-character LIKE wildcard,
+ * producing false-positive segment matches. `ESCAPE '\'` in the query below
+ * neutralises that.) */
+function escapeLikeToken(token) {
+    return token.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+/**
+ * Query `chunks` for every row whose `symbol_name` equals `token`
+ * case-insensitively (full-name match) OR whose `symbol_name` ends with
+ * `.` + `token` case-insensitively (segment match — the only chunk type with
+ * a dot in `symbol_name` is `method`, `symbol_name = `${className}.${methodName}``,
+ * `typescript.ts:324`; a chunk with no dot can only ever full-name-match, per
+ * the registration's "no segment logic needed for class_shell").
+ *
+ * Full-name equality is a plain parameterized `=` (no wildcard risk). Segment
+ * matching uses `LIKE` with the token pre-escaped (see `escapeLikeToken`) so
+ * an underscore inside the token cannot masquerade as a wildcard.
+ */
+async function matchToken(db, token) {
+    const lower = token.toLowerCase();
+    const likePattern = `%.${escapeLikeToken(lower)}`;
+    const rows = await db
+        .selectFrom('chunks')
+        .select(['chunk_id', 'symbol_name', 'chunk_type', 'parent_symbol', 'file_path', 'language'])
+        .where('symbol_name', 'is not', null)
+        // NOTE: the doubled backslash below is JS template-literal escaping for a
+        // SINGLE literal backslash in the resulting SQL text (`ESCAPE '\'`) — a
+        // lone `\'` here would be parsed by JS as an escaped quote, silently
+        // dropping the backslash and producing invalid SQL (`ESCAPE ''`).
+        .where(sql `(LOWER(symbol_name) = ${lower} OR LOWER(symbol_name) LIKE ${likePattern} ESCAPE '\\')`)
+        .execute();
+    // `WHERE symbol_name IS NOT NULL` guarantees no row here has a null
+    // symbol_name, but Kysely's column type (`string | null`, per the schema)
+    // does not narrow from a runtime predicate — filter with a type guard
+    // rather than a non-null assertion (banned in product code, §3.1).
+    return rows
+        .filter((r) => r.symbol_name !== null)
+        .map((r) => {
+        const matchType = r.symbol_name.toLowerCase() === lower ? 'full' : 'segment';
+        return {
+            chunk_id: r.chunk_id,
+            symbol_name: r.symbol_name,
+            chunk_type: r.chunk_type,
+            parent_symbol: r.parent_symbol,
+            file_path: r.file_path,
+            language: r.language,
+            match_type: matchType,
+        };
+    });
+}
+/**
+ * Drop candidates outside the caller's scope.
+ *
+ * Applied to the merged pool BEFORE ordering and capping, not after, for two
+ * reasons. The cap would otherwise be spent on rows that are about to be
+ * discarded, so a narrow `file_pattern` over a crowded symbol name would
+ * silently return fewer in-scope declarations than the index holds — the same
+ * silently-incomplete answer the scope filter exists to prevent. And the
+ * ordering itself is scope-dependent: rank position 2 is "how many candidates
+ * share this matched name", which is a property of the pool being ranked, so a
+ * scoped search must count within its own scope to order consistently with what
+ * it returns.
+ */
+function applyScope(candidates, matcher) {
+    if (matcher === null)
+        return [...candidates];
+    return candidates.filter((c) => matcher(c.file_path, c.language));
+}
+/** The final dot-segment of a symbol name (itself, if no dot present). */
+function finalDotSegment(symbolName) {
+    const idx = symbolName.lastIndexOf('.');
+    return idx === -1 ? symbolName : symbolName.slice(idx + 1);
+}
+/**
+ * Ranker D: declaration-exact match against `chunks.symbol_name` (full-name
+ * or final-dot-segment), case-insensitive, deterministically ordered.
+ *
+ * Ordering (registration): full-name matches before segment-only matches;
+ * then fewer total same-matched-name candidates first; then ascending
+ * chunk_id. JUDGMENT CALL (flagged per this codebase's convention, e.g.
+ * `eval/idfuse-score.mjs`'s a-fortiori routing note): "same-name" is read as
+ * "same MATCHED name" — full-name candidates group by their own
+ * `symbol_name`; segment candidates group by the shared final dot-segment
+ * (the quantity the design review's F-4 finding is actually about — a
+ * `toJSON`-class query facing ~140 candidates that all share the SEGMENT
+ * "toJSON", not 140 candidates sharing one `symbol_name`, since each belongs
+ * to a different class). This groups the exact multiplicity class the
+ * registration's own fixture (Gate B, high-multiplicity segment) is built to
+ * exercise.
+ *
+ * `options.scope` restricts the candidate pool to the caller's `file_pattern` /
+ * `language` before any of the above is computed, so `diagnostics.candidate_count`
+ * and the ordering both describe the scoped pool — a scoped search behaves as
+ * though the index contained only the files in scope.
+ *
+ * @param query - the RAW query string (term derivation happens here).
+ */
+export async function searchRankerD(db, query, options) {
+    const rawTerms = deriveRankerDTerms(query);
+    const primaryTerms = [...new Set(rawTerms.filter(isEligiblePrimaryTerm))];
+    // matchesByTerm caches every matchToken() call so the final candidate
+    // assembly never re-queries the same term twice.
+    const matchesByTerm = new Map();
+    for (const t of primaryTerms)
+        matchesByTerm.set(t, await matchToken(db, t));
+    if (primaryTerms.length === 0) {
+        return {
+            rows: [],
+            diagnostics: {
+                fired: false,
+                top_match_channel: null,
+                candidate_count: 0,
+                primary_eligible_terms: primaryTerms,
+            },
+        };
+    }
+    // Merge per-term matches into one candidate map keyed by chunk_id — a
+    // chunk reachable via more than one eligible term is counted once. If any
+    // matching term produced a 'full' hit for that chunk, 'full' wins (a chunk
+    // can only structurally be a 'full' match for its OWN symbol_name and a
+    // 'segment' match for its OWN symbol_name's final segment — these are the
+    // same string only when the symbol_name has no dot, so this precedence
+    // never silently discards information; it only resolves the case where two
+    // DIFFERENT terms both matched the same chunk).
+    const byChunkId = new Map();
+    for (const t of primaryTerms) {
+        const matches = matchesByTerm.get(t) ?? [];
+        for (const m of matches) {
+            const existing = byChunkId.get(m.chunk_id);
+            if (existing === undefined || (existing.match_type === 'segment' && m.match_type === 'full')) {
+                byChunkId.set(m.chunk_id, m);
+            }
+        }
+    }
+    const candidates = applyScope([...byChunkId.values()], compileScopeMatcher(options.scope ?? {}));
+    // Ordering: matchedName grouping (see JSDoc above) — count how many
+    // candidates in THIS query's pool share the same (case-insensitive)
+    // matched name, then sort full-before-segment, ascending count, ascending
+    // chunk_id.
+    const matchedNameOf = (c) => (c.match_type === 'full' ? c.symbol_name : finalDotSegment(c.symbol_name)).toLowerCase();
+    const nameCounts = new Map();
+    for (const c of candidates) {
+        const key = matchedNameOf(c);
+        nameCounts.set(key, (nameCounts.get(key) ?? 0) + 1);
+    }
+    candidates.sort((a, b) => {
+        const typeRank = (c) => (c.match_type === 'full' ? 0 : 1);
+        if (typeRank(a) !== typeRank(b))
+            return typeRank(a) - typeRank(b);
+        const countA = nameCounts.get(matchedNameOf(a)) ?? 0;
+        const countB = nameCounts.get(matchedNameOf(b)) ?? 0;
+        if (countA !== countB)
+            return countA - countB;
+        return a.chunk_id < b.chunk_id ? -1 : a.chunk_id > b.chunk_id ? 1 : 0;
+    });
+    const capped = candidates.slice(0, options.limit);
+    const first = candidates[0];
+    return {
+        rows: capped.map((c) => ({
+            chunk_id: c.chunk_id,
+            symbol_name: c.symbol_name,
+            chunk_type: c.chunk_type,
+            match_type: c.match_type,
+        })),
+        diagnostics: {
+            fired: candidates.length > 0,
+            top_match_channel: first !== undefined ? first.match_type : null,
+            candidate_count: candidates.length,
+            primary_eligible_terms: primaryTerms,
+        },
+    };
+}
+//# sourceMappingURL=declex.js.map

package/dist/search/declex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declex.js","sourceRoot":"","sources":["../../src/search/declex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,GAAG,EAAgB,MAAM,QAAQ,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAuC,MAAM,YAAY,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C,8EAA8E;AAC9E,mDAAmD;AACnD,8EAA8E;AAE9E;;gFAEgF;AAChF,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAO,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;AAC9C,CAAC;AAED,MAAM,qBAAqB,GAAG,6BAA6B,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY;IAChD,OAAO,CACL,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;QAClB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAClB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAClB,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CACjC,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,0BAA0B,CAAC,KAAa;IACtD,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;AACjE,CAAC;AAED,8EAA8E;AAC9E,sEAAsE;AACtE,8EAA8E;AAE9E;;;;;wBAKwB;AACxB,SAAS,eAAe,CAAC,KAAa;IACpC,OAAO,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AACnD,CAAC;AAqBD;;;;;;;;;;;GAWG;AACH,KAAK,UAAU,UAAU,CAAC,EAAM,EAAE,KAAa;IAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IAClC,MAAM,WAAW,GAAG,KAAK,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;IAElD,MAAM,IAAI,GAAG,MAAM,EAAE;SAClB,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,CAAC,UAAU,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;SAC3F,KAAK,CAAC,aAAa,EAAE,QAAQ,EAAE,IAAI,CAAC;QACrC,0EAA0E;QAC1E,wEAAwE;QACxE,qEAAqE;QACrE,kEAAkE;SACjE,KAAK,CAAC,GAAG,CAAS,yBAAyB,KAAK,+BAA+B,WAAW,eAAe,CAAC;SAC1G,OAAO,EAAE,CAAC;IAEb,oEAAoE;IACpE,0EAA0E;IAC1E,sEAAsE;IACtE,mEAAmE;IACnE,OAAO,IAAI;SACR,MAAM,CAAC,CAAC,CAAC,EAA2C,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,IAAI,CAAC;SAC9E,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,SAAS,GAAuB,CAAC,CAAC,WAAW,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;QACjG,OAAO;YACL,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,WAAW,EAAE,CAAC,CAAC,WAAW;YAC1B,UAAU,EAAE,CAAC,CAAC,UAAU;YACxB,aAAa,EAAE,CAAC,CAAC,aAAa;YAC9B,SAAS,EAAE,CAAC,CAAC,SAAS;YACtB,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,UAAU,EAAE,SAAS;SACtB,CAAC;IACJ,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,UAAU,CACjB,UAA0C,EAC1C,OAA4B;IAE5B,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,CAAC,GAAG,UAAU,CAAC,CAAC;IAC7C,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AACpE,CAAC;AAED,0EAA0E;AAC1E,SAAS,eAAe,CAAC,UAAkB;IACzC,MAAM,GAAG,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACxC,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAC7D,CAAC;AA2CD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,EAAM,EACN,KAAa,EACb,OAA4B;IAE5B,MAAM,QAAQ,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC3C,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAE1E,sEAAsE;IACtE,iDAAiD;IACjD,MAAM,aAAa,GAAG,IAAI,GAAG,EAAiC,CAAC;IAC/D,KAAK,MAAM,CAAC,IAAI,YAAY;QAAE,aAAa,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAE5E,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO;YACL,IAAI,EAAE,EAAE;YACR,WAAW,EAAE;gBACX,KAAK,EAAE,KAAK;gBACZ,iBAAiB,EAAE,IAAI;gBACvB,eAAe,EAAE,CAAC;gBAClB,sBAAsB,EAAE,YAAY;aACrC;SACF,CAAC;IACJ,CAAC;IAED,sEAAsE;IACtE,0EAA0E;IAC1E,2EAA2E;IAC3E,wEAAwE;IACxE,0EAA0E;IAC1E,uEAAuE;IACvE,2EAA2E;IAC3E,gDAAgD;IAChD,MAAM,SAAS,GAAG,IAAI,GAAG,EAA+B,CAAC;IACzD,KAAK,MAAM,CAAC,IAAI,YAAY,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC3C,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACxB,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YAC3C,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,EAAE,CAAC;gBAC7F,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC;IAEjG,oEAAoE;IACpE,oEAAoE;IACpE,0EAA0E;IAC1E,YAAY;IACZ,MAAM,aAAa,GAAG,CAAC,CAAsB,EAAU,EAAE,CACvD,CAAC,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAC3F,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAC7B,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACtD,CAAC;IACD,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACvB,MAAM,QAAQ,GAAG,CAAC,CAAsB,EAAU,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvF,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAClE,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACrD,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,MAAM,KAAK,MAAM;YAAE,OAAO,MAAM,GAAG,MAAM,CAAC;QAC9C,OAAO,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAClD,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAE5B,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACvB,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,WAAW,EAAE,CAAC,CAAC,WAAW;YAC1B,UAAU,EAAE,CAAC,CAAC,UAAU;YACxB,UAAU,EAAE,CAAC,CAAC,UAAU;SACzB,CAAC,CAAC;QACH,WAAW,EAAE;YACX,KAAK,EAAE,UAAU,CAAC,MAAM,GAAG,CAAC;YAC5B,iBAAiB,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI;YAChE,eAAe,EAAE,UAAU,CAAC,MAAM;YAClC,sBAAsB,EAAE,YAAY;SACrC;KACF,CAAC;AACJ,CAAC"}

package/dist/search/fts.d.ts

@@ -0,0 +1,77 @@
+import type { Db } from '../graph/db.js';
+export interface FtsSearchOptions {
+    readonly limit: number;
+    readonly filePattern?: string | null;
+    readonly language?: string | null;
+}
+export interface FtsSearchRow {
+    readonly chunk_id: string;
+    readonly symbol_name: string | null;
+    readonly bm25_score: number;
+    readonly match_snippet: string;
+}
+/**
+ * BM25 search over `chunk_fts` using SQLite FTS5.
+ *
+ * The trigram tokeniser surfaces camelCase identifiers and partial matches.
+ * `bm25(chunk_fts)` returns negative scores — lower (more negative) is a
+ * better match. Results are sorted ascending (best first) before RRF ranking.
+ *
+ * `filePattern` and `language` are applied as an `IN` list on `file_path`,
+ * built before the ORDER BY and LIMIT clauses so the restriction is part of
+ * the ranked query rather than a post-filter on its window. Both are resolved
+ * through `./scope.ts`, which owns the glob and language semantics for every
+ * ranker `fusedSearch` fuses — this function must not translate the pattern
+ * itself, or the two rankers can disagree about what the caller asked for.
+ * `chunk_type` and `only_exported` are post-filters applied by the caller
+ * after fetching full chunk records from the chunk store.
+ */
+export declare function searchFts(db: Db, query: string, options: FtsSearchOptions): Promise<FtsSearchRow[]>;
+export interface IdentifierFtsRow {
+    readonly chunk_id: string;
+}
+/**
+ * Exact-identifier search over `identifier_fts`.
+ *
+ * Used by `mast_callers` to produce the `potential_matches` set — chunks that
+ * contain the symbol name as an identifier token but whose call site the
+ * heuristic resolver could not statically link.
+ */
+export declare function searchIdentifiers(db: Db, symbolName: string, limit?: number): Promise<IdentifierFtsRow[]>;
+/**
+ * Uncapped match count for `symbolName` over `identifier_fts` — same
+ * phrase-quoted MATCH expression as {@link searchIdentifiers} (via the shared
+ * {@link buildIdentifierMatchExpr} helper, never duplicated), no `LIMIT`.
+ *
+ * F10 (Stage 3, IMPLEMENTATION_PLAN.md): `searchIdentifiers`' cap silently
+ * dropped real matches with no signal the cap was hit
+ * (`eval/GITNEXUS_COMPARISON.md` M4 — `isUndefined` reported 50 candidates
+ * when the real count was 71). Callers should run this ONLY when the capped
+ * fetch came back full (`identRows.length === limit`) — below the cap, the
+ * fetch count already IS the real count, and this query would be pure waste.
+ */
+export declare function countIdentifierMatches(db: Db, symbolName: string): Promise<number>;
+/**
+ * Near-miss identifier search over `identifier_fts`.
+ *
+ * Unlike {@link searchIdentifiers} (which requires an exact phrase match on the
+ * full symbol), this ORs each term so a chunk matching *any* sub-term is
+ * returned. Used by the zero-result assist path to gather candidate chunks
+ * whose identifiers partially overlap a query that otherwise found nothing.
+ *
+ * Terms are quoted as phrases so separator chars never leak into FTS5 query
+ * syntax. Returns an empty array when no usable term remains.
+ */
+export declare function searchIdentifierNearMiss(db: Db, terms: readonly string[], limit?: number): Promise<IdentifierFtsRow[]>;
+/**
+ * Split an identifier-shaped query into its constituent sub-terms.
+ *
+ * Handles camelCase (`getUser` → `get`, `user`), acronym boundaries
+ * (`HTTPServer` → `http`, `server`), and snake/kebab separators. Sub-terms are
+ * lowercased (FTS5 trigram matching is case-insensitive), de-duplicated, and
+ * filtered below the 3-char trigram floor — a sub-term shorter than a trigram
+ * cannot match `chunk_fts` anyway. Returns an empty array when nothing usable
+ * remains, so callers can short-circuit the assist.
+ */
+export declare function splitIdentifierTerms(query: string): string[];
+//# sourceMappingURL=fts.d.ts.map

package/dist/search/fts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fts.d.ts","sourceRoot":"","sources":["../../src/search/fts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAQzC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,SAAS,CAC7B,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,EAAE,CAAC,CA+DzB;AAMD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,EAAE,EACN,UAAU,EAAE,MAAM,EAClB,KAAK,SAAK,GACT,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAS7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASxF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,SAAK,GACT,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAU7B;AAMD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAc5D"}

package/dist/search/fts.js

@@ -0,0 +1,223 @@
+import { sql } from 'kysely';
+import { resolveScopedPaths } from './scope.js';
+import { chunkValuesForSqlite } from '../graph/sqliteBatch.js';
+/**
+ * BM25 search over `chunk_fts` using SQLite FTS5.
+ *
+ * The trigram tokeniser surfaces camelCase identifiers and partial matches.
+ * `bm25(chunk_fts)` returns negative scores — lower (more negative) is a
+ * better match. Results are sorted ascending (best first) before RRF ranking.
+ *
+ * `filePattern` and `language` are applied as an `IN` list on `file_path`,
+ * built before the ORDER BY and LIMIT clauses so the restriction is part of
+ * the ranked query rather than a post-filter on its window. Both are resolved
+ * through `./scope.ts`, which owns the glob and language semantics for every
+ * ranker `fusedSearch` fuses — this function must not translate the pattern
+ * itself, or the two rankers can disagree about what the caller asked for.
+ * `chunk_type` and `only_exported` are post-filters applied by the caller
+ * after fetching full chunk records from the chunk store.
+ */
+export async function searchFts(db, query, options) {
+    // Sanitise the user query into a safe FTS5 expression. Passing the raw string
+    // to MATCH lets FTS5 interpret `(`, `:`, `"`, `OR`, etc. as query syntax — a
+    // query like `handleLogin(req` would throw "fts5: syntax error" and (because
+    // this runs outside fusedSearch's try/catch) fail the whole search.
+    const matchExpr = toFtsMatch(query);
+    if (matchExpr === null)
+        return [];
+    // SQLite FTS5 UNINDEXED columns support IN with a literal list reliably,
+    // but LIKE and subquery IN may not be applied by the FTS5 query planner.
+    // The scope is therefore materialised against the regular `files` table
+    // first, then passed as an IN list to the FTS query.
+    const allowedPaths = await resolveScopedPaths(db, {
+        filePattern: options.filePattern,
+        language: options.language,
+    });
+    // A scope that matched no indexed file is an empty result, not an
+    // unrestricted one — `null` means "no scope given" and must not be conflated.
+    if (allowedPaths !== null && allowedPaths.length === 0)
+        return [];
+    const rowLimit = options.limit * 2;
+    // Build all WHERE conditions before ORDER BY / LIMIT.
+    const ranked = (paths) => {
+        let q = db
+            .selectFrom('chunk_fts')
+            .select([
+            'chunk_id',
+            'symbol_name',
+            sql `bm25(chunk_fts)`.as('bm25_score'),
+            sql `snippet(chunk_fts, 0, '**', '**', '...', 12)`.as('match_snippet'),
+        ])
+            .where(sql `chunk_fts MATCH ${matchExpr}`);
+        if (paths !== null)
+            q = q.where('file_path', 'in', [...paths]);
+        return q.orderBy(sql `bm25(chunk_fts)`, 'asc').limit(rowLimit).execute();
+    };
+    if (allowedPaths === null)
+        return ranked(null);
+    // The scope can name every indexed file — a `language` filter on a large
+    // monorepo does exactly that — and an IN list is one bound parameter per
+    // path, so past SQLITE_MAX_VARIABLES the statement throws `too many SQL
+    // variables` and the search fails outright.
+    //
+    // Splitting is safe for a ranked, limited query: each batch is a subset of
+    // the scope, so the global best `rowLimit` rows are necessarily contained in
+    // the union of the per-batch best `rowLimit` rows. Re-sorting that union and
+    // re-applying the limit therefore reproduces the single-statement result
+    // exactly. bm25 is negative, best-first is ascending — the same convention
+    // the SQL above uses.
+    // Two parameters of the statement's budget are not path values: the MATCH
+    // expression and the LIMIT. Declaring them is not defensive padding — a
+    // batch of exactly SQLITE_MAX_VARIABLES paths threw here, and the test at
+    // `graph/__tests__/in-list-batching.test.ts` fails again if a future
+    // predicate binds a third without being counted.
+    const NON_PATH_BOUND_PARAMS = 2;
+    const batches = chunkValuesForSqlite(allowedPaths, 1, NON_PATH_BOUND_PARAMS);
+    if (batches.length === 1)
+        return ranked(allowedPaths);
+    const merged = [];
+    for (const batch of batches)
+        merged.push(...await ranked(batch));
+    merged.sort((a, b) => a.bm25_score - b.bm25_score);
+    return merged.slice(0, rowLimit);
+}
+/**
+ * Exact-identifier search over `identifier_fts`.
+ *
+ * Used by `mast_callers` to produce the `potential_matches` set — chunks that
+ * contain the symbol name as an identifier token but whose call site the
+ * heuristic resolver could not statically link.
+ */
+export async function searchIdentifiers(db, symbolName, limit = 50) {
+    const matchExpr = buildIdentifierMatchExpr(symbolName);
+    if (matchExpr === null)
+        return [];
+    return db
+        .selectFrom('identifier_fts')
+        .select('chunk_id')
+        .where(sql `identifier_fts MATCH ${matchExpr}`)
+        .limit(limit)
+        .execute();
+}
+/**
+ * Uncapped match count for `symbolName` over `identifier_fts` — same
+ * phrase-quoted MATCH expression as {@link searchIdentifiers} (via the shared
+ * {@link buildIdentifierMatchExpr} helper, never duplicated), no `LIMIT`.
+ *
+ * F10 (Stage 3, IMPLEMENTATION_PLAN.md): `searchIdentifiers`' cap silently
+ * dropped real matches with no signal the cap was hit
+ * (`eval/GITNEXUS_COMPARISON.md` M4 — `isUndefined` reported 50 candidates
+ * when the real count was 71). Callers should run this ONLY when the capped
+ * fetch came back full (`identRows.length === limit`) — below the cap, the
+ * fetch count already IS the real count, and this query would be pure waste.
+ */
+export async function countIdentifierMatches(db, symbolName) {
+    const matchExpr = buildIdentifierMatchExpr(symbolName);
+    if (matchExpr === null)
+        return 0;
+    const row = await db
+        .selectFrom('identifier_fts')
+        .select((eb) => eb.fn.count('chunk_id').as('count'))
+        .where(sql `identifier_fts MATCH ${matchExpr}`)
+        .executeTakeFirst();
+    return row?.count ?? 0;
+}
+/**
+ * Near-miss identifier search over `identifier_fts`.
+ *
+ * Unlike {@link searchIdentifiers} (which requires an exact phrase match on the
+ * full symbol), this ORs each term so a chunk matching *any* sub-term is
+ * returned. Used by the zero-result assist path to gather candidate chunks
+ * whose identifiers partially overlap a query that otherwise found nothing.
+ *
+ * Terms are quoted as phrases so separator chars never leak into FTS5 query
+ * syntax. Returns an empty array when no usable term remains.
+ */
+export async function searchIdentifierNearMiss(db, terms, limit = 20) {
+    const cleaned = terms.map((t) => t.trim()).filter((t) => t.length > 0);
+    if (cleaned.length === 0)
+        return [];
+    const matchExpr = cleaned.map((t) => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+    return db
+        .selectFrom('identifier_fts')
+        .select('chunk_id')
+        .where(sql `identifier_fts MATCH ${matchExpr}`)
+        .limit(limit)
+        .execute();
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Split an identifier-shaped query into its constituent sub-terms.
+ *
+ * Handles camelCase (`getUser` → `get`, `user`), acronym boundaries
+ * (`HTTPServer` → `http`, `server`), and snake/kebab separators. Sub-terms are
+ * lowercased (FTS5 trigram matching is case-insensitive), de-duplicated, and
+ * filtered below the 3-char trigram floor — a sub-term shorter than a trigram
+ * cannot match `chunk_fts` anyway. Returns an empty array when nothing usable
+ * remains, so callers can short-circuit the assist.
+ */
+export function splitIdentifierTerms(query) {
+    const spaced = query
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // camelCase: fooBar -> foo Bar
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2'); // acronym: HTTPServer -> HTTP Server
+    const seen = new Set();
+    const out = [];
+    for (const part of spaced.split(/[^A-Za-z0-9]+/)) {
+        const term = part.toLowerCase();
+        if (term.length < 3)
+            continue;
+        if (seen.has(term))
+            continue;
+        seen.add(term);
+        out.push(term);
+    }
+    return out;
+}
+/**
+ * Build the phrase-quoted FTS5 MATCH expression shared by
+ * {@link searchIdentifiers} and {@link countIdentifierMatches} — the two must
+ * agree on exactly which rows count as a match, or the "real count" F10
+ * reports could disagree with what the capped fetch actually returned.
+ * Quoting as a phrase means any separator char (e.g. `Class.method`) is
+ * matched literally rather than parsed as FTS5 query syntax. Returns null for
+ * an empty/whitespace-only name, so callers can short-circuit instead of
+ * running an invalid MATCH query.
+ */
+function buildIdentifierMatchExpr(symbolName) {
+    const term = symbolName.trim();
+    if (term === '')
+        return null;
+    return `"${term.replace(/"/g, '""')}"`;
+}
+/**
+ * Turn a free-form query into a safe FTS5 MATCH expression for the trigram
+ * `chunk_fts`: identifier-ish tokens (length ≥ 3, the trigram minimum), each
+ * quoted as a phrase so no character is treated as query syntax, joined by
+ * `OR`. Returns null when no usable token remains, so the caller can
+ * short-circuit to an empty result instead of running an invalid query.
+ *
+ * **F15 — why OR and not AND.** FTS5 ANDs bare space-separated phrases, so the
+ * previous space-join required a chunk to contain *every* token. A conceptual
+ * multi-word query therefore matched nothing at all: measured against the nest
+ * corpus, 6 of 20 TSDoc-derived queries returned zero rows despite the corpus
+ * plainly containing the target symbol (e.g. "precondition failed exception
+ * defines an http for type errors" → 0 rows ANDed, 5 ORed). That silently
+ * crippled the lexical half of hybrid search, and made the vector store look
+ * indispensable when it was partly compensating for this bug — see
+ * IMPLEMENTATION_PLAN.md § "nest replication".
+ *
+ * Recall is not traded for precision here: `bm25()` already ranks by term
+ * coverage and inverse document frequency, so a chunk matching every token
+ * still outranks one matching a single common token. OR widens the candidate
+ * pool and lets the ranker do the discriminating — which is what
+ * `identifier_fts` (searchIdentifiers, below) has always done.
+ */
+function toFtsMatch(query) {
+    const tokens = (query.match(/[A-Za-z0-9_]+/g) ?? []).filter((t) => t.length >= 3);
+    if (tokens.length === 0)
+        return null;
+    return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+}
+//# sourceMappingURL=fts.js.map

package/dist/search/fts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fts.js","sourceRoot":"","sources":["../../src/search/fts.ts"],"names":[],"mappings":"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"}