evrex-mcp 0.8.0 → 0.8.2

package/dist/index.js

@@ -63,7 +63,7 @@ var init_client = __esm({
       // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
       // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
       // which wants ranked hits fast, not a synthesized paragraph.
-      search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths }),
+      search: (repoPath, text, filePaths, boost) => post("/search", { repoPath, text, filePaths, boost }),
       // Everything that happened in a repo, newest first, bounded by days — the
       // same query the desktop Timeline screen makes. Sessions and commits
       // interleaved, each with the handle evrex_expand takes.
@@ -525,6 +525,29 @@ async function synthesizeAnswer(question, evidence, client2, options = {}) {
   };
 }
 
+// ../../packages/llm-core/src/retrieval-boost.ts
+var CORPUS = `The corpus is an engineering-memory index built from a team's coding-agent conversations and git history, retrieved with Postgres full-text OR-matching plus BM25 (exact word stems match; meanings do not). Searchable documents:
+- Conversation turns: prose by the person and the agent, plus tool-call lines like "[tool_call: Edit] apps/backend/src/query/query.service.ts" \u2014 so file paths, function names, error strings and identifiers appear verbatim.
+- Extracted insights: short titled records of decisions made, approaches REJECTED (with the reason), constraints, and procedures.
+- Commit messages: conventional-commit subjects and explanatory bodies.`;
+var EXPAND_SYSTEM = `You expand a search query into terms that will match an engineering record.
+
+${CORPUS}
+
+Given a person's question, produce the search terms most likely to appear VERBATIM in that corpus but absent from the question itself: the identifiers an engineer would have typed (function, constant, env var, file names), the error text the failure would have printed, and the words the same idea takes in commit-message register ("fix the flaky test" \u2192 "flaky", "deflake", "retry", "timeout"). Prefer specific over general \u2014 "RLS" and "row level security" over "database permissions". Never invent identifiers you are not confident exist in this kind of codebase; a wrong specific term matches nothing and costs nothing, but fill the list with your best evidence-seeking guesses.
+
+Respond with JSON only: {"terms": ["...", ...]} \u2014 3 to 8 terms, each 1 to 4 words, no duplicates of the question's own words.`;
+var RERANK_SYSTEM = `You order search results for an engineer's question about their own project's history.
+
+${CORPUS}
+
+You are given the question and a numbered list of candidate results that lexical retrieval fetched. Order the candidate ids best-first by how much each would actually help ANSWER the question:
+- Recorded reasoning outranks mechanical record: a decision, a rejected approach with its reason, a constraint, or an explanation beats a log line or a file listing that merely shares words with the question.
+- A candidate about the question's subject beats one that only quotes its vocabulary; watch for results that repeat the question's words while being about something else entirely.
+- Prefer the origin of an idea over a later mention of it; among near-duplicates prefer the more complete one; use the date only to break ties.
+
+Respond with JSON only: {"ranked": ["id", ...]} \u2014 every listed id at most once, ids from the list only, best first. Include every id you consider relevant; omit only what would waste the reader's attention.`;
+
 // ../../packages/llm-core/src/cli-client.ts
 import { execFile } from "node:child_process";
 var TIMEOUT_MS = 12e4;
@@ -646,6 +669,29 @@ ${request2.user}`;
 // ../../packages/llm-core/src/provider-clients.ts
 import Anthropic3 from "@anthropic-ai/sdk";
 var NOOP = { warn: () => void 0, error: () => void 0 };
+var BATCH_POLL_MS = 5e3;
+var BATCH_TIMEOUT_MS = 6 * 60 * 60 * 1e3;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function totalize(items, results) {
+  for (const item of items) if (!results.has(item.id)) results.set(item.id, null);
+  return results;
+}
+function totalizeIds(ids, results) {
+  for (const id of ids) if (!results.has(id)) results.set(id, null);
+  return results;
+}
+async function pollToCompletion(handle, resolve, sleepFn, onTimeout) {
+  const startedAt = Date.now();
+  for (; ; ) {
+    const resolved = await resolve(handle);
+    if (resolved) return resolved;
+    if (Date.now() - startedAt > BATCH_TIMEOUT_MS) {
+      onTimeout(handle.id);
+      return null;
+    }
+    await sleepFn(BATCH_POLL_MS);
+  }
+}
 var realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var MAX_RETRIES = 4;
 var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
@@ -653,12 +699,12 @@ function isExhaustedStatus(status, retriesSpent) {
   if (status === 401 || status === 403) return true;
   return status === 429 && retriesSpent;
 }
-async function waitBeforeRetry(response, attempt, sleep) {
+async function waitBeforeRetry(response, attempt, sleep2) {
   const header = response.headers.get("retry-after") ?? response.headers.get("x-ratelimit-reset-tokens");
   const seconds = header ? parseDuration(header) : null;
   const backoff = Math.min(8 * 2 ** attempt, 60);
   const wait = Math.min(seconds ?? backoff, MAX_RETRY_WAIT_SECONDS);
-  await sleep(wait * 1e3);
+  await sleep2(wait * 1e3);
 }
 var MAX_RETRY_WAIT_SECONDS = 90;
 function parseDuration(value) {
@@ -678,7 +724,7 @@ function parseJsonBody(text) {
     return null;
   }
 }
-var AnthropicClient = class {
+var AnthropicClient = class _AnthropicClient {
   constructor(key, model, logger) {
     this.model = model;
     this.logger = logger;
@@ -687,37 +733,47 @@ var AnthropicClient = class {
   provider = "anthropic";
   exhausted = false;
   sdk;
+  // The one place a ModelRequest becomes Anthropic's message params, so the
+  // single and batch paths cannot drift on the cache breakpoint or the
+  // json_schema wiring.
+  messageParams(request2) {
+    return {
+      model: request2.model ?? this.model,
+      max_tokens: request2.maxTokens ?? DEFAULT_MAX_TOKENS,
+      // The breakpoint sits at the end of the system prompt, which is the
+      // only part of these requests that repeats. Rendering order is
+      // tools -> system -> messages, so a marker here caches everything
+      // ahead of the transcript.
+      //
+      // Deliberately NOT on the user block. That block is a different
+      // transcript chunk on every call, so a breakpoint there would write a
+      // fresh cache entry per request and read none of them back — paying
+      // the write premium for nothing, which is worse than not caching.
+      system: [
+        {
+          type: "text",
+          text: request2.system,
+          cache_control: { type: "ephemeral" }
+        }
+      ],
+      messages: [{ role: "user", content: request2.user }],
+      ...request2.schema ? {
+        output_config: {
+          format: { type: "json_schema", schema: request2.schema }
+        }
+      } : {}
+    };
+  }
+  static messageText(message) {
+    return message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
   async completeJson(request2) {
     try {
-      const message = await this.sdk.messages.create({
-        model: request2.model ?? this.model,
-        max_tokens: request2.maxTokens ?? DEFAULT_MAX_TOKENS,
-        // The breakpoint sits at the end of the system prompt, which is the
-        // only part of these requests that repeats. Rendering order is
-        // tools -> system -> messages, so a marker here caches everything
-        // ahead of the transcript.
-        //
-        // Deliberately NOT on the user block. That block is a different
-        // transcript chunk on every call, so a breakpoint there would write a
-        // fresh cache entry per request and read none of them back — paying
-        // the write premium for nothing, which is worse than not caching.
-        system: [
-          {
-            type: "text",
-            text: request2.system,
-            cache_control: { type: "ephemeral" }
-          }
-        ],
-        messages: [{ role: "user", content: request2.user }],
-        ...request2.schema ? {
-          output_config: {
-            format: { type: "json_schema", schema: request2.schema }
-          }
-        } : {}
-      });
+      const message = await this.sdk.messages.create(
+        this.messageParams(request2)
+      );
       this.reportCacheUsage(message.usage);
-      const text = message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-      return parseJsonBody(text);
+      return parseJsonBody(_AnthropicClient.messageText(message));
     } catch (err) {
       const status = err?.status;
       if (typeof status === "number" && isExhaustedStatus(status, true)) {
@@ -727,6 +783,58 @@ var AnthropicClient = class {
       return null;
     }
   }
+  async submitBatch(items) {
+    if (items.length === 0) return null;
+    try {
+      const created = await this.sdk.messages.batches.create({
+        requests: items.map((item) => ({
+          custom_id: item.id,
+          params: this.messageParams(item.request)
+        }))
+      });
+      return { provider: "anthropic", id: created.id, itemIds: items.map((i) => i.id) };
+    } catch (err) {
+      const status = err?.status;
+      if (typeof status === "number" && isExhaustedStatus(status, true)) {
+        this.exhausted = true;
+      }
+      this.logger.warn(`anthropic batch submit failed: ${describeError(err)}`);
+      return null;
+    }
+  }
+  async resolveBatch(handle) {
+    try {
+      const batch = await this.sdk.messages.batches.retrieve(handle.id);
+      if (batch.processing_status !== "ended") return null;
+      const results = /* @__PURE__ */ new Map();
+      for await (const entry of await this.sdk.messages.batches.results(
+        handle.id
+      )) {
+        results.set(
+          entry.custom_id,
+          entry.result.type === "succeeded" ? parseJsonBody(_AnthropicClient.messageText(entry.result.message)) : null
+        );
+      }
+      return totalizeIds(handle.itemIds, results);
+    } catch (err) {
+      this.logger.warn(`anthropic batch resolve failed: ${describeError(err)}`);
+      return totalizeIds(handle.itemIds, /* @__PURE__ */ new Map());
+    }
+  }
+  async completeJsonBatch(items) {
+    if (items.length === 0) return /* @__PURE__ */ new Map();
+    const handle = await this.submitBatch(items);
+    if (!handle) return totalize(items, /* @__PURE__ */ new Map());
+    const resolved = await pollToCompletion(
+      handle,
+      (h) => this.resolveBatch(h),
+      sleep,
+      (id) => this.logger.warn(
+        `anthropic batch ${id} did not finish within the cap; the sessions it covers stay unextracted until the next pass`
+      )
+    );
+    return resolved ?? totalize(items, /* @__PURE__ */ new Map());
+  }
   /**
    * Says out loud whether the cache was actually used.
    *
@@ -753,12 +861,12 @@ var AnthropicClient = class {
     );
   }
 };
-var GoogleClient = class {
-  constructor(key, model, logger, sleep = realSleep) {
+var GoogleClient = class _GoogleClient {
+  constructor(key, model, logger, sleep2 = realSleep) {
     this.key = key;
     this.model = model;
     this.logger = logger;
-    this.sleep = sleep;
+    this.sleep = sleep2;
   }
   provider = "google";
   exhausted = false;
@@ -801,56 +909,129 @@ ${JSON.stringify(request2.schema)}` : "";
       return null;
     }
   }
+  static GEMINI_BASE = "https://generativelanguage.googleapis.com/v1beta";
+  async submitBatch(items) {
+    if (items.length === 0) return null;
+    const model = items[0].request.model ?? this.model;
+    try {
+      const create = await fetch(
+        `${_GoogleClient.GEMINI_BASE}/models/${encodeURIComponent(model)}:batchGenerateContent`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-goog-api-key": this.key
+          },
+          body: JSON.stringify({
+            batch: {
+              display_name: "evrex-extraction",
+              input_config: {
+                requests: {
+                  requests: items.map((item) => {
+                    const shape = item.request.schema ? `
+
+Respond with JSON matching exactly this schema:
+${JSON.stringify(item.request.schema)}` : "";
+                    return {
+                      request: {
+                        systemInstruction: {
+                          parts: [{ text: item.request.system + shape }]
+                        },
+                        contents: [
+                          { role: "user", parts: [{ text: item.request.user }] }
+                        ],
+                        generationConfig: { responseMimeType: "application/json" }
+                      },
+                      metadata: { key: item.id }
+                    };
+                  })
+                }
+              }
+            }
+          })
+        }
+      );
+      if (!create.ok) {
+        if (isExhaustedStatus(create.status, true)) this.exhausted = true;
+        this.logger.warn(
+          `google batch submit failed: ${create.status} ${(await create.text()).slice(0, 200)}`
+        );
+        return null;
+      }
+      const name = (await create.json()).name;
+      if (!name) {
+        this.logger.warn("google batch: no job name returned");
+        return null;
+      }
+      return { provider: "google", id: name, itemIds: items.map((i) => i.id) };
+    } catch (err) {
+      this.logger.warn(`google batch submit failed: ${describeError(err)}`);
+      return null;
+    }
+  }
+  async resolveBatch(handle) {
+    try {
+      const poll = await fetch(`${_GoogleClient.GEMINI_BASE}/${handle.id}`, {
+        headers: { "x-goog-api-key": this.key }
+      });
+      if (!poll.ok) {
+        this.logger.warn(`google batch poll failed: ${poll.status}`);
+        return totalizeIds(handle.itemIds, /* @__PURE__ */ new Map());
+      }
+      const job = await poll.json();
+      const state = job.state ?? "";
+      if (state === "JOB_STATE_FAILED" || state === "JOB_STATE_CANCELLED" || state === "JOB_STATE_EXPIRED") {
+        this.logger.warn(`google batch ${handle.id} ended ${state}`);
+        return totalizeIds(handle.itemIds, /* @__PURE__ */ new Map());
+      }
+      if (state !== "JOB_STATE_SUCCEEDED") return null;
+      const inlined = job.response?.inlinedResponses ?? [];
+      const results = /* @__PURE__ */ new Map();
+      handle.itemIds.forEach((id, i) => {
+        const text = inlined[i]?.response?.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("");
+        results.set(id, text ? parseJsonBody(text) : null);
+      });
+      return totalizeIds(handle.itemIds, results);
+    } catch (err) {
+      this.logger.warn(`google batch resolve failed: ${describeError(err)}`);
+      return totalizeIds(handle.itemIds, /* @__PURE__ */ new Map());
+    }
+  }
+  async completeJsonBatch(items) {
+    if (items.length === 0) return /* @__PURE__ */ new Map();
+    const handle = await this.submitBatch(items);
+    if (!handle) return totalize(items, /* @__PURE__ */ new Map());
+    const resolved = await pollToCompletion(
+      handle,
+      (h) => this.resolveBatch(h),
+      this.sleep,
+      (id) => this.logger.warn(
+        `google batch ${id} did not finish within the cap; leaving its sessions for a later pass`
+      )
+    );
+    return resolved ?? totalize(items, /* @__PURE__ */ new Map());
+  }
 };
 var OpenAiCompatibleClient = class {
-  constructor(provider, baseUrl, key, model, logger, sleep = realSleep) {
+  constructor(provider, baseUrl, key, model, logger, sleep2 = realSleep) {
     this.provider = provider;
     this.baseUrl = baseUrl;
     this.key = key;
     this.model = model;
     this.logger = logger;
-    this.sleep = sleep;
+    this.sleep = sleep2;
+    if (this.provider === "openai") {
+      this.completeJsonBatch = (items) => this.runBatch(items);
+    }
   }
   exhausted = false;
+  completeJsonBatch;
   async completeJson(request2, attempt = 0) {
-    const strict = this.provider === "openai";
-    const shape = request2.schema && !strict ? `
-
-Respond with JSON matching exactly this schema:
-${JSON.stringify(request2.schema)}` : "";
     try {
       const res = await fetch(`${this.baseUrl}/chat/completions`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          // A local server does not want one, and some reject an empty bearer
-          // token outright.
-          ...this.key ? { Authorization: `Bearer ${this.key}` } : {}
-        },
-        body: JSON.stringify({
-          model: request2.model ?? this.model,
-          messages: [
-            { role: "system", content: request2.system + shape },
-            { role: "user", content: request2.user }
-          ],
-          ...request2.schema && strict ? {
-            response_format: {
-              type: "json_schema",
-              json_schema: {
-                name: "evrex_result",
-                strict: true,
-                schema: request2.schema
-              }
-            }
-          } : { response_format: { type: "json_object" } },
-          // Extraction is a reading task with a right answer, not a writing
-          // task, and a default sampling temperature makes it a different
-          // answer each run: one model scored 53% and then 20% on the same ten
-          // sessions before this was pinned. Indexing twice must not produce
-          // two different histories.
-          temperature: 0,
-          stream: false
-        })
+        headers: this.authHeaders(),
+        body: JSON.stringify(this.chatBody(request2))
       });
       if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES) {
         await waitBeforeRetry(res, attempt, this.sleep);
@@ -871,6 +1052,147 @@ ${JSON.stringify(request2.schema)}` : "";
       return null;
     }
   }
+  authHeaders() {
+    return {
+      "Content-Type": "application/json",
+      // A local server does not want one, and some reject an empty bearer token.
+      ...this.key ? { Authorization: `Bearer ${this.key}` } : {}
+    };
+  }
+  // One place a ModelRequest becomes the chat body, so completeJson and the
+  // batch path cannot drift on response_format or the pinned temperature.
+  chatBody(request2) {
+    const strict = this.provider === "openai";
+    const shape = request2.schema && !strict ? `
+
+Respond with JSON matching exactly this schema:
+${JSON.stringify(request2.schema)}` : "";
+    return {
+      model: request2.model ?? this.model,
+      messages: [
+        { role: "system", content: request2.system + shape },
+        { role: "user", content: request2.user }
+      ],
+      ...request2.schema && strict ? {
+        response_format: {
+          type: "json_schema",
+          json_schema: {
+            name: "evrex_result",
+            strict: true,
+            schema: request2.schema
+          }
+        }
+      } : { response_format: { type: "json_object" } },
+      // A reading task with a right answer: temperature pinned so indexing
+      // twice is the same history.
+      temperature: 0,
+      stream: false
+    };
+  }
+  async runBatch(items) {
+    const results = /* @__PURE__ */ new Map();
+    if (items.length === 0) return results;
+    const auth = this.key ? { Authorization: `Bearer ${this.key}` } : {};
+    try {
+      const jsonl = items.map(
+        (item) => JSON.stringify({
+          custom_id: item.id,
+          method: "POST",
+          url: "/v1/chat/completions",
+          body: this.chatBody(item.request)
+        })
+      ).join("\n");
+      const form = new FormData();
+      form.append("purpose", "batch");
+      form.append(
+        "file",
+        new Blob([jsonl], { type: "application/jsonl" }),
+        "evrex-batch.jsonl"
+      );
+      const upload = await fetch(`${this.baseUrl}/files`, {
+        method: "POST",
+        headers: auth,
+        body: form
+      });
+      if (!upload.ok) {
+        if (isExhaustedStatus(upload.status, true)) this.exhausted = true;
+        this.logger.warn(
+          `openai batch upload failed: ${upload.status} ${(await upload.text()).slice(0, 200)}`
+        );
+        return totalize(items, results);
+      }
+      const fileId = (await upload.json()).id;
+      if (!fileId) return totalize(items, results);
+      const created = await fetch(`${this.baseUrl}/batches`, {
+        method: "POST",
+        headers: this.authHeaders(),
+        body: JSON.stringify({
+          input_file_id: fileId,
+          endpoint: "/v1/chat/completions",
+          completion_window: "24h"
+        })
+      });
+      if (!created.ok) {
+        this.logger.warn(
+          `openai batch create failed: ${created.status} ${(await created.text()).slice(0, 200)}`
+        );
+        return totalize(items, results);
+      }
+      const batchId = (await created.json()).id;
+      if (!batchId) return totalize(items, results);
+      let status = "";
+      let outputFileId;
+      const startedAt = Date.now();
+      while (status !== "completed") {
+        if (Date.now() - startedAt > BATCH_TIMEOUT_MS) {
+          this.logger.warn(
+            `openai batch ${batchId} did not finish within the cap; leaving its sessions for a later pass`
+          );
+          return totalize(items, results);
+        }
+        await this.sleep(BATCH_POLL_MS);
+        const poll = await fetch(`${this.baseUrl}/batches/${batchId}`, {
+          headers: auth
+        });
+        if (!poll.ok) {
+          this.logger.warn(`openai batch poll failed: ${poll.status}`);
+          return totalize(items, results);
+        }
+        const job = await poll.json();
+        status = job.status ?? "";
+        outputFileId = job.output_file_id;
+        if (status === "failed" || status === "expired" || status === "cancelled") {
+          this.logger.warn(`openai batch ${batchId} ended ${status}`);
+          return totalize(items, results);
+        }
+      }
+      if (!outputFileId) return totalize(items, results);
+      const out = await fetch(`${this.baseUrl}/files/${outputFileId}/content`, {
+        headers: auth
+      });
+      if (!out.ok) {
+        this.logger.warn(`openai batch results fetch failed: ${out.status}`);
+        return totalize(items, results);
+      }
+      for (const line of (await out.text()).split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const row = JSON.parse(line);
+          const content = row.response?.body?.choices?.[0]?.message?.content;
+          if (row.custom_id) {
+            results.set(
+              row.custom_id,
+              typeof content === "string" ? parseJsonBody(content) : null
+            );
+          }
+        } catch {
+        }
+      }
+    } catch (err) {
+      this.logger.warn(`openai batch failed: ${describeError(err)}`);
+    }
+    return totalize(items, results);
+  }
 };
 function describeError(err) {
   return err instanceof Error ? err.message : String(err);
@@ -882,9 +1204,9 @@ function createModelClient(key, options = {}) {
   const model = options.model ?? DEFAULT_MODELS[provider];
   const trimmed = key.trim();
   if (provider === "anthropic") return new AnthropicClient(trimmed, model, logger);
-  const sleep = options.sleep ?? realSleep;
+  const sleep2 = options.sleep ?? realSleep;
   if (provider === "google")
-    return new GoogleClient(trimmed, model, logger, sleep);
+    return new GoogleClient(trimmed, model, logger, sleep2);
   const cli = CLI_SPECS[provider];
   if (cli) return new CliClient(cli, model, logger);
   if (provider === "local") {
@@ -894,7 +1216,7 @@ function createModelClient(key, options = {}) {
       null,
       model,
       logger,
-      sleep
+      sleep2
     );
   }
   const baseUrl = options.baseUrl ?? OPENAI_COMPATIBLE_BASE_URLS[provider];
@@ -905,7 +1227,7 @@ function createModelClient(key, options = {}) {
     trimmed,
     model,
     logger,
-    sleep
+    sleep2
   );
 }
 

package/dist/pretool.js

@@ -49,7 +49,7 @@ var evrexApi = {
   // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
   // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
   // which wants ranked hits fast, not a synthesized paragraph.
-  search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths }),
+  search: (repoPath, text, filePaths, boost) => post("/search", { repoPath, text, filePaths, boost }),
   // Everything that happened in a repo, newest first, bounded by days — the
   // same query the desktop Timeline screen makes. Sessions and commits
   // interleaved, each with the handle evrex_expand takes.

package/dist/tickets.js

@@ -63,7 +63,7 @@ var init_client = __esm({
       // Evidence-only retrieval (BM25 + embedding), no LLM synthesis call — see
       // apps/backend/src/query/query.service.ts#search. Used by evrex_search,
       // which wants ranked hits fast, not a synthesized paragraph.
-      search: (repoPath, text, filePaths) => post("/search", { repoPath, text, filePaths }),
+      search: (repoPath, text, filePaths, boost) => post("/search", { repoPath, text, filePaths, boost }),
       // Everything that happened in a repo, newest first, bounded by days — the
       // same query the desktop Timeline screen makes. Sessions and commits
       // interleaved, each with the handle evrex_expand takes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evrex-mcp",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "MCP server that gives coding agents the recorded reasoning behind a repo: prior decisions, hard constraints, and approaches already rejected.",
   "keywords": [
     "mcp",
@@ -36,27 +36,28 @@
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "bundle": "node scripts/bundle.mjs",
+    "dev": "tsc -p tsconfig.json --watch",
+    "lint": "eslint .",
+    "check-types": "tsc --noEmit",
+    "test": "tsc -p tsconfig.json && node --test dist/*.test.js",
+    "prepack": "pnpm run bundle"
+  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.72.0",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@repo/eslint-config": "workspace:*",
+    "@repo/ingest-core": "workspace:*",
+    "@repo/llm-core": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
     "@types/node": "^24.0.0",
     "esbuild": "^0.25.12",
     "eslint": "^9.39.1",
-    "typescript": "^5.9.2",
-    "@repo/eslint-config": "0.0.0",
-    "@repo/ingest-core": "0.0.0",
-    "@repo/llm-core": "0.0.0",
-    "@repo/typescript-config": "0.0.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "bundle": "node scripts/bundle.mjs",
-    "dev": "tsc -p tsconfig.json --watch",
-    "lint": "eslint .",
-    "check-types": "tsc --noEmit",
-    "test": "tsc -p tsconfig.json && node --test dist/*.test.js"
+    "typescript": "^5.9.2"
   }
-}
+}