bluera-knowledge 0.9.31 → 0.9.34

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

@@ -1,15 +1,11 @@
-import type { ToolHandler, ToolResponse } from '../types.js';
-import type {
-  CheckJobStatusArgs,
-  ListJobsArgs,
-  CancelJobArgs
-} from '../schemas/index.js';
+import { JobService } from '../../services/job.service.js';
 import {
   CheckJobStatusArgsSchema,
   ListJobsArgsSchema,
-  CancelJobArgsSchema
+  CancelJobArgsSchema,
 } from '../schemas/index.js';
-import { JobService } from '../../services/job.service.js';
+import type { CheckJobStatusArgs, ListJobsArgs, CancelJobArgs } from '../schemas/index.js';
+import type { ToolHandler, ToolResponse } from '../types.js';
 
 /**
  * Handle check_job_status requests
@@ -36,9 +32,9 @@ export const handleCheckJobStatus: ToolHandler<CheckJobStatusArgs> = (
     content: [
       {
         type: 'text',
-        text: JSON.stringify(job, null, 2)
-      }
-    ]
+        text: JSON.stringify(job, null, 2),
+      },
+    ],
   });
 };
 
@@ -47,10 +43,7 @@ export const handleCheckJobStatus: ToolHandler<CheckJobStatusArgs> = (
  *
  * Lists all jobs with optional filtering by status or active status.
  */
-export const handleListJobs: ToolHandler<ListJobsArgs> = (
-  args,
-  context
-): Promise<ToolResponse> => {
+export const handleListJobs: ToolHandler<ListJobsArgs> = (args, context): Promise<ToolResponse> => {
   // Validate arguments with Zod
   const validated = ListJobsArgsSchema.parse(args);
 
@@ -71,9 +64,9 @@ export const handleListJobs: ToolHandler<ListJobsArgs> = (
     content: [
       {
         type: 'text',
-        text: JSON.stringify({ jobs }, null, 2)
-      }
-    ]
+        text: JSON.stringify({ jobs }, null, 2),
+      },
+    ],
   });
 };
 
@@ -105,12 +98,16 @@ export const handleCancelJob: ToolHandler<CancelJobArgs> = (
     content: [
       {
         type: 'text',
-        text: JSON.stringify({
-          success: true,
-          job,
-          message: 'Job cancelled successfully'
-        }, null, 2)
-      }
-    ]
+        text: JSON.stringify(
+          {
+            success: true,
+            job,
+            message: 'Job cancelled successfully',
+          },
+          null,
+          2
+        ),
+      },
+    ],
   });
 };

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

@@ -13,7 +13,7 @@ function parseSearchResponse(text: string): { header: string; json: Record<strin
   const jsonStr = parts.slice(1).join('\n\n');
   return {
     header,
-    json: JSON.parse(jsonStr || '{}')
+    json: JSON.parse(jsonStr || '{}'),
   };
 }
 
@@ -28,18 +28,16 @@ describe('Search Handlers', () => {
     // Create mock services
     mockServices = {
       store: {
-        list: vi.fn().mockResolvedValue([
-          { id: 'store1', name: 'Test Store', type: 'file' }
-        ]),
+        list: vi.fn().mockResolvedValue([{ id: 'store1', name: 'Test Store', type: 'file' }]),
         getByIdOrName: vi.fn().mockResolvedValue({
           id: 'store1',
           name: 'Test Store',
           type: 'file',
-          path: '/test/path'
-        })
+          path: '/test/path',
+        }),
       },
       lance: {
-        initialize: vi.fn().mockResolvedValue(undefined)
+        initialize: vi.fn().mockResolvedValue(undefined),
       },
       search: {
         search: vi.fn().mockResolvedValue({
@@ -49,19 +47,19 @@ describe('Search Handlers', () => {
               score: 0.95,
               content: 'test content for search',
               metadata: { storeId: 'store1' },
-              summary: { file: 'test.ts', line: 1 }
-            }
+              summary: { file: 'test.ts', line: 1 },
+            },
           ],
           totalResults: 1,
           mode: 'hybrid',
-          timeMs: 50
-        })
-      }
+          timeMs: 50,
+        }),
+      },
     } as unknown as ServiceContainer;
 
     mockContext = {
       services: mockServices,
-      options: {}
+      options: {},
     };
   });
 
@@ -80,7 +78,7 @@ describe('Search Handlers', () => {
       expect(mockServices.search.search).toHaveBeenCalledWith(
         expect.objectContaining({
           query: 'test query',
-          stores: ['store1']
+          stores: ['store1'],
         })
       );
 
@@ -113,10 +111,7 @@ describe('Search Handlers', () => {
     });
 
     it('should initialize all stores', async () => {
-      await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
+      await handleSearch({ query: 'test', detail: 'minimal', limit: 10 }, mockContext);
 
       expect(mockServices.lance.initialize).toHaveBeenCalledWith('store1');
     });
@@ -127,18 +122,12 @@ describe('Search Handlers', () => {
       );
 
       await expect(
-        handleSearch(
-          { query: 'test', detail: 'minimal', limit: 10 },
-          mockContext
-        )
+        handleSearch({ query: 'test', detail: 'minimal', limit: 10 }, mockContext)
       ).rejects.toThrow('Failed to initialize vector stores');
     });
 
     it('should cache search results', async () => {
-      await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
+      await handleSearch({ query: 'test', detail: 'minimal', limit: 10 }, mockContext);
 
       // Verify cache was populated
       const cached = resultCache.get('doc1');
@@ -166,7 +155,7 @@ describe('Search Handlers', () => {
         createdAt: new Date(),
         updatedAt: new Date(),
         status: 'ready',
-        description: 'Test'
+        description: 'Test',
       });
 
       const result = await handleSearch(
@@ -221,7 +210,7 @@ describe('Search Handlers', () => {
         score: 0.95,
         content: 'test content for get full context',
         metadata: { storeId: 'store1', docId: 'doc1' },
-        summary: { file: 'test.ts', line: 1 }
+        summary: { file: 'test.ts', line: 1 },
       });
     });
 
@@ -233,13 +222,10 @@ describe('Search Handlers', () => {
         content: 'test content',
         metadata: { storeId: 'store1', docId: 'doc1' },
         summary: { file: 'test.ts', line: 1 },
-        full: { code: 'full code here' }
+        full: { code: 'full code here' },
       });
 
-      const result = await handleGetFullContext(
-        { resultId: 'doc1' },
-        mockContext
-      );
+      const result = await handleGetFullContext({ resultId: 'doc1' }, mockContext);
 
       const response = JSON.parse(result.content[0]?.text ?? '{}');
       expect(response.id).toBe('doc1');
@@ -251,12 +237,9 @@ describe('Search Handlers', () => {
     });
 
     it('should throw if result not in cache', async () => {
-      await expect(
-        handleGetFullContext(
-          { resultId: 'nonexistent' },
-          mockContext
-        )
-      ).rejects.toThrow('Result not found in cache');
+      await expect(handleGetFullContext({ resultId: 'nonexistent' }, mockContext)).rejects.toThrow(
+        'Result not found in cache'
+      );
     });
 
     it('should re-query for full context if not already full', async () => {
@@ -268,25 +251,22 @@ describe('Search Handlers', () => {
             content: 'test content',
             metadata: { storeId: 'store1', docId: 'doc1' },
             summary: { file: 'test.ts', line: 1 },
-            full: { code: 'full code from re-query' }
-          }
+            full: { code: 'full code from re-query' },
+          },
         ],
         totalResults: 1,
         mode: 'hybrid',
-        timeMs: 50
+        timeMs: 50,
       });
 
-      const result = await handleGetFullContext(
-        { resultId: 'doc1' },
-        mockContext
-      );
+      const result = await handleGetFullContext({ resultId: 'doc1' }, mockContext);
 
       expect(mockServices.store.getByIdOrName).toHaveBeenCalledWith('store1');
       expect(mockServices.lance.initialize).toHaveBeenCalledWith('store1');
       expect(mockServices.search.search).toHaveBeenCalledWith(
         expect.objectContaining({
           detail: 'full',
-          limit: 1
+          limit: 1,
         })
       );
 
@@ -297,12 +277,9 @@ describe('Search Handlers', () => {
     it('should throw if store not found', async () => {
       vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(undefined);
 
-      await expect(
-        handleGetFullContext(
-          { resultId: 'doc1' },
-          mockContext
-        )
-      ).rejects.toThrow('Store not found');
+      await expect(handleGetFullContext({ resultId: 'doc1' }, mockContext)).rejects.toThrow(
+        'Store not found'
+      );
     });
 
     it('should return cached result with warning if re-query fails', async () => {
@@ -310,13 +287,10 @@ describe('Search Handlers', () => {
         results: [], // No matching result found
         totalResults: 0,
         mode: 'hybrid',
-        timeMs: 50
+        timeMs: 50,
       });
 
-      const result = await handleGetFullContext(
-        { resultId: 'doc1' },
-        mockContext
-      );
+      const result = await handleGetFullContext({ resultId: 'doc1' }, mockContext);
 
       const response = JSON.parse(result.content[0]?.text ?? '{}');
       expect(response.id).toBe('doc1');
@@ -332,18 +306,15 @@ describe('Search Handlers', () => {
             content: 'test content',
             metadata: { storeId: 'store1', docId: 'doc1' },
             summary: { file: 'test.ts', line: 1 },
-            full: { code: 'full code from re-query' }
-          }
+            full: { code: 'full code from re-query' },
+          },
         ],
         totalResults: 1,
         mode: 'hybrid',
-        timeMs: 50
+        timeMs: 50,
       });
 
-      await handleGetFullContext(
-        { resultId: 'doc1' },
-        mockContext
-      );
+      await handleGetFullContext({ resultId: 'doc1' }, mockContext);
 
       const cached = resultCache.get('doc1');
       expect(cached?.full).toBeDefined();

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

@@ -1,11 +1,11 @@
-import type { ToolHandler, ToolResponse } from '../types.js';
-import type { SearchArgs, GetFullContextArgs } from '../schemas/index.js';
+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 { LRUCache } from '../cache.js';
 import type { SearchResult } from '../../types/search.js';
-import { createLogger, summarizePayload } from '../../logging/index.js';
-import { estimateTokens, formatTokenCount } from '../../services/token.service.js';
+import type { SearchArgs, GetFullContextArgs } from '../schemas/index.js';
+import type { ToolHandler, ToolResponse } from '../types.js';
 
 const logger = createLogger('mcp-search');
 
@@ -26,27 +26,33 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
   // Validate arguments with Zod
   const validated = SearchArgsSchema.parse(args);
 
-  logger.info({
-    query: validated.query,
-    stores: validated.stores,
-    detail: validated.detail,
-    limit: validated.limit,
-    intent: validated.intent,
-  }, 'Search started');
+  logger.info(
+    {
+      query: validated.query,
+      stores: validated.stores,
+      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);
+  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 {
@@ -65,7 +71,7 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
     stores: storeIds,
     mode: 'hybrid',
     limit: validated.limit,
-    detail: validated.detail
+    detail: validated.detail,
   };
 
   const results = await services.search.search(searchQuery);
@@ -76,29 +82,35 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
   }
 
   // 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 !== undefined && 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
-  }, null, 2);
+  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,
+    },
+    null,
+    2
+  );
 
   // Calculate actual token estimate based on response content
   const responseTokens = estimateTokens(responseJson);
@@ -107,21 +119,24 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
   const header = `Search: "${validated.query}" | Results: ${String(results.totalResults)} | ${formatTokenCount(responseTokens)} tokens | ${String(results.timeMs)}ms\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');
+  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
-      }
-    ]
+        text: header + responseJson,
+      },
+    ],
   };
 };
 
@@ -147,35 +162,40 @@ export const handleGetFullContext: ToolHandler<GetFullContextArgs> = async (
   const cachedResult = resultCache.get(resultId);
 
   if (!cachedResult) {
-    throw new Error(
-      `Result not found in cache: ${resultId}. Run a search first to cache results.`
-    );
+    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');
+    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
-        }
-      ]
+          text: responseJson,
+        },
+      ],
     };
   }
 
@@ -194,13 +214,13 @@ export const handleGetFullContext: ToolHandler<GetFullContextArgs> = async (
     stores: [store.id],
     mode: 'hybrid',
     limit: 1,
-    detail: 'full'
+    detail: 'full',
   };
 
   const results = await services.search.search(searchQuery);
 
   // Find matching result by ID
-  const fullResult = results.results.find(r => r.id === resultId);
+  const fullResult = results.results.find((r) => r.id === resultId);
 
   if (!fullResult) {
     // Return cached result even if we couldn't get full detail
@@ -208,42 +228,53 @@ export const handleGetFullContext: ToolHandler<GetFullContextArgs> = async (
       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)
-        }
-      ]
+          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');
+  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
-      }
-    ]
+        text: responseJson,
+      },
+    ],
   };
 };