@hanhnd/agent-kit 1.0.39 → 1.0.40

package/dist/cli.js

@@ -15195,6 +15195,22 @@ async function withTimeout(promise, timeoutMs, createError) {
     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/utils/paths.ts
 import * as os2 from "os";
@@ -15912,9 +15928,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;
@@ -15922,7 +15948,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 {
@@ -15942,21 +15968,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;
@@ -15998,8 +16033,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;

package/dist/entrypoints/server.js

@@ -23,13 +23,13 @@ registerIntegrationTools(server);
 registerCoreTools(server);
 registerAgentTools(server);
 const workspaceRoot = getWorkspaceRoot();
-const memoryIndexer = registerMemoryTools(server, workspaceRoot);
+const memorySubsystem = registerMemoryTools(server, workspaceRoot);
 // ═══════════════════════════════════════════════════════════════
 // START SERVER
 // ═══════════════════════════════════════════════════════════════
 const transport = new StdioServerTransport();
 await server.connect(transport);
 // Fire-and-forget startup indexing — must run after server.connect
-if (memoryIndexer) {
-    void memoryIndexer.startupIndex();
+if (memorySubsystem) {
+    void memorySubsystem.startWarmup();
 }

package/dist/mcp/memory.d.ts

@@ -1,16 +1,11 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { MemoryIndexer } from '../services/memory/indexer.js';
-import { MemoryStore } from '../services/memory/store.js';
-import type { MemoryConfig } from '../services/memory/types.js';
+import { type MemorySubsystem, type MemorySubsystemOverrides } from '../services/memory/subsystem.js';
 import { type ProjectSettings } from '../core/config/index.js';
 /**
  * Initializes the memory subsystem and registers all memory tools.
- * Returns the MemoryIndexer so the caller can fire startupIndex() after server.connect().
+ * Returns the MemorySubsystem so the caller can fire startWarmup() after server.connect().
  * Returns null when memory is disabled (settings.memory.enabled !== true).
  */
-export declare function registerMemoryTools(server: McpServer, workspaceRoot: string, overrides?: {
-    indexer?: MemoryIndexer;
-    store?: MemoryStore;
-    config?: MemoryConfig;
+export declare function registerMemoryTools(server: McpServer, workspaceRoot: string, overrides?: MemorySubsystemOverrides & {
     settings?: ProjectSettings;
-}): MemoryIndexer | null;
+}): MemorySubsystem | null;

package/dist/mcp/memory.js

@@ -1,29 +1,33 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { z } from 'zod';
-import { Embedder } from '../services/memory/embedder.js';
-import { MemoryIndexer } from '../services/memory/indexer.js';
-import { MemoryStore } from '../services/memory/store.js';
+import { createMemorySubsystem, } from '../services/memory/subsystem.js';
 import { SOURCE_TYPES } from '../services/memory/types.js';
 import { initializeConversationDigestModel } from '../services/digest/processor.js';
 import { DEFAULT_DIGEST_MODEL_ID } from '../services/digest/constants.js';
 import { formatError, mcpJson, mcpText } from '../utils/utils.js';
-import { loadGlobalSettings, resolveConversationDigestConfig, resolveMemoryConfig, } from '../core/config/index.js';
+import { loadGlobalSettings, resolveConversationDigestConfig } from '../core/config/index.js';
 /**
- * Registers tool handlers onto an already-constructed indexer/store pair.
+ * Registers tool handlers against the current memory subsystem state.
  */
-function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoot = process.cwd()) {
+function registerMemoryToolHandlers(server, subsystem, workspaceRoot = process.cwd()) {
+    const { config } = subsystem;
     server.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.', {
         query: z.string().min(1).describe('Keyword-only search query with stopwords removed'),
         top_k: z.number().int().positive().optional().describe('Number of results to return'),
     }, 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 ?? config.topK);
+            const lifecycleNote = formatLifecycleNote(subsystem);
             const degradedNote = !store.vecAvailable
                 ? '⚠️ Vector search unavailable — 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) => {
@@ -34,7 +38,7 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
                 return `### ${displaySource} (score: ${r.score.toFixed(3)})\n${content}`;
             })
                 .join('\n\n---\n\n');
-            return mcpText(`${degradedNote}${formatted}`);
+            return mcpText(`${lifecycleNote}${degradedNote}${formatted}`);
         }
         catch (err) {
             return mcpText(`kit_memory_search failed: ${formatError(err)}`);
@@ -45,6 +49,10 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
         source_type: z.enum(SOURCE_TYPES).optional().describe('Optional source type filter'),
     }, 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.');
@@ -71,6 +79,13 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
         content: z.string().min(1).describe('Content to save to memory'),
     }, 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,
@@ -109,22 +124,31 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
         }
     });
 }
+function formatLifecycleNote(subsystem) {
+    if (subsystem.status.state === 'warming' || subsystem.status.state === 'initializing') {
+        return '⚠️ Memory index is warming — results may be stale until startup indexing completes.\n\n';
+    }
+    if (subsystem.status.state === 'degraded') {
+        return `⚠️ Memory index is degraded${subsystem.status.error ? `: ${subsystem.status.error}` : ''}.\n\n`;
+    }
+    return '';
+}
+function formatInitializationFailure(subsystem) {
+    const detail = subsystem.status.error ? `: ${subsystem.status.error}` : '';
+    return `Memory initialization failed${detail}`;
+}
 /**
  * Initializes the memory subsystem and registers all memory tools.
- * Returns the MemoryIndexer so the caller can fire startupIndex() after server.connect().
+ * Returns the MemorySubsystem so the caller can fire startWarmup() after server.connect().
  * Returns null when memory is disabled (settings.memory.enabled !== true).
  */
 export function registerMemoryTools(server, workspaceRoot, overrides) {
     const settings = overrides?.settings ?? loadGlobalSettings();
     if (settings.memory?.enabled !== true)
         return null;
-    const config = overrides?.config ?? resolveMemoryConfig(settings, workspaceRoot);
-    const store = overrides?.store ?? new MemoryStore(path.join(config.wikiDir, 'index.db'), config);
-    const indexer = overrides?.indexer ??
-        (() => {
-            const embedder = new Embedder(config.embeddingModel);
-            return new MemoryIndexer(store, embedder, config);
-        })();
-    registerMemoryToolHandlers(server, indexer, store, config, workspaceRoot);
-    return indexer;
+    const subsystem = createMemorySubsystem(workspaceRoot, { ...overrides, settings });
+    if (!subsystem)
+        return null;
+    registerMemoryToolHandlers(server, subsystem, workspaceRoot);
+    return subsystem;
 }