@dpesch/mantisbt-mcp-server 1.5.4 → 1.5.5

package/CHANGELOG.md

@@ -7,6 +7,13 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.5.5] – 2026-03-18
+
+### Fixed
+- Semantic search index sync: eliminated O(n²) disk write amplification during initial index builds. Previously `addBatch()` wrote the entire `index.json` to disk after every batch, causing n/batch_size complete rewrites for a full rebuild. Now `addBatch()` only updates the in-memory map; a new `flush()` method (atomic write via tmp file + rename) persists to disk. `SearchSyncService.sync()` calls `flush()` as a checkpoint every 100 indexed issues (`CHECKPOINT_INTERVAL=100`), limiting data loss on process kill to at most 100 issues, and performs a final flush after the loop for any remaining items.
+
+---
+
 ## [1.5.4] – 2026-03-18
 
 ### Fixed

package/dist/search/store.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { readFile, writeFile, rename, mkdir, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 // ---------------------------------------------------------------------------
 // VectraStore
@@ -34,8 +34,10 @@ export class VectraStore {
     }
     async persist() {
         const indexFile = join(this.vectraDir, 'index.json');
+        const tmpFile = indexFile + '.tmp';
         const data = JSON.stringify([...this.items.values()]);
-        await writeFile(indexFile, data, 'utf-8');
+        await writeFile(tmpFile, data, 'utf-8');
+        await rename(tmpFile, indexFile);
     }
     async add(item) {
         await this.ensureLoaded();
@@ -47,6 +49,9 @@ export class VectraStore {
         for (const item of items) {
             this.items.set(item.id, item);
         }
+        // No persist() here — call flush() once after all batches are processed.
+    }
+    async flush() {
         await this.persist();
     }
     async search(vector, topN) {

package/dist/search/sync.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 const PAGE_SIZE = 50;
 const EMBED_BATCH_SIZE = 10;
+const CHECKPOINT_INTERVAL = 100; // flush to disk every N indexed issues
 export class SearchSyncService {
     client;
     store;
@@ -17,6 +18,7 @@ export class SearchSyncService {
         const { issues: allIssues, totalFromApi } = await this.fetchAllIssues(lastSyncedAt ?? undefined, projectId);
         let indexed = 0;
         let skipped = 0;
+        let indexedSinceCheckpoint = 0;
         // Process in batches of EMBED_BATCH_SIZE
         for (let i = 0; i < allIssues.length; i += EMBED_BATCH_SIZE) {
             const batch = allIssues.slice(i, i + EMBED_BATCH_SIZE);
@@ -43,6 +45,17 @@ export class SearchSyncService {
             }));
             await this.store.addBatch(batchItems);
             indexed += batchItems.length;
+            indexedSinceCheckpoint += batchItems.length;
+            // Checkpoint flush: persist every CHECKPOINT_INTERVAL issues to limit
+            // data loss if the process is killed before the final flush.
+            if (indexedSinceCheckpoint >= CHECKPOINT_INTERVAL) {
+                await this.store.flush();
+                indexedSinceCheckpoint = 0;
+            }
+        }
+        // Final flush for any remaining items not yet written by a checkpoint.
+        if (indexedSinceCheckpoint > 0) {
+            await this.store.flush();
         }
         await this.store.setLastSyncedAt(new Date().toISOString());
         // Persist the best known total for get_search_index_status.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpesch/mantisbt-mcp-server",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "description": "MCP server for MantisBT REST API – read and manage bug tracker issues",
   "author": "Dominik Pesch",
   "license": "MIT",

package/tests/helpers/search-mocks.ts

@@ -45,6 +45,7 @@ export function makeMockStore(options?: { lastSyncedAt?: string | null; itemCoun
     resetLastSyncedAt: vi.fn(async () => {}),
     getLastKnownTotal: vi.fn(async () => options?.lastKnownTotal ?? null),
     setLastKnownTotal: vi.fn(async () => {}),
+    flush: vi.fn(async () => {}),
   };
 }
 

package/tests/search/store.test.ts

@@ -146,3 +146,48 @@ describe('VectraStore.resetLastSyncedAt', () => {
     expect(await store.getLastSyncedAt()).toBeNull();
   });
 });
+
+describe('VectraStore.addBatch', () => {
+  it('increases in-memory count without persisting to disk', async () => {
+    await store.addBatch([
+      { id: 1, vector: randomVector(), metadata: { summary: 'A' } },
+      { id: 2, vector: randomVector(), metadata: { summary: 'B' } },
+    ]);
+    expect(await store.count()).toBe(2);
+
+    // A new instance reading the same dir must not see the items yet
+    const store2 = new VectraStore(dir);
+    expect(await store2.count()).toBe(0);
+  });
+
+  it('persists items after flush()', async () => {
+    await store.addBatch([
+      { id: 10, vector: randomVector(), metadata: { summary: 'X' } },
+      { id: 11, vector: randomVector(), metadata: { summary: 'Y' } },
+    ]);
+    await store.flush();
+
+    const store2 = new VectraStore(dir);
+    expect(await store2.count()).toBe(2);
+  });
+
+  it('accumulates items across multiple addBatch calls before flush', async () => {
+    await store.addBatch([{ id: 1, vector: randomVector(), metadata: { summary: 'First' } }]);
+    await store.addBatch([{ id: 2, vector: randomVector(), metadata: { summary: 'Second' } }]);
+    await store.flush();
+
+    const store2 = new VectraStore(dir);
+    expect(await store2.count()).toBe(2);
+  });
+});
+
+describe('VectraStore.flush (atomic write)', () => {
+  it('leaves no .tmp file after a successful flush', async () => {
+    const { readdir } = await import('node:fs/promises');
+    await store.addBatch([{ id: 1, vector: randomVector(), metadata: { summary: 'Test' } }]);
+    await store.flush();
+
+    const files = await readdir(join(dir, 'vectra'));
+    expect(files.some(f => f.endsWith('.tmp'))).toBe(false);
+  });
+});

package/tests/search/sync.test.ts

@@ -144,6 +144,60 @@ describe('SearchSyncService.sync – project_id', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// flush / checkpoint behaviour
+// ---------------------------------------------------------------------------
+
+describe('SearchSyncService.sync – flush and checkpoint', () => {
+  function makeIssues(count: number) {
+    return Array.from({ length: count }, (_, i) => ({
+      id: i + 1,
+      summary: `Issue ${i + 1}`,
+      description: `Description ${i + 1}`,
+      updated_at: '2024-03-10T08:00:00Z',
+    }));
+  }
+
+  it('calls flush exactly once when fewer than 100 issues are indexed', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: makeIssues(50), total_count: 50 }))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    await service.sync();
+
+    // Only the final flush, no checkpoint
+    expect(store.flush).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls flush exactly once when exactly 100 issues are indexed (checkpoint covers all, no redundant final)', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: makeIssues(100), total_count: 100 }))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    await service.sync();
+
+    // Checkpoint at 100 covers all items; indexedSinceCheckpoint resets to 0 → no redundant final flush
+    expect(store.flush).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls flush twice when 110 issues are indexed (checkpoint at 100 + final for remaining 10)', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: makeIssues(110), total_count: 110 }))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    await service.sync();
+
+    // Checkpoint at 100, then final flush for remaining 10
+    expect(store.flush).toHaveBeenCalledTimes(2);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // total_count persistence (regression: MantisBT installations without total_count)
 // ---------------------------------------------------------------------------