@mrrlin-dev/mcp 0.4.123 → 0.4.125

package/dist/bin.cjs

@@ -39249,6 +39249,7 @@ var mrrlinTaskUpdateSchema = external_exports.object({
   directorThreadProvider: external_exports.enum(["codex", "claude", "agy"]).nullable().optional(),
   declaredOutcome: mrrlinDeclaredOutcomeSchema.nullable().optional(),
   dueDate: external_exports.string().date().nullable().optional(),
+  expectedUpdatedAt: external_exports.string().datetime().optional(),
   impact: mrrlinTaskImpactSchema.optional(),
   notes: external_exports.string().nullable().optional(),
   planId: mrrlinPlanIdSchema.nullable().optional(),
@@ -40730,83 +40731,132 @@ function createMrrlinClient(config2) {
   const customFetch = config2.fetch ?? globalThis.fetch;
   const baseUrl = config2.baseUrl.replace(/\/$/, "");
   const token = config2.token;
-  async function request(path33, init) {
-    const method = init?.method ?? "GET";
+  function parseRetryAfter(response) {
+    const header = response.headers.get("retry-after");
+    if (!header)
+      return null;
+    const seconds = Number(header);
+    if (!isNaN(seconds) && seconds >= 0) {
+      return seconds * 1e3;
+    }
+    const dateMs = Date.parse(header);
+    if (!isNaN(dateMs)) {
+      const diff = dateMs - Date.now();
+      return diff > 0 ? diff : 0;
+    }
+    return null;
+  }
+  const RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+  async function abortableDelay(ms, signal) {
+    if (signal?.aborted) {
+      throw new DOMException("The user aborted a request.", "AbortError");
+    }
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        if (signal)
+          signal.removeEventListener("abort", onAbort);
+        resolve2();
+      }, ms);
+      function onAbort() {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        reject(new DOMException("The user aborted a request.", "AbortError"));
+      }
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+  }
+  async function executeFetch(path33, init) {
+    const method = (init?.method ?? "GET").toUpperCase();
     const headers = new Headers(init?.headers ?? {});
     if (token && !headers.has("authorization")) {
       headers.set("authorization", `Bearer ${token}`);
     }
-    const response = await customFetch(`${baseUrl}${path33}`, { ...init, headers });
-    if (!response.ok) {
-      const body = await response.text();
-      let code = `HTTP_${response.status}`;
-      let violations = null;
-      let message = `Mrrlin API ${method} ${path33} failed: ${response.status}`;
+    const url2 = `${baseUrl}${path33}`;
+    const isIdempotent = method === "GET" || method === "HEAD";
+    const maxAttempts = isIdempotent ? 3 : 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
       try {
-        const parsed = JSON.parse(body);
-        const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
-        if (violationsParsed.success) {
-          code = violationsParsed.data.code;
-          violations = violationsParsed.data.violations;
-          message = violationsParsed.data.message;
-        } else {
-          const errorParsed = apiErrorSchema.safeParse(parsed);
-          if (errorParsed.success) {
-            code = errorParsed.data.code;
-            message = errorParsed.data.message;
+        if (init?.signal?.aborted) {
+          throw new DOMException("The user aborted a request.", "AbortError");
+        }
+        const response = await customFetch(url2, { ...init, headers });
+        if (response.ok) {
+          return response;
+        }
+        if (isIdempotent && RETRYABLE_STATUS_CODES.has(response.status) && attempt < maxAttempts - 1) {
+          const retryAfterMs = parseRetryAfter(response);
+          if (retryAfterMs !== null && retryAfterMs > 1e4) {
+            return response;
+          }
+          try {
+            await response.body?.cancel();
+          } catch {
           }
+          const backoffMs = retryAfterMs ?? Math.floor(Math.random() * Math.min(2e3, 250 * Math.pow(2, attempt)));
+          await abortableDelay(backoffMs, init?.signal);
+          continue;
         }
-      } catch {
+        return response;
+      } catch (err) {
+        if (init?.signal?.aborted || err?.name === "AbortError") {
+          throw err;
+        }
+        if (isIdempotent && attempt < maxAttempts - 1) {
+          const backoffMs = Math.floor(Math.random() * Math.min(2e3, 250 * Math.pow(2, attempt)));
+          await abortableDelay(backoffMs, init?.signal);
+          continue;
+        }
+        throw err;
       }
-      throw new MrrlinApiError({
-        code,
-        method,
-        path: path33,
-        responseBody: body,
-        status: response.status,
-        violations,
-        message
-      });
+    }
+    throw new Error(`Failed to execute ${method} ${path33}`);
+  }
+  async function handleResponseError(response, method, path33) {
+    const body = await response.text();
+    let code = `HTTP_${response.status}`;
+    let violations = null;
+    let message = `Mrrlin API ${method} ${path33} failed: ${response.status}`;
+    try {
+      const parsed = JSON.parse(body);
+      const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
+      if (violationsParsed.success) {
+        code = violationsParsed.data.code;
+        violations = violationsParsed.data.violations;
+        message = violationsParsed.data.message;
+      } else {
+        const errorParsed = apiErrorSchema.safeParse(parsed);
+        if (errorParsed.success) {
+          code = errorParsed.data.code;
+          message = errorParsed.data.message;
+        }
+      }
+    } catch {
+    }
+    throw new MrrlinApiError({
+      code,
+      method,
+      path: path33,
+      responseBody: body,
+      status: response.status,
+      violations,
+      message
+    });
+  }
+  async function request(path33, init) {
+    const method = init?.method ?? "GET";
+    const response = await executeFetch(path33, init);
+    if (!response.ok) {
+      await handleResponseError(response, method, path33);
     }
     return response.json();
   }
   async function requestText(path33, init) {
     const method = init?.method ?? "GET";
-    const headers = new Headers(init?.headers ?? {});
-    if (token && !headers.has("authorization")) {
-      headers.set("authorization", `Bearer ${token}`);
-    }
-    const response = await customFetch(`${baseUrl}${path33}`, { ...init, headers });
+    const response = await executeFetch(path33, init);
     if (!response.ok) {
-      const body = await response.text();
-      let code = `HTTP_${response.status}`;
-      let violations = null;
-      let message = `Mrrlin API ${method} ${path33} failed: ${response.status}`;
-      try {
-        const parsed = JSON.parse(body);
-        const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
-        if (violationsParsed.success) {
-          code = violationsParsed.data.code;
-          violations = violationsParsed.data.violations;
-          message = violationsParsed.data.message;
-        } else {
-          const errorParsed = apiErrorSchema.safeParse(parsed);
-          if (errorParsed.success) {
-            code = errorParsed.data.code;
-            message = errorParsed.data.message;
-          }
-        }
-      } catch {
-      }
-      throw new MrrlinApiError({
-        code,
-        method,
-        path: path33,
-        responseBody: body,
-        status: response.status,
-        violations,
-        message
-      });
+      await handleResponseError(response, method, path33);
     }
     return response.text();
   }
@@ -41968,6 +42018,48 @@ function createMrrlinClient(config2) {
 var import_promises3 = __toESM(require("node:fs/promises"), 1);
 var import_node_path5 = __toESM(require("node:path"), 1);
 var INCLUDED_DOC_FOLDERS = /* @__PURE__ */ new Set(["_meta", "explanation", "how-to", "reference", "sdd", "tutorials"]);
+var cachedPreparedIndex = null;
+var preparedIndexMap = /* @__PURE__ */ new WeakMap();
+function prepareWikiChunks(chunks) {
+  const documents = chunks.map((chunk) => tokenize(`${chunk.heading_path.join(" ")} ${chunk.chunk_text}`));
+  const averageLength = documents.reduce((sum, tokens2) => sum + tokens2.length, 0) / Math.max(documents.length, 1);
+  const documentFrequency = /* @__PURE__ */ new Map();
+  const termFrequencies = documents.map((tokens2) => {
+    const freqs = /* @__PURE__ */ new Map();
+    for (const token of tokens2) {
+      freqs.set(token, (freqs.get(token) ?? 0) + 1);
+    }
+    for (const token of freqs.keys()) {
+      documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
+    }
+    return freqs;
+  });
+  return {
+    chunks,
+    documents,
+    termFrequencies,
+    documentFrequency,
+    averageLength
+  };
+}
+async function getOrPrepareWikiIndex(indexPath) {
+  const resolvedIndexPath = await resolveIndexPath(indexPath);
+  const stat3 = await import_promises3.default.stat(resolvedIndexPath);
+  if (cachedPreparedIndex && cachedPreparedIndex.filePath === resolvedIndexPath && cachedPreparedIndex.mtimeMs === stat3.mtimeMs && cachedPreparedIndex.size === stat3.size) {
+    return cachedPreparedIndex;
+  }
+  const raw = await import_promises3.default.readFile(resolvedIndexPath, "utf8");
+  const chunks = wikiKnowledgeIndexSchema.parse(JSON.parse(raw));
+  const prepared = {
+    ...prepareWikiChunks(chunks),
+    filePath: resolvedIndexPath,
+    mtimeMs: stat3.mtimeMs,
+    size: stat3.size
+  };
+  cachedPreparedIndex = prepared;
+  preparedIndexMap.set(chunks, prepared);
+  return prepared;
+}
 function toPosixPath(input) {
   return input.split(import_node_path5.default.sep).join("/");
 }
@@ -42115,50 +42207,51 @@ async function buildWikiKnowledgeIndex(options = {}) {
   const documents = await listWikiDocuments(options);
   return wikiKnowledgeIndexSchema.parse(documents.flatMap(buildChunksForDocument));
 }
-async function loadBuiltWikiKnowledgeIndex(indexPath) {
-  const resolvedIndexPath = await resolveIndexPath(indexPath);
-  const raw = await import_promises3.default.readFile(resolvedIndexPath, "utf8");
-  return wikiKnowledgeIndexSchema.parse(JSON.parse(raw));
-}
 function tokenize(input) {
   return input.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 2);
 }
-function searchKnowledgeIndex(index, query, limit = 5) {
-  const queryTokens = tokenize(query);
-  if (queryTokens.length === 0)
-    return [];
-  const documents = index.map((chunk) => tokenize(`${chunk.heading_path.join(" ")} ${chunk.chunk_text}`));
-  const averageLength = documents.reduce((sum, tokens2) => sum + tokens2.length, 0) / Math.max(documents.length, 1);
-  const documentFrequency = /* @__PURE__ */ new Map();
-  for (const tokens2 of documents) {
-    for (const token of new Set(tokens2)) {
-      documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
-    }
-  }
+function scorePreparedIndex(prepared, queryTokens, limit = 5) {
   const k1 = 1.2;
   const b = 0.75;
-  const scored = index.map((chunk, chunkIndex) => {
-    const tokens2 = documents[chunkIndex] ?? [];
-    const frequencies = /* @__PURE__ */ new Map();
-    for (const token of tokens2) {
-      frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
-    }
+  const { chunks, documents, termFrequencies, documentFrequency, averageLength } = prepared;
+  const totalDocs = documents.length;
+  const scored = chunks.map((chunk, chunkIndex) => {
+    const frequencies = termFrequencies[chunkIndex] ?? /* @__PURE__ */ new Map();
+    const docLen = documents[chunkIndex]?.length ?? 0;
     const score = queryTokens.reduce((sum, token) => {
       const tf = frequencies.get(token) ?? 0;
       if (tf === 0)
         return sum;
       const df = documentFrequency.get(token) ?? 0;
-      const idf = Math.log(1 + (documents.length - df + 0.5) / (df + 0.5));
-      const denominator = tf + k1 * (1 - b + b * (tokens2.length / Math.max(averageLength, 1)));
+      const idf = Math.log(1 + (totalDocs - df + 0.5) / (df + 0.5));
+      const denominator = tf + k1 * (1 - b + b * (docLen / Math.max(averageLength, 1)));
       return sum + idf * (tf * (k1 + 1) / denominator);
     }, 0);
     return { ...chunk, score };
   });
   return scored.filter((result) => result.score > 0).sort((a, b2) => b2.score - a.score || a.wiki_url.localeCompare(b2.wiki_url)).slice(0, limit).map((result) => wikiKnowledgeSearchResultSchema.parse(result));
 }
+function searchKnowledgeIndex(index, query, limit = 5) {
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0)
+    return [];
+  let prepared = preparedIndexMap.get(index);
+  if (!prepared) {
+    prepared = prepareWikiChunks(index);
+    preparedIndexMap.set(index, prepared);
+  }
+  return scorePreparedIndex(prepared, queryTokens, limit);
+}
 async function searchKnowledge(query, options = {}) {
-  const index = options.docsRoot ? await buildWikiKnowledgeIndex({ docsRoot: options.docsRoot }) : await loadBuiltWikiKnowledgeIndex(options.indexPath);
-  return searchKnowledgeIndex(index, query, options.limit ?? 5);
+  if (options.docsRoot) {
+    const index = await buildWikiKnowledgeIndex({ docsRoot: options.docsRoot });
+    return searchKnowledgeIndex(index, query, options.limit ?? 5);
+  }
+  const prepared = await getOrPrepareWikiIndex(options.indexPath);
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0)
+    return [];
+  return scorePreparedIndex(prepared, queryTokens, options.limit ?? 5);
 }
 
 // src/consensus/verdict.ts
@@ -62120,7 +62213,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.123";
+var PKG_VERSION = "0.4.125";
 
 // src/receipt-signing.ts
 var import_node_crypto13 = __toESM(require("node:crypto"), 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.123",
+  "version": "0.4.125",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"