@dpesch/mantisbt-mcp-server 1.0.3 → 1.2.0

package/tests/fixtures/get_issue_fields_sample.json

@@ -0,0 +1,110 @@
+{
+  "issues": [
+    {
+      "id": 7857,
+      "summary": "Issue summary 1",
+      "description": "Issue description 1",
+      "project": {
+        "id": 54,
+        "name": "Project 2"
+      },
+      "category": {
+        "id": 394,
+        "name": "Hooks"
+      },
+      "reporter": {
+        "id": 51,
+        "name": "user_1",
+        "real_name": "User One",
+        "email": "user1@example.com"
+      },
+      "handler": {
+        "id": 51,
+        "name": "user_1",
+        "real_name": "User One",
+        "email": "user1@example.com"
+      },
+      "status": {
+        "id": 80,
+        "name": "resolved",
+        "label": "erledigt",
+        "color": "#e8e8e8"
+      },
+      "resolution": {
+        "id": 20,
+        "name": "fixed",
+        "label": "erledigt"
+      },
+      "view_state": {
+        "id": 10,
+        "name": "public",
+        "label": "öffentlich"
+      },
+      "priority": {
+        "id": 30,
+        "name": "normal",
+        "label": "normal"
+      },
+      "severity": {
+        "id": 0,
+        "name": "@0@",
+        "label": "@0@"
+      },
+      "reproducibility": {
+        "id": 70,
+        "name": "have not tried",
+        "label": "nicht getestet"
+      },
+      "sticky": false,
+      "created_at": "2026-03-15T22:11:31+01:00",
+      "updated_at": "2026-03-15T22:23:08+01:00",
+      "history": [
+        {
+          "created_at": "2026-03-15T22:11:31+01:00",
+          "user": {
+            "id": 51,
+            "name": "user_1",
+            "real_name": "User One",
+            "email": "user1@example.com"
+          },
+          "type": {
+            "id": 1,
+            "name": "issue-new"
+          },
+          "message": "Neuer Eintrag"
+        },
+        {
+          "created_at": "2026-03-15T22:23:08+01:00",
+          "user": {
+            "id": 51,
+            "name": "user_1",
+            "real_name": "User One",
+            "email": "user1@example.com"
+          },
+          "field": {
+            "name": "status",
+            "label": "Status"
+          },
+          "type": {
+            "id": 0,
+            "name": "field-updated"
+          },
+          "old_value": {
+            "id": 50,
+            "name": "assigned",
+            "label": "zugewiesen",
+            "color": "#afbed5"
+          },
+          "new_value": {
+            "id": 80,
+            "name": "resolved",
+            "label": "erledigt",
+            "color": "#e8e8e8"
+          },
+          "message": "Status",
+          "change": "zugewiesen => erledigt"
+        }
+      ]
+    }
+  ]
+}

package/tests/fixtures/list_issues.json

@@ -62,6 +62,40 @@
       "sticky": false,
       "created_at": "2026-03-13T09:58:23+01:00",
       "updated_at": "2026-03-13T11:25:19+01:00"
+    },
+    {
+      "id": 7900,
+      "summary": "Issue summary 4 (open)",
+      "description": "Issue description 4",
+      "project": { "id": 54, "name": "Project 2" },
+      "category": { "id": 350, "name": "Konfiguration" },
+      "reporter": { "id": 52, "name": "user_2" },
+      "handler": {
+        "id": 51,
+        "name": "user_1",
+        "real_name": "User One",
+        "email": "user1@example.com"
+      },
+      "status": { "id": 50, "name": "assigned", "label": "zugewiesen", "color": "#e8e8e8" },
+      "priority": { "id": 30, "name": "normal", "label": "normal" },
+      "severity": { "id": 210, "name": "Wartung", "label": "Wartung" },
+      "sticky": false,
+      "created_at": "2026-03-14T10:00:00+01:00",
+      "updated_at": "2026-03-14T10:00:00+01:00"
+    },
+    {
+      "id": 7901,
+      "summary": "Issue summary 5 (open, new)",
+      "description": "Issue description 5",
+      "project": { "id": 54, "name": "Project 2" },
+      "category": { "id": 350, "name": "Konfiguration" },
+      "reporter": { "id": 52, "name": "user_2" },
+      "status": { "id": 10, "name": "new", "label": "neu", "color": "#fcbdbd" },
+      "priority": { "id": 30, "name": "normal", "label": "normal" },
+      "severity": { "id": 210, "name": "Wartung", "label": "Wartung" },
+      "sticky": false,
+      "created_at": "2026-03-14T11:00:00+01:00",
+      "updated_at": "2026-03-14T11:00:00+01:00"
     }
   ]
 }

package/tests/helpers/mock-server.ts

@@ -1,3 +1,13 @@
+export function makeResponse(status: number, body: string): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: `Status ${status}`,
+    text: () => Promise.resolve(body),
+    headers: { get: (_key: string) => null },
+  } as unknown as Response;
+}
+
 // Typ für das Result-Objekt das die Tools zurückgeben
 export interface ToolResult {
   content: Array<{ type: string; text: string }>;

package/tests/helpers/search-mocks.ts

@@ -0,0 +1,58 @@
+import { vi } from 'vitest';
+import type { VectorStore, VectorStoreItem } from '../../src/search/store.js';
+import type { Embedder } from '../../src/search/embedder.js';
+
+// ---------------------------------------------------------------------------
+// Shared constants
+// ---------------------------------------------------------------------------
+
+export const MOCK_VECTOR = Array(384).fill(0.1) as number[];
+
+// ---------------------------------------------------------------------------
+// makeMockStore
+// ---------------------------------------------------------------------------
+
+export function makeMockStore(options?: { lastSyncedAt?: string | null; itemCount?: number }): VectorStore {
+  const lastSyncedAt = options?.lastSyncedAt ?? null;
+  const addedItems: VectorStoreItem[] = [];
+  let count = options?.itemCount ?? 0;
+
+  return {
+    add: vi.fn(async (item: VectorStoreItem) => {
+      addedItems.push(item);
+      count++;
+    }),
+    addBatch: vi.fn(async (items: VectorStoreItem[]) => {
+      for (const item of items) {
+        addedItems.push(item);
+      }
+      count += items.length;
+    }),
+    search: vi.fn(async (_vec: number[], topN: number) =>
+      Array.from({ length: Math.min(topN, count) }, (_, i) => ({
+        id: i + 1,
+        score: 1 - i * 0.1,
+      }))
+    ),
+    delete: vi.fn(async () => {}),
+    count: vi.fn(async () => count),
+    clear: vi.fn(async () => {
+      addedItems.splice(0);
+      count = 0;
+    }),
+    getLastSyncedAt: vi.fn(async () => lastSyncedAt),
+    setLastSyncedAt: vi.fn(async () => {}),
+    resetLastSyncedAt: vi.fn(async () => {}),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// makeMockEmbedder
+// ---------------------------------------------------------------------------
+
+export function makeMockEmbedder(): Embedder {
+  return {
+    embed: vi.fn(async () => MOCK_VECTOR),
+    embedBatch: vi.fn(async (texts: string[]) => texts.map(() => MOCK_VECTOR)),
+  } as unknown as Embedder;
+}

package/tests/search/store.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { randomBytes } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { VectraStore } from '../../src/search/store.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function randomVector(dim = 384): number[] {
+  return Array.from({ length: dim }, () => Math.random() * 2 - 1);
+}
+
+function tmpDir(): string {
+  return join(tmpdir(), `mantis-search-test-${randomBytes(8).toString('hex')}`);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+let store: VectraStore;
+let dir: string;
+
+beforeEach(() => {
+  dir = tmpDir();
+  store = new VectraStore(dir);
+});
+
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('VectraStore.count', () => {
+  it('returns 0 on an empty store', async () => {
+    expect(await store.count()).toBe(0);
+  });
+});
+
+describe('VectraStore.add', () => {
+  it('increases count after adding an item', async () => {
+    await store.add({ id: 1, vector: randomVector(), metadata: { summary: 'First issue' } });
+    expect(await store.count()).toBe(1);
+  });
+
+  it('persists across store instances (same dir)', async () => {
+    await store.add({ id: 42, vector: randomVector(), metadata: { summary: 'Persistent' } });
+
+    const store2 = new VectraStore(dir);
+    expect(await store2.count()).toBe(1);
+  });
+
+  it('overwrites an existing item with the same id', async () => {
+    const vec1 = randomVector();
+    const vec2 = randomVector();
+    await store.add({ id: 7, vector: vec1, metadata: { summary: 'Original' } });
+    await store.add({ id: 7, vector: vec2, metadata: { summary: 'Updated' } });
+    expect(await store.count()).toBe(1);
+  });
+});
+
+describe('VectraStore.search', () => {
+  it('returns results sorted by descending score', async () => {
+    const queryVec = randomVector();
+    // Add items with known vectors; one is identical to the query (score = 1)
+    await store.add({ id: 1, vector: [...queryVec], metadata: { summary: 'Exact match' } });
+    await store.add({ id: 2, vector: randomVector(), metadata: { summary: 'Random' } });
+    await store.add({ id: 3, vector: randomVector(), metadata: { summary: 'Another random' } });
+
+    const results = await store.search(queryVec, 3);
+
+    expect(results.length).toBe(3);
+    expect(results[0]!.id).toBe(1);
+    expect(results[0]!.score).toBeCloseTo(1, 5);
+    // Scores are descending
+    for (let i = 1; i < results.length; i++) {
+      expect(results[i - 1]!.score).toBeGreaterThanOrEqual(results[i]!.score);
+    }
+  });
+
+  it('respects the topN limit', async () => {
+    for (let i = 1; i <= 5; i++) {
+      await store.add({ id: i, vector: randomVector(), metadata: { summary: `Issue ${i}` } });
+    }
+    const results = await store.search(randomVector(), 3);
+    expect(results.length).toBe(3);
+  });
+
+  it('returns empty array on empty store', async () => {
+    const results = await store.search(randomVector(), 5);
+    expect(results).toEqual([]);
+  });
+});
+
+describe('VectraStore.delete', () => {
+  it('removes an item and decreases count', async () => {
+    await store.add({ id: 10, vector: randomVector(), metadata: { summary: 'To delete' } });
+    await store.add({ id: 11, vector: randomVector(), metadata: { summary: 'To keep' } });
+    await store.delete(10);
+    expect(await store.count()).toBe(1);
+  });
+
+  it('does nothing when deleting a non-existent id', async () => {
+    await store.add({ id: 5, vector: randomVector(), metadata: { summary: 'Exists' } });
+    await store.delete(9999);
+    expect(await store.count()).toBe(1);
+  });
+});
+
+describe('VectraStore.clear', () => {
+  it('removes all items', async () => {
+    for (let i = 1; i <= 3; i++) {
+      await store.add({ id: i, vector: randomVector(), metadata: { summary: `Issue ${i}` } });
+    }
+    await store.clear();
+    expect(await store.count()).toBe(0);
+  });
+});
+
+describe('VectraStore.getLastSyncedAt / setLastSyncedAt', () => {
+  it('returns null initially', async () => {
+    expect(await store.getLastSyncedAt()).toBeNull();
+  });
+
+  it('returns the value after setting it', async () => {
+    const ts = '2024-01-15T10:00:00.000Z';
+    await store.setLastSyncedAt(ts);
+    expect(await store.getLastSyncedAt()).toBe(ts);
+  });
+
+  it('persists the value across instances', async () => {
+    const ts = '2024-06-01T12:34:56.000Z';
+    await store.setLastSyncedAt(ts);
+
+    const store2 = new VectraStore(dir);
+    expect(await store2.getLastSyncedAt()).toBe(ts);
+  });
+});
+
+describe('VectraStore.resetLastSyncedAt', () => {
+  it('clears the lastSyncedAt value', async () => {
+    await store.setLastSyncedAt('2024-01-01T00:00:00.000Z');
+    await store.resetLastSyncedAt();
+    expect(await store.getLastSyncedAt()).toBeNull();
+  });
+});

package/tests/search/sync.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { MantisClient } from '../../src/client.js';
+import { SearchSyncService } from '../../src/search/sync.js';
+import { makeMockStore, makeMockEmbedder } from '../helpers/search-mocks.js';
+import { makeResponse } from '../helpers/mock-server.js';
+import type { Embedder } from '../../src/search/embedder.js';
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const ISSUE_FIXTURE = [
+  { id: 101, summary: 'Login fails on mobile', description: 'Steps to reproduce...', updated_at: '2024-03-10T08:00:00Z' },
+  { id: 102, summary: 'Dashboard loads slowly', description: 'Takes over 10 seconds', updated_at: '2024-03-09T14:00:00Z' },
+  { id: 103, description: 'No summary here', updated_at: '2024-03-08T10:00:00Z' }, // no summary → skipped
+];
+
+const LIST_ISSUES_RESPONSE = {
+  issues: ISSUE_FIXTURE,
+  total_count: ISSUE_FIXTURE.length,
+};
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+let client: MantisClient;
+let embedder: Embedder;
+
+beforeEach(() => {
+  client = new MantisClient('https://mantis.example.com', 'test-token');
+  embedder = makeMockEmbedder();
+  vi.stubGlobal('fetch', vi.fn());
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// sync without previous state
+// ---------------------------------------------------------------------------
+
+describe('SearchSyncService.sync – no previous state', () => {
+  it('indexes all issues with summaries and skips those without', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify(LIST_ISSUES_RESPONSE))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    const result = await service.sync();
+
+    // 2 issues have summaries, 1 does not
+    expect(result.indexed).toBe(2);
+    expect(result.skipped).toBe(1);
+    expect(store.addBatch).toHaveBeenCalledTimes(1);
+    expect(store.setLastSyncedAt).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls the API without updated_after when no lastSyncedAt', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify(LIST_ISSUES_RESPONSE))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    await service.sync();
+
+    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
+    const url = new URL(calledUrl);
+    expect(url.searchParams.has('updated_after')).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sync with lastSyncedAt (incremental)
+// ---------------------------------------------------------------------------
+
+describe('SearchSyncService.sync – incremental (with lastSyncedAt)', () => {
+  it('passes updated_after to the API', async () => {
+    const lastSync = '2024-03-09T00:00:00.000Z';
+    const store = makeMockStore({ lastSyncedAt: lastSync });
+    const incrementalResponse = {
+      issues: [ISSUE_FIXTURE[0]!], // only one newer issue
+      total_count: 1,
+    };
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify(incrementalResponse))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    await service.sync();
+
+    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
+    const url = new URL(calledUrl);
+    expect(url.searchParams.get('updated_after')).toBe(lastSync);
+    expect(store.addBatch).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Issues without summary are skipped
+// ---------------------------------------------------------------------------
+
+describe('SearchSyncService.sync – skip issues without summary', () => {
+  it('returns correct skipped count', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    const onlyNoSummaryResponse = {
+      issues: [{ id: 200, description: 'No summary', updated_at: '2024-01-01T00:00:00Z' }],
+      total_count: 1,
+    };
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify(onlyNoSummaryResponse))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    const result = await service.sync();
+
+    expect(result.indexed).toBe(0);
+    expect(result.skipped).toBe(1);
+    expect(store.addBatch).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// project_id is forwarded
+// ---------------------------------------------------------------------------
+
+describe('SearchSyncService.sync – project_id', () => {
+  it('passes project_id to the API', async () => {
+    const store = makeMockStore({ lastSyncedAt: null });
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: [], total_count: 0 }))
+    );
+
+    const service = new SearchSyncService(client, store, embedder);
+    await service.sync(7);
+
+    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
+    const url = new URL(calledUrl);
+    expect(url.searchParams.get('project_id')).toBe('7');
+  });
+});

package/tests/search/tools.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { MantisClient } from '../../src/client.js';
+import { registerSearchTools } from '../../src/search/tools.js';
+import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
+import { makeMockStore, makeMockEmbedder } from '../helpers/search-mocks.js';
+import type { Embedder } from '../../src/search/embedder.js';
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+let mockServer: MockMcpServer;
+let client: MantisClient;
+let embedder: Embedder;
+
+beforeEach(() => {
+  mockServer = new MockMcpServer();
+  client = new MantisClient('https://mantis.example.com', 'test-token');
+  embedder = makeMockEmbedder();
+  vi.stubGlobal('fetch', vi.fn());
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+
+describe('registerSearchTools – registration', () => {
+  it('registers search_issues', () => {
+    const store = makeMockStore({ itemCount: 0 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+    expect(mockServer.hasToolRegistered('search_issues')).toBe(true);
+  });
+
+  it('registers rebuild_search_index', () => {
+    const store = makeMockStore({ itemCount: 0 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+    expect(mockServer.hasToolRegistered('rebuild_search_index')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// search_issues – empty store
+// ---------------------------------------------------------------------------
+
+describe('search_issues – empty store', () => {
+  it('returns error message when store is empty', async () => {
+    const store = makeMockStore({ itemCount: 0 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', { query: 'login error', top_n: 5 });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('Search index is empty');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// search_issues – with results
+// ---------------------------------------------------------------------------
+
+describe('search_issues – with results', () => {
+  it('returns a JSON array with id and score', async () => {
+    const store = makeMockStore({ itemCount: 3 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', { query: 'login error', top_n: 3 });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number; score: number }>;
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBeGreaterThan(0);
+    expect(typeof parsed[0]!.id).toBe('number');
+    expect(typeof parsed[0]!.score).toBe('number');
+  });
+
+  it('respects the top_n parameter', async () => {
+    const store = makeMockStore({ itemCount: 10 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', { query: 'bug', top_n: 2 });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number; score: number }>;
+    expect(parsed.length).toBeLessThanOrEqual(2);
+  });
+
+  it('calls embedder.embed with the query', async () => {
+    const store = makeMockStore({ itemCount: 1 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    await mockServer.callTool('search_issues', { query: 'performance issue', top_n: 5 });
+
+    expect(embedder.embed).toHaveBeenCalledWith('performance issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// rebuild_search_index – full rebuild
+// ---------------------------------------------------------------------------
+
+describe('rebuild_search_index – full: true', () => {
+  it('clears the store and resets lastSyncedAt before syncing', async () => {
+    const store = makeMockStore({ itemCount: 5 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: [], total_count: 0 }))
+    );
+
+    await mockServer.callTool('rebuild_search_index', { full: true });
+
+    expect(store.clear).toHaveBeenCalled();
+    expect(store.resetLastSyncedAt).toHaveBeenCalled();
+  });
+
+  it('returns indexed, skipped, duration_ms in the response', async () => {
+    const store = makeMockStore({ itemCount: 0 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: [], total_count: 0 }))
+    );
+
+    const result = await mockServer.callTool('rebuild_search_index', { full: false });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as {
+      indexed: number;
+      skipped: number;
+      duration_ms: number;
+    };
+    expect(typeof parsed.indexed).toBe('number');
+    expect(typeof parsed.skipped).toBe('number');
+    expect(typeof parsed.duration_ms).toBe('number');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// rebuild_search_index – incremental (full: false)
+// ---------------------------------------------------------------------------
+
+describe('rebuild_search_index – full: false', () => {
+  it('does NOT clear the store', async () => {
+    const store = makeMockStore({ itemCount: 0 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: [], total_count: 0 }))
+    );
+
+    await mockServer.callTool('rebuild_search_index', { full: false });
+
+    expect(store.clear).not.toHaveBeenCalled();
+    expect(store.resetLastSyncedAt).not.toHaveBeenCalled();
+  });
+});