@dpesch/mantisbt-mcp-server 1.10.3 → 1.10.6

package/tests/search/highlight.test.ts

@@ -1,129 +0,0 @@
-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/store.test.ts

@@ -1,193 +0,0 @@
-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();
-  });
-});
-
-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

@@ -1,249 +0,0 @@
-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');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 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)
-// ---------------------------------------------------------------------------
-
-describe('SearchSyncService.sync – setLastKnownTotal persistence', () => {
-  it('persists total_count from API response', async () => {
-    const store = makeMockStore({ lastSyncedAt: null });
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issues: ISSUE_FIXTURE, total_count: 42 }))
-    );
-
-    const service = new SearchSyncService(client, store, embedder);
-    const result = await service.sync();
-
-    expect(store.setLastKnownTotal).toHaveBeenCalledWith(42);
-    expect(result.total).toBe(42);
-  });
-
-  it('uses indexed+skipped as fallback when API omits total_count (full rebuild)', async () => {
-    // Regression test: MantisBT installations that do not return total_count
-    const store = makeMockStore({ lastSyncedAt: null });
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issues: ISSUE_FIXTURE })) // no total_count field
-    );
-
-    const service = new SearchSyncService(client, store, embedder);
-    const result = await service.sync();
-
-    // ISSUE_FIXTURE: 2 indexed (have summary), 1 skipped (no summary) → total = 3
-    expect(result.total).toBe(3);
-    expect(store.setLastKnownTotal).toHaveBeenCalledWith(3);
-  });
-
-  it('falls back to store.count() for incremental sync when API omits total_count', async () => {
-    // MantisBT installations without total_count: incremental sync uses the current store
-    // size as best available estimate so the status tool never shows "total unknown".
-    const store = makeMockStore({ lastSyncedAt: '2024-03-01T00:00:00.000Z', itemCount: 100 });
-    vi.mocked(fetch).mockResolvedValue(
-      makeResponse(200, JSON.stringify({ issues: [ISSUE_FIXTURE[0]!] })) // no total_count, partial result
-    );
-
-    const service = new SearchSyncService(client, store, embedder);
-    const result = await service.sync();
-
-    // store.count() returns 101 after adding the 1 new item (mock increments count on addBatch)
-    expect(result.total).toBeGreaterThan(0);
-    expect(store.setLastKnownTotal).toHaveBeenCalled();
-  });
-});