bluera-knowledge 0.14.0 → 0.14.1

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

@@ -1,189 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { handleCheckJobStatus, handleListJobs, handleCancelJob } from './job.handler.js';
-import type { HandlerContext } from '../types.js';
-import type { CheckJobStatusArgs, ListJobsArgs, CancelJobArgs } from '../schemas/index.js';
-import { JobService } from '../../services/job.service.js';
-import { mkdtempSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('job.handler', () => {
-  let tempDir: string;
-  let mockContext: HandlerContext;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'job-handler-test-'));
-    mockContext = {
-      services: {} as any,
-      options: { dataDir: tempDir },
-    };
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('handleCheckJobStatus', () => {
-    it('should return job status', async () => {
-      const jobService = new JobService(tempDir);
-      const job = jobService.createJob({
-        type: 'index',
-        details: { storeId: 'test-store' },
-        message: 'Indexing...',
-      });
-
-      const args: CheckJobStatusArgs = { jobId: job.id };
-      const result = await handleCheckJobStatus(args, mockContext);
-
-      expect(result.content).toHaveLength(1);
-      const data = JSON.parse(result.content[0].text);
-      expect(data.id).toBe(job.id);
-      expect(data.status).toBe('pending');
-    });
-
-    it('should throw if job not found', async () => {
-      const args: CheckJobStatusArgs = { jobId: 'nonexistent' };
-
-      try {
-        await handleCheckJobStatus(args, mockContext);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Job not found: nonexistent');
-      }
-    });
-
-    it('should validate arguments with Zod', async () => {
-      const invalidArgs = { jobId: 123 } as any;
-
-      try {
-        await handleCheckJobStatus(invalidArgs, mockContext);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeDefined();
-      }
-    });
-  });
-
-  describe('handleListJobs', () => {
-    it('should list all jobs', async () => {
-      const jobService = new JobService(tempDir);
-      jobService.createJob({
-        type: 'index',
-        details: { storeId: 'store1' },
-        message: 'Indexing store1',
-      });
-      jobService.createJob({
-        type: 'clone',
-        details: { url: 'https://example.com' },
-        message: 'Cloning repo',
-      });
-
-      const args: ListJobsArgs = {};
-      const result = await handleListJobs(args, mockContext);
-
-      expect(result.content).toHaveLength(1);
-      const data = JSON.parse(result.content[0].text);
-      expect(data.jobs).toHaveLength(2);
-    });
-
-    it('should filter by status', async () => {
-      const jobService = new JobService(tempDir);
-      const job1 = jobService.createJob({
-        type: 'index',
-        details: { storeId: 'store1' },
-        message: 'Indexing',
-      });
-      jobService.createJob({
-        type: 'clone',
-        details: { url: 'https://example.com' },
-        message: 'Cloning',
-      });
-
-      // Update job1 status
-      jobService.updateJob(job1.id, { status: 'completed' });
-
-      const args: ListJobsArgs = { status: 'completed' };
-      const result = await handleListJobs(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.jobs).toHaveLength(1);
-      expect(data.jobs[0].status).toBe('completed');
-    });
-
-    it('should filter active jobs only', async () => {
-      const jobService = new JobService(tempDir);
-      const job1 = jobService.createJob({
-        type: 'index',
-        details: { storeId: 'store1' },
-        message: 'Indexing',
-      });
-      jobService.createJob({
-        type: 'clone',
-        details: { url: 'https://example.com' },
-        message: 'Cloning',
-      });
-
-      jobService.updateJob(job1.id, { status: 'completed' });
-
-      const args: ListJobsArgs = { activeOnly: true };
-      const result = await handleListJobs(args, mockContext);
-
-      const data = JSON.parse(result.content[0].text);
-      expect(data.jobs).toHaveLength(1);
-      expect(data.jobs[0].status).not.toBe('completed');
-    });
-  });
-
-  describe('handleCancelJob', () => {
-    it('should cancel a pending job', async () => {
-      const jobService = new JobService(tempDir);
-      const job = jobService.createJob({
-        type: 'index',
-        details: { storeId: 'test-store' },
-        message: 'Indexing...',
-      });
-
-      const args: CancelJobArgs = { jobId: job.id };
-      const result = await handleCancelJob(args, mockContext);
-
-      expect(result.content).toHaveLength(1);
-      const data = JSON.parse(result.content[0].text);
-      expect(data.success).toBe(true);
-      expect(data.job.status).toBe('cancelled');
-    });
-
-    it('should throw if job not found', async () => {
-      const args: CancelJobArgs = { jobId: 'nonexistent' };
-
-      try {
-        await handleCancelJob(args, mockContext);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Job nonexistent not found');
-      }
-    });
-
-    it('should throw if job already completed', async () => {
-      const jobService = new JobService(tempDir);
-      const job = jobService.createJob({
-        type: 'index',
-        details: { storeId: 'test-store' },
-        message: 'Indexing...',
-      });
-
-      jobService.updateJob(job.id, { status: 'completed' });
-
-      const args: CancelJobArgs = { jobId: job.id };
-
-      try {
-        await handleCancelJob(args, mockContext);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Cannot cancel completed job');
-      }
-    });
-  });
-});

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

@@ -1,118 +0,0 @@
-import { JobService } from '../../services/job.service.js';
-import {
-  CheckJobStatusArgsSchema,
-  ListJobsArgsSchema,
-  CancelJobArgsSchema,
-} from '../schemas/index.js';
-import type { CheckJobStatusArgs, ListJobsArgs, CancelJobArgs } from '../schemas/index.js';
-import type { ToolHandler, ToolResponse } from '../types.js';
-
-/**
- * Handle check_job_status requests
- *
- * Retrieves the current status of a background job.
- */
-export const handleCheckJobStatus: ToolHandler<CheckJobStatusArgs> = (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = CheckJobStatusArgsSchema.parse(args);
-
-  const { options } = context;
-
-  const jobService = new JobService(options.dataDir);
-  const job = jobService.getJob(validated.jobId);
-
-  if (!job) {
-    throw new Error(`Job not found: ${validated.jobId}`);
-  }
-
-  return Promise.resolve({
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(job, null, 2),
-      },
-    ],
-  });
-};
-
-/**
- * Handle list_jobs requests
- *
- * Lists all jobs with optional filtering by status or active status.
- * Automatically cleans up stale pending jobs (>2 hours old) before listing.
- */
-export const handleListJobs: ToolHandler<ListJobsArgs> = (args, context): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = ListJobsArgsSchema.parse(args);
-
-  const { options } = context;
-
-  const jobService = new JobService(options.dataDir);
-
-  // Auto-cleanup: mark stale pending jobs as failed (>2 hours with no progress)
-  // This handles jobs where the worker never started or crashed
-  jobService.cleanupStalePendingJobs(2, { markAsFailed: true });
-
-  let jobs;
-  if (validated.activeOnly === true) {
-    jobs = jobService.listActiveJobs();
-  } else if (validated.status !== undefined) {
-    jobs = jobService.listJobs(validated.status);
-  } else {
-    jobs = jobService.listJobs();
-  }
-
-  return Promise.resolve({
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify({ jobs }, null, 2),
-      },
-    ],
-  });
-};
-
-/**
- * Handle cancel_job requests
- *
- * Cancels a running or pending background job.
- * Kills the worker process if it exists.
- */
-export const handleCancelJob: ToolHandler<CancelJobArgs> = (
-  args,
-  context
-): Promise<ToolResponse> => {
-  // Validate arguments with Zod
-  const validated = CancelJobArgsSchema.parse(args);
-
-  const { options } = context;
-
-  const jobService = new JobService(options.dataDir);
-  const result = jobService.cancelJob(validated.jobId);
-
-  if (!result.success) {
-    throw new Error(result.error.message);
-  }
-
-  const job = jobService.getJob(validated.jobId);
-
-  return Promise.resolve({
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(
-          {
-            success: true,
-            job,
-            message: 'Job cancelled successfully',
-          },
-          null,
-          2
-        ),
-      },
-    ],
-  });
-};

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

@@ -1,324 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { handleSearch, handleGetFullContext, resultCache } from './search.handler.js';
-import type { HandlerContext } from '../types.js';
-import type { ServiceContainer } from '../../services/index.js';
-
-/**
- * Extract JSON from search response that includes a header line.
- * Format: "Search: ... | Results: ... | ~X tokens | Xms\n\n{json}"
- */
-function parseSearchResponse(text: string): { header: string; json: Record<string, unknown> } {
-  const parts = text.split('\n\n');
-  const header = parts[0] ?? '';
-  const jsonStr = parts.slice(1).join('\n\n');
-  return {
-    header,
-    json: JSON.parse(jsonStr || '{}'),
-  };
-}
-
-describe('Search Handlers', () => {
-  let mockContext: HandlerContext;
-  let mockServices: ServiceContainer;
-
-  beforeEach(() => {
-    // Clear result cache before each test
-    resultCache.clear();
-
-    // Create mock services
-    mockServices = {
-      store: {
-        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',
-        }),
-      },
-      lance: {
-        initialize: vi.fn().mockResolvedValue(undefined),
-      },
-      search: {
-        search: vi.fn().mockResolvedValue({
-          results: [
-            {
-              id: 'doc1',
-              score: 0.95,
-              content: 'test content for search',
-              metadata: { storeId: 'store1' },
-              summary: { file: 'test.ts', line: 1 },
-            },
-          ],
-          totalResults: 1,
-          mode: 'hybrid',
-          timeMs: 50,
-        }),
-      },
-    } as unknown as ServiceContainer;
-
-    mockContext = {
-      services: mockServices,
-      options: {},
-    };
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('handleSearch', () => {
-    it('should search across all stores when no stores specified', async () => {
-      const result = await handleSearch(
-        { query: 'test query', detail: 'minimal', limit: 10 },
-        mockContext
-      );
-
-      expect(mockServices.store.list).toHaveBeenCalled();
-      expect(mockServices.search.search).toHaveBeenCalledWith(
-        expect.objectContaining({
-          query: 'test query',
-          stores: ['store1'],
-        })
-      );
-
-      const { header, json: response } = parseSearchResponse(result.content[0]?.text ?? '');
-      expect(header).toContain('Search: "test query"');
-      expect(header).toContain('Results: 1');
-      expect(header).toContain('tokens');
-      expect(response.results).toHaveLength(1);
-      expect(response.totalResults).toBe(1);
-    });
-
-    it('should use specified stores', async () => {
-      await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10, stores: ['store1'] },
-        mockContext
-      );
-
-      expect(mockServices.store.getByIdOrName).toHaveBeenCalledWith('store1');
-    });
-
-    it('should throw if store not found', async () => {
-      vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(undefined);
-
-      await expect(
-        handleSearch(
-          { query: 'test', detail: 'minimal', limit: 10, stores: ['nonexistent'] },
-          mockContext
-        )
-      ).rejects.toThrow('Store not found');
-    });
-
-    it('should initialize all stores', async () => {
-      await handleSearch({ query: 'test', detail: 'minimal', limit: 10 }, mockContext);
-
-      expect(mockServices.lance.initialize).toHaveBeenCalledWith('store1');
-    });
-
-    it('should throw on store initialization error', async () => {
-      vi.mocked(mockServices.lance.initialize).mockRejectedValue(
-        new Error('Lance initialization failed')
-      );
-
-      await expect(
-        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);
-
-      // Verify cache was populated
-      const cached = resultCache.get('doc1');
-      expect(cached).toBeDefined();
-      expect(cached?.id).toBe('doc1');
-    });
-
-    it('should show token count in header', async () => {
-      const result = await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
-
-      const { header } = parseSearchResponse(result.content[0]?.text ?? '');
-      // Header should contain token count (either "~X tokens" or "~X.Xk tokens")
-      expect(header).toMatch(/~\d+\.?\d*k? tokens/);
-    });
-
-    it('should add repoRoot for repo stores', async () => {
-      vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue({
-        id: 'store1',
-        name: 'Test Repo',
-        type: 'repo',
-        path: '/repos/test',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        status: 'ready',
-        description: 'Test',
-      });
-
-      const result = await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
-
-      const { json: response } = parseSearchResponse(result.content[0]?.text ?? '');
-      expect(response.results[0]?.summary.repoRoot).toBe('/repos/test');
-    });
-
-    it('should not add repoRoot for file stores', async () => {
-      const result = await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
-
-      const { json: response } = parseSearchResponse(result.content[0]?.text ?? '');
-      expect(response.results[0]?.summary.repoRoot).toBeUndefined();
-    });
-
-    it('should include storeName in results', async () => {
-      const result = await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
-
-      const { json: response } = parseSearchResponse(result.content[0]?.text ?? '');
-      expect(response.results[0]?.summary.storeName).toBe('Test Store');
-    });
-
-    it('should include search metadata in response', async () => {
-      const result = await handleSearch(
-        { query: 'test', detail: 'minimal', limit: 10 },
-        mockContext
-      );
-
-      const { header, json: response } = parseSearchResponse(result.content[0]?.text ?? '');
-      expect(response).toHaveProperty('totalResults', 1);
-      expect(response).toHaveProperty('mode', 'hybrid');
-      expect(response).toHaveProperty('timeMs', 50);
-      // Token count is now in header, not in JSON
-      expect(header).toContain('tokens');
-    });
-  });
-
-  describe('handleGetFullContext', () => {
-    beforeEach(() => {
-      // Seed cache with a result
-      resultCache.set('doc1', {
-        id: 'doc1',
-        score: 0.95,
-        content: 'test content for get full context',
-        metadata: { storeId: 'store1', docId: 'doc1' },
-        summary: { file: 'test.ts', line: 1 },
-      });
-    });
-
-    it('should return cached result if already full', async () => {
-      // Set up cache with full result
-      resultCache.set('doc1', {
-        id: 'doc1',
-        score: 0.95,
-        content: 'test content',
-        metadata: { storeId: 'store1', docId: 'doc1' },
-        summary: { file: 'test.ts', line: 1 },
-        full: { code: 'full code here' },
-      });
-
-      const result = await handleGetFullContext({ resultId: 'doc1' }, mockContext);
-
-      const response = JSON.parse(result.content[0]?.text ?? '{}');
-      expect(response.id).toBe('doc1');
-      expect(response.full).toBeDefined();
-      expect(response.full.code).toBe('full code here');
-
-      // Should not create services or search again
-      expect(mockServices.store.getByIdOrName).not.toHaveBeenCalled();
-    });
-
-    it('should throw if result not in cache', async () => {
-      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 () => {
-      vi.mocked(mockServices.search.search).mockResolvedValue({
-        results: [
-          {
-            id: 'doc1',
-            score: 0.95,
-            content: 'test content',
-            metadata: { storeId: 'store1', docId: 'doc1' },
-            summary: { file: 'test.ts', line: 1 },
-            full: { code: 'full code from re-query' },
-          },
-        ],
-        totalResults: 1,
-        mode: 'hybrid',
-        timeMs: 50,
-      });
-
-      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,
-        })
-      );
-
-      const response = JSON.parse(result.content[0]?.text ?? '{}');
-      expect(response.full?.code).toBe('full code from re-query');
-    });
-
-    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'
-      );
-    });
-
-    it('should return cached result with warning if re-query fails', async () => {
-      vi.mocked(mockServices.search.search).mockResolvedValue({
-        results: [], // No matching result found
-        totalResults: 0,
-        mode: 'hybrid',
-        timeMs: 50,
-      });
-
-      const result = await handleGetFullContext({ resultId: 'doc1' }, mockContext);
-
-      const response = JSON.parse(result.content[0]?.text ?? '{}');
-      expect(response.id).toBe('doc1');
-      expect(response.warning).toContain('Could not retrieve full context');
-    });
-
-    it('should update cache with full result after re-query', async () => {
-      vi.mocked(mockServices.search.search).mockResolvedValue({
-        results: [
-          {
-            id: 'doc1',
-            score: 0.95,
-            content: 'test content',
-            metadata: { storeId: 'store1', docId: 'doc1' },
-            summary: { file: 'test.ts', line: 1 },
-            full: { code: 'full code from re-query' },
-          },
-        ],
-        totalResults: 1,
-        mode: 'hybrid',
-        timeMs: 50,
-      });
-
-      await handleGetFullContext({ resultId: 'doc1' }, mockContext);
-
-      const cached = resultCache.get('doc1');
-      expect(cached?.full).toBeDefined();
-      expect(cached?.full?.code).toBe('full code from re-query');
-    });
-  });
-});