@mcptoolshop/claude-synergy 0.0.0 → 1.0.0

package/dist/chunk-YFGUTT22.js

@@ -0,0 +1,754 @@
+// src/db.ts
+import Database from "better-sqlite3";
+import { readFileSync, mkdirSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+import * as sqliteVec from "sqlite-vec";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var SCHEMA_VERSION = 2;
+function openDb(path, opts = {}) {
+  const abs = resolve(path);
+  mkdirSync(dirname(abs), { recursive: true });
+  const db = new Database(abs);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  if (opts.loadVec !== false) {
+    try {
+      sqliteVec.load(db);
+    } catch (e) {
+      const quiet = process.env.HK_DEBUG_VEC_LOAD_FAIL_SILENT || process.env.CLAUDE_SYNERGY_QUIET || process.env.MCP_QUIET;
+      if (!quiet) {
+        console.error(`[warn] sqlite-vec load failed: ${e.message}`);
+      }
+    }
+  }
+  return db;
+}
+function initSchema(db, schemaPath) {
+  const existing = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='products'`).get();
+  if (existing) {
+    ensureSchemaVersion(db);
+    return;
+  }
+  const resolved = schemaPath ?? resolveSchemaPath();
+  const sql = readFileSync(resolved, "utf-8");
+  db.exec(sql);
+  ensureSchemaVersion(db);
+}
+function ensureSchemaVersion(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  const row = db.prepare(`SELECT value FROM schema_meta WHERE key = 'schema_version'`).get();
+  const currentVersion = row ? parseInt(row.value, 10) : 0;
+  if (currentVersion > SCHEMA_VERSION) {
+    throw new Error(
+      `Database schema version ${currentVersion} is newer than this tool supports (version ${SCHEMA_VERSION}). Please upgrade claude-synergy: npm update -g @mcptoolshop/claude-synergy`
+    );
+  }
+  if (currentVersion < SCHEMA_VERSION) {
+    migrateSchema(db, currentVersion, SCHEMA_VERSION);
+    db.prepare(`
+      INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', @version)
+    `).run({ version: String(SCHEMA_VERSION) });
+  }
+}
+function migrateSchema(db, fromVersion, toVersion) {
+  void db;
+  void fromVersion;
+  void toVersion;
+}
+function resolveSchemaPath() {
+  const candidates = [
+    join(__dirname, "..", "schema.sql"),
+    join(process.cwd(), "schema.sql")
+  ];
+  for (const p of candidates) {
+    try {
+      readFileSync(p);
+      return p;
+    } catch {
+    }
+  }
+  throw new Error(`schema.sql not found in: ${candidates.join(", ")}`);
+}
+
+// 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.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) {
+  if (product) {
+    const sql2 = `
+      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 r.product = ?
+      GROUP BY r.product, r.version
+      ORDER BY r.released_at DESC
+      LIMIT ?
+    `;
+    return db.prepare(sql2).all(product, limit);
+  }
+  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
+    GROUP BY r.product, r.version
+    ORDER BY r.released_at DESC
+    LIMIT ?
+  `;
+  return db.prepare(sql).all(limit);
+}
+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 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);
+}
+
+// src/providers/embedding/ollama.ts
+function providerTimeoutMs() {
+  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 safeErrorBody(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 OllamaEmbeddingProvider = class {
+  name = "ollama";
+  model;
+  dimension = 768;
+  host;
+  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_EMBED_MODEL ?? "nomic-embed-text";
+  }
+  async embed(inputs) {
+    if (inputs.length === 0) return [];
+    const timeoutMs = providerTimeoutMs();
+    let res;
+    try {
+      res = await fetch(`${this.host}/api/embed`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          input: inputs
+        }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+        throw new Error(`Ollama embed request timed out after ${timeoutMs}ms \u2014 is the Ollama server responsive?`);
+      }
+      throw e;
+    }
+    if (!res.ok) throw new Error(`Ollama embed ${res.status}: ${await safeErrorBody(res)}`);
+    const json = await res.json();
+    return json.embeddings.map((e) => {
+      if (e.length !== this.dimension) {
+        throw new Error(
+          `expected dimension ${this.dimension} for ${this.model}, got ${e.length}. Set OLLAMA_EMBED_MODEL or update dimension.`
+        );
+      }
+      return Float32Array.from(e);
+    });
+  }
+};
+
+// src/providers/retry.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+async function withRetry(fn, opts = {}) {
+  const maxAttempts = opts.maxAttempts ?? 3;
+  const baseDelayMs = opts.baseDelayMs ?? 1e3;
+  const maxDelayMs = opts.maxDelayMs ?? 3e4;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (opts.signal?.aborted) {
+      throw new Error("Operation cancelled via AbortSignal");
+    }
+    try {
+      const data = await fn(attempt);
+      return { data, attempts: attempt };
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt >= maxAttempts) break;
+      if (!isRetryable(lastError)) break;
+      const expDelay = baseDelayMs * Math.pow(2, attempt - 1);
+      const cappedDelay = Math.min(expDelay, maxDelayMs);
+      const jitteredDelay = Math.random() * cappedDelay;
+      await sleep(jitteredDelay, opts.signal);
+    }
+  }
+  throw lastError;
+}
+function isRetryable(err) {
+  const msg = err.message;
+  for (const status of RETRYABLE_STATUSES) {
+    if (msg.includes(String(status))) return true;
+  }
+  if (err.name === "TimeoutError" || err.name === "AbortError") return true;
+  if (msg.includes("timed out")) return true;
+  if (msg.includes("ECONNRESET") || msg.includes("ECONNREFUSED")) return true;
+  if (msg.includes("fetch failed") || msg.includes("network")) return true;
+  return false;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Operation cancelled via AbortSignal"));
+      return;
+    }
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(new Error("Operation cancelled via AbortSignal"));
+    }, { once: true });
+  });
+}
+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>";
+  }
+}
+
+// src/providers/embedding/voyage.ts
+var VoyageEmbeddingProvider = class {
+  name = "voyage";
+  model;
+  dimension = 768;
+  apiKey;
+  /** Accumulated usage across all embed() calls on this instance. */
+  _usage = { tokens: 0, requests: 0 };
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.VOYAGE_API_KEY ?? "";
+    this.model = opts.model ?? "voyage-3-large";
+    if (!this.apiKey) {
+      throw new Error("voyage embedding 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 embed(inputs, signal) {
+    const timeoutMs = providerTimeoutMs2();
+    const { data: result } = await withRetry(
+      async () => {
+        let res;
+        try {
+          res = await fetch("https://api.voyageai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+              "authorization": `Bearer ${this.apiKey}`,
+              "content-type": "application/json"
+            },
+            body: JSON.stringify({
+              model: this.model,
+              input: inputs,
+              input_type: "document",
+              output_dimension: this.dimension
+            }),
+            signal: signal ?? AbortSignal.timeout(timeoutMs)
+          });
+        } catch (e) {
+          if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+            throw new Error(`Voyage embed request timed out after ${timeoutMs}ms \u2014 is the API responsive?`);
+          }
+          throw e;
+        }
+        if (!res.ok) throw new Error(`Voyage ${res.status}: ${await safeErrorBody2(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) => Float32Array.from(d.embedding));
+  }
+};
+
+// src/providers/rerank/ollama-judge.ts
+function providerTimeoutMs3() {
+  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 safeErrorBody3(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 = providerTimeoutMs3();
+    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 safeErrorBody3(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 = providerTimeoutMs2();
+    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 safeErrorBody2(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 = providerTimeoutMs2();
+    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 safeErrorBody2(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 emb = makeEmbeddingProvider(opts.embedProviderName ?? "ollama");
+  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.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 ?? "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 makeEmbeddingProvider(name) {
+  switch (name) {
+    case "ollama":
+      return new OllamaEmbeddingProvider();
+    case "voyage":
+      return new VoyageEmbeddingProvider();
+  }
+}
+function makeRerankProvider(name) {
+  switch (name) {
+    case "ollama-judge":
+      return new OllamaJudgeRerankProvider();
+    case "voyage":
+      return new VoyageRerankProvider();
+    case "cohere":
+      return new CohereRerankProvider();
+  }
+}
+
+export {
+  openDb,
+  initSchema,
+  searchChanges,
+  lookupEntity,
+  recentReleases,
+  listProducts,
+  entityFrequency,
+  OllamaEmbeddingProvider,
+  VoyageEmbeddingProvider,
+  hybridSearch
+};