@hanhnd/agent-kit 1.0.39 → 1.0.40

package/dist/server.js

@@ -3222,8 +3222,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path15) {
-      let input = path15;
+    function removeDotSegments(path16) {
+      let input = path16;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3422,8 +3422,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path15, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
+        const [path16, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -22164,8 +22164,8 @@ function getErrorMap() {
 
 // ../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path15, errorMaps, issueData } = params;
-  const fullPath = [...path15, ...issueData.path || []];
+  const { data, path: path16, errorMaps, issueData } = params;
+  const fullPath = [...path16, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -22281,11 +22281,11 @@ var errorUtil;
 
 // ../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path15, key) {
+  constructor(parent, value, path16, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path15;
+    this._path = path16;
     this._key = key;
   }
   get path() {
@@ -25923,10 +25923,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path16) {
+  if (!path16)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path16.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -26246,11 +26246,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path16, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path16);
     return iss;
   });
 }
@@ -36777,7 +36777,10 @@ ${ticket.fields.labels?.join(", ") || "None"}`;
 
 // src/mcp/memory.ts
 import * as fs11 from "fs";
-import * as path14 from "path";
+import * as path15 from "path";
+
+// src/services/memory/subsystem.ts
+import * as path10 from "path";
 
 // src/services/memory/embedder.ts
 var EmbedderError = class extends Error {
@@ -36993,6 +36996,37 @@ ${sectionText}` : sectionText;
   return chunks;
 }
 
+// src/utils/async.ts
+async function withTimeout(promise, timeoutMs, createError) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(createError());
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function mapLimit(items, limit, worker) {
+  if (items.length === 0) return [];
+  const concurrency = Math.max(1, Math.floor(limit));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function runWorker() {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex;
+      nextIndex++;
+      results[currentIndex] = await worker(items[currentIndex], currentIndex);
+    }
+  }
+  const runners = Array.from({ length: Math.min(concurrency, items.length) }, () => runWorker());
+  await Promise.all(runners);
+  return results;
+}
+
 // src/services/memory/indexer.ts
 function deriveSourceType(source) {
   if (source.startsWith("compiled/provisional/conversation-digests/")) return "digest";
@@ -37009,9 +37043,19 @@ var MemoryIndexer = class {
   }
   _ready = false;
   async indexFile(absolutePath) {
-    return this.indexFileRelativeTo(absolutePath, this.config.wikiDir);
+    const mutation = await this.prepareIndexFileRelativeTo(absolutePath, this.config.wikiDir);
+    return this.commitPreparedMutation(mutation);
   }
-  async indexFileRelativeTo(absolutePath, sourceRoot) {
+  makeSkippedMutation(source, skipped) {
+    return {
+      source,
+      chunksToUpsert: [],
+      embeddings: [],
+      idsToDelete: [],
+      stats: { indexed: 0, deleted: 0, skipped }
+    };
+  }
+  async prepareIndexFileRelativeTo(absolutePath, sourceRoot) {
     const source = path8.relative(sourceRoot, absolutePath);
     const existingChunkIds = this.store.hashesBySource(source);
     let text;
@@ -37019,7 +37063,7 @@ var MemoryIndexer = class {
       text = await fs6.promises.readFile(absolutePath, "utf8");
     } catch (err) {
       console.warn(`[memory-indexer] Cannot read file ${absolutePath}:`, err);
-      return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
+      return this.makeSkippedMutation(source, existingChunkIds.size);
     }
     let fileMtimeAt;
     try {
@@ -37039,21 +37083,30 @@ var MemoryIndexer = class {
         embeddings = await this.embedder.embed(toIndex.map((c) => c.content));
       } catch (err) {
         console.warn(`[memory-indexer] Embedding failed for ${absolutePath}:`, err);
-        return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
+        return this.makeSkippedMutation(source, existingChunkIds.size);
       }
     }
-    if (toIndex.length > 0) {
-      this.store.upsert(toIndex, embeddings);
-    }
-    if (toDelete.length > 0) {
-      this.store.deleteByIds(toDelete);
-    }
     return {
-      indexed: toIndex.length,
-      deleted: toDelete.length,
-      skipped: allChunks.length - toIndex.length
+      source,
+      chunksToUpsert: toIndex,
+      embeddings,
+      idsToDelete: toDelete,
+      stats: {
+        indexed: toIndex.length,
+        deleted: toDelete.length,
+        skipped: allChunks.length - toIndex.length
+      }
     };
   }
+  commitPreparedMutation(mutation) {
+    if (mutation.chunksToUpsert.length > 0) {
+      this.store.upsert(mutation.chunksToUpsert, mutation.embeddings);
+    }
+    if (mutation.idsToDelete.length > 0) {
+      this.store.deleteByIds(mutation.idsToDelete);
+    }
+    return mutation.stats;
+  }
   async indexDirectory(rootDir, opts = {}) {
     const totals = { indexed: 0, deleted: 0, skipped: 0 };
     let rootExists;
@@ -37095,8 +37148,13 @@ var MemoryIndexer = class {
         totals.deleted += 1;
       }
     }
-    for (const file of files) {
-      const stats = await this.indexFileRelativeTo(file, relativeBase);
+    const preparedMutations = await mapLimit(
+      files,
+      opts.fileConcurrency ?? 2,
+      (file) => this.prepareIndexFileRelativeTo(file, relativeBase)
+    );
+    for (const mutation of preparedMutations) {
+      const stats = this.commitPreparedMutation(mutation);
       totals.indexed += stats.indexed;
       totals.deleted += stats.deleted;
       totals.skipped += stats.skipped;
@@ -37609,45 +37667,103 @@ var MemoryStore = class {
   }
 };
 
+// src/services/memory/subsystem.ts
+var DefaultMemorySubsystem = class {
+  constructor(config2, indexer, store, initialState, initialError) {
+    this.config = config2;
+    this.indexer = indexer;
+    this.store = store;
+    this.lifecycleStatus = makeStatus(initialState, initialError);
+  }
+  lifecycleStatus;
+  get status() {
+    return this.lifecycleStatus;
+  }
+  async startWarmup() {
+    if (!this.indexer) {
+      this.lifecycleStatus = makeStatus("failed", this.lifecycleStatus.error ?? "Memory indexer is unavailable");
+      return;
+    }
+    this.lifecycleStatus = makeStatus("warming");
+    try {
+      await this.indexer.startupIndex();
+      this.lifecycleStatus = makeStatus("ready");
+    } catch (err) {
+      this.lifecycleStatus = makeStatus(this.store ? "degraded" : "failed", formatError3(err));
+    }
+  }
+  close() {
+    this.store?.close();
+  }
+};
+function makeStatus(state, error2) {
+  return {
+    state,
+    ready: state === "ready",
+    warming: state === "initializing" || state === "warming",
+    degraded: state === "degraded" || state === "failed",
+    error: error2
+  };
+}
+function formatError3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createMemorySubsystem(workspaceRoot2, overrides = {}) {
+  const config2 = overrides.config ?? resolveMemoryConfig(overrides.settings ?? {}, workspaceRoot2);
+  if (config2.enabled !== true) return null;
+  let store = overrides.store ?? null;
+  let indexer = overrides.indexer ?? null;
+  try {
+    store = store ?? new MemoryStore(path10.join(config2.wikiDir, "index.db"), config2);
+    if (!indexer) {
+      const embedder = new Embedder(config2.embeddingModel);
+      indexer = new MemoryIndexer(store, embedder, config2);
+    }
+    return new DefaultMemorySubsystem(config2, indexer, store, "initializing");
+  } catch (err) {
+    return new DefaultMemorySubsystem(config2, indexer, store, "failed", formatError3(err));
+  }
+}
+
 // src/services/digest/processor.ts
 import * as fs10 from "node:fs";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 
 // src/services/digest/constants.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 var DEFAULT_DIGEST_MODEL_ID = "base" /* BASE */;
 var DEFAULT_DIGEST_MAX_INPUT_CHARS = 1e4;
 var DEFAULT_DIGEST_TIMEOUT_MS = 12e4;
 var KIT_DIR = ".agent-kit";
-var WIKI_DIR = path10.join(KIT_DIR, "wiki");
-var WIKI_RAW_DIR = path10.join(WIKI_DIR, "raw");
-var PROVISIONAL_DIGEST_DIR = path10.join(WIKI_DIR, "compiled", "provisional", "conversation-digests");
-var DIGEST_WORKER_DIR = path10.join(WIKI_DIR, "digest");
-var DIGEST_LOCKFILE_REL_PATH = path10.join(DIGEST_WORKER_DIR, "digest-worker.lock");
-var DIGEST_WORKER_STATUS_REL_PATH = path10.join(DIGEST_WORKER_DIR, "digest-worker.status.json");
-var DIGEST_WORKER_LOG_REL_PATH = path10.join(DIGEST_WORKER_DIR, "digest-worker.log");
+var WIKI_DIR = path11.join(KIT_DIR, "wiki");
+var WIKI_RAW_DIR = path11.join(WIKI_DIR, "raw");
+var PROVISIONAL_DIGEST_DIR = path11.join(WIKI_DIR, "compiled", "provisional", "conversation-digests");
+var DIGEST_WORKER_DIR = path11.join(WIKI_DIR, "digest");
+var DIGEST_LOCKFILE_REL_PATH = path11.join(DIGEST_WORKER_DIR, "digest-worker.lock");
+var DIGEST_WORKER_STATUS_REL_PATH = path11.join(DIGEST_WORKER_DIR, "digest-worker.status.json");
+var DIGEST_WORKER_LOG_REL_PATH = path11.join(DIGEST_WORKER_DIR, "digest-worker.log");
 var LLAMA_CONTEXT_SIZE = 8192;
 var LLAMA_MAX_GENERATED_TOKENS = 512;
 var LLAMA_TEMPERATURE = 0.1;
 
 // src/services/digest/files.ts
 import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 function defaultProvisionalDigestDir(workspaceRoot2) {
-  return path11.join(workspaceRoot2, PROVISIONAL_DIGEST_DIR);
+  return path12.join(workspaceRoot2, PROVISIONAL_DIGEST_DIR);
 }
 function readConversationDigestInput(workspaceRoot2, inputPath) {
-  const absoluteInput = path11.isAbsolute(inputPath) ? inputPath : path11.resolve(workspaceRoot2, inputPath);
+  const absoluteInput = path12.isAbsolute(inputPath) ? inputPath : path12.resolve(workspaceRoot2, inputPath);
   const content = fs8.readFileSync(absoluteInput, "utf8");
   return {
-    sourcePath: path11.relative(workspaceRoot2, absoluteInput),
+    sourcePath: path12.relative(workspaceRoot2, absoluteInput),
     content,
     contentHash: sha256Hex(content)
   };
 }
 function provisionalDigestPath(outDir, input) {
-  const safeName = path11.basename(input.sourcePath).replace(/\.[^.]+$/, "").replace(/[^a-z0-9._-]+/gi, "-");
-  return path11.join(outDir, `${input.contentHash.slice(0, 16)}-${safeName}.md`);
+  const safeName = path12.basename(input.sourcePath).replace(/\.[^.]+$/, "").replace(/[^a-z0-9._-]+/gi, "-");
+  return path12.join(outDir, `${input.contentHash.slice(0, 16)}-${safeName}.md`);
 }
 function findExistingProvisionalDigest(outDir, input) {
   const markdownPath = provisionalDigestPath(outDir, input);
@@ -37722,25 +37838,8 @@ function getDigestModelSpec(modelId) {
 
 // src/services/digest/providers/llama-local.ts
 import * as fs9 from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import { getLlama, LlamaChatSession, createModelDownloader } from "node-llama-cpp";
-
-// src/utils/async.ts
-async function withTimeout(promise, timeoutMs, createError) {
-  let timer;
-  const timeout = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => {
-      reject(createError());
-    }, timeoutMs);
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-
-// src/services/digest/providers/llama-local.ts
 var LlamaLocalDigestProviderError = class extends Error {
   constructor(message) {
     super(message);
@@ -37748,7 +37847,7 @@ var LlamaLocalDigestProviderError = class extends Error {
   }
 };
 function titleFromSource(sourcePath) {
-  return path12.basename(sourcePath).replace(/\.[^.]+$/, "").replace(/[_-]+/g, " ");
+  return path13.basename(sourcePath).replace(/\.[^.]+$/, "").replace(/[_-]+/g, " ");
 }
 function trimConversationExport(content, maxInputChars) {
   const trimmed = content.trim();
@@ -37791,7 +37890,7 @@ function sanitizeConversationDigestMarkdown(generatedText) {
 }
 async function createLlamaLocalDigestProvider(modelId) {
   const spec = getDigestModelSpec(modelId);
-  const modelCacheDir = path12.join(MODEL_CACHE_DIR, "llama");
+  const modelCacheDir = path13.join(MODEL_CACHE_DIR, "llama");
   fs9.mkdirSync(modelCacheDir, { recursive: true });
   let modelFilePath;
   try {
@@ -37860,13 +37959,13 @@ ${sanitized}`;
 
 // src/services/digest/processor.ts
 function digestLockPath(workspaceRoot2) {
-  return path13.join(workspaceRoot2, DIGEST_LOCKFILE_REL_PATH);
+  return path14.join(workspaceRoot2, DIGEST_LOCKFILE_REL_PATH);
 }
 function discoverPendingConversationFiles(workspaceRoot2) {
-  const rawDir = path13.join(workspaceRoot2, WIKI_RAW_DIR);
+  const rawDir = path14.join(workspaceRoot2, WIKI_RAW_DIR);
   let files;
   try {
-    files = fs10.readdirSync(rawDir).filter((f) => f.startsWith("conv_") && f.endsWith(".md")).map((f) => path13.join(rawDir, f)).sort((a, b) => fs10.statSync(a).mtimeMs - fs10.statSync(b).mtimeMs);
+    files = fs10.readdirSync(rawDir).filter((f) => f.startsWith("conv_") && f.endsWith(".md")).map((f) => path14.join(rawDir, f)).sort((a, b) => fs10.statSync(a).mtimeMs - fs10.statSync(b).mtimeMs);
   } catch (err) {
     if (err.code === "ENOENT") {
       files = [];
@@ -37894,7 +37993,7 @@ async function indexProvisionalDigestFile(workspaceRoot2, markdownPath, indexer)
     const settings = loadGlobalSettings();
     const config2 = resolveMemoryConfig(settings, workspaceRoot2);
     if (config2.enabled !== true) return { indexed: false };
-    store = new MemoryStore(path13.join(config2.wikiDir, "index.db"), config2);
+    store = new MemoryStore(path14.join(config2.wikiDir, "index.db"), config2);
     const embedder = new Embedder(config2.embeddingModel);
     await embedder.initialize();
     await new MemoryIndexer(store, embedder, config2).indexFile(markdownPath);
@@ -37906,7 +38005,7 @@ async function indexProvisionalDigestFile(workspaceRoot2, markdownPath, indexer)
   }
 }
 async function digestConversationFile(options) {
-  const outDir = options.outDir ? path13.resolve(options.workspaceRoot, options.outDir) : defaultProvisionalDigestDir(options.workspaceRoot);
+  const outDir = options.outDir ? path14.resolve(options.workspaceRoot, options.outDir) : defaultProvisionalDigestDir(options.workspaceRoot);
   const input = readConversationDigestInput(options.workspaceRoot, options.inputPath);
   const existingPath = findExistingProvisionalDigest(outDir, input);
   if (existingPath) {
@@ -37961,7 +38060,7 @@ async function digestPendingConversations({
     let indexer;
     const memoryConfig = resolveMemoryConfig(loadGlobalSettings(), workspaceRoot2);
     if (memoryConfig.enabled === true) {
-      const store = new MemoryStore(path13.join(memoryConfig.wikiDir, "index.db"), memoryConfig);
+      const store = new MemoryStore(path14.join(memoryConfig.wikiDir, "index.db"), memoryConfig);
       const embedder = new Embedder(memoryConfig.embeddingModel);
       indexer = new MemoryIndexer(store, embedder, memoryConfig);
       closeIndexer = () => store.close();
@@ -38042,7 +38141,8 @@ async function initializeConversationDigestModel(input) {
 }
 
 // src/mcp/memory.ts
-function registerMemoryToolHandlers(server2, indexer, store, config2, workspaceRoot2 = process.cwd()) {
+function registerMemoryToolHandlers(server2, subsystem, workspaceRoot2 = process.cwd()) {
+  const { config: config2 } = subsystem;
   server2.tool(
     "kit_memory_search",
     "Search persistent memory for factual or semantic matches (decisions, concepts, entities). Extract concise keywords only, removing stopwords and filler words from the user request before querying. Use kit_memory_recent for temporal or recency questions.",
@@ -38052,10 +38152,15 @@ function registerMemoryToolHandlers(server2, indexer, store, config2, workspaceR
     },
     async ({ query, top_k }) => {
       try {
+        if (!subsystem.indexer || !subsystem.store) {
+          return mcpText(formatInitializationFailure(subsystem));
+        }
+        const { indexer, store } = subsystem;
         const results = await indexer.search(query, top_k ?? config2.topK);
+        const lifecycleNote = formatLifecycleNote(subsystem);
         const degradedNote = !store.vecAvailable ? "\u26A0\uFE0F Vector search unavailable \u2014 showing keyword-only results.\n\n" : "";
         if (results.length === 0) {
-          return mcpText(`${degradedNote}No memories found for query: "${query}"`);
+          return mcpText(`${lifecycleNote}${degradedNote}No memories found for query: "${query}"`);
         }
         const formatted = results.map((r) => {
           const displaySource = r.chunk.source.replace(/^compiled\//, "");
@@ -38064,7 +38169,7 @@ ${r.chunk.content}` : r.chunk.content;
           return `### ${displaySource} (score: ${r.score.toFixed(3)})
 ${content}`;
         }).join("\n\n---\n\n");
-        return mcpText(`${degradedNote}${formatted}`);
+        return mcpText(`${lifecycleNote}${degradedNote}${formatted}`);
       } catch (err) {
         return mcpText(`kit_memory_search failed: ${formatError2(err)}`);
       }
@@ -38079,12 +38184,16 @@ ${content}`;
     },
     async ({ n, source_type }) => {
       try {
+        if (!subsystem.store) {
+          return mcpText(formatInitializationFailure(subsystem));
+        }
+        const store = subsystem.store;
         const rows = store.getRecentSources({ limit: n ?? 5, sourceType: source_type });
         if (rows.length === 0) return mcpText("No recent sources found.");
         const blocks = [];
         for (const row of rows) {
           try {
-            const content = await fs11.promises.readFile(path14.join(config2.wikiDir, row.source), "utf8");
+            const content = await fs11.promises.readFile(path15.join(config2.wikiDir, row.source), "utf8");
             const displaySource = row.source.replace(/^compiled\//, "");
             blocks.push(`### ${displaySource}
 ${content}`);
@@ -38107,6 +38216,13 @@ ${content}`);
     },
     async ({ content }) => {
       try {
+        if (!subsystem.indexer) {
+          return mcpJson({
+            saved: false,
+            error: formatInitializationFailure(subsystem)
+          });
+        }
+        const indexer = subsystem.indexer;
         await indexer.save(content);
         return mcpJson({
           saved: true,
@@ -38149,17 +38265,28 @@ ${content}`);
     }
   );
 }
+function formatLifecycleNote(subsystem) {
+  if (subsystem.status.state === "warming" || subsystem.status.state === "initializing") {
+    return "\u26A0\uFE0F Memory index is warming \u2014 results may be stale until startup indexing completes.\n\n";
+  }
+  if (subsystem.status.state === "degraded") {
+    return `\u26A0\uFE0F Memory index is degraded${subsystem.status.error ? `: ${subsystem.status.error}` : ""}.
+
+`;
+  }
+  return "";
+}
+function formatInitializationFailure(subsystem) {
+  const detail = subsystem.status.error ? `: ${subsystem.status.error}` : "";
+  return `Memory initialization failed${detail}`;
+}
 function registerMemoryTools(server2, workspaceRoot2, overrides) {
   const settings = overrides?.settings ?? loadGlobalSettings();
   if (settings.memory?.enabled !== true) return null;
-  const config2 = overrides?.config ?? resolveMemoryConfig(settings, workspaceRoot2);
-  const store = overrides?.store ?? new MemoryStore(path14.join(config2.wikiDir, "index.db"), config2);
-  const indexer = overrides?.indexer ?? (() => {
-    const embedder = new Embedder(config2.embeddingModel);
-    return new MemoryIndexer(store, embedder, config2);
-  })();
-  registerMemoryToolHandlers(server2, indexer, store, config2, workspaceRoot2);
-  return indexer;
+  const subsystem = createMemorySubsystem(workspaceRoot2, { ...overrides, settings });
+  if (!subsystem) return null;
+  registerMemoryToolHandlers(server2, subsystem, workspaceRoot2);
+  return subsystem;
 }
 
 // src/entrypoints/server.ts
@@ -38171,9 +38298,9 @@ registerIntegrationTools(server);
 registerCoreTools(server);
 registerAgentTools(server);
 var workspaceRoot = getWorkspaceRoot();
-var memoryIndexer = registerMemoryTools(server, workspaceRoot);
+var memorySubsystem = registerMemoryTools(server, workspaceRoot);
 var transport = new StdioServerTransport();
 await server.connect(transport);
-if (memoryIndexer) {
-  void memoryIndexer.startupIndex();
+if (memorySubsystem) {
+  void memorySubsystem.startWarmup();
 }

package/dist/services/memory/index.d.ts

@@ -1,5 +1,7 @@
 export { MemoryStore, StoreError } from './store.js';
 export { Embedder, EmbedderError } from './embedder.js';
 export { MemoryIndexer } from './indexer.js';
-export type { MemoryChunk, SearchResult, MemoryConfig, IndexStats, SourceType, RecentSource } from './types.js';
+export { createMemorySubsystem } from './subsystem.js';
+export type { MemorySubsystem, MemorySubsystemOverrides } from './subsystem.js';
+export type { MemoryChunk, SearchResult, MemoryConfig, IndexStats, SourceType, RecentSource, MemoryLifecycleState, MemoryLifecycleStatus, IndexDirectoryOptions, PreparedIndexMutation, } from './types.js';
 export { DEFAULT_MEMORY_CONFIG } from './constants.js';

package/dist/services/memory/index.js

@@ -1,4 +1,5 @@
 export { MemoryStore, StoreError } from './store.js';
 export { Embedder, EmbedderError } from './embedder.js';
 export { MemoryIndexer } from './indexer.js';
+export { createMemorySubsystem } from './subsystem.js';
 export { DEFAULT_MEMORY_CONFIG } from './constants.js';

package/dist/services/memory/indexer.d.ts

@@ -1,5 +1,5 @@
 import type { MemoryStore } from './store.js';
-import type { IndexStats, MemoryConfig, SearchResult, SourceType } from './types.js';
+import type { IndexDirectoryOptions, IndexStats, MemoryConfig, SearchResult, SourceType } from './types.js';
 interface TextEmbedder {
     embed(texts: string[]): Promise<Float32Array[]>;
     initialize(): Promise<void>;
@@ -12,11 +12,10 @@ export declare class MemoryIndexer {
     private _ready;
     constructor(store: MemoryStore, embedder: TextEmbedder, config: MemoryConfig);
     indexFile(absolutePath: string): Promise<IndexStats>;
-    private indexFileRelativeTo;
-    indexDirectory(rootDir: string, opts?: {
-        relativeBase?: string;
-        excludeFiles?: string[];
-    }): Promise<IndexStats>;
+    private makeSkippedMutation;
+    private prepareIndexFileRelativeTo;
+    private commitPreparedMutation;
+    indexDirectory(rootDir: string, opts?: IndexDirectoryOptions): Promise<IndexStats>;
     search(query: string, topK: number): Promise<SearchResult[]>;
     save(content: string): Promise<IndexStats>;
     startupIndex(): Promise<void>;

package/dist/services/memory/indexer.js

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { chunkMarkdown } from './chunker.js';
 import { DENSE_SCORE_FLOOR, FETCH_MULTIPLIER, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RECENCY_WEIGHT, RRF_K, } from './constants.js';
+import { mapLimit } from '../../utils/async.js';
 import { acquireLock, releaseLock } from '../../utils/files.js';
 export function deriveSourceType(source) {
     if (source.startsWith('compiled/provisional/conversation-digests/'))
@@ -25,9 +26,19 @@ export class MemoryIndexer {
         this.config = config;
     }
     async indexFile(absolutePath) {
-        return this.indexFileRelativeTo(absolutePath, this.config.wikiDir);
+        const mutation = await this.prepareIndexFileRelativeTo(absolutePath, this.config.wikiDir);
+        return this.commitPreparedMutation(mutation);
     }
-    async indexFileRelativeTo(absolutePath, sourceRoot) {
+    makeSkippedMutation(source, skipped) {
+        return {
+            source,
+            chunksToUpsert: [],
+            embeddings: [],
+            idsToDelete: [],
+            stats: { indexed: 0, deleted: 0, skipped },
+        };
+    }
+    async prepareIndexFileRelativeTo(absolutePath, sourceRoot) {
         const source = path.relative(sourceRoot, absolutePath);
         const existingChunkIds = this.store.hashesBySource(source);
         let text;
@@ -36,7 +47,7 @@ export class MemoryIndexer {
         }
         catch (err) {
             console.warn(`[memory-indexer] Cannot read file ${absolutePath}:`, err);
-            return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
+            return this.makeSkippedMutation(source, existingChunkIds.size);
         }
         let fileMtimeAt;
         try {
@@ -58,21 +69,30 @@ export class MemoryIndexer {
             }
             catch (err) {
                 console.warn(`[memory-indexer] Embedding failed for ${absolutePath}:`, err);
-                return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
+                return this.makeSkippedMutation(source, existingChunkIds.size);
             }
         }
-        if (toIndex.length > 0) {
-            this.store.upsert(toIndex, embeddings);
-        }
-        if (toDelete.length > 0) {
-            this.store.deleteByIds(toDelete);
-        }
         return {
-            indexed: toIndex.length,
-            deleted: toDelete.length,
-            skipped: allChunks.length - toIndex.length,
+            source,
+            chunksToUpsert: toIndex,
+            embeddings,
+            idsToDelete: toDelete,
+            stats: {
+                indexed: toIndex.length,
+                deleted: toDelete.length,
+                skipped: allChunks.length - toIndex.length,
+            },
         };
     }
+    commitPreparedMutation(mutation) {
+        if (mutation.chunksToUpsert.length > 0) {
+            this.store.upsert(mutation.chunksToUpsert, mutation.embeddings);
+        }
+        if (mutation.idsToDelete.length > 0) {
+            this.store.deleteByIds(mutation.idsToDelete);
+        }
+        return mutation.stats;
+    }
     async indexDirectory(rootDir, opts = {}) {
         const totals = { indexed: 0, deleted: 0, skipped: 0 };
         let rootExists;
@@ -119,8 +139,9 @@ export class MemoryIndexer {
                 totals.deleted += 1;
             }
         }
-        for (const file of files) {
-            const stats = await this.indexFileRelativeTo(file, relativeBase);
+        const preparedMutations = await mapLimit(files, opts.fileConcurrency ?? 2, (file) => this.prepareIndexFileRelativeTo(file, relativeBase));
+        for (const mutation of preparedMutations) {
+            const stats = this.commitPreparedMutation(mutation);
             totals.indexed += stats.indexed;
             totals.deleted += stats.deleted;
             totals.skipped += stats.skipped;