bluera-knowledge 0.14.0 → 0.14.1

package/src/mcp/handlers/search.handler.ts

@@ -1,287 +0,0 @@
-import { createLogger, summarizePayload } from '../../logging/index.js';
-import { estimateTokens, formatTokenCount } from '../../services/token.service.js';
-import { LRUCache } from '../cache.js';
-import { SearchArgsSchema, GetFullContextArgsSchema } from '../schemas/index.js';
-import type { SearchQuery, DocumentId, StoreId } from '../../types/index.js';
-import type { SearchResult } from '../../types/search.js';
-import type { SearchArgs, GetFullContextArgs } from '../schemas/index.js';
-import type { ToolHandler, ToolResponse } from '../types.js';
-
-const logger = createLogger('mcp-search');
-
-// Create result cache for get_full_context
-// Uses LRU cache to prevent memory leaks (max 1000 items)
-export const resultCache = new LRUCache<DocumentId, SearchResult>(1000);
-
-/**
- * Handle search requests
- *
- * Searches across specified stores (or all stores if none specified) using
- * hybrid vector + FTS search. Results are cached for get_full_context retrieval.
- */
-export const handleSearch: ToolHandler<SearchArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = SearchArgsSchema.parse(args);
-
-  logger.info(
-    {
-      query: validated.query,
-      stores: validated.stores,
-      mode: validated.mode,
-      detail: validated.detail,
-      limit: validated.limit,
-      intent: validated.intent,
-    },
-    'Search started'
-  );
-
-  const { services } = context;
-
-  // Get all stores if none specified, resolve store names to IDs
-  const storeIds: StoreId[] =
-    validated.stores !== undefined
-      ? await Promise.all(
-          validated.stores.map(async (s) => {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const store = await services.store.getByIdOrName(s as StoreId);
-            if (!store) {
-              throw new Error(`Store not found: ${s}`);
-            }
-            return store.id;
-          })
-        )
-      : (await services.store.list()).map((s) => s.id);
-
-  // Initialize stores with error handling
-  try {
-    for (const storeId of storeIds) {
-      await services.lance.initialize(storeId);
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to initialize vector stores: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-
-  // Perform search
-  const searchQuery: SearchQuery = {
-    query: validated.query,
-    stores: storeIds,
-    mode: validated.mode,
-    limit: validated.limit,
-    detail: validated.detail,
-    threshold: validated.threshold,
-    minRelevance: validated.minRelevance,
-  };
-
-  const results = await services.search.search(searchQuery);
-
-  // Cache results for get_full_context (with LRU eviction)
-  for (const result of results.results) {
-    resultCache.set(result.id, result);
-  }
-
-  // Add repoRoot to results for cloned repos
-  const enhancedResults = await Promise.all(
-    results.results.map(async (r) => {
-      const storeId = r.metadata.storeId;
-      const store = await services.store.getByIdOrName(storeId);
-
-      return {
-        id: r.id,
-        score: r.score,
-        summary: {
-          ...r.summary,
-          storeName: store?.name,
-          repoRoot: store?.type === 'repo' ? store.path : undefined,
-        },
-        context: r.context,
-        full: r.full,
-      };
-    })
-  );
-
-  const responseJson = JSON.stringify(
-    {
-      results: enhancedResults,
-      totalResults: results.totalResults,
-      mode: results.mode,
-      timeMs: results.timeMs,
-      confidence: results.confidence,
-      maxRawScore: results.maxRawScore,
-    },
-    null,
-    2
-  );
-
-  // Calculate actual token estimate based on response content
-  const responseTokens = estimateTokens(responseJson);
-
-  // Create visible header with token usage and confidence
-  const confidenceInfo =
-    results.confidence !== undefined ? ` | Confidence: ${results.confidence}` : '';
-  const header = `Search: "${validated.query}" | Results: ${String(results.totalResults)} | ${formatTokenCount(responseTokens)} tokens | ${String(results.timeMs)}ms${confidenceInfo}\n\n`;
-
-  // Log the complete MCP response that will be sent to Claude Code
-  logger.info(
-    {
-      query: validated.query,
-      totalResults: results.totalResults,
-      responseTokens,
-      timeMs: results.timeMs,
-      ...summarizePayload(responseJson, 'mcp-response', validated.query),
-    },
-    'Search complete - context sent to Claude Code'
-  );
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: header + responseJson,
-      },
-    ],
-  };
-};
-
-/**
- * Handle get_full_context requests
- *
- * Retrieves full context for a previously cached search result.
- * If the result isn't already full, re-queries with full detail level.
- */
-export const handleGetFullContext: ToolHandler<GetFullContextArgs> = async (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = GetFullContextArgsSchema.parse(args);
-
-  logger.info({ resultId: validated.resultId }, 'Get full context requested');
-
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const resultId = validated.resultId as DocumentId;
-
-  // Check cache for result
-  const cachedResult = resultCache.get(resultId);
-
-  if (!cachedResult) {
-    throw new Error(`Result not found in cache: ${resultId}. Run a search first to cache results.`);
-  }
-
-  // If result already has full context, return it
-  if (cachedResult.full) {
-    const responseJson = JSON.stringify(
-      {
-        id: cachedResult.id,
-        score: cachedResult.score,
-        summary: cachedResult.summary,
-        context: cachedResult.context,
-        full: cachedResult.full,
-      },
-      null,
-      2
-    );
-
-    logger.info(
-      {
-        resultId,
-        cached: true,
-        hasFullContext: true,
-        ...summarizePayload(responseJson, 'mcp-full-context', resultId),
-      },
-      'Full context retrieved from cache'
-    );
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: responseJson,
-        },
-      ],
-    };
-  }
-
-  // Otherwise, re-query with full detail
-  const { services } = context;
-  const store = await services.store.getByIdOrName(cachedResult.metadata.storeId);
-
-  if (!store) {
-    throw new Error(`Store not found: ${cachedResult.metadata.storeId}`);
-  }
-
-  await services.lance.initialize(store.id);
-
-  const searchQuery: SearchQuery = {
-    query: cachedResult.content.substring(0, 100), // Use snippet of content as query
-    stores: [store.id],
-    mode: 'hybrid',
-    limit: 1,
-    detail: 'full',
-  };
-
-  const results = await services.search.search(searchQuery);
-
-  // Find matching result by ID
-  const fullResult = results.results.find((r) => r.id === resultId);
-
-  if (!fullResult) {
-    // Return cached result even if we couldn't get full detail
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(
-            {
-              id: cachedResult.id,
-              score: cachedResult.score,
-              summary: cachedResult.summary,
-              context: cachedResult.context,
-              warning: 'Could not retrieve full context, returning cached minimal result',
-            },
-            null,
-            2
-          ),
-        },
-      ],
-    };
-  }
-
-  // Update cache with full result
-  resultCache.set(resultId, fullResult);
-
-  const responseJson = JSON.stringify(
-    {
-      id: fullResult.id,
-      score: fullResult.score,
-      summary: fullResult.summary,
-      context: fullResult.context,
-      full: fullResult.full,
-    },
-    null,
-    2
-  );
-
-  logger.info(
-    {
-      resultId,
-      cached: false,
-      hasFullContext: true,
-      ...summarizePayload(responseJson, 'mcp-full-context', resultId),
-    },
-    'Full context retrieved via re-query'
-  );
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: responseJson,
-      },
-    ],
-  };
-};

package/src/mcp/handlers/store.handler.test.ts

@@ -1,408 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import {
-  handleListStores,
-  handleGetStoreInfo,
-  handleCreateStore,
-  handleIndexStore,
-  handleDeleteStore,
-} from './store.handler.js';
-import type { HandlerContext } from '../types.js';
-import type {
-  ListStoresArgs,
-  GetStoreInfoArgs,
-  CreateStoreArgs,
-  IndexStoreArgs,
-  DeleteStoreArgs,
-} from '../schemas/index.js';
-import { StoreService } from '../../services/store.service.js';
-import { mkdtempSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-// Mock the worker spawn function
-vi.mock('../../workers/spawn-worker.js', () => ({
-  spawnBackgroundWorker: vi.fn(),
-}));
-
-import { spawnBackgroundWorker } from '../../workers/spawn-worker.js';
-const mockSpawnBackgroundWorker = spawnBackgroundWorker as ReturnType<typeof vi.fn>;
-
-describe('store.handler', () => {
-  let tempDir: string;
-  let mockContext: HandlerContext;
-  let storeService: StoreService;
-
-  beforeEach(async () => {
-    tempDir = mkdtempSync(join(tmpdir(), 'store-handler-test-'));
-    storeService = new StoreService(tempDir);
-
-    mockContext = {
-      services: {
-        store: storeService,
-        lance: {
-          deleteStore: vi.fn().mockResolvedValue(undefined),
-        },
-        codeGraph: {
-          deleteGraph: vi.fn().mockResolvedValue(undefined),
-        },
-      } as any,
-      options: { dataDir: tempDir },
-    };
-
-    mockSpawnBackgroundWorker.mockClear();
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('handleListStores', () => {
-    it('should list all stores', async () => {
-      // Create two file stores to avoid git clone issues
-      const path1 = mkdtempSync(join(tmpdir(), 'store1-'));
-      const path2 = mkdtempSync(join(tmpdir(), 'store2-'));
-
-      await storeService.create({
-        name: 'store1',
-        type: 'file',
-        path: path1,
-        description: 'Test store 1',
-      });
-      await storeService.create({
-        name: 'store2',
-        type: 'file',
-        path: path2,
-        description: 'Test store 2',
-      });
-
-      const args: ListStoresArgs = {};
-      const result = await handleListStores(args, mockContext);
-
-      expect(result.content).toHaveLength(1);
-      const data = JSON.parse(result.content[0].text);
-      expect(data.stores.length).toBeGreaterThanOrEqual(2);
-
-      rmSync(path1, { recursive: true, force: true });
-      rmSync(path2, { recursive: true, force: true });
-    });
-
-    it('should filter stores by type', async () => {
-      await storeService.create({
-        name: 'file-store',
-        type: 'file',
-        path: tempDir,
-        description: 'File store',
-      });
-      await storeService.create({
-        name: 'repo-store',
-        type: 'repo',
-        url: 'https://github.com/test/repo',
-        description: 'Repo store',
-      });
-
-      const args: ListStoresArgs = { type: 'file' };
-      const result = await handleListStores(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.stores).toHaveLength(1);
-      expect(data.stores[0].type).toBe('file');
-    });
-
-    it('should include store metadata', async () => {
-      const createResult = await storeService.create({
-        name: 'test-store',
-        type: 'file',
-        path: tempDir,
-        description: 'Test description',
-      });
-
-      const args: ListStoresArgs = {};
-      const result = await handleListStores(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      const store = data.stores[0];
-      expect(store.id).toBe(createResult.data.id);
-      expect(store.name).toBe('test-store');
-      expect(store.type).toBe('file');
-      expect(store.description).toBe('Test description');
-      expect(store.createdAt).toBeDefined();
-    });
-  });
-
-  describe('handleGetStoreInfo', () => {
-    it('should get store by ID', async () => {
-      const createResult = await storeService.create({
-        name: 'test-store',
-        type: 'file',
-        path: tempDir,
-        description: 'Test store',
-      });
-
-      const args: GetStoreInfoArgs = { store: createResult.data.id };
-      const result = await handleGetStoreInfo(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.id).toBe(createResult.data.id);
-      expect(data.name).toBe('test-store');
-    });
-
-    it('should get store by name', async () => {
-      await storeService.create({
-        name: 'test-store',
-        type: 'file',
-        path: tempDir,
-        description: 'Test store',
-      });
-
-      const args: GetStoreInfoArgs = { store: 'test-store' };
-      const result = await handleGetStoreInfo(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.name).toBe('test-store');
-    });
-
-    it('should include all store fields', async () => {
-      await storeService.create({
-        name: 'file-store',
-        type: 'file',
-        path: tempDir,
-        description: 'Test description',
-      });
-
-      const args: GetStoreInfoArgs = { store: 'file-store' };
-      const result = await handleGetStoreInfo(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.id).toBeDefined();
-      expect(data.name).toBe('file-store');
-      expect(data.type).toBe('file');
-      expect(data.path).toBe(tempDir);
-      expect(data.description).toBe('Test description');
-      expect(data.status).toBeDefined();
-      expect(data.createdAt).toBeDefined();
-      expect(data.updatedAt).toBeDefined();
-    });
-
-    it('should throw if store not found', async () => {
-      const args: GetStoreInfoArgs = { store: 'nonexistent' };
-
-      await expect(handleGetStoreInfo(args, mockContext)).rejects.toThrow(
-        'Store not found: nonexistent'
-      );
-    });
-  });
-
-  describe('handleCreateStore', () => {
-    it('should create file store from path', async () => {
-      const sourcePath = mkdtempSync(join(tmpdir(), 'source-'));
-      writeFileSync(join(sourcePath, 'test.txt'), 'test content');
-
-      const args: CreateStoreArgs = {
-        name: 'new-store',
-        type: 'file',
-        source: sourcePath,
-        description: 'New test store',
-      };
-
-      const result = await handleCreateStore(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.store.name).toBe('new-store');
-      expect(data.store.type).toBe('file');
-      expect(data.job.id).toBeDefined();
-      expect(data.job.status).toBe('pending');
-
-      rmSync(sourcePath, { recursive: true, force: true });
-    });
-
-    it('should spawn background worker with jobId and dataDir', async () => {
-      const sourcePath = mkdtempSync(join(tmpdir(), 'source-'));
-      writeFileSync(join(sourcePath, 'test.txt'), 'test content');
-
-      const args: CreateStoreArgs = {
-        name: 'worker-test',
-        type: 'file',
-        source: sourcePath,
-      };
-
-      const result = await handleCreateStore(args, mockContext);
-      const data = JSON.parse(result.content[0].text);
-
-      expect(mockSpawnBackgroundWorker).toHaveBeenCalledWith(data.job.id, tempDir);
-
-      rmSync(sourcePath, { recursive: true, force: true });
-    });
-
-    it('should create repo store from URL', async () => {
-      const args: CreateStoreArgs = {
-        name: 'repo-store',
-        type: 'repo',
-        source: 'https://github.com/test/repo.git',
-        branch: 'main',
-        description: 'Git repo store',
-      };
-
-      // This will fail to clone, but should still create the store record
-      await expect(handleCreateStore(args, mockContext)).rejects.toThrow(/Git clone failed/);
-
-      // Verify store was NOT created since clone failed
-      const stores = await storeService.list();
-      const found = stores.find((s) => s.name === 'repo-store');
-      expect(found).toBeUndefined();
-    });
-
-    it('should detect URL sources correctly', async () => {
-      const httpArgs: CreateStoreArgs = {
-        name: 'http-store',
-        type: 'repo',
-        source: 'http://github.com/test/repo',
-      };
-
-      // Will fail to clone, which is expected
-      await expect(handleCreateStore(httpArgs, mockContext)).rejects.toThrow(/Git clone failed/);
-    });
-
-    it('should reject store with nonexistent path', async () => {
-      // File store creation validates path existence for security
-      const args: CreateStoreArgs = {
-        name: 'bad-store',
-        type: 'file',
-        source: '/nonexistent/path/that/does/not/exist',
-      };
-
-      await expect(handleCreateStore(args, mockContext)).rejects.toThrow(
-        /Directory does not exist/
-      );
-    });
-  });
-
-  describe('handleIndexStore', () => {
-    it('should start indexing for existing store', async () => {
-      const createResult = await storeService.create({
-        name: 'index-test',
-        type: 'file',
-        path: tempDir,
-        description: 'Test indexing',
-      });
-
-      const args: IndexStoreArgs = { store: createResult.data.id };
-      const result = await handleIndexStore(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.store.id).toBe(createResult.data.id);
-      expect(data.store.name).toBe('index-test');
-      expect(data.job.id).toBeDefined();
-      expect(data.job.status).toBe('pending');
-      expect(data.message).toContain('Indexing started');
-    });
-
-    it('should spawn background worker with jobId and dataDir', async () => {
-      const createResult = await storeService.create({
-        name: 'index-worker-test',
-        type: 'file',
-        path: tempDir,
-      });
-
-      const args: IndexStoreArgs = { store: createResult.data.id };
-      const result = await handleIndexStore(args, mockContext);
-      const data = JSON.parse(result.content[0].text);
-
-      expect(mockSpawnBackgroundWorker).toHaveBeenCalledWith(data.job.id, tempDir);
-    });
-
-    it('should work with store name', async () => {
-      await storeService.create({
-        name: 'named-store',
-        type: 'file',
-        path: tempDir,
-        description: 'Test',
-      });
-
-      const args: IndexStoreArgs = { store: 'named-store' };
-      const result = await handleIndexStore(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.store.name).toBe('named-store');
-    });
-
-    it('should throw if store not found', async () => {
-      const args: IndexStoreArgs = { store: 'nonexistent' };
-
-      await expect(handleIndexStore(args, mockContext)).rejects.toThrow(
-        'Store not found: nonexistent'
-      );
-    });
-  });
-
-  describe('handleDeleteStore', () => {
-    it('should delete existing store by name', async () => {
-      await storeService.create({
-        name: 'delete-test',
-        type: 'file',
-        path: tempDir,
-      });
-
-      const args: DeleteStoreArgs = { store: 'delete-test' };
-      const result = await handleDeleteStore(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.deleted).toBe(true);
-      expect(data.store.name).toBe('delete-test');
-      expect(data.message).toContain('Successfully deleted');
-
-      // Verify store is actually deleted
-      const stores = await storeService.list();
-      expect(stores.find((s) => s.name === 'delete-test')).toBeUndefined();
-    });
-
-    it('should delete store by ID', async () => {
-      const createResult = await storeService.create({
-        name: 'delete-by-id',
-        type: 'file',
-        path: tempDir,
-      });
-
-      const args: DeleteStoreArgs = { store: createResult.data.id };
-      const result = await handleDeleteStore(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.deleted).toBe(true);
-      expect(data.store.id).toBe(createResult.data.id);
-    });
-
-    it('should call lance.deleteStore', async () => {
-      const createResult = await storeService.create({
-        name: 'lance-delete-test',
-        type: 'file',
-        path: tempDir,
-      });
-
-      const args: DeleteStoreArgs = { store: 'lance-delete-test' };
-      await handleDeleteStore(args, mockContext);
-
-      expect(mockContext.services.lance.deleteStore).toHaveBeenCalledWith(createResult.data.id);
-    });
-
-    it('should throw if store not found', async () => {
-      const args: DeleteStoreArgs = { store: 'nonexistent' };
-
-      await expect(handleDeleteStore(args, mockContext)).rejects.toThrow(
-        'Store not found: nonexistent'
-      );
-    });
-
-    it('should include store type in response', async () => {
-      await storeService.create({
-        name: 'type-test',
-        type: 'file',
-        path: tempDir,
-      });
-
-      const args: DeleteStoreArgs = { store: 'type-test' };
-      const result = await handleDeleteStore(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.store.type).toBe('file');
-    });
-  });
-});