memorix 1.5.0 → 1.5.1

package/dist/cli/index.js

@@ -3221,7 +3221,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.5.0" : pkg.version;
+  return true ? "1.5.1" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -22327,6 +22327,8 @@ function getPreferredBatchSize(config2) {
 }
 function parseBatchLimit(error40) {
   if (!(error40 instanceof Error)) return null;
+  const status = error40 instanceof EmbeddingAPIError ? error40.status : Number(error40.message.match(/Embedding API error \((\d{3})\)/i)?.[1] ?? 0);
+  if (status > 0 && status !== 400) return null;
   const explicit = error40.message.match(/should not be larger than\s+(\d+)/i);
   if (explicit) return parseInt(explicit[1], 10);
   if (/batch size/i.test(error40.message)) {
@@ -22339,37 +22341,99 @@ async function fetchWithRetry(url2, apiKey, body, options = {}, attempt = 0, nat
   const controller = new AbortController();
   const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(100, Math.min(Math.floor(options.timeoutMs), 6e4)) : 1e4;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
   let response;
   try {
     response = await fetch(url2, {
       method: "POST",
       headers: nativeGemini ? { "Content-Type": "application/json", "x-goog-api-key": apiKey } : { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal
     });
   } catch (err) {
     clearTimeout(timeout);
-    if (err instanceof Error && err.name === "AbortError") {
+    if (err instanceof Error && (err.name === "AbortError" || controller.signal.aborted || options.signal?.aborted)) {
       throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url2}`);
     }
     throw err;
   }
-  clearTimeout(timeout);
-  if (response.ok) {
-    return response.json();
+  try {
+    if (response.ok) {
+      return await raceWithAbort(
+        response.json(),
+        signal
+      );
+    }
+    if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
+      const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
+      const retryAfter = response.headers.get("retry-after");
+      const parsedRetryAfter = retryAfter ? parseInt(retryAfter, 10) * 1e3 : NaN;
+      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay2;
+      console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
+      await waitForRetry(waitMs, options.signal);
+      return fetchWithRetry(url2, apiKey, body, options, attempt + 1, nativeGemini);
+    }
+    const errorText2 = await raceWithAbort(
+      response.text().catch(() => "unknown error"),
+      signal
+    );
+    throw new EmbeddingAPIError(response.status, errorText2);
+  } catch (err) {
+    if (err instanceof Error && (err.name === "AbortError" || controller.signal.aborted || options.signal?.aborted)) {
+      throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url2}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
   }
-  if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
-    const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
-    const retryAfter = response.headers.get("retry-after");
-    const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : delay2;
-    console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
+}
+function abortError() {
+  const error40 = new Error("Embedding API request aborted");
+  error40.name = "AbortError";
+  return error40;
+}
+function raceWithAbort(promise2, signal) {
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise((resolve6, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise2.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve6(value);
+      },
+      (error40) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error40);
+      }
+    );
+  });
+}
+async function waitForRetry(waitMs, signal) {
+  if (!signal) {
     await new Promise((resolve6) => setTimeout(resolve6, waitMs));
-    return fetchWithRetry(url2, apiKey, body, options, attempt + 1, nativeGemini);
+    return;
   }
-  const errorText2 = await response.text().catch(() => "unknown error");
-  throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
+  const abortSignal = signal;
+  if (abortSignal.aborted) throw new Error("Embedding API retry aborted");
+  await new Promise((resolve6, reject) => {
+    const timer = setTimeout(done, waitMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      abortSignal.removeEventListener("abort", onAbort);
+      reject(new Error("Embedding API retry aborted"));
+    };
+    function done() {
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve6();
+    }
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
 }
-var cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, APIEmbeddingProvider;
+var cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, EmbeddingAPIError, APIEmbeddingProvider;
 var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
@@ -22388,6 +22452,14 @@ var init_api_provider = __esm({
     DASHSCOPE_MAX_BATCH_SIZE = 10;
     MAX_RETRIES2 = 3;
     BASE_DELAY_MS = 500;
+    EmbeddingAPIError = class extends Error {
+      status;
+      constructor(status, detail) {
+        super(`Embedding API error (${status}): ${detail}`);
+        this.name = "EmbeddingAPIError";
+        this.status = status;
+      }
+    };
     APIEmbeddingProvider = class _APIEmbeddingProvider {
       name;
       dimensions;
@@ -22599,15 +22671,14 @@ var init_api_provider = __esm({
             }
           } catch (error40) {
             const providerLimit = parseBatchLimit(error40);
-            const fallbackSize = providerLimit ?? Math.ceil(chunkTexts.length / 2);
-            if (chunkTexts.length > 1 && fallbackSize < chunkTexts.length) {
+            if (providerLimit !== null && chunkTexts.length > 1 && providerLimit < chunkTexts.length) {
               console.error(
-                `[memorix] Embedding batch too large for provider, retrying in chunks of ${fallbackSize}`
+                `[memorix] Embedding batch too large for provider, retrying in chunks of ${providerLimit}`
               );
-              for (let start = 0; start < chunkTexts.length; start += fallbackSize) {
+              for (let start = 0; start < chunkTexts.length; start += providerLimit) {
                 await processChunk(
-                  chunkTexts.slice(start, start + fallbackSize),
-                  chunkIndices.slice(start, start + fallbackSize)
+                  chunkTexts.slice(start, start + providerLimit),
+                  chunkIndices.slice(start, start + providerLimit)
                 );
               }
               return;
@@ -23471,22 +23542,23 @@ function getLLMConfig() {
 function setLLMConfig(config2) {
   currentConfig = config2;
 }
-async function callLLM(systemPrompt, userMessage) {
+async function callLLM(systemPrompt, userMessage, signal) {
   if (!currentConfig) {
     throw new Error("LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY.");
   }
   if (currentConfig.provider === "anthropic") {
-    return callAnthropic(systemPrompt, userMessage);
+    return callAnthropic(systemPrompt, userMessage, signal);
   }
-  return callOpenAICompatible(systemPrompt, userMessage);
+  return callOpenAICompatible(systemPrompt, userMessage, signal);
 }
-async function callOpenAICompatible(systemPrompt, userMessage) {
+async function callOpenAICompatible(systemPrompt, userMessage, signal) {
   const config2 = currentConfig;
   let base = config2.baseUrl.replace(/\/+$/, "");
   if (!base.endsWith("/v1")) base += "/v1";
   const url2 = `${base}/chat/completions`;
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url2, {
-    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS),
+    signal: fetchSignal,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -23503,10 +23575,10 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error40 = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
+    const error40 = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
     throw new Error(`LLM API error (${response.status}): ${error40}`);
   }
-  const data = await readResponseJson(response);
+  const data = await readResponseJson(response, signal);
   return {
     content: data.choices[0]?.message?.content ?? "",
     usage: data.usage ? {
@@ -23515,11 +23587,12 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     } : void 0
   };
 }
-async function callAnthropic(systemPrompt, userMessage) {
+async function callAnthropic(systemPrompt, userMessage, signal) {
   const config2 = currentConfig;
   const url2 = `${config2.baseUrl}/messages`;
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url2, {
-    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS),
+    signal: fetchSignal,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -23537,10 +23610,10 @@ async function callAnthropic(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error40 = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
+    const error40 = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
     throw new Error(`Anthropic API error (${response.status}): ${error40}`);
   }
-  const data = await readResponseJson(response);
+  const data = await readResponseJson(response, signal);
   return {
     content: data.content[0]?.text ?? "",
     usage: data.usage ? {
@@ -24045,6 +24118,57 @@ function withTimeout(promise2, ms2, label) {
     );
   });
 }
+function withTimeoutSignal(operation, ms2, label, parentSignal) {
+  const controller = new AbortController();
+  const signal = parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal;
+  return new Promise((resolve6, reject) => {
+    let settled = false;
+    let timedOut = false;
+    let timer;
+    const cleanup = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      parentSignal?.removeEventListener("abort", onParentAbort);
+    };
+    const onParentAbort = () => {
+      if (settled || timedOut) return;
+      settled = true;
+      cleanup();
+      reject(parentSignal?.reason ?? new Error(`${label} aborted`));
+    };
+    parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+    timer = setTimeout(() => {
+      if (settled) return;
+      timedOut = true;
+      controller.abort(new Error(`${label} timed out after ${ms2}ms`));
+      settled = true;
+      cleanup();
+      reject(new Error(`${label} timed out after ${ms2}ms`));
+    }, ms2);
+    let pending;
+    try {
+      pending = operation(signal);
+    } catch (error40) {
+      settled = true;
+      cleanup();
+      reject(error40);
+      return;
+    }
+    pending.then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve6(value);
+      },
+      (error40) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(timedOut ? new Error(`${label} timed out after ${ms2}ms`) : error40);
+      }
+    );
+  });
+}
 var init_timeout = __esm({
   "src/timeout.ts"() {
     "use strict";
@@ -178220,7 +178344,13 @@ async function maintainLongTermMemories(input) {
   }
   for (const group of groups.values()) {
     if (group.length < 2) continue;
-    group.sort((a4, b4) => Date.parse(b4.createdAt) - Date.parse(a4.createdAt));
+    group.sort((a4, b4) => {
+      const byCreatedAt = Date.parse(b4.createdAt) - Date.parse(a4.createdAt);
+      if (byCreatedAt !== 0) return byCreatedAt;
+      const byUpdatedAt = Date.parse(b4.updatedAt) - Date.parse(a4.updatedAt);
+      if (byUpdatedAt !== 0) return byUpdatedAt;
+      return b4.id.localeCompare(a4.id);
+    });
     const newest = group[0];
     for (const older of group.slice(1)) {
       try {
@@ -184736,16 +184866,18 @@ async function searchObservations(options) {
           );
         } else {
           const EMBEDDING_TIMEOUT_MS = 15e3;
-          queryVector = await withTimeout(
-            provider2.embedInput ? provider2.embedInput(
+          queryVector = await withTimeoutSignal(
+            (signal) => provider2.embedInput ? provider2.embedInput(
               { modality: "text", text: expandedEmbeddingQuery },
-              { intent: "query", timeoutMs: EMBEDDING_TIMEOUT_MS, retry: false }
+              { intent: "query", timeoutMs: EMBEDDING_TIMEOUT_MS, retry: false, signal }
             ) : provider2.embed(expandedEmbeddingQuery, {
               timeoutMs: EMBEDDING_TIMEOUT_MS,
-              retry: false
+              retry: false,
+              signal
             }),
             EMBEDDING_TIMEOUT_MS,
-            "Embedding"
+            "Embedding",
+            options.signal
           );
           mark("embedding");
           const cjkRatio = (originalQuery.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / originalQuery.length;
@@ -199205,13 +199337,13 @@ function verifyType(declaredType, narrative, title) {
   }
   return { type: declaredType, corrected: false };
 }
-async function extractFactsWithLLM(narrative, title, existingFacts) {
+async function extractFactsWithLLM(narrative, title, existingFacts, signal) {
   try {
     const { callLLM: callLLM2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
     const input = `Title: ${title}
 Content: ${narrative}${existingFacts.length > 0 ? `
 Already known facts (don't repeat): ${existingFacts.join("; ")}` : ""}`;
-    const response = await callLLM2(LLM_EXTRACT_PROMPT, input);
+    const response = await callLLM2(LLM_EXTRACT_PROMPT, input, signal);
     const text2 = response.content.trim();
     const jsonMatch = text2.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return [];
@@ -199220,15 +199352,16 @@ Already known facts (don't repeat): ${existingFacts.join("; ")}` : ""}`;
     if (!Array.isArray(facts)) return [];
     const existingLower = new Set(existingFacts.map((f7) => f7.toLowerCase().trim()));
     return facts.filter((f7) => typeof f7 === "string" && f7.length >= 5).filter((f7) => !existingLower.has(f7.toLowerCase().trim())).slice(0, 10);
-  } catch {
+  } catch (error40) {
+    if (signal?.aborted) throw error40;
     return [];
   }
 }
-async function runExtract(input, existingEntities, useLLM = false) {
+async function runExtract(input, existingEntities, useLLM = false, signal) {
   const callerFacts = input.facts ?? [];
   let extractedFacts;
   if (useLLM) {
-    extractedFacts = await extractFactsWithLLM(input.narrative, input.title, callerFacts);
+    extractedFacts = await extractFactsWithLLM(input.narrative, input.title, callerFacts, signal);
     if (extractedFacts.length === 0) {
       extractedFacts = extractFacts2(input.narrative, callerFacts);
     }
@@ -199448,7 +199581,7 @@ function mergeFacts2(oldFacts, newFacts) {
   }
   return merged;
 }
-async function resolveWithLLM(extracted, hits, getObservation2) {
+async function resolveWithLLM(extracted, hits, getObservation2, signal) {
   try {
     const { callLLM: callLLM2 } = await Promise.resolve().then(() => (init_provider2(), provider_exports2));
     const existingMemories = hits.slice(0, 5).map((h5, i4) => ({
@@ -199465,7 +199598,7 @@ Facts: ${extracted.facts.join("; ")}
 
 EXISTING MEMORIES:
 ${existingMemories.map((m6) => `[ID:${m6.id}] ${m6.title} | ${m6.content} | Facts: ${m6.facts}`).join("\n")}`;
-    const response = await callLLM2(LLM_RESOLVE_PROMPT, input);
+    const response = await callLLM2(LLM_RESOLVE_PROMPT, input, signal);
     const text2 = response.content.trim();
     const jsonMatch = text2.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return null;
@@ -199502,7 +199635,8 @@ ${existingMemories.map((m6) => `[ID:${m6.id}] ${m6.title} | ${m6.content} | Fact
       };
     }
     return null;
-  } catch {
+  } catch (error40) {
+    if (signal?.aborted) throw error40;
     return null;
   }
 }
@@ -199520,19 +199654,20 @@ function scoreCandidate(extracted, candidate2) {
   const contradiction = hasContradiction(candidate2.narrative, extracted.narrative);
   return { score, searchSimilarity, entityMatch, richer, contradiction };
 }
-async function runResolve(extracted, projectId, searchMemories3, getObservation2, useLLM = false) {
+async function runResolve(extracted, projectId, searchMemories3, getObservation2, useLLM = false, signal) {
   const query = `${extracted.title} ${extracted.narrative.substring(0, 200)}`;
   let hits;
   try {
-    hits = await searchMemories3(query, 5, projectId);
-  } catch {
+    hits = await searchMemories3(query, 5, projectId, signal);
+  } catch (error40) {
+    if (signal?.aborted) throw error40;
     return { action: "new", reason: "Search unavailable, defaulting to new" };
   }
   if (hits.length === 0) {
     return { action: "new", reason: "No similar existing memories found" };
   }
   if (useLLM) {
-    const llmResult = await resolveWithLLM(extracted, hits, getObservation2);
+    const llmResult = await resolveWithLLM(extracted, hits, getObservation2, signal);
     if (llmResult) return llmResult;
   }
   const scored = hits.map((hit) => ({
@@ -199954,7 +200089,7 @@ async function runFormation(input, config2) {
   const existingEntities = config2.getEntityNames();
   const extractStartTime = Date.now();
   emitStageEvent("extract", "start");
-  const extraction = await runExtract(input, existingEntities, config2.useLLM);
+  const extraction = await runExtract(input, existingEntities, config2.useLLM, config2.signal);
   stageDurationsMs.extract = Date.now() - extractStartTime;
   emitStageEvent("extract", "success", stageDurationsMs.extract);
   stagesCompleted = 1;
@@ -199974,7 +200109,8 @@ async function runFormation(input, config2) {
       input.projectId,
       config2.searchMemories,
       config2.getObservation,
-      config2.useLLM
+      config2.useLLM,
+      config2.signal
     );
     stageDurationsMs.resolve = Date.now() - resolveStartTime;
     emitStageEvent("resolve", "success", stageDurationsMs.resolve);
@@ -258708,7 +258844,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.5.0" : "1.0.1"
+    version: true ? "1.5.1" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -258897,8 +259033,8 @@ The path should point to a directory containing a .git folder.`
                 mode: "active",
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
-                searchMemories: async (q4, limit2, pid) => {
-                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader });
+                searchMemories: async (q4, limit2, pid, signal) => {
+                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader, signal });
                   if (result.entries.length === 0) return [];
                   const details = await compactDetail(result.entries.map((e5) => e5.id), { reader });
                   return details.documents.map((d4, i4) => ({
@@ -258928,16 +259064,19 @@ The path should point to a directory containing a .git folder.`
                 getEntityNames: () => graphManager.getEntityNames(),
                 onStageEvent: onFormationStageEvent
               };
-              formationResult = await withTimeout(
-                runFormation({
-                  entityName,
-                  type,
-                  title,
-                  narrative,
-                  facts: safeFacts,
-                  projectId: project.id,
-                  source: "explicit"
-                }, formationConfig),
+              formationResult = await withTimeoutSignal(
+                async (signal) => {
+                  formationConfig.signal = signal;
+                  return runFormation({
+                    entityName,
+                    type,
+                    title,
+                    narrative,
+                    facts: safeFacts,
+                    projectId: project.id,
+                    source: "explicit"
+                  }, formationConfig);
+                },
                 FORMATION_TIMEOUT_MS,
                 "Formation pipeline"
               );
@@ -259287,8 +259426,8 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 mode: formationMode,
                 useLLM: isLLMEnabled(),
                 minValueScore: 0.3,
-                searchMemories: async (q4, limit2, pid) => {
-                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader });
+                searchMemories: async (q4, limit2, pid, signal) => {
+                  const result = await compactSearch({ query: q4, limit: limit2, projectId: pid, status: "active", reader, signal });
                   if (result.entries.length === 0) return [];
                   const details = await compactDetail(result.entries.map((e5) => e5.id), { reader });
                   return details.documents.map((d4, i4) => ({
@@ -259309,8 +259448,11 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
                 },
                 getEntityNames: () => graphManager.getEntityNames()
               };
-              const formed = await withTimeout(
-                runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig),
+              const formed = await withTimeoutSignal(
+                async (signal) => {
+                  formationConfig.signal = signal;
+                  return runFormation({ entityName, type, title, narrative, facts: safeFacts, projectId: project.id, source: "explicit", topicKey }, formationConfig);
+                },
                 FORMATION_TIMEOUT_MS,
                 "Shadow formation"
               );