@mcptoolshop/claude-synergy 1.1.1 → 1.2.1

package/dist/chunk-2J45LIMO.js

@@ -0,0 +1,745 @@
+import {
+  AppError,
+  getEmbeddingDim,
+  makeEmbeddingProvider,
+  providerTimeoutMs,
+  safeErrorBody,
+  withRetry
+} from "./chunk-CEIOLMDT.js";
+
+// src/query.ts
+function searchChanges(db, query, opts = {}) {
+  const limit = opts.limit ?? 20;
+  const filters = [];
+  const params = { query, limit };
+  if (opts.product) {
+    filters.push("c.product = @product");
+    params.product = opts.product;
+  }
+  if (opts.since) {
+    filters.push("r.released_at >= @since");
+    params.since = opts.since;
+  }
+  if (opts.until) {
+    filters.push("r.released_at <= @until");
+    params.until = opts.until;
+  }
+  if (opts.kind) {
+    filters.push("c.kind = @kind");
+    params.kind = opts.kind;
+  }
+  const where = filters.length > 0 ? `AND ${filters.join(" AND ")}` : "";
+  const sql = `
+    SELECT c.product, c.version, r.released_at,
+           c.ordinal, c.kind, c.text AS body,
+           snippet(changes_fts, 0, '[[', ']]', '\u2026', 16) AS snippet
+    FROM changes_fts
+    JOIN changes c ON changes_fts.rowid = c.id
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    WHERE changes_fts MATCH @query
+      ${where}
+    ORDER BY r.released_at DESC, c.ordinal ASC
+    LIMIT @limit
+  `;
+  const rows = db.prepare(sql).all(params);
+  return rows.map((r) => ({ ...r, text: r.body }));
+}
+function lookupEntity(db, type, value) {
+  const sql = `
+    SELECT c.product, c.version, r.released_at, c.ordinal, c.kind, c.text,
+           '' AS snippet
+    FROM entities e
+    JOIN changes c ON e.change_id = c.id
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    WHERE e.entity_type = ? AND e.entity_value = ?
+    ORDER BY r.released_at ASC, c.product
+  `;
+  return db.prepare(sql).all(type, value);
+}
+function recentReleases(db, product, limit = 20, since) {
+  const filters = [];
+  const params = { limit };
+  if (product) {
+    filters.push("r.product = @product");
+    params.product = product;
+  }
+  if (since) {
+    filters.push("r.released_at >= @since");
+    params.since = since;
+  }
+  const where = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
+  const sql = `
+    SELECT r.product, r.version, r.released_at, COUNT(c.id) AS change_count
+    FROM releases r
+    LEFT JOIN changes c ON c.product = r.product AND c.version = r.version
+    ${where}
+    GROUP BY r.product, r.version
+    ORDER BY r.released_at DESC
+    LIMIT @limit
+  `;
+  return db.prepare(sql).all(params);
+}
+function listProducts(db) {
+  const sql = `
+    SELECT p.name, p.display_name,
+           COUNT(DISTINCT r.version) AS release_count,
+           (SELECT version FROM releases r2 WHERE r2.product = p.name ORDER BY r2.released_at DESC LIMIT 1) AS latest_version,
+           (SELECT released_at FROM releases r2 WHERE r2.product = p.name ORDER BY r2.released_at DESC LIMIT 1) AS latest_date
+    FROM products p
+    LEFT JOIN releases r ON r.product = p.name
+    GROUP BY p.name
+    ORDER BY release_count DESC
+  `;
+  return db.prepare(sql).all();
+}
+function getSyncStatus(db, opts = {}) {
+  const filters = [];
+  const params = {};
+  if (opts.product) {
+    filters.push("p.name = @product");
+    params.product = opts.product;
+  }
+  const where = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
+  const sql = `
+    SELECT p.name                       AS product,
+           p.fetch_strategy             AS fetch_strategy,
+           m.version                    AS last_release_at,
+           m.updated_at                 AS last_fetch_attempt,
+           CASE WHEN m.updated_at IS NULL THEN NULL
+                ELSE ROUND((julianday('now') - julianday(m.updated_at)) * 24.0, 1)
+           END                          AS hours_since_fetch,
+           (SELECT COUNT(DISTINCT r.version)
+            FROM releases r
+            WHERE r.product = p.name)   AS releases_ingested
+    FROM products p
+    LEFT JOIN markers m
+      ON m.product = p.name
+     AND m.name = 'last_fetched_release_at'
+    ${where}
+    ORDER BY (hours_since_fetch IS NULL) DESC,
+             hours_since_fetch DESC,
+             p.name ASC
+  `;
+  const rows = db.prepare(sql).all(params);
+  if (opts.staleOnly) {
+    const cutoff = opts.staleHours ?? 24;
+    return rows.filter(
+      (r) => r.fetch_strategy !== "manual" && (r.hours_since_fetch === null || r.hours_since_fetch > cutoff)
+    );
+  }
+  return rows;
+}
+function entityFrequency(db, type, limit = 30) {
+  const sql = `
+    SELECT e.entity_value AS value,
+           COUNT(*) AS count,
+           MIN(r.released_at) AS first_seen
+    FROM entities e
+    JOIN changes c ON e.change_id = c.id
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    WHERE e.entity_type = ?
+    GROUP BY e.entity_value
+    ORDER BY count DESC, first_seen ASC
+    LIMIT ?
+  `;
+  return db.prepare(sql).all(type, limit);
+}
+function browseChanges(db, opts = {}) {
+  const limit = opts.limit ?? 20;
+  const filters = [];
+  const params = { limit };
+  if (opts.product) {
+    filters.push("c.product = @product");
+    params.product = opts.product;
+  }
+  if (opts.since) {
+    filters.push("r.released_at >= @since");
+    params.since = opts.since;
+  }
+  if (opts.until) {
+    filters.push("r.released_at <= @until");
+    params.until = opts.until;
+  }
+  if (opts.kind) {
+    filters.push("c.kind = @kind");
+    params.kind = opts.kind;
+  }
+  const where = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
+  const sql = `
+    SELECT c.product, c.version, r.released_at,
+           c.ordinal, c.kind, c.text AS body,
+           '' AS snippet
+    FROM changes c
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    ${where}
+    ORDER BY r.released_at DESC, c.product, c.ordinal ASC
+    LIMIT @limit
+  `;
+  const rows = db.prepare(sql).all(params);
+  return rows.map((r) => ({ ...r, text: r.body }));
+}
+function getChangesSince(db, opts) {
+  if (!opts.since) {
+    throw new AppError({
+      code: "QUERY_SINCE_REQUIRED",
+      message: "getChangesSince requires a `since` date",
+      hint: 'pass since as YYYY-MM-DD (e.g. "2026-01-01")'
+    });
+  }
+  const limit = opts.limit ?? 200;
+  const filters = ["r.released_at >= @since"];
+  const params = { since: opts.since };
+  if (opts.until) {
+    filters.push("r.released_at <= @until");
+    params.until = opts.until;
+  }
+  if (opts.product) {
+    filters.push("c.product = @product");
+    params.product = opts.product;
+  }
+  if (opts.kind) {
+    filters.push("c.kind = @kind");
+    params.kind = opts.kind;
+  }
+  const where = `WHERE ${filters.join(" AND ")}`;
+  const sql = `
+    SELECT c.product, c.version, r.released_at, c.ordinal, c.kind, c.text
+    FROM changes c
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    ${where}
+    ORDER BY r.released_at DESC, c.product, c.version, c.ordinal ASC
+  `;
+  const rows = db.prepare(sql).all(params);
+  const grouped = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const r of rows) {
+    if (total >= limit) break;
+    const key = `${r.product}@${r.version}`;
+    let bucket = grouped.get(key);
+    if (!bucket) {
+      bucket = {
+        product: r.product,
+        version: r.version,
+        released_at: r.released_at,
+        changes: []
+      };
+      grouped.set(key, bucket);
+    }
+    bucket.changes.push({ ordinal: r.ordinal, kind: r.kind, text: r.text });
+    total++;
+  }
+  return Array.from(grouped.values());
+}
+function compareVersions(db, opts) {
+  if (!opts.product || !opts.fromVersion || !opts.toVersion) {
+    throw new AppError({
+      code: "QUERY_COMPARE_ARGS",
+      message: "compareVersions requires product, fromVersion, and toVersion",
+      hint: 'pass all three as strings, e.g. { product: "claude-code", fromVersion: "2.1.100", toVersion: "2.1.147" }'
+    });
+  }
+  const endpoint = db.prepare(`
+    SELECT version, released_at FROM releases
+    WHERE product = ? AND version = ?
+  `);
+  const fromRow = endpoint.get(opts.product, opts.fromVersion);
+  const toRow = endpoint.get(opts.product, opts.toVersion);
+  if (!fromRow || !toRow) {
+    return [];
+  }
+  if (!fromRow.released_at || !toRow.released_at) {
+    throw new AppError({
+      code: "QUERY_VERSION_NO_DATE",
+      message: `cannot compare versions without released_at on both endpoints (${opts.product}@${opts.fromVersion} or ${opts.toVersion} is missing a date)`,
+      hint: "re-ingest the affected product so released_at is populated"
+    });
+  }
+  const sql = `
+    SELECT c.product, c.version, r.released_at, c.ordinal, c.kind, c.text
+    FROM changes c
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    WHERE c.product = @product
+      AND r.released_at > @fromDate
+      AND r.released_at <= @toDate
+    ORDER BY r.released_at DESC, c.version, c.ordinal ASC
+  `;
+  const rows = db.prepare(sql).all({
+    product: opts.product,
+    fromDate: fromRow.released_at,
+    toDate: toRow.released_at
+  });
+  const grouped = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const key = `${r.product}@${r.version}`;
+    let bucket = grouped.get(key);
+    if (!bucket) {
+      bucket = {
+        product: r.product,
+        version: r.version,
+        released_at: r.released_at,
+        changes: []
+      };
+      grouped.set(key, bucket);
+    }
+    bucket.changes.push({ ordinal: r.ordinal, kind: r.kind, text: r.text });
+  }
+  return Array.from(grouped.values());
+}
+function listSynergies(db, opts = {}) {
+  const filters = [];
+  const params = {};
+  if (opts.product) {
+    filters.push("s.id IN (SELECT synergy_id FROM synergy_products WHERE product = @product)");
+    params.product = opts.product;
+  }
+  if (opts.status) {
+    filters.push("s.status = @status");
+    params.status = opts.status;
+  }
+  const where = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
+  const limitClause = opts.limit ? "LIMIT @limit" : "";
+  if (opts.limit) params.limit = opts.limit;
+  const sql = `
+    SELECT s.id, s.name, s.title, s.trigger, s.status, s.last_validated, s.notes_path
+    FROM synergies s
+    ${where}
+    ORDER BY s.last_validated DESC, s.name
+    ${limitClause}
+  `;
+  const rows = db.prepare(sql).all(params);
+  if (rows.length === 0) return [];
+  const ids = rows.map((r) => r.id);
+  const productsByIdSql = `
+    SELECT synergy_id, product FROM synergy_products
+    WHERE synergy_id IN (${ids.map(() => "?").join(",")})
+    ORDER BY synergy_id, product
+  `;
+  const productRows = db.prepare(productsByIdSql).all(...ids);
+  const productsById = /* @__PURE__ */ new Map();
+  for (const pr of productRows) {
+    if (!productsById.has(pr.synergy_id)) productsById.set(pr.synergy_id, []);
+    productsById.get(pr.synergy_id).push(pr.product);
+  }
+  return rows.map((r) => ({ ...r, products: productsById.get(r.id) ?? [] }));
+}
+function getSynergy(db, name) {
+  const synergy = db.prepare(`
+      SELECT id, name, title, trigger, status, last_validated, notes_path
+      FROM synergies WHERE name = ?
+    `).get(name);
+  if (!synergy) return null;
+  const products = db.prepare(`SELECT product FROM synergy_products WHERE synergy_id = ? ORDER BY product`).all(synergy.id).map((r) => r.product);
+  const steps = db.prepare(`SELECT ordinal, text FROM synergy_steps WHERE synergy_id = ? ORDER BY ordinal`).all(synergy.id);
+  const evidence = db.prepare(`SELECT source_url, quote, source_kind FROM synergy_evidence WHERE synergy_id = ?`).all(synergy.id);
+  const change_refs = db.prepare(`
+      SELECT scr.change_id, c.product, c.version, c.text
+      FROM synergy_change_refs scr
+      JOIN changes c ON c.id = scr.change_id
+      WHERE scr.synergy_id = ?
+      ORDER BY c.product, c.version
+    `).all(synergy.id);
+  return {
+    ...synergy,
+    products,
+    steps,
+    evidence,
+    change_refs
+  };
+}
+
+// src/providers/rerank/ollama-judge.ts
+function providerTimeoutMs2() {
+  const raw = process.env.CLAUDE_SYNERGY_PROVIDER_TIMEOUT_MS;
+  const n = raw === void 0 ? NaN : parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : 6e4;
+}
+async function safeErrorBody2(res, max = 200) {
+  try {
+    const body = await res.text();
+    const safe = body.split("\n").filter((l) => !/x-api-key|authorization|bearer|api[-_]?key/i.test(l)).join("\n");
+    return safe.slice(0, max);
+  } catch {
+    return "<unreadable>";
+  }
+}
+var OllamaJudgeRerankProvider = class {
+  name = "ollama-judge";
+  host;
+  model;
+  constructor(opts = {}) {
+    const rawHost = opts.host ?? process.env.OLLAMA_HOST ?? "http://localhost:11434";
+    this.host = /^https?:\/\//.test(rawHost) ? rawHost : `http://${rawHost}`;
+    this.model = opts.model ?? process.env.OLLAMA_RERANK_MODEL ?? "qwen3:8b";
+  }
+  async rerank(query, candidates) {
+    if (candidates.length === 0) return [];
+    const docs = candidates.map((c, i) => `Doc ${i + 1}: ${c.text.slice(0, 400)}`).join("\n\n");
+    const prompt = [
+      `You are a relevance judge for a Claude changelog search.`,
+      `Rate each document 0-10 for how well it answers the user's query.`,
+      `Respond with EXACTLY ${candidates.length} integers, one per line, in order. No prose, no explanations, no doc numbers, just one integer per line.`,
+      ``,
+      `Query: ${query}`,
+      ``,
+      docs,
+      ``,
+      `Scores (one integer per line, ${candidates.length} lines total):`
+    ].join("\n");
+    const timeoutMs = providerTimeoutMs2();
+    let res;
+    try {
+      res = await fetch(`${this.host}/api/generate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          prompt,
+          stream: false,
+          think: false,
+          // for qwen3/o1-style models; harmless on others
+          options: { temperature: 0, num_predict: Math.max(120, candidates.length * 4) }
+        }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+        throw new Error(`Ollama judge rerank timed out after ${timeoutMs}ms \u2014 is the Ollama server responsive?`);
+      }
+      throw e;
+    }
+    if (!res.ok) throw new Error(`Ollama judge ${res.status}: ${await safeErrorBody2(res)}`);
+    const json = await res.json();
+    const scores = parseScores(json.response, candidates.length);
+    return candidates.map((c, i) => ({ id: c.id, score: scores[i] ?? 0 }));
+  }
+};
+function parseScores(response, n) {
+  const lines = response.split(/\r?\n/);
+  const out = [];
+  for (const line of lines) {
+    if (out.length >= n) break;
+    const m = line.match(/-?\d+(?:\.\d+)?/);
+    if (!m) continue;
+    const v = parseFloat(m[0]);
+    if (Number.isFinite(v)) out.push(Math.max(0, Math.min(10, v)));
+  }
+  while (out.length < n) out.push(0);
+  return out;
+}
+
+// src/providers/rerank/voyage.ts
+var VoyageRerankProvider = class {
+  name = "voyage";
+  apiKey;
+  model;
+  /** Accumulated usage across all rerank() calls on this instance. */
+  _usage = { tokens: 0, requests: 0 };
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.VOYAGE_API_KEY ?? "";
+    this.model = opts.model ?? "rerank-2";
+    if (!this.apiKey) {
+      throw new Error("voyage rerank provider requires VOYAGE_API_KEY");
+    }
+  }
+  /** Get accumulated usage stats. */
+  get usage() {
+    return { ...this._usage };
+  }
+  /** Reset accumulated usage counters. */
+  resetUsage() {
+    this._usage = { tokens: 0, requests: 0 };
+  }
+  async rerank(query, candidates, signal) {
+    if (candidates.length === 0) return [];
+    const timeoutMs = providerTimeoutMs();
+    const { data: result } = await withRetry(
+      async () => {
+        let res;
+        try {
+          res = await fetch("https://api.voyageai.com/v1/rerank", {
+            method: "POST",
+            headers: {
+              "authorization": `Bearer ${this.apiKey}`,
+              "content-type": "application/json"
+            },
+            body: JSON.stringify({
+              model: this.model,
+              query,
+              documents: candidates.map((c) => c.text),
+              top_k: candidates.length
+            }),
+            signal: signal ?? AbortSignal.timeout(timeoutMs)
+          });
+        } catch (e) {
+          if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+            throw new Error(`Voyage rerank request timed out after ${timeoutMs}ms \u2014 is the API responsive?`);
+          }
+          throw e;
+        }
+        if (!res.ok) throw new Error(`Voyage rerank ${res.status}: ${await safeErrorBody(res)}`);
+        const json = await res.json();
+        return json;
+      },
+      { maxAttempts: 3, signal }
+    );
+    this._usage.requests++;
+    if (result.usage?.total_tokens) {
+      this._usage.tokens += result.usage.total_tokens;
+    }
+    return result.data.map((d) => ({
+      id: candidates[d.index].id,
+      score: d.relevance_score
+    }));
+  }
+};
+
+// src/providers/rerank/cohere.ts
+var CohereRerankProvider = class {
+  name = "cohere";
+  apiKey;
+  model;
+  /** Accumulated usage across all rerank() calls on this instance. */
+  _usage = { tokens: 0, requests: 0 };
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.COHERE_API_KEY ?? "";
+    this.model = opts.model ?? "rerank-v3.5";
+    if (!this.apiKey) {
+      throw new Error("cohere rerank provider requires COHERE_API_KEY");
+    }
+  }
+  /** Get accumulated usage stats. */
+  get usage() {
+    return { ...this._usage };
+  }
+  /** Reset accumulated usage counters. */
+  resetUsage() {
+    this._usage = { tokens: 0, requests: 0 };
+  }
+  async rerank(query, candidates, signal) {
+    if (candidates.length === 0) return [];
+    const timeoutMs = providerTimeoutMs();
+    const { data: result } = await withRetry(
+      async () => {
+        let res;
+        try {
+          res = await fetch("https://api.cohere.com/v2/rerank", {
+            method: "POST",
+            headers: {
+              "authorization": `Bearer ${this.apiKey}`,
+              "content-type": "application/json"
+            },
+            body: JSON.stringify({
+              model: this.model,
+              query,
+              documents: candidates.map((c) => c.text),
+              top_n: candidates.length
+            }),
+            signal: signal ?? AbortSignal.timeout(timeoutMs)
+          });
+        } catch (e) {
+          if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+            throw new Error(`Cohere rerank request timed out after ${timeoutMs}ms \u2014 is the API responsive?`);
+          }
+          throw e;
+        }
+        if (!res.ok) throw new Error(`Cohere rerank ${res.status}: ${await safeErrorBody(res)}`);
+        const json = await res.json();
+        return json;
+      },
+      { maxAttempts: 3, signal }
+    );
+    this._usage.requests++;
+    if (result.meta?.billed_units?.search_units) {
+      this._usage.tokens += result.meta.billed_units.search_units;
+    }
+    return result.results.map((r) => ({
+      id: candidates[r.index].id,
+      score: r.relevance_score
+    }));
+  }
+};
+
+// src/hybrid.ts
+var MAX_LIMIT = 500;
+function clampLimit(value, fallback, name) {
+  const v = value ?? fallback;
+  if (typeof v !== "number" || !Number.isFinite(v)) {
+    throw new Error(`hybridSearch: ${name} must be a finite number (got ${String(v)})`);
+  }
+  const n = v | 0;
+  return Math.max(1, Math.min(n, MAX_LIMIT));
+}
+function hasVecTable(db) {
+  const tagged = db;
+  if (typeof tagged.__synergyHasVec === "boolean") return tagged.__synergyHasVec;
+  try {
+    db.prepare("SELECT count(*) FROM chunks_vec LIMIT 0").get();
+    tagged.__synergyHasVec = true;
+  } catch {
+    tagged.__synergyHasVec = false;
+  }
+  return tagged.__synergyHasVec;
+}
+var warnedNoVec = false;
+async function hybridSearch(db, query, opts = {}) {
+  const safeLimit = clampLimit(opts.limit, 20, "limit");
+  const safeTopK = clampLimit(opts.topK, 60, "topK");
+  const rerankRequested = clampLimit(opts.rerankCandidates, 20, "rerankCandidates");
+  const safeRerankN = Math.max(safeLimit, rerankRequested);
+  const rrfK = opts.rrfK ?? 60;
+  if (typeof rrfK !== "number" || !Number.isFinite(rrfK)) {
+    throw new Error(`hybridSearch: rrfK must be a finite number (got ${String(rrfK)})`);
+  }
+  const embedName = opts.embed ?? opts.embedProviderName ?? "ollama";
+  const dbDim = getEmbeddingDim(db) ?? void 0;
+  const emb = makeEmbeddingProvider(embedName, { dim: dbDim });
+  const filters = [];
+  const params = {};
+  if (opts.product) {
+    filters.push("ch.product = @product");
+    params.product = opts.product;
+  }
+  if (opts.since) {
+    filters.push("ch.released_at >= @since");
+    params.since = opts.since;
+  }
+  if (opts.until) {
+    filters.push("ch.released_at <= @until");
+    params.until = opts.until;
+  }
+  if (opts.kind) {
+    filters.push("EXISTS (SELECT 1 FROM changes c WHERE c.id = ch.change_id AND c.kind = @kind)");
+    params.kind = opts.kind;
+  }
+  const whereClause = filters.length > 0 ? `AND ${filters.join(" AND ")}` : "";
+  let fts = [];
+  try {
+    const ftsSql = `
+      SELECT ch.id AS id, row_number() OVER (ORDER BY bm25(chunks_fts)) AS rank_pos
+      FROM chunks_fts
+      JOIN chunks ch ON chunks_fts.rowid = ch.id
+      WHERE chunks_fts MATCH @query
+        ${whereClause}
+      ORDER BY bm25(chunks_fts)
+      LIMIT @topK
+    `;
+    fts = db.prepare(ftsSql).all({ ...params, query, topK: safeTopK });
+  } catch (e) {
+    const sanitized = query.replace(/[^A-Za-z0-9 ]/g, " ").trim();
+    if (sanitized) {
+      const ftsSql = `
+        SELECT ch.id AS id, row_number() OVER (ORDER BY bm25(chunks_fts)) AS rank_pos
+        FROM chunks_fts
+        JOIN chunks ch ON chunks_fts.rowid = ch.id
+        WHERE chunks_fts MATCH @query
+          ${whereClause}
+        ORDER BY bm25(chunks_fts)
+        LIMIT @topK
+      `;
+      fts = db.prepare(ftsSql).all({ ...params, query: sanitized, topK: safeTopK });
+    }
+  }
+  const vecAvailable = hasVecTable(db);
+  let vec = [];
+  if (vecAvailable) {
+    const [qvec] = await emb.embed([query]);
+    const vecSql = `
+      SELECT ch.id AS id, row_number() OVER (ORDER BY distance) AS rank_pos
+      FROM chunks_vec
+      JOIN chunks ch ON ch.id = chunks_vec.rowid
+      WHERE chunks_vec.embedding MATCH @qvec AND k = @topK
+        ${whereClause}
+      ORDER BY distance
+    `;
+    vec = db.prepare(vecSql).all({ ...params, qvec, topK: safeTopK });
+  } else if (!warnedNoVec && !process.env.MCP_QUIET && !process.env.CLAUDE_SYNERGY_QUIET) {
+    console.warn("[hybrid] sqlite-vec table not found; using BM25-only");
+    warnedNoVec = true;
+  }
+  const scores = /* @__PURE__ */ new Map();
+  for (const r of fts) {
+    const cur = scores.get(r.id) ?? { bm25: null, vec: null, score: 0 };
+    cur.bm25 = r.rank_pos;
+    cur.score += 1 / (rrfK + r.rank_pos);
+    scores.set(r.id, cur);
+  }
+  for (const r of vec) {
+    const cur = scores.get(r.id) ?? { bm25: null, vec: null, score: 0 };
+    cur.vec = r.rank_pos;
+    cur.score += 1 / (rrfK + r.rank_pos);
+    scores.set(r.id, cur);
+  }
+  if (scores.size === 0) return [];
+  const rrfRanked = Array.from(scores.entries()).sort(([, a], [, b]) => b.score - a.score).slice(0, safeRerankN);
+  const candidateIds = rrfRanked.map(([id]) => id);
+  const placeholders = candidateIds.map(() => "?").join(",");
+  const rowsSql = `
+    SELECT ch.id AS chunk_id, ch.change_id, ch.product, ch.release_version AS version,
+           ch.released_at, c.kind, c.text, ch.contextualized
+    FROM chunks ch
+    JOIN changes c ON c.id = ch.change_id
+    WHERE ch.id IN (${placeholders})
+  `;
+  const rows = db.prepare(rowsSql).all(...candidateIds);
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of rows) byId.set(r.chunk_id, r);
+  const rerankProviderName = opts.rerankProviderName ?? (isKnownReranker(opts.rerank) ? opts.rerank : "none");
+  let rerankScores = /* @__PURE__ */ new Map();
+  if (rerankProviderName !== "none") {
+    const reranker = makeRerankProvider(rerankProviderName);
+    const candidates = rrfRanked.slice(0, rerankRequested).map(([id]) => ({ id, text: byId.get(id)?.contextualized ?? byId.get(id)?.text ?? "" })).filter((c) => c.text);
+    const results = await reranker.rerank(query, candidates);
+    for (const r of results) rerankScores.set(r.id, r.score);
+  }
+  const final = rrfRanked.map(([id, score]) => ({
+    id,
+    rrf: score.score,
+    bm25: score.bm25,
+    vec: score.vec,
+    rerank: rerankScores.get(id) ?? null
+  })).sort((a, b) => {
+    if (rerankProviderName !== "none" && a.rerank !== null && b.rerank !== null) {
+      return b.rerank - a.rerank;
+    }
+    return b.rrf - a.rrf;
+  }).slice(0, safeLimit);
+  return final.map((entry) => {
+    const r = byId.get(entry.id);
+    if (!r) return null;
+    return {
+      ...r,
+      bm25_rank: entry.bm25,
+      vec_rank: entry.vec,
+      rrf_score: entry.rrf,
+      rerank_score: entry.rerank
+    };
+  }).filter(Boolean);
+}
+function isKnownReranker(v) {
+  return v === "none" || v === "ollama-judge" || v === "voyage" || v === "cohere";
+}
+function makeRerankProvider(name) {
+  switch (name) {
+    case "ollama-judge":
+      return new OllamaJudgeRerankProvider();
+    case "voyage":
+      return new VoyageRerankProvider();
+    case "cohere":
+      return new CohereRerankProvider();
+  }
+}
+
+export {
+  searchChanges,
+  lookupEntity,
+  recentReleases,
+  listProducts,
+  getSyncStatus,
+  entityFrequency,
+  browseChanges,
+  getChangesSince,
+  compareVersions,
+  listSynergies,
+  getSynergy,
+  hybridSearch
+};