@mcptoolshop/claude-synergy 1.0.0 → 1.1.0

package/dist/chunk-H3466JDH.js

@@ -0,0 +1,1564 @@
+// src/errors.ts
+var AppError = class extends Error {
+  code;
+  hint;
+  cause;
+  retryable;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "AppError";
+    this.code = opts.code;
+    this.hint = opts.hint;
+    this.cause = opts.cause;
+    this.retryable = opts.retryable ?? false;
+  }
+  /** Return the structured JSON shape (useful for --json output and MCP results). */
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      hint: this.hint,
+      ...this.cause ? { cause: this.cause } : {},
+      ...this.retryable ? { retryable: this.retryable } : {}
+    };
+  }
+};
+function formatError(err, verbose = false) {
+  if (err instanceof AppError) {
+    const lines = [`\u2717 [${err.code}] ${err.message}`];
+    lines.push(`  hint: ${err.hint}`);
+    if (verbose && err.cause) {
+      lines.push(`  cause: ${err.cause}`);
+    }
+    return lines.join("\n");
+  }
+  if (err instanceof Error) {
+    return `\u2717 ${err.message}`;
+  }
+  return `\u2717 ${String(err)}`;
+}
+
+// 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 __dirname2 = dirname(fileURLToPath(import.meta.url));
+var SCHEMA_VERSION = 3;
+var DEFAULT_EMBEDDING_DIM = 768;
+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) {
+  if (fromVersion < 3 && toVersion >= 3) {
+    const hasDim = db.prepare(`SELECT value FROM schema_meta WHERE key = 'embedding_dim'`).get();
+    if (!hasDim) {
+      db.prepare(`
+        INSERT INTO schema_meta (key, value) VALUES ('embedding_dim', @dim)
+      `).run({ dim: String(DEFAULT_EMBEDDING_DIM) });
+    }
+  }
+  void toVersion;
+}
+function getEmbeddingDim(db) {
+  try {
+    const row = db.prepare(`SELECT value FROM schema_meta WHERE key = 'embedding_dim'`).get();
+    if (!row) return null;
+    const n = parseInt(row.value, 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+function setEmbeddingDim(db, dim) {
+  if (!Number.isFinite(dim) || dim <= 0 || (dim | 0) !== dim) {
+    throw new AppError({
+      code: "EMBEDDING_DIM_INVALID",
+      message: `embedding dimension must be a positive integer (got ${String(dim)})`,
+      hint: "pass a positive integer dim, e.g. 768 (nomic-embed-text), 1536 (text-embedding-3-small), or 3072 (text-embedding-3-large)"
+    });
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  const existing = getEmbeddingDim(db);
+  if (existing !== null && existing !== dim) {
+    const hasChunks = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='chunks'`).get();
+    let chunkCount = 0;
+    if (hasChunks) {
+      const row = db.prepare(`SELECT COUNT(*) AS n FROM chunks`).get();
+      chunkCount = row.n;
+    }
+    if (chunkCount > 0) {
+      throw new AppError({
+        code: "EMBEDDING_DIM_MISMATCH",
+        message: `database is configured for ${existing}-d embeddings but the requested provider produces ${dim}-d vectors (${chunkCount} existing chunks)`,
+        hint: `re-init the DB to switch dimensions: rm <db-path>, then 'hk init' and 'hk embed' again. Existing chunks would be invalid against the new vector index.`
+      });
+    }
+  }
+  db.prepare(`
+    INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('embedding_dim', @dim)
+  `).run({ dim: String(dim) });
+}
+function resolveSchemaPath() {
+  const candidates = [
+    join(__dirname2, "..", "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.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 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/embed.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/providers/context/none.ts
+var NoneContextProvider = class {
+  name = "none";
+  async contextFor(_chunk, _release) {
+    return "";
+  }
+};
+
+// src/providers/context/structured.ts
+var StructuredContextProvider = class {
+  name = "structured";
+  async contextFor(chunk, release) {
+    const date = release.releasedAt ?? "unknown date";
+    const positional = `change ${chunk.ordinalInRelease} of ${chunk.totalInRelease}`;
+    return `In ${release.product} ${release.version} (${date}), ${chunk.kind} (${positional}):`;
+  }
+};
+
+// src/providers/context/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 OllamaContextProvider = class {
+  name = "ollama";
+  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_GEN_MODEL ?? "llama3.2:3b";
+  }
+  async contextFor(chunk, release) {
+    const releaseSnippet = release.siblings.map((s, i) => `${i + 1}. ${s.text}`).slice(0, 30).join("\n");
+    const prompt = [
+      `<document>`,
+      `${release.product} ${release.version} release notes (${release.releasedAt ?? "unknown date"}):`,
+      releaseSnippet,
+      `</document>`,
+      ``,
+      `Here is the chunk we want to situate within the whole document:`,
+      `<chunk>`,
+      chunk.text,
+      `</chunk>`,
+      ``,
+      `Please give a short succinct context (1 sentence, max 30 words) to situate this chunk within the overall document for improving search retrieval of the chunk. Mention any related product names, env vars, command names, or APIs. Answer only with the succinct context and nothing else.`
+    ].join("\n");
+    const timeoutMs = providerTimeoutMs();
+    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,
+          options: { temperature: 0, num_predict: 80 }
+        }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+        throw new Error(`Ollama context request timed out after ${timeoutMs}ms \u2014 is the Ollama server responsive?`);
+      }
+      throw e;
+    }
+    if (!res.ok) throw new Error(`Ollama ${res.status}: ${await safeErrorBody(res)}`);
+    const json = await res.json();
+    return json.response.trim();
+  }
+};
+
+// src/providers/context/claude-haiku.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 ClaudeHaikuContextProvider = class {
+  name = "claude-haiku";
+  apiKey;
+  model;
+  cachedDocByRelease = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+    this.model = opts.model ?? "claude-haiku-4-5-20251001";
+    if (!this.apiKey) {
+      throw new Error("claude-haiku context provider requires ANTHROPIC_API_KEY");
+    }
+  }
+  async contextFor(chunk, release) {
+    const releaseKey = `${release.product}@${release.version}`;
+    let doc = this.cachedDocByRelease.get(releaseKey);
+    if (!doc) {
+      doc = release.siblings.map((s, i) => `${i + 1}. ${s.text}`).join("\n");
+      this.cachedDocByRelease.set(releaseKey, doc);
+    }
+    const userPrompt = [
+      `Chunk: ${chunk.text}`,
+      ``,
+      `Give a 1-sentence context (max 30 words) situating this chunk in the release. Mention related products, env vars, commands. Output ONLY the context.`
+    ].join("\n");
+    const timeoutMs = providerTimeoutMs2();
+    let res;
+    try {
+      res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 80,
+          system: [
+            {
+              type: "text",
+              text: `${release.product} ${release.version} (${release.releasedAt}) release notes:
+${doc}`,
+              cache_control: { type: "ephemeral" }
+            }
+          ],
+          messages: [{ role: "user", content: userPrompt }]
+        }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+        throw new Error(`Anthropic API request timed out after ${timeoutMs}ms \u2014 is the API responsive?`);
+      }
+      throw e;
+    }
+    if (!res.ok) throw new Error(`Anthropic API ${res.status}: ${await safeErrorBody2(res)}`);
+    const json = await res.json();
+    return (json.content.find((c) => c.type === "text")?.text ?? "").trim();
+  }
+};
+
+// src/providers/embedding/ollama.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 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 = providerTimeoutMs3();
+    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 safeErrorBody3(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 providerTimeoutMs4() {
+  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 safeErrorBody4(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 = providerTimeoutMs4();
+    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 safeErrorBody4(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/embedding/openai.ts
+var NATIVE_DIMS = {
+  "text-embedding-3-small": 1536,
+  "text-embedding-3-large": 3072,
+  "text-embedding-ada-002": 1536
+};
+var OpenAIEmbeddingProvider = class {
+  name = "openai";
+  model;
+  dimension;
+  apiKey;
+  baseUrl;
+  /** Whether the requested dimension matches native (skip sending `dimensions` param). */
+  useNativeDim;
+  _usage = { tokens: 0, requests: 0 };
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    this.model = opts.model ?? process.env.OPENAI_EMBED_MODEL ?? "text-embedding-3-small";
+    this.baseUrl = opts.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+    const native = NATIVE_DIMS[this.model];
+    if (opts.dim !== void 0) {
+      if (native !== void 0 && opts.dim > native) {
+        throw new Error(
+          `OpenAI model ${this.model} has native dim ${native}; requested ${opts.dim} exceeds native and cannot be expanded.`
+        );
+      }
+      this.dimension = opts.dim;
+      this.useNativeDim = native !== void 0 && opts.dim === native;
+    } else {
+      this.dimension = native ?? 1536;
+      this.useNativeDim = true;
+    }
+    if (!this.apiKey) {
+      throw new Error("openai embedding provider requires OPENAI_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) {
+    if (inputs.length === 0) return [];
+    const timeoutMs = providerTimeoutMs4();
+    const body = {
+      model: this.model,
+      input: inputs
+    };
+    if (!this.useNativeDim) {
+      body.dimensions = this.dimension;
+    }
+    const { data: result } = await withRetry(
+      async () => {
+        let res;
+        try {
+          res = await fetch(`${this.baseUrl}/embeddings`, {
+            method: "POST",
+            headers: {
+              "authorization": `Bearer ${this.apiKey}`,
+              "content-type": "application/json"
+            },
+            body: JSON.stringify(body),
+            signal: signal ?? AbortSignal.timeout(timeoutMs)
+          });
+        } catch (e) {
+          if (e?.name === "TimeoutError" || e?.name === "AbortError") {
+            throw new Error(`OpenAI embed request timed out after ${timeoutMs}ms \u2014 is the API responsive?`);
+          }
+          throw e;
+        }
+        if (!res.ok) throw new Error(`OpenAI ${res.status}: ${await safeErrorBody4(res)}`);
+        const json = await res.json();
+        return json;
+      },
+      { maxAttempts: 3, signal }
+    );
+    this._usage.requests++;
+    const totalTokens = result.usage?.total_tokens ?? result.usage?.prompt_tokens;
+    if (typeof totalTokens === "number") {
+      this._usage.tokens += totalTokens;
+    }
+    const sorted = [...result.data].sort((a, b) => a.index - b.index);
+    return sorted.map((d) => {
+      if (d.embedding.length !== this.dimension) {
+        throw new Error(
+          `OpenAI returned ${d.embedding.length}-d embedding for ${this.model}; expected ${this.dimension}. Check OPENAI_EMBED_MODEL or re-init the DB.`
+        );
+      }
+      return Float32Array.from(d.embedding);
+    });
+  }
+};
+
+// src/embed.ts
+var __dirname3 = dirname2(fileURLToPath2(import.meta.url));
+function initVecSchema(db, opts = {}) {
+  if (opts.dim !== void 0) {
+    setEmbeddingDim(db, opts.dim);
+  }
+  const existing = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='chunks'`).get();
+  if (!existing) {
+    const schemaPath = resolveSchemaVecPath();
+    const sql = readFileSync2(schemaPath, "utf-8");
+    db.exec(sql);
+  }
+  const hasVec = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='chunks_vec'`).get();
+  if (!hasVec) {
+    const dim = getEmbeddingDim(db) ?? DEFAULT_EMBEDDING_DIM;
+    db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS chunks_vec USING vec0(embedding FLOAT[${dim}])`);
+  }
+}
+function resolveSchemaVecPath() {
+  const candidates = [
+    join2(__dirname3, "..", "schema-vec.sql"),
+    join2(process.cwd(), "schema-vec.sql")
+  ];
+  for (const p of candidates) {
+    try {
+      readFileSync2(p);
+      return p;
+    } catch {
+    }
+  }
+  throw new Error(`schema-vec.sql not found in: ${candidates.join(", ")}`);
+}
+async function embedAll(db, opts) {
+  const ctx = makeContextProvider(opts.contextProviderName);
+  const existingDim = getEmbeddingDim(db);
+  const emb = makeEmbeddingProvider(opts.embeddingProviderName, {
+    dim: existingDim ?? void 0
+  });
+  setEmbeddingDim(db, emb.dimension);
+  initVecSchema(db);
+  const productFilter = opts.product ? "AND c.product = @product" : "";
+  const forceFilter = opts.force ? "" : "AND ch.id IS NULL";
+  const limitClause = opts.limit ? "LIMIT @limit" : "";
+  const pendingSql = `
+    SELECT c.id AS change_id, c.product, c.version, r.released_at, c.kind, c.text, c.ordinal
+    FROM changes c
+    JOIN releases r ON c.product = r.product AND c.version = r.version
+    LEFT JOIN chunks ch ON ch.change_id = c.id
+    WHERE 1=1
+      ${productFilter}
+      ${forceFilter}
+    ORDER BY c.product, c.version, c.ordinal
+    ${limitClause}
+  `;
+  const params = {};
+  if (opts.product) params.product = opts.product;
+  if (opts.limit) params.limit = opts.limit;
+  const pending = db.prepare(pendingSql).all(params);
+  if (pending.length === 0) {
+    return {
+      contextProvider: ctx.name,
+      embeddingProvider: emb.name,
+      chunksCreated: 0,
+      chunksSkipped: 0,
+      contextMs: 0,
+      embedMs: 0,
+      totalMs: 0
+    };
+  }
+  const byRelease = /* @__PURE__ */ new Map();
+  for (const row of pending) {
+    const key = `${row.product}@${row.version}`;
+    if (!byRelease.has(key)) byRelease.set(key, []);
+    byRelease.get(key).push({
+      changeId: row.change_id,
+      product: row.product,
+      releaseVersion: row.version,
+      releasedAt: row.released_at,
+      kind: row.kind,
+      text: row.text,
+      ordinalInRelease: row.ordinal,
+      totalInRelease: 0
+      // backfilled below
+    });
+  }
+  for (const [, list] of byRelease) {
+    for (const c of list) c.totalInRelease = list.length;
+  }
+  const startTotal = Date.now();
+  let contextMs = 0;
+  let embedMs = 0;
+  const contextsByChange = /* @__PURE__ */ new Map();
+  const allChunks = [];
+  for (const [, siblings] of byRelease) {
+    const release = {
+      product: siblings[0].product,
+      version: siblings[0].releaseVersion,
+      releasedAt: siblings[0].releasedAt,
+      siblings
+    };
+    for (const chunk of siblings) {
+      if (opts.signal?.aborted) break;
+      const t0 = Date.now();
+      const ctxPrefix = await ctx.contextFor(chunk, release);
+      contextMs += Date.now() - t0;
+      contextsByChange.set(chunk.changeId, ctxPrefix);
+      allChunks.push(chunk);
+    }
+    if (opts.signal?.aborted) break;
+  }
+  const batchSize = opts.batchSize ?? 64;
+  const insertChunk = db.prepare(`
+    INSERT OR REPLACE INTO chunks
+      (change_id, product, release_version, released_at, context_prefix, original_text, contextualized, context_provider, embedding_model, embedded_at)
+    VALUES
+      (@change_id, @product, @release_version, @released_at, @context_prefix, @original_text, @contextualized, @context_provider, @embedding_model, @embedded_at)
+  `);
+  const deleteVec = db.prepare(`DELETE FROM chunks_vec WHERE rowid = ?`);
+  const insertVec = db.prepare(`INSERT INTO chunks_vec(rowid, embedding) VALUES (?, ?)`);
+  let created = 0;
+  let stoppedEarly = false;
+  let stopReason;
+  const usage = { requests: 0, tokens: 0 };
+  const totalBatches = Math.ceil(allChunks.length / batchSize);
+  for (let i = 0; i < allChunks.length; i += batchSize) {
+    if (opts.signal?.aborted) {
+      stoppedEarly = true;
+      stopReason = "cancelled";
+      break;
+    }
+    if (opts.maxRequests !== void 0 && usage.requests >= opts.maxRequests) {
+      stoppedEarly = true;
+      stopReason = "budget_requests";
+      break;
+    }
+    if (opts.maxTokens !== void 0 && usage.tokens >= opts.maxTokens) {
+      stoppedEarly = true;
+      stopReason = "budget_tokens";
+      break;
+    }
+    const batch = allChunks.slice(i, i + batchSize);
+    const texts = batch.map((c) => {
+      const prefix = contextsByChange.get(c.changeId) ?? "";
+      return prefix ? `${prefix}
+
+${c.text}` : c.text;
+    });
+    const t0 = Date.now();
+    const vectors = await emb.embed(texts);
+    embedMs += Date.now() - t0;
+    usage.requests++;
+    if ("usage" in emb) {
+      const provUsage = emb.usage;
+      if (provUsage && typeof provUsage.tokens === "number") {
+        usage.tokens = provUsage.tokens;
+      }
+    }
+    const tx = db.transaction(() => {
+      for (let j = 0; j < batch.length; j++) {
+        const c = batch[j];
+        const prefix = contextsByChange.get(c.changeId) ?? "";
+        const contextualized = prefix ? `${prefix}
+
+${c.text}` : c.text;
+        const result = insertChunk.run({
+          change_id: c.changeId,
+          product: c.product,
+          release_version: c.releaseVersion,
+          released_at: c.releasedAt,
+          context_prefix: prefix,
+          original_text: c.text,
+          contextualized,
+          context_provider: ctx.name,
+          embedding_model: `${emb.name}:${emb.model}`,
+          embedded_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const chunkId = Number(result.lastInsertRowid);
+        deleteVec.run(chunkId);
+        insertVec.run(BigInt(chunkId), vectors[j]);
+        created++;
+      }
+    });
+    tx();
+    if (opts.onProgress) {
+      opts.onProgress({
+        batchesCompleted: Math.floor(i / batchSize) + 1,
+        batchesTotal: totalBatches,
+        chunksCompleted: created,
+        chunksTotal: allChunks.length,
+        provider: `${emb.name}:${emb.model}`,
+        tokensUsed: usage.tokens,
+        requestsMade: usage.requests
+      });
+    }
+  }
+  const stats = {
+    contextProvider: ctx.name,
+    embeddingProvider: `${emb.name}:${emb.model}`,
+    chunksCreated: created,
+    chunksSkipped: 0,
+    contextMs,
+    embedMs,
+    totalMs: Date.now() - startTotal
+  };
+  if (usage.requests > 0) {
+    stats.usage = usage;
+  }
+  if (stoppedEarly) {
+    stats.stoppedEarly = true;
+    stats.stopReason = stopReason;
+  }
+  return stats;
+}
+function makeContextProvider(name) {
+  switch (name) {
+    case "none":
+      return new NoneContextProvider();
+    case "structured":
+      return new StructuredContextProvider();
+    case "ollama":
+      return new OllamaContextProvider();
+    case "claude-haiku":
+      return new ClaudeHaikuContextProvider();
+    default:
+      throw new Error(`unknown context provider: ${name}`);
+  }
+}
+function makeEmbeddingProvider(name, opts = {}) {
+  switch (name) {
+    case "ollama":
+      return new OllamaEmbeddingProvider({ model: opts.model });
+    case "voyage":
+      return new VoyageEmbeddingProvider({ model: opts.model });
+    case "openai":
+      return new OpenAIEmbeddingProvider({ model: opts.model, dim: opts.dim });
+    default: {
+      const _exhaustive = name;
+      throw new AppError({
+        code: "EMBED_PROVIDER_UNKNOWN",
+        message: `unknown embedding provider: ${String(_exhaustive)}`,
+        hint: "use one of: ollama | voyage | openai"
+      });
+    }
+  }
+}
+
+// src/providers/rerank/ollama-judge.ts
+function providerTimeoutMs5() {
+  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 safeErrorBody5(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 = providerTimeoutMs5();
+    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 safeErrorBody5(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 = providerTimeoutMs4();
+    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 safeErrorBody4(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 = providerTimeoutMs4();
+    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 safeErrorBody4(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 {
+  AppError,
+  formatError,
+  openDb,
+  initSchema,
+  searchChanges,
+  lookupEntity,
+  recentReleases,
+  listProducts,
+  entityFrequency,
+  browseChanges,
+  getChangesSince,
+  compareVersions,
+  listSynergies,
+  getSynergy,
+  embedAll,
+  hybridSearch
+};