bluera-knowledge 0.9.32 → 0.9.34

package/src/mcp/schemas/index.test.ts

@@ -9,7 +9,7 @@ import {
   DeleteStoreArgsSchema,
   CheckJobStatusArgsSchema,
   ListJobsArgsSchema,
-  CancelJobArgsSchema
+  CancelJobArgsSchema,
 } from './index.js';
 
 describe('MCP Schema Validation', () => {
@@ -18,7 +18,7 @@ describe('MCP Schema Validation', () => {
       const result = SearchArgsSchema.parse({
         query: 'test query',
         detail: 'minimal',
-        limit: 10
+        limit: 10,
       });
 
       expect(result.query).toBe('test query');
@@ -34,13 +34,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty query', () => {
-      expect(() => SearchArgsSchema.parse({ query: '' }))
-        .toThrow('Query must be a non-empty string');
+      expect(() => SearchArgsSchema.parse({ query: '' })).toThrow(
+        'Query must be a non-empty string'
+      );
     });
 
     it('should validate detail enum', () => {
-      expect(() => SearchArgsSchema.parse({ query: 'test', detail: 'invalid' }))
-        .toThrow();
+      expect(() => SearchArgsSchema.parse({ query: 'test', detail: 'invalid' })).toThrow();
 
       const minimal = SearchArgsSchema.parse({ query: 'test', detail: 'minimal' });
       expect(minimal.detail).toBe('minimal');
@@ -55,7 +55,7 @@ describe('MCP Schema Validation', () => {
     it('should validate intent enum', () => {
       const result = SearchArgsSchema.parse({
         query: 'test',
-        intent: 'find-implementation'
+        intent: 'find-implementation',
       });
 
       expect(result.intent).toBe('find-implementation');
@@ -64,21 +64,18 @@ describe('MCP Schema Validation', () => {
     it('should validate stores array', () => {
       const result = SearchArgsSchema.parse({
         query: 'test',
-        stores: ['store1', 'store2']
+        stores: ['store1', 'store2'],
       });
 
       expect(result.stores).toEqual(['store1', 'store2']);
     });
 
     it('should reject invalid limit', () => {
-      expect(() => SearchArgsSchema.parse({ query: 'test', limit: -1 }))
-        .toThrow();
+      expect(() => SearchArgsSchema.parse({ query: 'test', limit: -1 })).toThrow();
 
-      expect(() => SearchArgsSchema.parse({ query: 'test', limit: 0 }))
-        .toThrow();
+      expect(() => SearchArgsSchema.parse({ query: 'test', limit: 0 })).toThrow();
 
-      expect(() => SearchArgsSchema.parse({ query: 'test', limit: 1.5 }))
-        .toThrow();
+      expect(() => SearchArgsSchema.parse({ query: 'test', limit: 1.5 })).toThrow();
     });
   });
 
@@ -89,13 +86,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty resultId', () => {
-      expect(() => GetFullContextArgsSchema.parse({ resultId: '' }))
-        .toThrow('Result ID must be a non-empty string');
+      expect(() => GetFullContextArgsSchema.parse({ resultId: '' })).toThrow(
+        'Result ID must be a non-empty string'
+      );
     });
 
     it('should reject missing resultId', () => {
-      expect(() => GetFullContextArgsSchema.parse({}))
-        .toThrow();
+      expect(() => GetFullContextArgsSchema.parse({})).toThrow();
     });
   });
 
@@ -117,8 +114,7 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject invalid type', () => {
-      expect(() => ListStoresArgsSchema.parse({ type: 'invalid' }))
-        .toThrow();
+      expect(() => ListStoresArgsSchema.parse({ type: 'invalid' })).toThrow();
     });
   });
 
@@ -129,13 +125,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty store', () => {
-      expect(() => GetStoreInfoArgsSchema.parse({ store: '' }))
-        .toThrow('Store name or ID must be a non-empty string');
+      expect(() => GetStoreInfoArgsSchema.parse({ store: '' })).toThrow(
+        'Store name or ID must be a non-empty string'
+      );
     });
 
     it('should reject missing store', () => {
-      expect(() => GetStoreInfoArgsSchema.parse({}))
-        .toThrow();
+      expect(() => GetStoreInfoArgsSchema.parse({})).toThrow();
     });
   });
 
@@ -144,7 +140,7 @@ describe('MCP Schema Validation', () => {
       const result = CreateStoreArgsSchema.parse({
         name: 'test-store',
         type: 'file',
-        source: '/path/to/source'
+        source: '/path/to/source',
       });
 
       expect(result.name).toBe('test-store');
@@ -158,7 +154,7 @@ describe('MCP Schema Validation', () => {
         type: 'repo',
         source: 'https://github.com/test/repo',
         branch: 'main',
-        description: 'Test repository'
+        description: 'Test repository',
       });
 
       expect(result.name).toBe('test-repo');
@@ -169,36 +165,46 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty name', () => {
-      expect(() => CreateStoreArgsSchema.parse({
-        name: '',
-        type: 'file',
-        source: '/path'
-      })).toThrow('Store name must be a non-empty string');
+      expect(() =>
+        CreateStoreArgsSchema.parse({
+          name: '',
+          type: 'file',
+          source: '/path',
+        })
+      ).toThrow('Store name must be a non-empty string');
     });
 
     it('should reject invalid type', () => {
-      expect(() => CreateStoreArgsSchema.parse({
-        name: 'test',
-        type: 'invalid',
-        source: '/path'
-      })).toThrow();
+      expect(() =>
+        CreateStoreArgsSchema.parse({
+          name: 'test',
+          type: 'invalid',
+          source: '/path',
+        })
+      ).toThrow();
     });
 
     it('should reject missing required fields', () => {
-      expect(() => CreateStoreArgsSchema.parse({
-        name: 'test',
-        type: 'file'
-      })).toThrow();
-
-      expect(() => CreateStoreArgsSchema.parse({
-        name: 'test',
-        source: '/path'
-      })).toThrow();
-
-      expect(() => CreateStoreArgsSchema.parse({
-        type: 'file',
-        source: '/path'
-      })).toThrow();
+      expect(() =>
+        CreateStoreArgsSchema.parse({
+          name: 'test',
+          type: 'file',
+        })
+      ).toThrow();
+
+      expect(() =>
+        CreateStoreArgsSchema.parse({
+          name: 'test',
+          source: '/path',
+        })
+      ).toThrow();
+
+      expect(() =>
+        CreateStoreArgsSchema.parse({
+          type: 'file',
+          source: '/path',
+        })
+      ).toThrow();
     });
   });
 
@@ -209,13 +215,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty store', () => {
-      expect(() => IndexStoreArgsSchema.parse({ store: '' }))
-        .toThrow('Store name or ID must be a non-empty string');
+      expect(() => IndexStoreArgsSchema.parse({ store: '' })).toThrow(
+        'Store name or ID must be a non-empty string'
+      );
     });
 
     it('should reject missing store', () => {
-      expect(() => IndexStoreArgsSchema.parse({}))
-        .toThrow();
+      expect(() => IndexStoreArgsSchema.parse({})).toThrow();
     });
   });
 
@@ -231,13 +237,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty store', () => {
-      expect(() => DeleteStoreArgsSchema.parse({ store: '' }))
-        .toThrow('Store name or ID must be a non-empty string');
+      expect(() => DeleteStoreArgsSchema.parse({ store: '' })).toThrow(
+        'Store name or ID must be a non-empty string'
+      );
     });
 
     it('should reject missing store', () => {
-      expect(() => DeleteStoreArgsSchema.parse({}))
-        .toThrow();
+      expect(() => DeleteStoreArgsSchema.parse({})).toThrow();
     });
   });
 
@@ -248,13 +254,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty jobId', () => {
-      expect(() => CheckJobStatusArgsSchema.parse({ jobId: '' }))
-        .toThrow('Job ID must be a non-empty string');
+      expect(() => CheckJobStatusArgsSchema.parse({ jobId: '' })).toThrow(
+        'Job ID must be a non-empty string'
+      );
     });
 
     it('should reject missing jobId', () => {
-      expect(() => CheckJobStatusArgsSchema.parse({}))
-        .toThrow();
+      expect(() => CheckJobStatusArgsSchema.parse({})).toThrow();
     });
   });
 
@@ -291,8 +297,7 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject invalid status', () => {
-      expect(() => ListJobsArgsSchema.parse({ status: 'invalid' }))
-        .toThrow();
+      expect(() => ListJobsArgsSchema.parse({ status: 'invalid' })).toThrow();
     });
   });
 
@@ -303,13 +308,13 @@ describe('MCP Schema Validation', () => {
     });
 
     it('should reject empty jobId', () => {
-      expect(() => CancelJobArgsSchema.parse({ jobId: '' }))
-        .toThrow('Job ID must be a non-empty string');
+      expect(() => CancelJobArgsSchema.parse({ jobId: '' })).toThrow(
+        'Job ID must be a non-empty string'
+      );
     });
 
     it('should reject missing jobId', () => {
-      expect(() => CancelJobArgsSchema.parse({}))
-        .toThrow();
+      expect(() => CancelJobArgsSchema.parse({})).toThrow();
     });
   });
 });

package/src/mcp/schemas/index.ts

@@ -17,11 +17,17 @@ import { z } from 'zod';
 export const SearchArgsSchema = z.object({
   query: z.string().min(1, 'Query must be a non-empty string'),
   intent: z
-    .enum(['find-pattern', 'find-implementation', 'find-usage', 'find-definition', 'find-documentation'])
+    .enum([
+      'find-pattern',
+      'find-implementation',
+      'find-usage',
+      'find-definition',
+      'find-documentation',
+    ])
     .optional(),
   detail: z.enum(['minimal', 'contextual', 'full']).default('minimal'),
   limit: z.number().int().positive().default(10),
-  stores: z.array(z.string()).optional()
+  stores: z.array(z.string()).optional(),
 });
 
 export type SearchArgs = z.infer<typeof SearchArgsSchema>;
@@ -30,7 +36,7 @@ export type SearchArgs = z.infer<typeof SearchArgsSchema>;
  * Schema for get_full_context tool arguments
  */
 export const GetFullContextArgsSchema = z.object({
-  resultId: z.string().min(1, 'Result ID must be a non-empty string')
+  resultId: z.string().min(1, 'Result ID must be a non-empty string'),
 });
 
 export type GetFullContextArgs = z.infer<typeof GetFullContextArgsSchema>;
@@ -43,7 +49,7 @@ export type GetFullContextArgs = z.infer<typeof GetFullContextArgsSchema>;
  * Schema for list_stores tool arguments
  */
 export const ListStoresArgsSchema = z.object({
-  type: z.enum(['file', 'repo', 'web']).optional()
+  type: z.enum(['file', 'repo', 'web']).optional(),
 });
 
 export type ListStoresArgs = z.infer<typeof ListStoresArgsSchema>;
@@ -52,7 +58,7 @@ export type ListStoresArgs = z.infer<typeof ListStoresArgsSchema>;
  * Schema for get_store_info tool arguments
  */
 export const GetStoreInfoArgsSchema = z.object({
-  store: z.string().min(1, 'Store name or ID must be a non-empty string')
+  store: z.string().min(1, 'Store name or ID must be a non-empty string'),
 });
 
 export type GetStoreInfoArgs = z.infer<typeof GetStoreInfoArgsSchema>;
@@ -65,7 +71,7 @@ export const CreateStoreArgsSchema = z.object({
   type: z.enum(['file', 'repo']),
   source: z.string().min(1, 'Source path or URL must be a non-empty string'),
   branch: z.string().optional(),
-  description: z.string().optional()
+  description: z.string().optional(),
 });
 
 export type CreateStoreArgs = z.infer<typeof CreateStoreArgsSchema>;
@@ -74,7 +80,7 @@ export type CreateStoreArgs = z.infer<typeof CreateStoreArgsSchema>;
  * Schema for index_store tool arguments
  */
 export const IndexStoreArgsSchema = z.object({
-  store: z.string().min(1, 'Store name or ID must be a non-empty string')
+  store: z.string().min(1, 'Store name or ID must be a non-empty string'),
 });
 
 export type IndexStoreArgs = z.infer<typeof IndexStoreArgsSchema>;
@@ -83,7 +89,7 @@ export type IndexStoreArgs = z.infer<typeof IndexStoreArgsSchema>;
  * Schema for delete_store tool arguments
  */
 export const DeleteStoreArgsSchema = z.object({
-  store: z.string().min(1, 'Store name or ID must be a non-empty string')
+  store: z.string().min(1, 'Store name or ID must be a non-empty string'),
 });
 
 export type DeleteStoreArgs = z.infer<typeof DeleteStoreArgsSchema>;
@@ -96,7 +102,7 @@ export type DeleteStoreArgs = z.infer<typeof DeleteStoreArgsSchema>;
  * Schema for check_job_status tool arguments
  */
 export const CheckJobStatusArgsSchema = z.object({
-  jobId: z.string().min(1, 'Job ID must be a non-empty string')
+  jobId: z.string().min(1, 'Job ID must be a non-empty string'),
 });
 
 export type CheckJobStatusArgs = z.infer<typeof CheckJobStatusArgsSchema>;
@@ -106,7 +112,7 @@ export type CheckJobStatusArgs = z.infer<typeof CheckJobStatusArgsSchema>;
  */
 export const ListJobsArgsSchema = z.object({
   activeOnly: z.boolean().optional(),
-  status: z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']).optional()
+  status: z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']).optional(),
 });
 
 export type ListJobsArgs = z.infer<typeof ListJobsArgsSchema>;
@@ -115,7 +121,7 @@ export type ListJobsArgs = z.infer<typeof ListJobsArgsSchema>;
  * Schema for cancel_job tool arguments
  */
 export const CancelJobArgsSchema = z.object({
-  jobId: z.string().min(1, 'Job ID must be a non-empty string')
+  jobId: z.string().min(1, 'Job ID must be a non-empty string'),
 });
 
 export type CancelJobArgs = z.infer<typeof CancelJobArgsSchema>;
@@ -132,7 +138,7 @@ export type CancelJobArgs = z.infer<typeof CancelJobArgsSchema>;
  */
 export const ExecuteArgsSchema = z.object({
   command: z.string().min(1, 'Command name is required'),
-  args: z.record(z.string(), z.unknown()).optional()
+  args: z.record(z.string(), z.unknown()).optional(),
 });
 
 export type ExecuteArgs = z.infer<typeof ExecuteArgsSchema>;

package/src/mcp/server.test.ts

@@ -28,7 +28,7 @@ describe('MCP Server', () => {
       const server = createMCPServer({
         dataDir: '/data',
         config: '/config.json',
-        projectRoot: '/project'
+        projectRoot: '/project',
       });
       expect(server).toBeDefined();
     });

package/src/mcp/server.ts

@@ -1,15 +1,12 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { createServices } from '../services/index.js';
-import { tools } from './handlers/index.js';
 import { handleExecute } from './handlers/execute.handler.js';
+import { tools } from './handlers/index.js';
 import { ExecuteArgsSchema } from './schemas/index.js';
-import type { MCPServerOptions } from './types.js';
 import { createLogger } from '../logging/index.js';
+import type { MCPServerOptions } from './types.js';
 
 const logger = createLogger('mcp-server');
 
@@ -35,74 +32,85 @@ export function createMCPServer(options: MCPServerOptions): Server {
         // Native search tool with full schema (most used, benefits from detailed params)
         {
           name: 'search',
-          description: 'Search all indexed knowledge stores with pattern detection and AI-optimized results. Returns structured code units with progressive context layers.',
+          description:
+            'Search all indexed knowledge stores with pattern detection and AI-optimized results. Returns structured code units with progressive context layers.',
           inputSchema: {
             type: 'object',
             properties: {
               query: {
                 type: 'string',
-                description: 'Search query (can include type signatures, constraints, or natural language)'
+                description:
+                  'Search query (can include type signatures, constraints, or natural language)',
               },
               intent: {
                 type: 'string',
-                enum: ['find-pattern', 'find-implementation', 'find-usage', 'find-definition', 'find-documentation'],
-                description: 'Search intent for better ranking'
+                enum: [
+                  'find-pattern',
+                  'find-implementation',
+                  'find-usage',
+                  'find-definition',
+                  'find-documentation',
+                ],
+                description: 'Search intent for better ranking',
               },
               detail: {
                 type: 'string',
                 enum: ['minimal', 'contextual', 'full'],
                 default: 'minimal',
-                description: 'Context detail level: minimal (summary only), contextual (+ imports/types), full (+ complete code)'
+                description:
+                  'Context detail level: minimal (summary only), contextual (+ imports/types), full (+ complete code)',
               },
               limit: {
                 type: 'number',
                 default: 10,
-                description: 'Maximum number of results'
+                description: 'Maximum number of results',
               },
               stores: {
                 type: 'array',
                 items: { type: 'string' },
-                description: 'Specific store IDs to search (optional)'
-              }
+                description: 'Specific store IDs to search (optional)',
+              },
             },
-            required: ['query']
-          }
+            required: ['query'],
+          },
         },
         // Native get_full_context tool (frequently used after search)
         {
           name: 'get_full_context',
-          description: 'Get complete code and context for a specific search result by ID. Use this after search to get full implementation details.',
+          description:
+            'Get complete code and context for a specific search result by ID. Use this after search to get full implementation details.',
           inputSchema: {
             type: 'object',
             properties: {
               resultId: {
                 type: 'string',
-                description: 'Result ID from previous search'
-              }
+                description: 'Result ID from previous search',
+              },
             },
-            required: ['resultId']
-          }
+            required: ['resultId'],
+          },
         },
         // Meta-tool for store and job management (consolidates 8 tools into 1)
         {
           name: 'execute',
-          description: 'Execute store/job management commands. Commands: stores, store:info, store:create, store:index, store:delete, jobs, job:status, job:cancel, help, commands',
+          description:
+            'Execute store/job management commands. Commands: stores, store:info, store:create, store:index, store:delete, jobs, job:status, job:cancel, help, commands',
           inputSchema: {
             type: 'object',
             properties: {
               command: {
                 type: 'string',
-                description: 'Command to execute (e.g., "stores", "store:create", "jobs", "help")'
+                description: 'Command to execute (e.g., "stores", "store:create", "jobs", "help")',
               },
               args: {
                 type: 'object',
-                description: 'Command arguments (e.g., {store: "mystore"} for store:info)'
-              }
+                description: 'Command arguments (e.g., {store: "mystore"} for store:info)',
+              },
             },
-            required: ['command']
-          }
-        }
-      ]
+            required: ['command'],
+          },
+        },
+      ],
     });
   });
 
@@ -114,11 +122,7 @@ export function createMCPServer(options: MCPServerOptions): Server {
     logger.info({ tool: name, args: JSON.stringify(args) }, 'Tool invoked');
 
     // Create services once (needed by all handlers)
-    const services = await createServices(
-      options.config,
-      options.dataDir,
-      options.projectRoot
-    );
+    const services = await createServices(options.config, options.dataDir, options.projectRoot);
     const context = { services, options };
 
     try {
@@ -130,7 +134,7 @@ export function createMCPServer(options: MCPServerOptions): Server {
         result = await handleExecute(validated, context);
       } else {
         // Find handler in registry for native tools (search, get_full_context)
-        const tool = tools.find(t => t.name === name);
+        const tool = tools.find((t) => t.name === name);
         if (tool === undefined) {
           throw new Error(`Unknown tool: ${name}`);
         }
@@ -148,11 +152,14 @@ export function createMCPServer(options: MCPServerOptions): Server {
       return result;
     } catch (error) {
       const durationMs = Date.now() - startTime;
-      logger.error({
-        tool: name,
-        durationMs,
-        error: error instanceof Error ? error.message : String(error),
-      }, 'Tool execution failed');
+      logger.error(
+        {
+          tool: name,
+          durationMs,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        'Tool execution failed'
+      );
       throw error;
     }
   });
@@ -161,10 +168,13 @@ export function createMCPServer(options: MCPServerOptions): Server {
 }
 
 export async function runMCPServer(options: MCPServerOptions): Promise<void> {
-  logger.info({
-    dataDir: options.dataDir,
-    projectRoot: options.projectRoot,
-  }, 'MCP server starting');
+  logger.info(
+    {
+      dataDir: options.dataDir,
+      projectRoot: options.projectRoot,
+    },
+    'MCP server starting'
+  );
 
   const server = createMCPServer(options);
   const transport = new StdioServerTransport();
@@ -182,9 +192,12 @@ if (isMCPServerEntry) {
   runMCPServer({
     dataDir: process.env['DATA_DIR'],
     config: process.env['CONFIG_PATH'],
-    projectRoot: process.env['PROJECT_ROOT'] ?? process.env['PWD']
+    projectRoot: process.env['PROJECT_ROOT'] ?? process.env['PWD'],
   }).catch((error: unknown) => {
-    logger.error({ error: error instanceof Error ? error.message : String(error) }, 'Failed to start MCP server');
+    logger.error(
+      { error: error instanceof Error ? error.message : String(error) },
+      'Failed to start MCP server'
+    );
     process.exit(1);
   });
 }