@bod.ee/db 0.7.0

package/src/server/FileAdapter.ts

@@ -0,0 +1,116 @@
+import { watch, type FSWatcher } from 'fs';
+import { readdir, stat, readFile, writeFile, mkdir } from 'fs/promises';
+import { join, relative, extname, dirname } from 'path';
+import type { BodDB } from './BodDB.ts';
+
+export class FileAdapterOptions {
+  /** Root directory to watch */
+  root: string = '.';
+  /** Base path in DB (e.g. 'files') */
+  basePath: string = 'files';
+  /** Watch for changes */
+  watch: boolean = true;
+  /** Index file content as string */
+  indexContent: boolean = false;
+  /** Store file metadata */
+  metadata: boolean = true;
+}
+
+const MIME_MAP: Record<string, string> = {
+  '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json',
+  '.js': 'application/javascript', '.ts': 'application/typescript',
+  '.html': 'text/html', '.css': 'text/css', '.csv': 'text/csv',
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.gif': 'image/gif',
+  '.svg': 'image/svg+xml', '.pdf': 'application/pdf',
+};
+
+export class FileAdapter {
+  readonly options: FileAdapterOptions;
+  private db: BodDB;
+  private watcher: FSWatcher | null = null;
+
+  constructor(db: BodDB, options?: Partial<FileAdapterOptions>) {
+    this.options = { ...new FileAdapterOptions(), ...options };
+    this.db = db;
+  }
+
+  async start(): Promise<void> {
+    await this.scan();
+    if (this.options.watch) {
+      this.watcher = watch(this.options.root, { recursive: true }, (_event, filename) => {
+        if (filename) this.syncFile(filename).catch(() => {});
+      });
+    }
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+  }
+
+  private async scan(): Promise<void> {
+    const files = await this.readDirRecursive(this.options.root);
+    for (const filePath of files) {
+      const relPath = relative(this.options.root, filePath);
+      await this.syncFile(relPath);
+    }
+  }
+
+  private async syncFile(relPath: string): Promise<void> {
+    const fullPath = join(this.options.root, relPath);
+    const dbPath = `${this.options.basePath}/${relPath.replace(/\\/g, '/')}`;
+
+    try {
+      const s = await stat(fullPath);
+      if (!s.isFile()) return;
+
+      const meta: Record<string, unknown> = {};
+      if (this.options.metadata) {
+        meta.size = s.size;
+        meta.mtime = s.mtimeMs;
+        meta.mime = MIME_MAP[extname(fullPath).toLowerCase()] ?? 'application/octet-stream';
+      }
+      if (this.options.indexContent) {
+        const content = await readFile(fullPath, 'utf-8');
+        meta._content = content;
+      }
+      this.db.set(dbPath, meta);
+    } catch {
+      // File was deleted
+      this.db.delete(dbPath);
+    }
+  }
+
+  /** Read file content through the adapter */
+  async readContent(relPath: string): Promise<string | null> {
+    const fullPath = join(this.options.root, relPath);
+    try {
+      return await readFile(fullPath, 'utf-8');
+    } catch {
+      return null;
+    }
+  }
+
+  /** Write file content through the adapter (write-through) */
+  async writeContent(relPath: string, content: string): Promise<void> {
+    const fullPath = join(this.options.root, relPath);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, 'utf-8');
+    // Sync will happen via watcher, or manually:
+    await this.syncFile(relPath);
+  }
+
+  private async readDirRecursive(dir: string): Promise<string[]> {
+    const results: string[] = [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await this.readDirRecursive(fullPath));
+      } else {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+}

package/src/server/MCPAdapter.ts

@@ -0,0 +1,409 @@
+import { BodClient } from '../client/BodClient.ts';
+
+export class MCPAdapterOptions {
+  serverName = 'bod-db';
+  serverVersion = '0.7.0';
+}
+
+interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: object;
+  handler: (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+interface JsonRpcRequest {
+  jsonrpc: string;
+  id?: string | number | null;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id?: string | number | null;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+export class MCPAdapter {
+  readonly options: MCPAdapterOptions;
+  private tools: MCPTool[] = [];
+
+  constructor(private client: BodClient, options?: Partial<MCPAdapterOptions>) {
+    this.options = { ...new MCPAdapterOptions(), ...options };
+    this.registerTools();
+  }
+
+  /** Normalize path: strip leading/trailing slashes, "/" becomes "" (root) */
+  private normPath(p: unknown): string {
+    if (typeof p !== 'string') return '';
+    return p.replace(/^\/+|\/+$/g, '');
+  }
+
+  private registerTools(): void {
+    const t = this.tools;
+    const c = this.client;
+
+    // --- Core CRUD ---
+    t.push({
+      name: 'db_get',
+      description: 'Get value at path. Use shallow:true to list immediate children only.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Database path' },
+          shallow: { type: 'boolean', description: 'Return shallow children list' },
+        },
+        required: ['path'],
+      },
+      handler: async (a) => { const p = this.normPath(a.path); return a.shallow ? c.getShallow(p) : c.get(p); },
+    });
+
+    t.push({
+      name: 'db_set',
+      description: 'Set value at path. Optionally set TTL in seconds.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          value: { description: 'Any JSON value' },
+          ttl: { type: 'number', description: 'Time-to-live in seconds' },
+        },
+        required: ['path', 'value'],
+      },
+      handler: async (a) => { await c.set(this.normPath(a.path), a.value, a.ttl ? { ttl: a.ttl as number } : undefined); return 'ok'; },
+    });
+
+    t.push({
+      name: 'db_update',
+      description: 'Multi-path update. Keys are paths, values are data to set.',
+      inputSchema: {
+        type: 'object',
+        properties: { updates: { type: 'object', description: 'Record<path, value>' } },
+        required: ['updates'],
+      },
+      handler: async (a) => {
+        const raw = a.updates as Record<string, unknown>;
+        const normalized: Record<string, unknown> = {};
+        for (const [k, v] of Object.entries(raw)) normalized[this.normPath(k)] = v;
+        await c.update(normalized);
+        return 'ok';
+      },
+    });
+
+    t.push({
+      name: 'db_delete',
+      description: 'Delete value at path (and all children).',
+      inputSchema: {
+        type: 'object',
+        properties: { path: { type: 'string' } },
+        required: ['path'],
+      },
+      handler: async (a) => { await c.delete(this.normPath(a.path)); return 'ok'; },
+    });
+
+    t.push({
+      name: 'db_push',
+      description: 'Push value with auto-generated time-sortable key. Returns the generated key.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          value: { description: 'Any JSON value' },
+          idempotencyKey: { type: 'string' },
+        },
+        required: ['path', 'value'],
+      },
+      handler: async (a) => c.push(this.normPath(a.path), a.value, a.idempotencyKey ? { idempotencyKey: a.idempotencyKey as string } : undefined),
+    });
+
+    t.push({
+      name: 'db_query',
+      description: 'Query children at path with optional filters, ordering, limit, offset.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          where: { type: 'array', items: { type: 'object', properties: { field: { type: 'string' }, op: { type: 'string' }, value: {} }, required: ['field', 'op', 'value'] } },
+          order: { type: 'object', properties: { field: { type: 'string' }, dir: { type: 'string', enum: ['asc', 'desc'] } }, required: ['field'] },
+          limit: { type: 'number' },
+          offset: { type: 'number' },
+        },
+        required: ['path'],
+      },
+      handler: async (a) => {
+        let q = c.query(this.normPath(a.path));
+        if (Array.isArray(a.where)) for (const f of a.where as any[]) q = q.where(f.field, f.op, f.value);
+        if (a.order) q = q.order((a.order as any).field, (a.order as any).dir);
+        if (a.limit != null) q = q.limit(a.limit as number);
+        if (a.offset != null) q = q.offset(a.offset as number);
+        return q.get();
+      },
+    });
+
+    // --- FTS ---
+    t.push({
+      name: 'db_search',
+      description: 'Full-text search. Returns [{path, data, rank}]. Requires FTS configured on server.',
+      inputSchema: {
+        type: 'object',
+        properties: { text: { type: 'string' }, path: { type: 'string' }, limit: { type: 'number' } },
+        required: ['text'],
+      },
+      handler: async (a) => c.search({ text: a.text as string, path: a.path ? this.normPath(a.path) : undefined, limit: a.limit as number }),
+    });
+
+    t.push({
+      name: 'db_index',
+      description: 'Index a path for full-text search. Pass content string or array of field names. Requires FTS configured on server.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          content: { type: 'string', description: 'Text content to index' },
+          fields: { type: 'array', items: { type: 'string' }, description: 'Field names to extract and index from the stored object' },
+        },
+        required: ['path'],
+      },
+      handler: async (a) => {
+        const p = this.normPath(a.path);
+        if (a.content) await c.index(p, a.content as string);
+        else if (a.fields) await c.index(p, a.fields as string[]);
+        else throw new Error('Provide content (string) or fields (string[])');
+        return 'ok';
+      },
+    });
+
+    // --- Vectors ---
+    t.push({
+      name: 'db_vector_search',
+      description: 'Vector similarity search. Returns [{path, data, score}]. Requires vectors configured on server.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'array', items: { type: 'number' }, description: 'Query embedding' },
+          path: { type: 'string' }, limit: { type: 'number' }, threshold: { type: 'number' },
+        },
+        required: ['query'],
+      },
+      handler: async (a) => c.vectorSearch({ query: a.query as number[], path: a.path ? this.normPath(a.path) : undefined, limit: a.limit as number, threshold: a.threshold as number }),
+    });
+
+    t.push({
+      name: 'db_vector_store',
+      description: 'Store a vector embedding at path. Requires vectors configured on server.',
+      inputSchema: {
+        type: 'object',
+        properties: { path: { type: 'string' }, embedding: { type: 'array', items: { type: 'number' } } },
+        required: ['path', 'embedding'],
+      },
+      handler: async (a) => { await c.vectorStore(this.normPath(a.path), a.embedding as number[]); return 'ok'; },
+    });
+
+    // --- Streams ---
+    t.push({
+      name: 'stream_read',
+      description: 'Read unacknowledged events from a stream topic for a consumer group.',
+      inputSchema: {
+        type: 'object',
+        properties: { topic: { type: 'string' }, groupId: { type: 'string' }, limit: { type: 'number' } },
+        required: ['topic', 'groupId'],
+      },
+      handler: async (a) => c._streamRead(this.normPath(a.topic), a.groupId as string, a.limit as number | undefined),
+    });
+
+    t.push({
+      name: 'stream_ack',
+      description: 'Acknowledge a stream event (advance consumer group offset).',
+      inputSchema: {
+        type: 'object',
+        properties: { topic: { type: 'string' }, groupId: { type: 'string' }, key: { type: 'string' } },
+        required: ['topic', 'groupId', 'key'],
+      },
+      handler: async (a) => { await c._streamAck(this.normPath(a.topic), a.groupId as string, a.key as string); return 'ok'; },
+    });
+
+    t.push({
+      name: 'stream_materialize',
+      description: 'Materialize a stream topic: merge snapshot + live events into a single view.',
+      inputSchema: {
+        type: 'object',
+        properties: { topic: { type: 'string' }, keepKey: { type: 'string' } },
+        required: ['topic'],
+      },
+      handler: async (a) => c.streamMaterialize(this.normPath(a.topic), a.keepKey ? { keepKey: a.keepKey as string } : undefined),
+    });
+
+    t.push({
+      name: 'stream_compact',
+      description: 'Compact a stream topic: fold events into snapshot, delete originals.',
+      inputSchema: {
+        type: 'object',
+        properties: { topic: { type: 'string' }, maxAge: { type: 'number' }, maxCount: { type: 'number' }, keepKey: { type: 'string' } },
+        required: ['topic'],
+      },
+      handler: async (a) => c.streamCompact(this.normPath(a.topic), { maxAge: a.maxAge as number, maxCount: a.maxCount as number, keepKey: a.keepKey as string }),
+    });
+
+    // --- MQ ---
+    t.push({
+      name: 'mq_push',
+      description: 'Push a message onto a queue. Returns the generated key.',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' }, value: { description: 'Any JSON value' } },
+        required: ['queue', 'value'],
+      },
+      handler: async (a) => c._mqSend('mq-push', { path: this.normPath(a.queue), value: a.value }),
+    });
+
+    t.push({
+      name: 'mq_fetch',
+      description: 'Fetch and claim messages from a queue (visibility timeout applies).',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' }, count: { type: 'number' } },
+        required: ['queue'],
+      },
+      handler: async (a) => c._mqSend('mq-fetch', { path: this.normPath(a.queue), count: a.count }),
+    });
+
+    t.push({
+      name: 'mq_ack',
+      description: 'Acknowledge (delete) a processed message.',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' }, key: { type: 'string' } },
+        required: ['queue', 'key'],
+      },
+      handler: async (a) => { await c._mqSend('mq-ack', { path: this.normPath(a.queue), key: a.key }); return 'ok'; },
+    });
+
+    t.push({
+      name: 'mq_nack',
+      description: 'Return a message to the queue (release visibility lock).',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' }, key: { type: 'string' } },
+        required: ['queue', 'key'],
+      },
+      handler: async (a) => { await c._mqSend('mq-nack', { path: this.normPath(a.queue), key: a.key }); return 'ok'; },
+    });
+
+    t.push({
+      name: 'mq_peek',
+      description: 'Peek at pending messages without claiming them.',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' }, count: { type: 'number' } },
+        required: ['queue'],
+      },
+      handler: async (a) => c._mqSend('mq-peek', { path: this.normPath(a.queue), count: a.count }),
+    });
+
+    t.push({
+      name: 'mq_dlq',
+      description: 'List dead-letter messages for a queue.',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' } },
+        required: ['queue'],
+      },
+      handler: async (a) => c._mqSend('mq-dlq', { path: this.normPath(a.queue) }),
+    });
+
+    t.push({
+      name: 'mq_purge',
+      description: 'Purge pending messages from a queue. Use all:true to also purge inflight + DLQ.',
+      inputSchema: {
+        type: 'object',
+        properties: { queue: { type: 'string' }, all: { type: 'boolean' } },
+        required: ['queue'],
+      },
+      handler: async (a) => c._mqSend('mq-purge', { path: this.normPath(a.queue), all: a.all }),
+    });
+  }
+
+  // --- JSON-RPC dispatch ---
+
+  async handle(req: JsonRpcRequest): Promise<JsonRpcResponse | null> {
+    const { method, id, params } = req;
+
+    if (method === 'notifications/initialized') return null;
+
+    if (method === 'initialize') {
+      return this.ok(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: this.options.serverName, version: this.options.serverVersion },
+      });
+    }
+
+    if (method === 'tools/list') {
+      return this.ok(id, {
+        tools: this.tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
+      });
+    }
+
+    if (method === 'tools/call') {
+      const name = (params as any)?.name as string;
+      const args = ((params as any)?.arguments ?? {}) as Record<string, unknown>;
+      const tool = this.tools.find(t => t.name === name);
+      if (!tool) return this.ok(id, { isError: true, content: [{ type: 'text', text: `Unknown tool: ${name}` }] });
+      try {
+        const result = await tool.handler(args);
+        const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+        return this.ok(id, { content: [{ type: 'text', text }] });
+      } catch (e: any) {
+        return this.ok(id, { isError: true, content: [{ type: 'text', text: e.message ?? String(e) }] });
+      }
+    }
+
+    return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown method: ${method}` } };
+  }
+
+  private ok(id: string | number | null | undefined, result: unknown): JsonRpcResponse {
+    return { jsonrpc: '2.0', id: id ?? null, result };
+  }
+
+  // --- Stdio transport ---
+
+  serveStdio(): void {
+    let buffer = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', async (chunk: string) => {
+      buffer += chunk;
+      const lines = buffer.split('\n');
+      buffer = lines.pop()!;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const req = JSON.parse(trimmed) as JsonRpcRequest;
+          const res = await this.handle(req);
+          if (res) process.stdout.write(JSON.stringify(res) + '\n');
+        } catch {
+          const err: JsonRpcResponse = { jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } };
+          process.stdout.write(JSON.stringify(err) + '\n');
+        }
+      }
+    });
+  }
+
+  // --- HTTP transport ---
+
+  httpHandler(): (req: Request) => Promise<Response> {
+    return async (req: Request): Promise<Response> => {
+      if (req.method !== 'POST') return new Response('POST only', { status: 405 });
+      try {
+        const body = await req.json() as JsonRpcRequest;
+        const res = await this.handle(body);
+        if (!res) return new Response(null, { status: 204 });
+        return Response.json(res);
+      } catch {
+        return Response.json({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }, { status: 400 });
+      }
+    };
+  }
+}