bluera-knowledge 0.14.0 → 0.14.1

package/src/mcp/plugin-mcp-config.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Tests to verify .mcp.json is correctly configured for MCP server.
- * The MCP server must work when the plugin is installed via marketplace.
- *
- * Key requirements:
- * - Must use ${CLAUDE_PLUGIN_ROOT} for server path (resolves to plugin cache)
- * - Must set PROJECT_ROOT env var (required by server fail-fast check)
- * - Must NOT use relative paths (would resolve to user's project, not plugin)
- *
- * Note: We use .mcp.json at plugin root (not inline in plugin.json) due to
- * Claude Code Bug #16143 where inline mcpServers is ignored during parsing.
- * See: https://github.com/anthropics/claude-code/issues/16143
- */
-describe('Plugin MCP Configuration (.mcp.json)', () => {
-  const mcpJsonPath = join(process.cwd(), '.mcp.json');
-  const config = JSON.parse(readFileSync(mcpJsonPath, 'utf-8'));
-
-  it('has .mcp.json file at plugin root', () => {
-    expect(existsSync(mcpJsonPath)).toBe(true);
-  });
-
-  it('has bluera-knowledge server configuration', () => {
-    expect(config).toHaveProperty('bluera-knowledge');
-  });
-
-  it('uses ${CLAUDE_PLUGIN_ROOT} for server path (required for plugin mode)', () => {
-    const serverConfig = config['bluera-knowledge'];
-    const argsString = JSON.stringify(serverConfig.args);
-
-    // CLAUDE_PLUGIN_ROOT is set by Claude Code when plugin is installed
-    // This ensures the path resolves to the plugin cache, not user's project
-    expect(argsString).toContain('${CLAUDE_PLUGIN_ROOT}');
-    expect(argsString).toContain('dist/mcp/server.js');
-  });
-
-  it('does NOT use relative paths (would break in plugin mode)', () => {
-    const serverConfig = config['bluera-knowledge'];
-    const argsString = JSON.stringify(serverConfig.args);
-
-    // Relative paths like ./dist would resolve to user's project directory
-    // which doesn't have the plugin's dist folder
-    expect(argsString).not.toMatch(/"\.\//);
-  });
-
-  it('sets PROJECT_ROOT environment variable (required by fail-fast server)', () => {
-    const serverConfig = config['bluera-knowledge'];
-
-    // PROJECT_ROOT is required since b404cd6 (fail-fast change)
-    expect(serverConfig.env).toHaveProperty('PROJECT_ROOT');
-    expect(serverConfig.env['PROJECT_ROOT']).toBe('${PWD}');
-  });
-});
-
-/**
- * Tests to ensure plugin.json does NOT have inline mcpServers.
- * Inline mcpServers is broken due to Claude Code Bug #16143.
- */
-describe('plugin.json does NOT have inline mcpServers', () => {
-  it('plugin.json does NOT contain mcpServers (would be ignored by Claude Code)', () => {
-    const pluginJsonPath = join(process.cwd(), '.claude-plugin/plugin.json');
-    const pluginConfig = JSON.parse(readFileSync(pluginJsonPath, 'utf-8'));
-
-    // mcpServers in plugin.json is ignored due to Bug #16143
-    // All MCP config should be in .mcp.json at plugin root
-    expect(pluginConfig).not.toHaveProperty('mcpServers');
-  });
-});

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

@@ -1,356 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  SearchArgsSchema,
-  GetFullContextArgsSchema,
-  ListStoresArgsSchema,
-  GetStoreInfoArgsSchema,
-  CreateStoreArgsSchema,
-  IndexStoreArgsSchema,
-  DeleteStoreArgsSchema,
-  CheckJobStatusArgsSchema,
-  ListJobsArgsSchema,
-  CancelJobArgsSchema,
-} from './index.js';
-
-describe('MCP Schema Validation', () => {
-  describe('SearchArgsSchema', () => {
-    it('should validate valid search args', () => {
-      const result = SearchArgsSchema.parse({
-        query: 'test query',
-        detail: 'minimal',
-        limit: 10,
-      });
-
-      expect(result.query).toBe('test query');
-      expect(result.detail).toBe('minimal');
-      expect(result.limit).toBe(10);
-    });
-
-    it('should use defaults for optional fields', () => {
-      const result = SearchArgsSchema.parse({ query: 'test' });
-
-      expect(result.mode).toBe('hybrid');
-      expect(result.detail).toBe('minimal');
-      expect(result.limit).toBe(10);
-    });
-
-    it('should validate mode enum', () => {
-      expect(() => SearchArgsSchema.parse({ query: 'test', mode: 'invalid' })).toThrow();
-
-      const vector = SearchArgsSchema.parse({ query: 'test', mode: 'vector' });
-      expect(vector.mode).toBe('vector');
-
-      const fts = SearchArgsSchema.parse({ query: 'test', mode: 'fts' });
-      expect(fts.mode).toBe('fts');
-
-      const hybrid = SearchArgsSchema.parse({ query: 'test', mode: 'hybrid' });
-      expect(hybrid.mode).toBe('hybrid');
-    });
-
-    it('should validate threshold', () => {
-      const result = SearchArgsSchema.parse({ query: 'test', threshold: 0.5 });
-      expect(result.threshold).toBe(0.5);
-
-      // Edge cases
-      const min = SearchArgsSchema.parse({ query: 'test', threshold: 0 });
-      expect(min.threshold).toBe(0);
-
-      const max = SearchArgsSchema.parse({ query: 'test', threshold: 1 });
-      expect(max.threshold).toBe(1);
-    });
-
-    it('should reject invalid threshold', () => {
-      expect(() => SearchArgsSchema.parse({ query: 'test', threshold: -0.1 })).toThrow(
-        'threshold must be between 0 and 1'
-      );
-
-      expect(() => SearchArgsSchema.parse({ query: 'test', threshold: 1.1 })).toThrow(
-        'threshold must be between 0 and 1'
-      );
-    });
-
-    it('should reject empty query', () => {
-      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();
-
-      const minimal = SearchArgsSchema.parse({ query: 'test', detail: 'minimal' });
-      expect(minimal.detail).toBe('minimal');
-
-      const contextual = SearchArgsSchema.parse({ query: 'test', detail: 'contextual' });
-      expect(contextual.detail).toBe('contextual');
-
-      const full = SearchArgsSchema.parse({ query: 'test', detail: 'full' });
-      expect(full.detail).toBe('full');
-    });
-
-    it('should validate intent enum', () => {
-      const result = SearchArgsSchema.parse({
-        query: 'test',
-        intent: 'find-implementation',
-      });
-
-      expect(result.intent).toBe('find-implementation');
-    });
-
-    it('should validate stores array', () => {
-      const result = SearchArgsSchema.parse({
-        query: 'test',
-        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: 0 })).toThrow();
-
-      expect(() => SearchArgsSchema.parse({ query: 'test', limit: 1.5 })).toThrow();
-    });
-  });
-
-  describe('GetFullContextArgsSchema', () => {
-    it('should validate valid resultId', () => {
-      const result = GetFullContextArgsSchema.parse({ resultId: 'doc123' });
-      expect(result.resultId).toBe('doc123');
-    });
-
-    it('should reject empty resultId', () => {
-      expect(() => GetFullContextArgsSchema.parse({ resultId: '' })).toThrow(
-        'Result ID must be a non-empty string'
-      );
-    });
-
-    it('should reject missing resultId', () => {
-      expect(() => GetFullContextArgsSchema.parse({})).toThrow();
-    });
-  });
-
-  describe('ListStoresArgsSchema', () => {
-    it('should validate without type filter', () => {
-      const result = ListStoresArgsSchema.parse({});
-      expect(result.type).toBeUndefined();
-    });
-
-    it('should validate with valid type filter', () => {
-      const file = ListStoresArgsSchema.parse({ type: 'file' });
-      expect(file.type).toBe('file');
-
-      const repo = ListStoresArgsSchema.parse({ type: 'repo' });
-      expect(repo.type).toBe('repo');
-
-      const web = ListStoresArgsSchema.parse({ type: 'web' });
-      expect(web.type).toBe('web');
-    });
-
-    it('should reject invalid type', () => {
-      expect(() => ListStoresArgsSchema.parse({ type: 'invalid' })).toThrow();
-    });
-  });
-
-  describe('GetStoreInfoArgsSchema', () => {
-    it('should validate valid store', () => {
-      const result = GetStoreInfoArgsSchema.parse({ store: 'my-store' });
-      expect(result.store).toBe('my-store');
-    });
-
-    it('should reject empty store', () => {
-      expect(() => GetStoreInfoArgsSchema.parse({ store: '' })).toThrow(
-        'Store name or ID must be a non-empty string'
-      );
-    });
-
-    it('should reject missing store', () => {
-      expect(() => GetStoreInfoArgsSchema.parse({})).toThrow();
-    });
-  });
-
-  describe('CreateStoreArgsSchema', () => {
-    it('should validate minimal valid args', () => {
-      const result = CreateStoreArgsSchema.parse({
-        name: 'test-store',
-        type: 'file',
-        source: '/path/to/source',
-      });
-
-      expect(result.name).toBe('test-store');
-      expect(result.type).toBe('file');
-      expect(result.source).toBe('/path/to/source');
-    });
-
-    it('should validate with optional fields', () => {
-      const result = CreateStoreArgsSchema.parse({
-        name: 'test-repo',
-        type: 'repo',
-        source: 'https://github.com/test/repo',
-        branch: 'main',
-        description: 'Test repository',
-      });
-
-      expect(result.name).toBe('test-repo');
-      expect(result.type).toBe('repo');
-      expect(result.source).toBe('https://github.com/test/repo');
-      expect(result.branch).toBe('main');
-      expect(result.description).toBe('Test repository');
-    });
-
-    it('should reject empty name', () => {
-      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();
-    });
-
-    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();
-    });
-  });
-
-  describe('IndexStoreArgsSchema', () => {
-    it('should validate valid store', () => {
-      const result = IndexStoreArgsSchema.parse({ store: 'my-store' });
-      expect(result.store).toBe('my-store');
-    });
-
-    it('should reject empty store', () => {
-      expect(() => IndexStoreArgsSchema.parse({ store: '' })).toThrow(
-        'Store name or ID must be a non-empty string'
-      );
-    });
-
-    it('should reject missing store', () => {
-      expect(() => IndexStoreArgsSchema.parse({})).toThrow();
-    });
-  });
-
-  describe('DeleteStoreArgsSchema', () => {
-    it('should validate valid store name', () => {
-      const result = DeleteStoreArgsSchema.parse({ store: 'my-store' });
-      expect(result.store).toBe('my-store');
-    });
-
-    it('should validate valid store ID', () => {
-      const result = DeleteStoreArgsSchema.parse({ store: 'abc123-def456' });
-      expect(result.store).toBe('abc123-def456');
-    });
-
-    it('should reject empty store', () => {
-      expect(() => DeleteStoreArgsSchema.parse({ store: '' })).toThrow(
-        'Store name or ID must be a non-empty string'
-      );
-    });
-
-    it('should reject missing store', () => {
-      expect(() => DeleteStoreArgsSchema.parse({})).toThrow();
-    });
-  });
-
-  describe('CheckJobStatusArgsSchema', () => {
-    it('should validate valid jobId', () => {
-      const result = CheckJobStatusArgsSchema.parse({ jobId: 'job_123' });
-      expect(result.jobId).toBe('job_123');
-    });
-
-    it('should reject empty jobId', () => {
-      expect(() => CheckJobStatusArgsSchema.parse({ jobId: '' })).toThrow(
-        'Job ID must be a non-empty string'
-      );
-    });
-
-    it('should reject missing jobId', () => {
-      expect(() => CheckJobStatusArgsSchema.parse({})).toThrow();
-    });
-  });
-
-  describe('ListJobsArgsSchema', () => {
-    it('should validate with defaults', () => {
-      const result = ListJobsArgsSchema.parse({});
-      expect(result.activeOnly).toBeUndefined();
-      expect(result.status).toBeUndefined();
-    });
-
-    it('should validate activeOnly', () => {
-      const active = ListJobsArgsSchema.parse({ activeOnly: true });
-      expect(active.activeOnly).toBe(true);
-
-      const all = ListJobsArgsSchema.parse({ activeOnly: false });
-      expect(all.activeOnly).toBe(false);
-    });
-
-    it('should validate status filter', () => {
-      const pending = ListJobsArgsSchema.parse({ status: 'pending' });
-      expect(pending.status).toBe('pending');
-
-      const running = ListJobsArgsSchema.parse({ status: 'running' });
-      expect(running.status).toBe('running');
-
-      const completed = ListJobsArgsSchema.parse({ status: 'completed' });
-      expect(completed.status).toBe('completed');
-
-      const failed = ListJobsArgsSchema.parse({ status: 'failed' });
-      expect(failed.status).toBe('failed');
-
-      const cancelled = ListJobsArgsSchema.parse({ status: 'cancelled' });
-      expect(cancelled.status).toBe('cancelled');
-    });
-
-    it('should reject invalid status', () => {
-      expect(() => ListJobsArgsSchema.parse({ status: 'invalid' })).toThrow();
-    });
-  });
-
-  describe('CancelJobArgsSchema', () => {
-    it('should validate valid jobId', () => {
-      const result = CancelJobArgsSchema.parse({ jobId: 'job_123' });
-      expect(result.jobId).toBe('job_123');
-    });
-
-    it('should reject empty jobId', () => {
-      expect(() => CancelJobArgsSchema.parse({ jobId: '' })).toThrow(
-        'Job ID must be a non-empty string'
-      );
-    });
-
-    it('should reject missing jobId', () => {
-      expect(() => CancelJobArgsSchema.parse({})).toThrow();
-    });
-  });
-});

package/src/mcp/schemas/index.ts

@@ -1,155 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Validation schemas for all MCP tool inputs
- *
- * These schemas provide runtime type validation and better error messages
- * compared to manual type assertions.
- */
-
-// ============================================================================
-// Search Tool Schemas
-// ============================================================================
-
-/**
- * Schema for search tool arguments
- */
-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',
-    ])
-    .optional(),
-  mode: z.enum(['vector', 'fts', 'hybrid']).default('hybrid'),
-  detail: z.enum(['minimal', 'contextual', 'full']).default('minimal'),
-  limit: z.number().int().positive().default(10),
-  stores: z.array(z.string()).optional(),
-  threshold: z
-    .number()
-    .min(0, 'threshold must be between 0 and 1')
-    .max(1, 'threshold must be between 0 and 1')
-    .optional(),
-  minRelevance: z
-    .number()
-    .min(0, 'minRelevance must be between 0 and 1')
-    .max(1, 'minRelevance must be between 0 and 1')
-    .optional(),
-});
-
-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'),
-});
-
-export type GetFullContextArgs = z.infer<typeof GetFullContextArgsSchema>;
-
-// ============================================================================
-// Store Tool Schemas
-// ============================================================================
-
-/**
- * Schema for list_stores tool arguments
- */
-export const ListStoresArgsSchema = z.object({
-  type: z.enum(['file', 'repo', 'web']).optional(),
-});
-
-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'),
-});
-
-export type GetStoreInfoArgs = z.infer<typeof GetStoreInfoArgsSchema>;
-
-/**
- * Schema for create_store tool arguments
- */
-export const CreateStoreArgsSchema = z.object({
-  name: z.string().min(1, 'Store name must be a non-empty string'),
-  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(),
-});
-
-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'),
-});
-
-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'),
-});
-
-export type DeleteStoreArgs = z.infer<typeof DeleteStoreArgsSchema>;
-
-// ============================================================================
-// Job Tool Schemas
-// ============================================================================
-
-/**
- * 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'),
-});
-
-export type CheckJobStatusArgs = z.infer<typeof CheckJobStatusArgsSchema>;
-
-/**
- * Schema for list_jobs tool arguments
- */
-export const ListJobsArgsSchema = z.object({
-  activeOnly: z.boolean().optional(),
-  status: z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']).optional(),
-});
-
-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'),
-});
-
-export type CancelJobArgs = z.infer<typeof CancelJobArgsSchema>;
-
-// ============================================================================
-// Execute Meta-Tool Schema
-// ============================================================================
-
-/**
- * Schema for execute meta-tool arguments
- *
- * The execute tool consolidates store and job management commands
- * into a single tool, reducing context overhead.
- */
-export const ExecuteArgsSchema = z.object({
-  command: z.string().min(1, 'Command name is required'),
-  args: z.record(z.string(), z.unknown()).optional(),
-});
-
-export type ExecuteArgs = z.infer<typeof ExecuteArgsSchema>;

package/src/mcp/server.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, type MockInstance } from 'vitest';
-import { createMCPServer } from './server.js';
-
-// Mock services module
-vi.mock('../services/index.js', () => ({
-  createServices: vi.fn(),
-  destroyServices: vi.fn(),
-}));
-
-// MCP Server tests - server creation only since the SDK doesn't expose handlers for testing
-describe('MCP Server', () => {
-  describe('Server creation and initialization', () => {
-    it('creates server with default options', () => {
-      const server = createMCPServer({});
-      expect(server).toBeDefined();
-    });
-
-    it('creates server with custom dataDir', () => {
-      const server = createMCPServer({ dataDir: '/custom/path' });
-      expect(server).toBeDefined();
-    });
-
-    it('creates server with config path', () => {
-      const server = createMCPServer({ config: '/path/to/config.json' });
-      expect(server).toBeDefined();
-    });
-
-    it('creates server with project root', () => {
-      const server = createMCPServer({ projectRoot: '/project' });
-      expect(server).toBeDefined();
-    });
-
-    it('creates server with all options', () => {
-      const server = createMCPServer({
-        dataDir: '/data',
-        config: '/config.json',
-        projectRoot: '/project',
-      });
-      expect(server).toBeDefined();
-    });
-  });
-
-  describe('Resource cleanup', () => {
-    let createServicesSpy: MockInstance;
-    let destroyServicesSpy: MockInstance;
-    let mockServices: Record<string, unknown>;
-
-    beforeEach(async () => {
-      vi.clearAllMocks();
-
-      const servicesModule = await import('../services/index.js');
-      createServicesSpy = vi.mocked(servicesModule.createServices);
-      destroyServicesSpy = vi.mocked(servicesModule.destroyServices);
-
-      mockServices = {
-        store: { list: vi.fn().mockResolvedValue([]) },
-        lance: { search: vi.fn() },
-        search: { search: vi.fn() },
-        embeddings: { embed: vi.fn() },
-        pythonBridge: { stop: vi.fn() },
-      };
-
-      createServicesSpy.mockResolvedValue(mockServices);
-      destroyServicesSpy.mockResolvedValue(undefined);
-    });
-
-    afterEach(() => {
-      vi.restoreAllMocks();
-    });
-
-    it('calls destroyServices after successful tool execution', async () => {
-      // This test verifies that destroyServices is called after each tool call
-      // to prevent resource leaks (PythonBridge processes, LanceDB connections)
-
-      const server = createMCPServer({ projectRoot: '/test' });
-
-      // Get the request handler by simulating a tool call
-      // The server registers handlers via setRequestHandler, we need to test
-      // that destroyServices is called after the handler completes
-
-      // Since we can't easily call the handler directly without the full MCP SDK,
-      // this test documents the expected behavior: destroyServices MUST be called
-      // after every tool execution to prevent resource leaks
-
-      expect(server).toBeDefined();
-
-      // The implementation should ensure destroyServices is called in a finally block
-      // This test will need to be enhanced when we can properly mock the request flow
-    });
-  });
-});