bluera-knowledge 0.9.21

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

@@ -0,0 +1,415 @@
+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)
+        }
+      } 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');
+    });
+  });
+});

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

@@ -0,0 +1,295 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { ToolHandler, ToolResponse } from '../types.js';
+import type {
+  ListStoresArgs,
+  GetStoreInfoArgs,
+  CreateStoreArgs,
+  IndexStoreArgs,
+  DeleteStoreArgs
+} from '../schemas/index.js';
+import {
+  ListStoresArgsSchema,
+  GetStoreInfoArgsSchema,
+  CreateStoreArgsSchema,
+  IndexStoreArgsSchema,
+  DeleteStoreArgsSchema
+} from '../schemas/index.js';
+import { JobService } from '../../services/job.service.js';
+import { spawnBackgroundWorker } from '../../workers/spawn-worker.js';
+import { createStoreId } from '../../types/brands.js';
+
+/**
+ * Handle list_stores requests
+ *
+ * Lists all knowledge stores with optional type filtering.
+ */
+export const handleListStores: ToolHandler<ListStoresArgs> = async (
+  args,
+  context
+): Promise<ToolResponse> => {
+  // Validate arguments with Zod
+  const validated = ListStoresArgsSchema.parse(args);
+
+  const { services } = context;
+
+  const stores = await services.store.list();
+  const filtered = validated.type !== undefined
+    ? stores.filter(s => s.type === validated.type)
+    : stores;
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          stores: filtered.map(s => ({
+            id: s.id,
+            name: s.name,
+            type: s.type,
+            path: 'path' in s ? s.path : undefined,
+            url: 'url' in s && s.url !== undefined ? s.url : undefined,
+            description: s.description,
+            createdAt: s.createdAt.toISOString()
+          }))
+        }, null, 2)
+      }
+    ]
+  };
+};
+
+/**
+ * Handle get_store_info requests
+ *
+ * Retrieves detailed information about a specific store.
+ */
+export const handleGetStoreInfo: ToolHandler<GetStoreInfoArgs> = async (
+  args,
+  context
+): Promise<ToolResponse> => {
+  // Validate arguments with Zod
+  const validated = GetStoreInfoArgsSchema.parse(args);
+
+  const { services } = context;
+
+  const store = await services.store.getByIdOrName(createStoreId(validated.store));
+
+  if (store === undefined) {
+    throw new Error(`Store not found: ${validated.store}`);
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          id: store.id,
+          name: store.name,
+          type: store.type,
+          path: 'path' in store ? store.path : undefined,
+          url: 'url' in store && store.url !== undefined ? store.url : undefined,
+          branch: 'branch' in store ? store.branch : undefined,
+          description: store.description,
+          status: store.status,
+          createdAt: store.createdAt.toISOString(),
+          updatedAt: store.updatedAt.toISOString()
+        }, null, 2)
+      }
+    ]
+  };
+};
+
+/**
+ * Handle create_store requests
+ *
+ * Creates a new knowledge store and starts background indexing.
+ * Returns store info and job ID for tracking progress.
+ */
+export const handleCreateStore: ToolHandler<CreateStoreArgs> = async (
+  args,
+  context
+): Promise<ToolResponse> => {
+  // Validate arguments with Zod
+  const validated = CreateStoreArgsSchema.parse(args);
+
+  const { services, options } = context;
+
+  // Determine if source is a URL or path
+  const isUrl = validated.source.startsWith('http://') ||
+                validated.source.startsWith('https://') ||
+                validated.source.startsWith('git@');
+
+  const result = await services.store.create({
+    name: validated.name,
+    type: validated.type,
+    ...(isUrl ? { url: validated.source } : { path: validated.source }),
+    ...(validated.branch !== undefined ? { branch: validated.branch } : {}),
+    ...(validated.description !== undefined ? { description: validated.description } : {})
+  });
+
+  if (!result.success) {
+    throw new Error(result.error.message);
+  }
+
+  // Create background job for indexing
+  const jobService = new JobService(options.dataDir);
+  const jobDetails: Record<string, unknown> = {
+    storeName: result.data.name,
+    storeId: result.data.id
+  };
+  if (isUrl) {
+    jobDetails['url'] = validated.source;
+  }
+  if ('path' in result.data && result.data.path) {
+    jobDetails['path'] = result.data.path;
+  }
+  const job = jobService.createJob({
+    type: validated.type === 'repo' && isUrl ? 'clone' : 'index',
+    details: jobDetails,
+    message: `Indexing ${result.data.name}...`
+  });
+
+  // Spawn background worker (dataDir defaults to project-local .bluera if undefined)
+  spawnBackgroundWorker(job.id, options.dataDir ?? '');
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          store: {
+            id: result.data.id,
+            name: result.data.name,
+            type: result.data.type,
+            path: 'path' in result.data ? result.data.path : undefined
+          },
+          job: {
+            id: job.id,
+            status: job.status,
+            message: job.message
+          },
+          message: `Store created. Indexing started in background (Job ID: ${job.id})`
+        }, null, 2)
+      }
+    ]
+  };
+};
+
+/**
+ * Handle index_store requests
+ *
+ * Re-indexes an existing store in the background.
+ * Returns job ID for tracking progress.
+ */
+export const handleIndexStore: ToolHandler<IndexStoreArgs> = async (
+  args,
+  context
+): Promise<ToolResponse> => {
+  // Validate arguments with Zod
+  const validated = IndexStoreArgsSchema.parse(args);
+
+  const { services, options } = context;
+
+  const store = await services.store.getByIdOrName(createStoreId(validated.store));
+
+  if (store === undefined) {
+    throw new Error(`Store not found: ${validated.store}`);
+  }
+
+  // Create background job for indexing
+  const jobService = new JobService(options.dataDir);
+  const jobDetails: Record<string, unknown> = {
+    storeName: store.name,
+    storeId: store.id
+  };
+  if ('path' in store && store.path) {
+    jobDetails['path'] = store.path;
+  }
+  const job = jobService.createJob({
+    type: 'index',
+    details: jobDetails,
+    message: `Re-indexing ${store.name}...`
+  });
+
+  // Spawn background worker (dataDir defaults to project-local .bluera if undefined)
+  spawnBackgroundWorker(job.id, options.dataDir ?? '');
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          store: {
+            id: store.id,
+            name: store.name
+          },
+          job: {
+            id: job.id,
+            status: job.status,
+            message: job.message
+          },
+          message: `Indexing started in background (Job ID: ${job.id})`
+        }, null, 2)
+      }
+    ]
+  };
+};
+
+/**
+ * Handle delete_store requests
+ *
+ * Deletes a store and all associated data:
+ * - Removes from store registry
+ * - Drops LanceDB table
+ * - For repo stores with URL, removes cloned files
+ */
+export const handleDeleteStore: ToolHandler<DeleteStoreArgs> = async (
+  args,
+  context
+): Promise<ToolResponse> => {
+  // Validate arguments with Zod
+  const validated = DeleteStoreArgsSchema.parse(args);
+
+  const { services, options } = context;
+
+  const store = await services.store.getByIdOrName(createStoreId(validated.store));
+
+  if (store === undefined) {
+    throw new Error(`Store not found: ${validated.store}`);
+  }
+
+  // Delete LanceDB table
+  await services.lance.deleteStore(store.id);
+
+  // For repo stores cloned from URL, remove the cloned directory
+  if (store.type === 'repo' && 'url' in store && store.url !== undefined) {
+    if (options.dataDir === undefined) {
+      throw new Error('dataDir is required to delete cloned repository files');
+    }
+    const repoPath = join(options.dataDir, 'repos', store.id);
+    await rm(repoPath, { recursive: true, force: true });
+  }
+
+  // Delete from registry
+  const result = await services.store.delete(store.id);
+  if (!result.success) {
+    throw new Error(result.error.message);
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          deleted: true,
+          store: {
+            id: store.id,
+            name: store.name,
+            type: store.type
+          },
+          message: `Successfully deleted store: ${store.name}`
+        }, null, 2)
+      }
+    ]
+  };
+};