@dpesch/mantisbt-mcp-server 1.8.2 → 1.9.0

package/tests/helpers/search-mocks.ts

@@ -12,10 +12,29 @@ export const MOCK_VECTOR = Array(384).fill(0.1) as number[];
 // makeMockStore
 // ---------------------------------------------------------------------------
 
-export function makeMockStore(options?: { lastSyncedAt?: string | null; itemCount?: number; lastKnownTotal?: number | null }): VectorStore {
+export interface MockStoreItem {
+  id: number;
+  score?: number;
+  updated_at?: string;
+}
+
+export function makeMockStore(options?: {
+  lastSyncedAt?: string | null;
+  itemCount?: number;
+  lastKnownTotal?: number | null;
+  items?: MockStoreItem[];
+}): VectorStore {
   const lastSyncedAt = options?.lastSyncedAt ?? null;
+  const seedItems = options?.items ?? null;
   const addedItems: VectorStoreItem[] = [];
-  let count = options?.itemCount ?? 0;
+  const itemMap = new Map<number, VectorStoreItem>(
+    (seedItems ?? []).map(i => [i.id, {
+      id: i.id,
+      vector: MOCK_VECTOR,
+      metadata: { summary: `Issue ${i.id}`, updated_at: i.updated_at },
+    }])
+  );
+  let count = options?.itemCount ?? seedItems?.length ?? 0;
 
   return {
     add: vi.fn(async (item: VectorStoreItem) => {
@@ -28,12 +47,16 @@ export function makeMockStore(options?: { lastSyncedAt?: string | null; itemCoun
       }
       count += items.length;
     }),
-    search: vi.fn(async (_vec: number[], topN: number) =>
-      Array.from({ length: Math.min(topN, count) }, (_, i) => ({
+    search: vi.fn(async (_vec: number[], topN: number) => {
+      if (seedItems) {
+        return seedItems.slice(0, topN).map(i => ({ id: i.id, score: i.score ?? 0.9 }));
+      }
+      return Array.from({ length: Math.min(topN, count) }, (_, i) => ({
         id: i + 1,
         score: 1 - i * 0.1,
-      }))
-    ),
+      }));
+    }),
+    getItem: vi.fn(async (id: number) => itemMap.get(id) ?? null),
     delete: vi.fn(async () => {}),
     count: vi.fn(async () => count),
     clear: vi.fn(async () => {

package/tests/search/highlight.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import { extractTerms, highlightText, extractSnippet } from '../../src/search/highlight.js';
+
+// ---------------------------------------------------------------------------
+// extractTerms
+// ---------------------------------------------------------------------------
+
+describe('extractTerms', () => {
+  it('splits by whitespace and returns terms of length >= 3', () => {
+    expect(extractTerms('login error')).toEqual(['login', 'error']);
+  });
+
+  it('filters out terms shorter than 3 characters', () => {
+    expect(extractTerms('a db login')).toEqual(['login']);
+  });
+
+  it('deduplicates terms case-insensitively', () => {
+    const terms = extractTerms('Login login LOGIN');
+    expect(terms).toHaveLength(1);
+    expect(terms[0]!.toLowerCase()).toBe('login');
+  });
+
+  it('sorts longest terms first to prevent partial-match overlap', () => {
+    const terms = extractTerms('err error errors');
+    expect(terms[0]).toBe('errors');
+    expect(terms[1]).toBe('error');
+  });
+
+  it('returns empty array for empty query', () => {
+    expect(extractTerms('')).toEqual([]);
+  });
+
+  it('returns empty array when all terms are too short', () => {
+    expect(extractTerms('a ab')).toEqual([]);
+  });
+
+  it('trims whitespace', () => {
+    expect(extractTerms('  login  error  ')).toEqual(['login', 'error']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// highlightText
+// ---------------------------------------------------------------------------
+
+describe('highlightText', () => {
+  it('wraps a matching term in **bold**', () => {
+    expect(highlightText('Login failed', ['login'])).toBe('**Login** failed');
+  });
+
+  it('is case-insensitive', () => {
+    expect(highlightText('CRASH on startup', ['crash'])).toBe('**CRASH** on startup');
+  });
+
+  it('highlights multiple terms', () => {
+    const result = highlightText('Login error occurred', ['login', 'error']);
+    expect(result).toBe('**Login** **error** occurred');
+  });
+
+  it('returns original text when no terms match', () => {
+    expect(highlightText('Something unrelated', ['crash'])).toBe('Something unrelated');
+  });
+
+  it('returns original text when terms array is empty', () => {
+    expect(highlightText('Login failed', [])).toBe('Login failed');
+  });
+
+  it('does not match term as substring within a word (word-boundary-aware)', () => {
+    // "or" should NOT match inside "error"
+    expect(highlightText('error occurred', ['or'])).toBe('error occurred');
+  });
+
+  it('escapes special regex characters in terms', () => {
+    // Term with special regex chars should not throw
+    expect(() => highlightText('test (foo)', ['(foo)'])).not.toThrow();
+  });
+
+  it('highlights all occurrences of a term', () => {
+    const result = highlightText('login and login again', ['login']);
+    expect(result).toBe('**login** and **login** again');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// extractSnippet
+// ---------------------------------------------------------------------------
+
+describe('extractSnippet', () => {
+  it('returns full text highlighted when text is short', () => {
+    const text = 'Login error on startup';
+    const result = extractSnippet(text, ['login']);
+    expect(result).toBe('**Login** error on startup');
+  });
+
+  it('returns first ~300 chars around the first match for long text', () => {
+    const prefix = 'x'.repeat(200);
+    const text = `${prefix} login error ${' unrelated text'.repeat(30)}`;
+    const result = extractSnippet(text, ['login']);
+    expect(result).toContain('**login**');
+    expect(result.length).toBeLessThanOrEqual(350); // snippet + some overhead
+  });
+
+  it('centers snippet around first match', () => {
+    const padding = 'word '.repeat(60); // ~300 chars before the match
+    const text = `${padding}crash happens here ${'and more text '.repeat(30)}`;
+    const result = extractSnippet(text, ['crash']);
+    expect(result).toContain('**crash**');
+  });
+
+  it('returns first 300 chars (no highlight) when no term matches', () => {
+    const text = 'a'.repeat(600);
+    const result = extractSnippet(text, ['nomatch']);
+    expect(result).toBe('a'.repeat(300) + '…');
+  });
+
+  it('returns full text (no truncation) when text is shorter than 300 chars and no match', () => {
+    const text = 'Short text with no match';
+    const result = extractSnippet(text, ['nomatch']);
+    expect(result).toBe(text);
+  });
+
+  it('respects custom contextChars parameter', () => {
+    const padding = 'x'.repeat(100);
+    const text = `${padding} crash ${padding}`;
+    const result = extractSnippet(text, ['crash'], 50);
+    expect(result).toContain('**crash**');
+    expect(result.length).toBeLessThanOrEqual(150);
+  });
+});

package/tests/search/tools.test.ts

@@ -332,6 +332,100 @@ describe('get_search_index_status – with stored total', () => {
 // get_search_index_status – edge cases
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// search_issues – date filters
+// ---------------------------------------------------------------------------
+
+describe('search_issues – updated_after filter (no select, uses store metadata)', () => {
+  it('returns only results whose store metadata updated_at is after the threshold', async () => {
+    const store = makeMockStore({
+      items: [
+        { id: 1, score: 0.9, updated_at: '2026-03-26T00:00:00Z' }, // pass
+        { id: 2, score: 0.8, updated_at: '2026-03-23T00:00:00Z' }, // fail
+        { id: 3, score: 0.7, updated_at: '2026-03-25T12:00:00Z' }, // pass
+      ],
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'test',
+      top_n: 10,
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number }>;
+    expect(parsed.map(r => r.id)).toEqual([1, 3]);
+  });
+
+  it('makes no API calls when filtering via store metadata (no select)', async () => {
+    const store = makeMockStore({
+      items: [{ id: 1, updated_at: '2026-03-26T00:00:00Z' }],
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    await mockServer.callTool('search_issues', {
+      query: 'test',
+      top_n: 5,
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('excludes results with no updated_at in store metadata', async () => {
+    const store = makeMockStore({
+      items: [
+        { id: 1, score: 0.9 },              // no updated_at → excluded
+        { id: 2, score: 0.8, updated_at: '2026-03-26T00:00:00Z' }, // pass
+      ],
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'test',
+      top_n: 10,
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number }>;
+    expect(parsed.map(r => r.id)).toEqual([2]);
+  });
+});
+
+describe('search_issues – updated_after filter (with select, uses fetched issue data)', () => {
+  it('returns only results whose fetched updated_at is after the threshold', async () => {
+    const store = makeMockStore({
+      items: [
+        { id: 1, score: 0.9 },
+        { id: 2, score: 0.8 },
+      ],
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({
+        issues: [{ id: 1, summary: 'Recent bug', updated_at: '2026-03-26T00:00:00Z' }],
+      })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({
+        issues: [{ id: 2, summary: 'Old bug', updated_at: '2026-03-20T00:00:00Z' }],
+      })));
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'test',
+      top_n: 10,
+      select: 'summary',
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number; summary: string }>;
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0]!.id).toBe(1);
+    expect(parsed[0]!.summary).toBe('Recent bug');
+  });
+});
+
 describe('get_search_index_status – edge cases', () => {
   it('returns 0 % when stored total is 0', async () => {
     const store = makeMockStore({ itemCount: 0, lastKnownTotal: 0 });
@@ -372,3 +466,167 @@ describe('get_search_index_status – edge cases', () => {
     expect(parsed.summary).toContain('total unknown');
   });
 });
+
+// ---------------------------------------------------------------------------
+// search_issues – highlight parameter
+// ---------------------------------------------------------------------------
+
+describe('search_issues – highlight: true (no select, uses store metadata)', () => {
+  it('adds highlights field with bolded terms from store metadata summary', async () => {
+    const store = makeMockStore({
+      items: [{ id: 1, score: 0.9 }],
+    });
+    vi.mocked(store.getItem).mockResolvedValue({
+      id: 1,
+      vector: [],
+      metadata: { summary: 'Login error occurred', description: 'The login fails with error code 500.' },
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'login error',
+      top_n: 1,
+      highlight: true,
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).toHaveProperty('highlights');
+    const highlights = parsed[0]!['highlights'] as Record<string, string>;
+    expect(highlights['summary']).toContain('**');
+  });
+
+  it('omits highlights field when no query terms match', async () => {
+    const store = makeMockStore({
+      items: [{ id: 1, score: 0.9 }],
+    });
+    vi.mocked(store.getItem).mockResolvedValue({
+      id: 1,
+      vector: [],
+      metadata: { summary: 'Unrelated issue', description: undefined },
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'xyzzy',
+      top_n: 1,
+      highlight: true,
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).not.toHaveProperty('highlights');
+  });
+
+  it('does not call store.getItem for highlighting when highlight is false', async () => {
+    const store = makeMockStore({ itemCount: 2 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    await mockServer.callTool('search_issues', { query: 'login', top_n: 2 });
+
+    // getItem should NOT have been called (no date filter, no highlight)
+    expect(store.getItem).not.toHaveBeenCalled();
+  });
+
+  it('still returns id and score alongside highlights', async () => {
+    const store = makeMockStore({
+      items: [{ id: 42, score: 0.85 }],
+    });
+    vi.mocked(store.getItem).mockResolvedValue({
+      id: 42,
+      vector: [],
+      metadata: { summary: 'Login timeout issue' },
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'login',
+      top_n: 1,
+      highlight: true,
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).toHaveProperty('id', 42);
+    expect(parsed[0]).toHaveProperty('score');
+    expect(parsed[0]).toHaveProperty('highlights');
+  });
+});
+
+describe('search_issues – highlight: true (with select)', () => {
+  it('highlights summary from fetched issue when summary is in select', async () => {
+    const store = makeMockStore({ itemCount: 1 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValueOnce(
+      makeResponse(200, JSON.stringify({
+        issues: [{ id: 1, summary: 'Login error in dashboard', status: { id: 10, name: 'new' } }],
+      }))
+    );
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'login error',
+      top_n: 1,
+      select: 'summary,status',
+      highlight: true,
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).toHaveProperty('highlights');
+    const highlights = parsed[0]!['highlights'] as Record<string, string>;
+    expect(highlights['summary']).toContain('**Login**');
+  });
+
+  it('falls back to store metadata for highlighting when API fetch fails', async () => {
+    const store = makeMockStore({ items: [{ id: 1, score: 0.9 }] });
+    vi.mocked(store.getItem).mockResolvedValue({
+      id: 1,
+      vector: [],
+      metadata: { summary: 'Login crash issue' },
+    });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValueOnce(makeResponse(500, 'Server Error'));
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'login',
+      top_n: 1,
+      select: 'summary',
+      highlight: true,
+    });
+
+    // Falls back to {id, score} but we still try to add highlights from store metadata
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).toHaveProperty('id', 1);
+  });
+});
+
+describe('search_issues – highlight: true combined with date filter', () => {
+  it('returns highlights only for date-filtered results (no select)', async () => {
+    const store = makeMockStore({
+      items: [
+        { id: 1, score: 0.9, updated_at: '2026-03-26T00:00:00Z' }, // passes filter
+        { id: 2, score: 0.8, updated_at: '2026-03-20T00:00:00Z' }, // filtered out
+      ],
+    });
+    vi.mocked(store.getItem).mockImplementation(async (id: number) => ({
+      id,
+      vector: [],
+      metadata: {
+        summary: id === 1 ? 'Login crash issue' : 'Old login bug',
+        updated_at: id === 1 ? '2026-03-26T00:00:00Z' : '2026-03-20T00:00:00Z',
+      },
+    }));
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', {
+      query: 'login',
+      top_n: 10,
+      highlight: true,
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number }>;
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0]!.id).toBe(1);
+  });
+});