@prom.codes/context-mcp 0.2.0 → 0.2.2

package/README.md

@@ -1,6 +1,6 @@
 # @prom.codes/context-mcp
 
-Prometheus Context Engine — local-first codebase indexing & retrieval as an MCP server (stdio).
+prom.codes Context — local-first codebase indexing & retrieval as an MCP server (stdio).
 
 ## Quick start
 
@@ -22,7 +22,7 @@ Prometheus Context Engine — local-first codebase indexing & retrieval as an MC
 
 With a `PROMETHEUS_API_KEY` the server runs in managed mode: it indexes
 your workspace into a local SQLite database (`~/.prometheus/<hash>.db`)
-and embeds via the Prometheus API. Your code never leaves your machine —
+and embeds via the prom.codes API. Your code never leaves your machine —
 only embedding text transits to the API.
 
 ## Native modules

package/dist/bin.js

@@ -7160,6 +7160,377 @@ var HashEmbeddingProvider = class {
   }
 };
 
+// ../rerank-voyage/dist/index.js
+var DEFAULT_MODEL2 = "rerank-2.5";
+var DEFAULT_BASE_URL = "https://api.voyageai.com/v1";
+var DEFAULT_BATCH5 = 100;
+var DEFAULT_RETRIES5 = 6;
+var DEFAULT_BACKOFF5 = 2e3;
+var DEFAULT_RETRY_MAX2 = 6e4;
+function parseRetryAfterMs2(value, now = Date.now()) {
+  if (value === null)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  if (/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) {
+    const secs = Number(trimmed);
+    if (!Number.isFinite(secs) || secs < 0)
+      return null;
+    return Math.round(secs * 1e3);
+  }
+  if (!/[A-Za-z]/.test(trimmed))
+    return null;
+  const ts = Date.parse(trimmed);
+  if (!Number.isFinite(ts))
+    return null;
+  const delta = ts - now;
+  return delta > 0 ? delta : 0;
+}
+function sleep5(ms, signal) {
+  return new Promise((resolve6, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve6();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable5(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var VoyageRerankProvider = class {
+  name;
+  model;
+  region;
+  #baseUrl;
+  #apiKey;
+  #batchSize;
+  #maxRetries;
+  #retryBaseMs;
+  #retryMaxMs;
+  #fetch;
+  constructor(opts) {
+    if (typeof opts.apiKey !== "string" || opts.apiKey === "") {
+      throw new Error("VoyageRerankProvider: apiKey is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`VoyageRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    this.model = opts.model ?? DEFAULT_MODEL2;
+    this.name = opts.name ?? `voyage:${this.model}`;
+    this.region = opts.region ?? "us";
+    this.#baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.#apiKey = opts.apiKey;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH5;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES5;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF5;
+    this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX2;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    for (let start = 0; start < candidates.length; start += this.#batchSize) {
+      const slice = candidates.slice(start, start + this.#batchSize);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+    }
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const body = {
+      query,
+      documents: batch.map((c) => c.text),
+      model: this.model,
+      return_documents: false,
+      truncation: true
+    };
+    const init = {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.#apiKey}`
+      },
+      body: JSON.stringify(body)
+    };
+    if (signal !== void 0)
+      init.signal = signal;
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      try {
+        const res = await this.#fetch(`${this.#baseUrl}/rerank`, init);
+        if (res.status === 429 || res.status >= 500 && res.status < 600) {
+          lastError = new Error(`${this.name}: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
+          await sleep5(backoff, signal);
+          continue;
+        }
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw nonRetryable5(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+        }
+        const payload = await res.json();
+        return this.#decode(payload, batch.length);
+      } catch (err) {
+        if (err?.name === "AbortError")
+          throw err;
+        if (err?.nonRetryable === true)
+          throw err;
+        if (attempt >= this.#maxRetries)
+          throw err;
+        lastError = err;
+        attempt += 1;
+        await sleep5(this.#computeBackoff(attempt, null), signal);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`${this.name}: exhausted ${this.#maxRetries} retries`);
+  }
+  #computeBackoff(attempt, retryAfterHeader) {
+    const exp = this.#retryBaseMs * 2 ** Math.max(0, attempt - 1);
+    const advised = parseRetryAfterMs2(retryAfterHeader);
+    const lower = advised === null ? exp : Math.max(exp, advised);
+    return Math.min(lower, this.#retryMaxMs);
+  }
+  #decode(payload, expected) {
+    if (!Array.isArray(payload.data) || payload.data.length !== expected) {
+      throw nonRetryable5(`${this.name}: expected ${expected} rerank rows, got ${payload.data?.length ?? 0}`);
+    }
+    return payload.data.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
+        throw nonRetryable5(`${this.name}: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
+        throw nonRetryable5(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevance_score };
+    });
+  }
+};
+
+// ../rerank-openai-compat/dist/index.js
+var DEFAULT_MODEL3 = "bge-reranker-base";
+var DEFAULT_BATCH6 = 100;
+var DEFAULT_RETRIES6 = 6;
+var DEFAULT_BACKOFF6 = 2e3;
+var DEFAULT_RETRY_MAX3 = 6e4;
+var DEFAULT_TIMEOUT = 18e4;
+function parseRetryAfterMs3(value, now = Date.now()) {
+  if (value === null)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  if (/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) {
+    const secs = Number(trimmed);
+    if (!Number.isFinite(secs) || secs < 0)
+      return null;
+    return Math.round(secs * 1e3);
+  }
+  if (!/[A-Za-z]/.test(trimmed))
+    return null;
+  const ts = Date.parse(trimmed);
+  if (!Number.isFinite(ts))
+    return null;
+  const delta = ts - now;
+  return delta > 0 ? delta : 0;
+}
+function sleep6(ms, signal) {
+  return new Promise((resolve6, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve6();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable6(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var OpenAICompatRerankProvider = class {
+  name;
+  model;
+  region;
+  #baseUrl;
+  #apiKey;
+  #batchSize;
+  #maxRetries;
+  #retryBaseMs;
+  #retryMaxMs;
+  #timeoutMs;
+  #fetch;
+  constructor(opts) {
+    if (typeof opts.baseUrl !== "string" || opts.baseUrl === "") {
+      throw new Error("OpenAICompatRerankProvider: baseUrl is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`OpenAICompatRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    if (opts.timeoutMs !== void 0 && (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 0)) {
+      throw new Error(`OpenAICompatRerankProvider: timeoutMs must be a non-negative integer (0 disables), got ${opts.timeoutMs}`);
+    }
+    this.model = opts.model ?? DEFAULT_MODEL3;
+    this.name = opts.name ?? `openai-compat:${this.model}`;
+    this.region = opts.region ?? "self-hosted";
+    this.#baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.#apiKey = opts.apiKey === void 0 || opts.apiKey === "" ? void 0 : opts.apiKey;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH6;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES6;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF6;
+    this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX3;
+    this.#timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    for (let start = 0; start < candidates.length; start += this.#batchSize) {
+      const slice = candidates.slice(start, start + this.#batchSize);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+    }
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const body = {
+      query,
+      documents: batch.map((c) => c.text),
+      model: this.model,
+      return_documents: false
+    };
+    const headers = { "content-type": "application/json" };
+    if (this.#apiKey !== void 0)
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    const payloadJson = JSON.stringify(body);
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      const controller = new AbortController();
+      let timedOut = false;
+      let timer;
+      if (this.#timeoutMs > 0) {
+        timer = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, this.#timeoutMs);
+      }
+      const onParentAbort = () => controller.abort();
+      if (signal !== void 0) {
+        if (signal.aborted)
+          controller.abort();
+        else
+          signal.addEventListener("abort", onParentAbort, { once: true });
+      }
+      const init = {
+        method: "POST",
+        headers,
+        body: payloadJson,
+        signal: controller.signal
+      };
+      try {
+        const res = await this.#fetch(`${this.#baseUrl}/rerank`, init);
+        if (res.status === 429 || res.status >= 500 && res.status < 600) {
+          lastError = new Error(`${this.name}: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
+          await sleep6(backoff, signal);
+          continue;
+        }
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw nonRetryable6(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+        }
+        const payload = await res.json();
+        return this.#decode(payload, batch.length);
+      } catch (err) {
+        const isAbort = err?.name === "AbortError";
+        if (isAbort && !timedOut)
+          throw err;
+        if (!isAbort && err?.nonRetryable === true)
+          throw err;
+        const normalized = timedOut ? new Error(`${this.name}: request timed out after ${this.#timeoutMs}ms`) : err;
+        if (attempt >= this.#maxRetries)
+          throw normalized;
+        lastError = normalized;
+        attempt += 1;
+        await sleep6(this.#computeBackoff(attempt, null), signal);
+      } finally {
+        if (timer !== void 0)
+          clearTimeout(timer);
+        if (signal !== void 0)
+          signal.removeEventListener("abort", onParentAbort);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`${this.name}: exhausted ${this.#maxRetries} retries`);
+  }
+  #computeBackoff(attempt, retryAfterHeader) {
+    const exp = this.#retryBaseMs * 2 ** Math.max(0, attempt - 1);
+    const advised = parseRetryAfterMs3(retryAfterHeader);
+    const lower = advised === null ? exp : Math.max(exp, advised);
+    return Math.min(lower, this.#retryMaxMs);
+  }
+  #decode(payload, expected) {
+    if (!Array.isArray(payload.results) || payload.results.length !== expected) {
+      throw nonRetryable6(`${this.name}: expected ${expected} rerank rows, got ${payload.results?.length ?? 0}`);
+    }
+    return payload.results.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
+        throw nonRetryable6(`${this.name}: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
+        throw nonRetryable6(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevance_score };
+    });
+  }
+};
+
 // dist/composition.js
 var RegionModeViolation = class extends Error {
   mode;
@@ -7395,6 +7766,56 @@ function discoverEmbeddingProvider(env, fetchImpl) {
   validateRegionMode(regionMode, picked.id, picked.provider.region);
   return { ...picked, regionMode };
 }
+function discoverRerankProvider(env, fetchImpl) {
+  const regionMode = parseRegionMode(env.PROMETHEUS_REGION_MODE);
+  const forced = env.PROMETHEUS_RERANK_PROVIDER?.toLowerCase() ?? "none";
+  if (forced === "" || forced === "none")
+    return { id: "none", provider: null };
+  if (forced === "voyage") {
+    const apiKey = env.VOYAGE_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new NoProviderError(`rerank provider "voyage" requested but VOYAGE_API_KEY is missing`);
+    }
+    const model = env.VOYAGE_RERANK_MODEL ?? "rerank-2.5";
+    const region = "us";
+    if (regionMode !== "default") {
+      throw new RegionModeViolation(regionMode, "voyage", region, regionMode === "eu-strict" ? ["nomic", "bge-m3", "mistral", "hash"] : ["nomic", "bge-m3", "hash"]);
+    }
+    const provider = new VoyageRerankProvider({
+      name: "voyage-rerank",
+      apiKey,
+      model,
+      region,
+      baseUrl: env.VOYAGE_BASE_URL ?? "https://api.voyageai.com/v1",
+      maxRetries: intEnv(env, "VOYAGE_RERANK_MAX_RETRIES", 6),
+      retryBaseMs: intEnv(env, "VOYAGE_RERANK_RETRY_BASE_MS", 2e3),
+      batchSize: intEnv(env, "VOYAGE_RERANK_BATCH", 100),
+      ...fetchOpt(fetchImpl)
+    });
+    return { id: "voyage", provider };
+  }
+  if (forced === "bge" || forced === "generic") {
+    const baseUrl = env.PROMETHEUS_RERANK_ENDPOINT;
+    if (baseUrl === void 0 || baseUrl === "") {
+      throw new NoProviderError(`rerank provider "${forced}" requested but PROMETHEUS_RERANK_ENDPOINT is missing`);
+    }
+    const model = env.PROMETHEUS_RERANK_MODEL ?? "bge-reranker-base";
+    const provider = new OpenAICompatRerankProvider({
+      name: env.PROMETHEUS_RERANK_NAME ?? `bge-rerank:${model}`,
+      model,
+      region: "self-hosted",
+      baseUrl,
+      maxRetries: intEnv(env, "PROMETHEUS_RERANK_MAX_RETRIES", 6),
+      retryBaseMs: intEnv(env, "PROMETHEUS_RERANK_RETRY_BASE_MS", 2e3),
+      batchSize: intEnv(env, "PROMETHEUS_RERANK_BATCH", 100),
+      timeoutMs: intEnv(env, "PROMETHEUS_RERANK_TIMEOUT_MS", 18e4),
+      ...apiKeyOpt(env.PROMETHEUS_RERANK_API_KEY),
+      ...fetchOpt(fetchImpl)
+    });
+    return { id: "bge", provider };
+  }
+  throw new NoProviderError(`unknown PROMETHEUS_RERANK_PROVIDER="${forced}" (expected "none", "voyage", or "bge")`);
+}
 function getStableDbPath(workspaceRoot) {
   const abs = resolve4(workspaceRoot);
   const hash = createHash3("sha256").update(abs).digest("hex").slice(0, 16);
@@ -7478,6 +7899,8 @@ async function composeFromEnv(opts) {
   const { id: storageBackend, adapter: storage, dbPath } = discoverStorageBackend(env, regionMode, storageOptions);
   await storage.init();
   const retriever = new HybridRetriever({ storage, embedder });
+  const { id: rerankId, provider: reranker } = discoverRerankProvider(env, opts.fetch);
+  const rerankTopN = intEnv(env, "PROMETHEUS_RERANK_TOP_N", 100);
   const managed = apiKeyPresent && storageBackend === "sqlite";
   let closed = false;
   return {
@@ -7492,6 +7915,9 @@ async function composeFromEnv(opts) {
     storageBackend,
     managed,
     dbPath,
+    reranker,
+    rerankId,
+    rerankTopN,
     async close() {
       if (closed)
         return;
@@ -7645,6 +8071,7 @@ var MAX_K = 50;
 var DEFAULT_K2 = 10;
 var MAX_FILE_BYTES = 256 * 1024;
 var MAX_SNIPPET_BYTES = 1500;
+var RERANK_DOC_BYTES = 4096;
 function symbolToJson(s) {
   return {
     name: s.name,
@@ -7671,7 +8098,7 @@ function textResult(payload) {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
   };
 }
-async function snippetForSymbol(workspaceRoot, symbol, cache) {
+async function snippetForSymbol(workspaceRoot, symbol, cache, capBytes = MAX_SNIPPET_BYTES) {
   try {
     const relPath = symbol.filePath;
     if (isSensitivePath(relPath))
@@ -7689,13 +8116,46 @@ async function snippetForSymbol(workspaceRoot, symbol, cache) {
     if (!(endByte > startByte))
       return null;
     const full = buf.subarray(startByte, endByte);
-    const truncated = full.byteLength > MAX_SNIPPET_BYTES;
-    const view = truncated ? full.subarray(0, MAX_SNIPPET_BYTES) : full;
+    const truncated = full.byteLength > capBytes;
+    const view = truncated ? full.subarray(0, capBytes) : full;
     return { text: view.toString("utf8"), truncated };
   } catch {
     return null;
   }
 }
+async function rerankHead(reranker, query, head, workspaceRoot, cache) {
+  const candidates = [];
+  for (let i = 0; i < head.length; i++) {
+    const snip = await snippetForSymbol(workspaceRoot, head[i].symbol, cache, RERANK_DOC_BYTES);
+    if (snip === null)
+      continue;
+    candidates.push({ id: String(i), text: snip.text });
+  }
+  if (candidates.length === 0)
+    return null;
+  let hits;
+  try {
+    hits = await reranker.rerank(query, candidates, { topK: candidates.length });
+  } catch {
+    return null;
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    const i = Number(hit.id);
+    if (!Number.isFinite(i) || seen.has(i))
+      continue;
+    seen.add(i);
+    const r = head[i];
+    if (r !== void 0)
+      out.push(r);
+  }
+  for (let i = 0; i < head.length; i++) {
+    if (!seen.has(i))
+      out.push(head[i]);
+  }
+  return out;
+}
 function resolveInWorkspace(workspaceRoot, input) {
   if (input === "")
     throw new Error("path must not be empty.");
@@ -7768,7 +8228,7 @@ var changedSinceInput = {
 };
 var emptyInput = {};
 function registerTools(server, deps) {
-  const { storage, retriever, workspaceRoot, workspaceId, workspaceName, regionMode, providerId, storageBackend } = deps;
+  const { storage, retriever, workspaceRoot, workspaceId, workspaceName, regionMode, providerId, storageBackend, reranker, rerankTopN } = deps;
   server.registerTool("search_code", {
     title: "Hybrid code search",
     description: "PRIMARY code search for this workspace \u2014 call this FIRST to find where something is defined, used or implemented, before reading files or guessing paths. Hybrid retrieval (lexical FTS + vector + symbol graph, RRF-fused) over natural-language or symbol queries. Returns the top-k symbols with provenance AND an inline source snippet per hit, so the result is usually actionable without a follow-up get_file. Set `includeSnippet: false` to omit the inline code (symbols only).",
@@ -7776,8 +8236,21 @@ function registerTools(server, deps) {
   }, async (args) => {
     const k = clampK(args.k);
     const includeSnippet = args.includeSnippet ?? true;
-    const results = await retriever.search(args.query, { k });
     const cache = /* @__PURE__ */ new Map();
+    const poolK = reranker ? Math.max(k, rerankTopN ?? 100) : k;
+    const pool = await retriever.search(args.query, { k: poolK });
+    let ordered = pool;
+    let reranked = false;
+    if (reranker && pool.length > 0) {
+      const head = pool.slice(0, rerankTopN ?? 100);
+      const tail = pool.slice(rerankTopN);
+      const reorderedHead = await rerankHead(reranker, args.query, head, workspaceRoot, cache);
+      if (reorderedHead !== null) {
+        ordered = reorderedHead.concat(tail);
+        reranked = true;
+      }
+    }
+    const results = ordered.slice(0, k);
     const mapped = await Promise.all(results.map(async (r) => {
       const base = {
         score: r.score,
@@ -7789,7 +8262,7 @@ function registerTools(server, deps) {
       const snip = await snippetForSymbol(workspaceRoot, r.symbol, cache);
       return snip === null ? base : { ...base, snippet: snip.text, snippetTruncated: snip.truncated };
     }));
-    return textResult({ query: args.query, k, results: mapped });
+    return textResult({ query: args.query, k, reranked, results: mapped });
   });
   server.registerTool("get_symbol", {
     title: "Exact symbol lookup",
@@ -7951,7 +8424,7 @@ function registerTools(server, deps) {
 var SERVER_IDENTITY = {
   name: "prometheus-context-mcp",
   version: PROMETHEUS_VERSION,
-  title: "Prometheus Context Engine"
+  title: "prom.codes Context"
 };
 function createServer(deps, options = {}) {
   const identity = { ...SERVER_IDENTITY, ...options.identity ?? {} };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prom.codes/context-mcp",
-  "version": "0.2.0",
-  "description": "Prometheus Context Engine — local-first codebase indexing & retrieval as an MCP server.",
+  "version": "0.2.2",
+  "description": "prom.codes Context — local-first codebase indexing & retrieval as an MCP server.",
   "type": "module",
   "bin": {
     "prometheus-context-mcp": "dist/bin.js"