bluera-knowledge 0.9.21

package/src/server/app.ts

@@ -0,0 +1,119 @@
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { z } from 'zod';
+import type { ServiceContainer } from '../services/index.js';
+import type { SearchQuery } from '../types/search.js';
+import { createStoreId } from '../types/brands.js';
+
+// HTTP API validation schemas (consistent with MCP schemas)
+const CreateStoreBodySchema = z.object({
+  name: z.string().min(1, 'Store name must be a non-empty string'),
+  type: z.enum(['file', 'repo', 'web']),
+  path: z.string().min(1).optional(),
+  url: z.string().min(1).optional(),
+  description: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  branch: z.string().optional(),
+  depth: z.number().int().positive().optional(),
+}).refine(
+  (data) => {
+    switch (data.type) {
+      case 'file': return data.path !== undefined;
+      case 'web': return data.url !== undefined;
+      case 'repo': return data.path !== undefined || data.url !== undefined;
+    }
+  },
+  { message: 'Missing required field: file stores need path, web stores need url, repo stores need path or url' }
+);
+
+const SearchBodySchema = z.object({
+  query: z.string().min(1, 'Query must be a non-empty string'),
+  detail: z.enum(['minimal', 'contextual', 'full']).optional(),
+  limit: z.number().int().positive().optional(),
+  stores: z.array(z.string()).optional(),
+});
+
+export function createApp(services: ServiceContainer): Hono {
+  const app = new Hono();
+
+  app.use('*', cors());
+
+  // Health check
+  app.get('/health', (c) => c.json({ status: 'ok' }));
+
+  // Stores
+  app.get('/api/stores', async (c) => {
+    const stores = await services.store.list();
+    return c.json(stores);
+  });
+
+  app.post('/api/stores', async (c) => {
+    const jsonData: unknown = await c.req.json();
+    const parseResult = CreateStoreBodySchema.safeParse(jsonData);
+    if (!parseResult.success) {
+      return c.json({ error: parseResult.error.issues[0]?.message ?? 'Invalid request body' }, 400);
+    }
+    const result = await services.store.create(parseResult.data);
+    if (result.success) {
+      return c.json(result.data, 201);
+    }
+    return c.json({ error: result.error.message }, 400);
+  });
+
+  app.get('/api/stores/:id', async (c) => {
+    const store = await services.store.getByIdOrName(c.req.param('id'));
+    if (!store) return c.json({ error: 'Not found' }, 404);
+    return c.json(store);
+  });
+
+  app.delete('/api/stores/:id', async (c) => {
+    const store = await services.store.getByIdOrName(c.req.param('id'));
+    if (!store) return c.json({ error: 'Not found' }, 404);
+    const result = await services.store.delete(store.id);
+    if (result.success) return c.json({ deleted: true });
+    return c.json({ error: result.error.message }, 400);
+  });
+
+  // Search
+  app.post('/api/search', async (c) => {
+    const jsonData: unknown = await c.req.json();
+    const parseResult = SearchBodySchema.safeParse(jsonData);
+    if (!parseResult.success) {
+      return c.json({ error: parseResult.error.issues[0]?.message ?? 'Invalid request body' }, 400);
+    }
+
+    const storeIds = (await services.store.list()).map(s => s.id);
+
+    for (const id of storeIds) {
+      await services.lance.initialize(id);
+    }
+
+    // Convert user-provided store strings to StoreIds, or use all stores
+    const requestedStores = parseResult.data.stores !== undefined
+      ? parseResult.data.stores.map(s => createStoreId(s))
+      : storeIds;
+
+    const query: SearchQuery = {
+      query: parseResult.data.query,
+      detail: parseResult.data.detail ?? 'minimal',
+      limit: parseResult.data.limit ?? 10,
+      stores: requestedStores,
+    };
+    const results = await services.search.search(query);
+    return c.json(results);
+  });
+
+  // Index
+  app.post('/api/stores/:id/index', async (c) => {
+    const store = await services.store.getByIdOrName(c.req.param('id'));
+    if (!store) return c.json({ error: 'Not found' }, 404);
+
+    await services.lance.initialize(store.id);
+    const result = await services.index.indexStore(store);
+
+    if (result.success) return c.json(result.data);
+    return c.json({ error: result.error.message }, 400);
+  });
+
+  return app;
+}

package/src/server/index.test.ts

@@ -0,0 +1,477 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createApp } from './index.js';
+import type { ServiceContainer } from '../services/index.js';
+import { createStoreId } from '../types/brands.js';
+import type { Store } from '../types/store.js';
+
+describe('Server Integration - Full App Creation', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        list: vi.fn(),
+        getByIdOrName: vi.fn(),
+        create: vi.fn(),
+        delete: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      search: {
+        search: vi.fn()
+      },
+      index: {
+        indexStore: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('creates app with all routes configured', async () => {
+    const app = createApp(mockServices);
+
+    expect(app).toBeDefined();
+    expect(typeof app.request).toBe('function');
+  });
+
+  it('handles health check endpoint', async () => {
+    const app = createApp(mockServices);
+
+    const res = await app.request('/health');
+
+    expect(res.status).toBe(200);
+    const json = await res.json();
+    expect(json).toEqual({ status: 'ok' });
+  });
+
+  it('handles 404 for unknown routes', async () => {
+    const app = createApp(mockServices);
+
+    const res = await app.request('/unknown-route');
+
+    expect(res.status).toBe(404);
+  });
+});
+
+describe('Server Integration - Store CRUD Flow', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        list: vi.fn(),
+        getByIdOrName: vi.fn(),
+        create: vi.fn(),
+        delete: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      search: {
+        search: vi.fn()
+      },
+      index: {
+        indexStore: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('completes full CRUD workflow', async () => {
+    const app = createApp(mockServices);
+
+    // 1. List stores (empty)
+    vi.mocked(mockServices.store.list).mockResolvedValue([]);
+
+    let res = await app.request('/api/stores');
+    let json = await res.json();
+    expect(json).toEqual([]);
+
+    // 2. Create store
+    const newStore: Store = {
+      id: createStoreId('new-store'),
+      name: 'test-store',
+      type: 'file',
+      path: '/tmp/test',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+
+    vi.mocked(mockServices.store.create).mockResolvedValue({
+      success: true,
+      data: newStore
+    });
+
+    res = await app.request('/api/stores', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        name: 'test-store',
+        type: 'file',
+        path: '/tmp/test'
+      })
+    });
+
+    expect(res.status).toBe(201);
+
+    // 3. Get store by ID
+    vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(newStore);
+
+    res = await app.request('/api/stores/new-store');
+    json = await res.json();
+    expect(json).toMatchObject({ id: 'new-store', name: 'test-store' });
+
+    // 4. Delete store
+    vi.mocked(mockServices.store.delete).mockResolvedValue({
+      success: true,
+      data: undefined
+    });
+
+    res = await app.request('/api/stores/new-store', {
+      method: 'DELETE'
+    });
+
+    expect(res.status).toBe(200);
+  });
+});
+
+describe('Server Integration - Search Flow', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        list: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      search: {
+        search: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('performs search across multiple stores', async () => {
+    const app = createApp(mockServices);
+
+    const stores: Store[] = [
+      {
+        id: createStoreId('store-1'),
+        name: 'store1',
+        type: 'file',
+        path: '/tmp/1',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      },
+      {
+        id: createStoreId('store-2'),
+        name: 'store2',
+        type: 'file',
+        path: '/tmp/2',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      }
+    ];
+
+    vi.mocked(mockServices.store.list).mockResolvedValue(stores);
+    vi.mocked(mockServices.search.search).mockResolvedValue({
+      results: [
+        { score: 0.9, summary: { location: 'file1.ts', purpose: 'Test' } }
+      ],
+      totalResults: 1
+    });
+
+    const res = await app.request('/api/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: 'test query' })
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockServices.lance.initialize).toHaveBeenCalledWith(createStoreId('store-1'));
+    expect(mockServices.lance.initialize).toHaveBeenCalledWith(createStoreId('store-2'));
+  });
+});
+
+describe('Server Integration - Index Flow', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        getByIdOrName: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      index: {
+        indexStore: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('indexes store after creation', async () => {
+    const app = createApp(mockServices);
+
+    const store: Store = {
+      id: createStoreId('store-1'),
+      name: 'test-store',
+      type: 'file',
+      path: '/tmp/test',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+
+    vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(store);
+    vi.mocked(mockServices.index.indexStore).mockResolvedValue({
+      success: true,
+      data: {
+        documentsIndexed: 5,
+        chunksCreated: 25,
+        timeMs: 500
+      }
+    });
+
+    const res = await app.request('/api/stores/store-1/index', {
+      method: 'POST'
+    });
+
+    expect(res.status).toBe(200);
+    expect(mockServices.lance.initialize).toHaveBeenCalledWith(createStoreId('store-1'));
+    expect(mockServices.index.indexStore).toHaveBeenCalledWith(store);
+  });
+});
+
+describe('Server Integration - Error Handling', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        create: vi.fn(),
+        getByIdOrName: vi.fn(),
+        delete: vi.fn()
+      },
+      index: {
+        indexStore: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('handles service errors gracefully', async () => {
+    const app = createApp(mockServices);
+
+    vi.mocked(mockServices.store.create).mockResolvedValue({
+      success: false,
+      error: new Error('Service error')
+    });
+
+    const res = await app.request('/api/stores', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        name: 'test',
+        type: 'file',
+        path: '/tmp/test'
+      })
+    });
+
+    expect(res.status).toBe(400);
+    const json = await res.json();
+    expect(json).toHaveProperty('error');
+  });
+
+  it('returns proper error codes for not found resources', async () => {
+    const app = createApp(mockServices);
+
+    vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(undefined);
+
+    const res = await app.request('/api/stores/nonexistent');
+
+    expect(res.status).toBe(404);
+  });
+});
+
+describe('Server Integration - Content Negotiation', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        list: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      search: {
+        search: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('returns JSON by default', async () => {
+    const app = createApp(mockServices);
+
+    vi.mocked(mockServices.store.list).mockResolvedValue([]);
+
+    const res = await app.request('/api/stores');
+
+    expect(res.headers.get('content-type')).toContain('application/json');
+  });
+
+  it('handles JSON POST bodies', async () => {
+    const app = createApp(mockServices);
+
+    vi.mocked(mockServices.store.list).mockResolvedValue([]);
+    vi.mocked(mockServices.search.search).mockResolvedValue({
+      results: [],
+      totalResults: 0
+    });
+
+    const res = await app.request('/api/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: 'test' })
+    });
+
+    expect(res.status).toBe(200);
+  });
+});
+
+describe('Server Integration - Route Parameters', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        getByIdOrName: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      index: {
+        indexStore: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('extracts store ID from URL', async () => {
+    const app = createApp(mockServices);
+
+    const store: Store = {
+      id: createStoreId('my-special-id'),
+      name: 'test',
+      type: 'file',
+      path: '/tmp/test',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+
+    vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(store);
+
+    await app.request('/api/stores/my-special-id');
+
+    expect(mockServices.store.getByIdOrName).toHaveBeenCalledWith('my-special-id');
+  });
+
+  it('handles URL-encoded store names', async () => {
+    const app = createApp(mockServices);
+
+    const store: Store = {
+      id: createStoreId('store-1'),
+      name: 'my store',
+      type: 'file',
+      path: '/tmp/test',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+
+    vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(store);
+
+    await app.request('/api/stores/my%20store');
+
+    expect(mockServices.store.getByIdOrName).toHaveBeenCalledWith('my store');
+  });
+});
+
+describe('Server Integration - HTTP Methods', () => {
+  let mockServices: ServiceContainer;
+
+  beforeEach(() => {
+    mockServices = {
+      store: {
+        list: vi.fn(),
+        getByIdOrName: vi.fn(),
+        create: vi.fn(),
+        delete: vi.fn()
+      },
+      lance: {
+        initialize: vi.fn()
+      },
+      search: {
+        search: vi.fn()
+      },
+      index: {
+        indexStore: vi.fn()
+      }
+    } as unknown as ServiceContainer;
+  });
+
+  it('supports GET requests', async () => {
+    const app = createApp(mockServices);
+
+    vi.mocked(mockServices.store.list).mockResolvedValue([]);
+
+    const res = await app.request('/api/stores', {
+      method: 'GET'
+    });
+
+    expect(res.status).toBe(200);
+  });
+
+  it('supports POST requests', async () => {
+    const app = createApp(mockServices);
+
+    vi.mocked(mockServices.store.list).mockResolvedValue([]);
+    vi.mocked(mockServices.search.search).mockResolvedValue({
+      results: [],
+      totalResults: 0
+    });
+
+    const res = await app.request('/api/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: 'test' })
+    });
+
+    expect(res.status).toBe(200);
+  });
+
+  it('supports DELETE requests', async () => {
+    const app = createApp(mockServices);
+
+    const store: Store = {
+      id: createStoreId('store-1'),
+      name: 'test',
+      type: 'file',
+      path: '/tmp/test',
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+
+    vi.mocked(mockServices.store.getByIdOrName).mockResolvedValue(store);
+    vi.mocked(mockServices.store.delete).mockResolvedValue({
+      success: true,
+      data: undefined
+    });
+
+    const res = await app.request('/api/stores/store-1', {
+      method: 'DELETE'
+    });
+
+    expect(res.status).toBe(200);
+  });
+});

package/src/server/index.ts

@@ -0,0 +1 @@
+export { createApp } from './app.js';