bluera-knowledge 0.14.0 → 0.14.2

package/tests/integration/serve.test.ts

@@ -1,260 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-import { spawn, type ChildProcess } from 'node:child_process';
-import { rm, mkdtemp, writeFile, mkdir } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-/**
- * Serve Command Integration Tests
- *
- * Tests that the HTTP server actually starts, responds to requests,
- * and shuts down cleanly. Unlike unit tests that mock the serve function,
- * these tests spawn a real server process and make actual HTTP requests.
- */
-describe('Serve Integration', () => {
-  let tempDir: string;
-  let testFilesDir: string;
-  let serverProcess: ChildProcess | null = null;
-  const TEST_PORT = 19877; // Use a unique port to avoid conflicts
-
-  beforeAll(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'serve-test-'));
-    testFilesDir = join(tempDir, 'files');
-    await mkdir(testFilesDir, { recursive: true });
-    await writeFile(
-      join(testFilesDir, 'test.md'),
-      '# Test Document\n\nContent for serve integration testing.'
-    );
-  }, 30000);
-
-  afterAll(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  afterEach(async () => {
-    // Clean up server process if still running
-    if (serverProcess !== null) {
-      serverProcess.kill('SIGTERM');
-      await new Promise<void>((resolve) => {
-        if (serverProcess !== null) {
-          serverProcess.on('exit', () => resolve());
-          // Force kill after timeout
-          setTimeout(() => {
-            if (serverProcess !== null) {
-              serverProcess.kill('SIGKILL');
-            }
-            resolve();
-          }, 2000);
-        } else {
-          resolve();
-        }
-      });
-      serverProcess = null;
-    }
-  });
-
-  /**
-   * Start the serve command and wait for it to be ready
-   */
-  async function startServer(port: number): Promise<ChildProcess> {
-    return new Promise((resolve, reject) => {
-      const proc = spawn(
-        'node',
-        ['dist/index.js', 'serve', '--port', String(port), '--data-dir', tempDir],
-        {
-          stdio: ['pipe', 'pipe', 'pipe'],
-        }
-      );
-
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          reject(new Error('Server startup timeout'));
-          proc.kill();
-        }
-      }, 30000);
-
-      proc.stdout?.on('data', (data: Buffer) => {
-        const output = data.toString();
-        if (output.includes('Starting server')) {
-          resolved = true;
-          clearTimeout(timeout);
-          // Give it a moment to actually start listening
-          setTimeout(() => resolve(proc), 500);
-        }
-      });
-
-      proc.stderr?.on('data', (data: Buffer) => {
-        // Log stderr but don't fail - some warnings are expected
-        console.error('Server stderr:', data.toString());
-      });
-
-      proc.on('error', (err) => {
-        if (!resolved) {
-          clearTimeout(timeout);
-          reject(err);
-        }
-      });
-
-      proc.on('exit', (code) => {
-        if (!resolved) {
-          clearTimeout(timeout);
-          reject(new Error(`Server exited with code ${String(code)}`));
-        }
-      });
-    });
-  }
-
-  /**
-   * Make an HTTP request with timeout
-   */
-  async function fetchWithTimeout(
-    url: string,
-    options: RequestInit = {},
-    timeoutMs = 5000
-  ): Promise<Response> {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      return await fetch(url, { ...options, signal: controller.signal });
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-
-  describe('Server Startup and Health', () => {
-    it('starts server and responds to /health', async () => {
-      serverProcess = await startServer(TEST_PORT);
-
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT}/health`);
-      expect(response.ok).toBe(true);
-
-      const body = (await response.json()) as { status: string };
-      expect(body.status).toBe('ok');
-    }, 60000);
-
-    it('responds with CORS headers', async () => {
-      serverProcess = await startServer(TEST_PORT + 1);
-
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 1}/health`, {
-        method: 'OPTIONS',
-        headers: {
-          Origin: 'http://localhost:3000',
-          'Access-Control-Request-Method': 'GET',
-        },
-      });
-
-      // CORS preflight should succeed
-      expect(response.ok).toBe(true);
-    }, 60000);
-  });
-
-  describe('Store API', () => {
-    beforeEach(async () => {
-      serverProcess = await startServer(TEST_PORT + 2);
-    });
-
-    it('lists stores via GET /api/stores', async () => {
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 2}/api/stores`);
-      expect(response.ok).toBe(true);
-
-      const body = (await response.json()) as unknown[];
-      expect(Array.isArray(body)).toBe(true);
-    }, 60000);
-
-    it('creates store via POST /api/stores', async () => {
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 2}/api/stores`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          name: 'serve-test-store',
-          type: 'file',
-          path: testFilesDir,
-        }),
-      });
-
-      expect(response.status).toBe(201);
-      const body = (await response.json()) as { id: string; name: string };
-      expect(body.name).toBe('serve-test-store');
-      expect(body.id).toBeDefined();
-    }, 60000);
-
-    it('returns 400 for invalid store creation', async () => {
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 2}/api/stores`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          name: 'invalid-store',
-          type: 'file',
-          // Missing required 'path' for file type
-        }),
-      });
-
-      expect(response.status).toBe(400);
-    }, 60000);
-  });
-
-  describe('Search API', () => {
-    it('handles search request via POST /api/search', async () => {
-      serverProcess = await startServer(TEST_PORT + 3);
-
-      // Search with no stores indexed - should return empty results
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 3}/api/search`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          query: 'test query',
-          limit: 5,
-        }),
-      });
-
-      expect(response.ok).toBe(true);
-      const body = (await response.json()) as { results: unknown[] };
-      expect(body.results).toBeDefined();
-      expect(Array.isArray(body.results)).toBe(true);
-    }, 60000);
-
-    it('returns 400 for invalid search request', async () => {
-      serverProcess = await startServer(TEST_PORT + 4);
-
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 4}/api/search`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          // Missing required 'query'
-        }),
-      });
-
-      expect(response.status).toBe(400);
-    }, 60000);
-  });
-
-  describe('Graceful Shutdown', () => {
-    it('shuts down cleanly on SIGTERM', async () => {
-      serverProcess = await startServer(TEST_PORT + 5);
-
-      // Verify server is running
-      const response = await fetchWithTimeout(`http://127.0.0.1:${TEST_PORT + 5}/health`);
-      expect(response.ok).toBe(true);
-
-      // Send SIGTERM
-      serverProcess.kill('SIGTERM');
-
-      // Wait for process to exit
-      const exitCode = await new Promise<number | null>((resolve) => {
-        if (serverProcess !== null) {
-          serverProcess.on('exit', (code) => resolve(code));
-          // Allow more time for graceful shutdown
-          setTimeout(() => resolve(null), 10000);
-        } else {
-          resolve(null);
-        }
-      });
-
-      // Process should exit cleanly (code 0) or be killed (null)
-      // On some systems the process may not exit with 0 due to async cleanup
-      expect(exitCode === 0 || exitCode === null).toBe(true);
-      serverProcess = null; // Already exited
-    }, 60000);
-  });
-});

package/tests/integration/stress.test.ts

@@ -1,326 +0,0 @@
-/**
- * Stress Tests
- *
- * Tests performance with moderate datasets (reduced scale for fast CI):
- * - Multiple file indexing
- * - Search performance
- * - Sequential operation performance
- * - Chunking behavior
- *
- * REWRITTEN: Now uses service APIs directly instead of CLI.
- * Dataset sizes reduced to keep tests fast (30 files instead of 150, 100 lines instead of 1000).
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { rm, mkdtemp, mkdir, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Benchmark, measure } from '../helpers/performance-metrics';
-import { StoreService } from '../../src/services/store.service.js';
-import { IndexService } from '../../src/services/index.service.js';
-import { SearchService } from '../../src/services/search.service.js';
-import { LanceStore } from '../../src/db/lance.js';
-import { EmbeddingEngine } from '../../src/db/embeddings.js';
-import type { StoreId } from '../../src/types/brands.js';
-
-describe('Stress Tests', () => {
-  let tempDir: string;
-  let largeDatasetDir: string;
-  let storeService: StoreService;
-  let indexService: IndexService;
-  let searchService: SearchService;
-  let lanceStore: LanceStore;
-  let embeddingEngine: EmbeddingEngine;
-  let stressStoreId: StoreId;
-
-  // Reduced dataset sizes for fast tests
-  const FILE_COUNT = 30; // Reduced from 150
-  const LARGE_FILE_LINES = 100; // Reduced from 1000
-
-  beforeAll(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'stress-test-'));
-    largeDatasetDir = join(tempDir, 'large-dataset');
-    await mkdir(largeDatasetDir, { recursive: true });
-
-    // Initialize services
-    lanceStore = new LanceStore(tempDir);
-    embeddingEngine = new EmbeddingEngine();
-    await embeddingEngine.initialize();
-
-    storeService = new StoreService(tempDir);
-    await storeService.initialize();
-
-    indexService = new IndexService(lanceStore, embeddingEngine);
-    searchService = new SearchService(lanceStore, embeddingEngine);
-  }, 30000);
-
-  afterAll(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe('Dataset Indexing', () => {
-    beforeAll(async () => {
-      // Generate test files with varied content (reduced to 30 files)
-      const categories = ['authentication', 'database', 'api', 'frontend', 'testing'];
-
-      const contentTemplates = [
-        (cat: string, i: number) =>
-          `# ${cat} Module ${i}\n\nThis module handles ${cat} functionality.\n\n## Overview\n\nThe ${cat} system provides essential features for the application.\n\n## Implementation\n\nKey features include:\n- Feature A for ${cat}\n- Feature B for ${cat}\n- Integration with other modules\n`,
-        (cat: string, i: number) =>
-          `export class ${cat}Service {\n  async process(data: ${cat}Data): Promise<${cat}Result> {\n    return { success: true };\n  }\n}\n`,
-        (cat: string, i: number) =>
-          `# ${cat} API\n\n## GET /${cat}/${i}\n\nRetrieve ${cat} data.\n\n## POST /${cat}/${i}\n\nCreate new ${cat} entry.\n`,
-      ];
-
-      let fileIndex = 0;
-      for (const category of categories) {
-        const categoryDir = join(largeDatasetDir, category);
-        await mkdir(categoryDir, { recursive: true });
-
-        for (let i = 0; i < Math.ceil(FILE_COUNT / categories.length); i++) {
-          const template = contentTemplates[fileIndex % contentTemplates.length];
-          const content = template(category, i);
-          const ext = fileIndex % 2 === 0 ? 'md' : 'ts';
-          await writeFile(join(categoryDir, `${category}-${i}.${ext}`), content);
-          fileIndex++;
-
-          if (fileIndex >= FILE_COUNT) break;
-        }
-        if (fileIndex >= FILE_COUNT) break;
-      }
-
-      // Create and index store
-      const storeResult = await storeService.create({
-        name: 'stress-store',
-        type: 'file',
-        path: largeDatasetDir,
-      });
-      if (!storeResult.success) throw storeResult.error;
-
-      stressStoreId = storeResult.data.id;
-      await lanceStore.initialize(stressStoreId);
-
-      const indexResult = await indexService.indexStore(storeResult.data);
-      if (!indexResult.success) throw indexResult.error;
-    }, 60000);
-
-    it(`indexes ${FILE_COUNT} files without timeout`, () => {
-      // Already indexed in beforeAll
-      expect(stressStoreId).toBeDefined();
-    });
-
-    it('verifies all documents were indexed', () => {
-      expect(stressStoreId).toBeDefined();
-    });
-  });
-
-  describe('Sequential Operation Performance', () => {
-    it('multiple sequential searches complete without timeout', async () => {
-      // Run 5 sequential searches - verify they complete, not relative performance
-      // (relative timing comparisons are too flaky across different CI hardware)
-      for (let i = 0; i < 5; i++) {
-        const result = await searchService.search({
-          query: 'module implementation',
-          stores: [stressStoreId],
-        });
-        expect(result.results).toBeDefined();
-      }
-    }, 30000);
-
-    it('alternating search modes complete without timeout', async () => {
-      const modes = ['vector', 'hybrid'] as const;
-
-      for (let i = 0; i < 6; i++) {
-        const mode = modes[i % modes.length];
-        const result = await searchService.search({
-          query: 'service implementation',
-          mode,
-          stores: [stressStoreId],
-        });
-        expect(result.results).toBeDefined();
-      }
-    }, 30000);
-  });
-
-  describe('Large File Chunking', () => {
-    let chunkingStoreId: StoreId;
-
-    beforeAll(async () => {
-      const largeFileDir = join(tempDir, 'large-files');
-      await mkdir(largeFileDir, { recursive: true });
-
-      // Create a file with 100 lines (reduced from 1000)
-      const lines: string[] = [];
-      for (let i = 0; i < LARGE_FILE_LINES; i++) {
-        lines.push(`## Section ${i}\n`);
-        lines.push(`This is content for section ${i}. It discusses various topics.\n`);
-        lines.push(`Key points:\n`);
-        lines.push(`- Point A about feature ${i}\n`);
-        lines.push(`- Point B about implementation ${i}\n\n`);
-      }
-
-      await writeFile(join(largeFileDir, 'large-document.md'), lines.join(''));
-
-      // Create and index store
-      const storeResult = await storeService.create({
-        name: 'chunking-store',
-        type: 'file',
-        path: largeFileDir,
-      });
-      if (!storeResult.success) throw storeResult.error;
-
-      chunkingStoreId = storeResult.data.id;
-      await lanceStore.initialize(chunkingStoreId);
-
-      const indexResult = await indexService.indexStore(storeResult.data);
-      if (!indexResult.success) throw indexResult.error;
-    }, 60000);
-
-    it('creates appropriate chunks for large files', () => {
-      expect(chunkingStoreId).toBeDefined();
-    });
-
-    it('searches across chunks efficiently', async () => {
-      const { measurement } = await measure('search-chunked', async () => {
-        return await searchService.search({
-          query: 'section implementation',
-          stores: [chunkingStoreId],
-        });
-      });
-
-      // Generous threshold - just catch catastrophic failures, not micro-benchmarks
-      expect(measurement.duration).toBeLessThan(10000);
-    });
-
-    it('finds content from different parts of large file', async () => {
-      const early = await searchService.search({
-        query: 'Section 10',
-        stores: [chunkingStoreId],
-      });
-      const middle = await searchService.search({
-        query: 'Section 50',
-        stores: [chunkingStoreId],
-      });
-      const late = await searchService.search({
-        query: 'Section 90',
-        stores: [chunkingStoreId],
-      });
-
-      const totalResults = early.results.length + middle.results.length + late.results.length;
-      expect(totalResults).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Memory and Resource Usage', () => {
-    it('handles successive queries without degradation', async () => {
-      const rapidBenchmark = new Benchmark('rapid-queries');
-
-      // Run 10 queries (reduced from 30)
-      for (let i = 0; i < 10; i++) {
-        await rapidBenchmark.run(async () => {
-          return await searchService.search({
-            query: 'module',
-            limit: 5,
-            stores: [stressStoreId],
-          });
-        });
-      }
-
-      const stats = rapidBenchmark.getStats();
-      // Generous threshold - just catch catastrophic failures
-      expect(stats.max).toBeLessThan(30000);
-    }, 60000);
-  });
-
-  describe('Concurrent Store Operations', () => {
-    it('handles operations on multiple stores', async () => {
-      const store2Dir = join(tempDir, 'store2');
-      const store3Dir = join(tempDir, 'store3');
-      await mkdir(store2Dir, { recursive: true });
-      await mkdir(store3Dir, { recursive: true });
-
-      await writeFile(
-        join(store2Dir, 'doc.md'),
-        '# Store 2 Document\n\nContent for testing store 2 operations.'
-      );
-      await writeFile(
-        join(store3Dir, 'doc.md'),
-        '# Store 3 Document\n\nContent for testing store 3 operations.'
-      );
-
-      // Create stores
-      const store2Result = await storeService.create({
-        name: 'stress-store-2',
-        type: 'file',
-        path: store2Dir,
-      });
-      const store3Result = await storeService.create({
-        name: 'stress-store-3',
-        type: 'file',
-        path: store3Dir,
-      });
-
-      if (!store2Result.success || !store3Result.success) {
-        throw new Error('Failed to create stores');
-      }
-
-      const store2Id = store2Result.data.id;
-      const store3Id = store3Result.data.id;
-
-      await lanceStore.initialize(store2Id);
-      await lanceStore.initialize(store3Id);
-
-      await indexService.indexStore(store2Result.data);
-      await indexService.indexStore(store3Result.data);
-
-      // Search across stores
-      const { measurement } = await measure('multi-store-search', async () => {
-        return await searchService.search({
-          query: 'document content',
-          stores: [stressStoreId, store2Id, store3Id],
-        });
-      });
-
-      // Generous threshold - just catch catastrophic failures
-      expect(measurement.duration).toBeLessThan(30000);
-    }, 60000);
-  });
-
-  describe('Edge Case Stress', () => {
-    it('handles many small results efficiently', async () => {
-      const response = await searchService.search({
-        query: 'module',
-        limit: 50,
-        stores: [stressStoreId],
-      });
-
-      expect(response.results.length).toBeGreaterThan(0);
-      expect(response.results.length).toBeLessThanOrEqual(50);
-    });
-
-    it('handles broad queries without timeout', async () => {
-      const { measurement } = await measure('broad-query', async () => {
-        return await searchService.search({
-          query: 'the',
-          limit: 20,
-          stores: [stressStoreId],
-        });
-      });
-
-      // Generous threshold - just catch catastrophic failures
-      expect(measurement.duration).toBeLessThan(30000);
-    });
-
-    it('handles queries with many potential matches', async () => {
-      const { measurement } = await measure('common-term', async () => {
-        return await searchService.search({
-          query: 'implementation',
-          stores: [stressStoreId],
-        });
-      });
-
-      // Generous threshold - just catch catastrophic failures
-      expect(measurement.duration).toBeLessThan(10000);
-    });
-  });
-});

package/tests/mcp/server.test.ts

@@ -1,15 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { createMCPServer } from '../../src/mcp/server.js';
-
-describe('MCP Server', () => {
-  it('should create server with search tool', () => {
-    const server = createMCPServer({
-      dataDir: '/tmp/test',
-      config: undefined,
-    });
-
-    expect(server).toBeDefined();
-    // Note: MCP SDK doesn't expose tools list directly for unit testing.
-    // Integration testing is performed manually via MCP inspector or client.
-  });
-});

package/tests/scripts/schemas/evaluation.json

@@ -1,44 +0,0 @@
-{
-  "type": "object",
-  "properties": {
-    "scores": {
-      "type": "object",
-      "properties": {
-        "relevance": { "type": "number", "minimum": 0, "maximum": 1 },
-        "ranking": { "type": "number", "minimum": 0, "maximum": 1 },
-        "coverage": { "type": "number", "minimum": 0, "maximum": 1 },
-        "snippetQuality": { "type": "number", "minimum": 0, "maximum": 1 },
-        "overall": { "type": "number", "minimum": 0, "maximum": 1 }
-      },
-      "required": ["relevance", "ranking", "coverage", "snippetQuality", "overall"]
-    },
-    "analysis": {
-      "type": "object",
-      "properties": {
-        "relevance": { "type": "string" },
-        "ranking": { "type": "string" },
-        "coverage": { "type": "string" },
-        "snippetQuality": { "type": "string" }
-      },
-      "required": ["relevance", "ranking", "coverage", "snippetQuality"]
-    },
-    "suggestions": {
-      "type": "array",
-      "items": { "type": "string" }
-    },
-    "resultAssessments": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "rank": { "type": "integer" },
-          "source": { "type": "string" },
-          "relevant": { "type": "boolean" },
-          "note": { "type": "string" }
-        },
-        "required": ["rank", "source", "relevant"]
-      }
-    }
-  },
-  "required": ["scores", "analysis", "suggestions", "resultAssessments"]
-}

package/tests/scripts/schemas/query-generation.json

@@ -1,21 +0,0 @@
-{
-  "type": "object",
-  "properties": {
-    "queries": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "query": { "type": "string" },
-          "intent": { "type": "string" },
-          "expectedContentTypes": {
-            "type": "array",
-            "items": { "type": "string" }
-          }
-        },
-        "required": ["query", "intent"]
-      }
-    }
-  },
-  "required": ["queries"]
-}