brainbank 0.1.3 → 0.1.4

package/src/cli/index.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+
+/**
+ * BrainBank — CLI Entry Point
+ *
+ * Dispatcher that routes commands to their handler modules.
+ */
+
+import { args, c } from './utils.ts';
+import { cmdIndex } from './commands/index.ts';
+import { cmdCollection } from './commands/collection.ts';
+import { cmdKv } from './commands/kv.ts';
+import { cmdDocs, cmdDocSearch } from './commands/docs.ts';
+import { cmdSearch, cmdHybridSearch, cmdKeywordSearch } from './commands/search.ts';
+import { cmdContext } from './commands/context.ts';
+import { cmdQuery } from './commands/query.ts';
+import { cmdFiles } from './commands/files.ts';
+import { cmdStats } from './commands/stats.ts';
+import { cmdReembed } from './commands/reembed.ts';
+import { cmdReindex } from './commands/reindex.ts';
+import { cmdWatch } from './commands/watch.ts';
+import { cmdMcp } from './commands/mcp.ts';
+import { cmdMcpExport } from './commands/mcp-export.ts';
+import { cmdDaemon } from './commands/daemon.ts';
+import { cmdStatus } from './commands/status.ts';
+import { showHelp } from './commands/help.ts';
+import { VERSION } from '@/constants.ts';
+
+const command = args[0];
+
+async function main(): Promise<void> {
+    switch (command) {
+        case '--version':
+        case '-v':
+            console.log(`brainbank v${VERSION}`);
+            break;
+        case 'i':
+        case 'index':       return cmdIndex();
+        case 'collection':  return cmdCollection();
+        case 'kv':          return cmdKv();
+        case 'docs':        return cmdDocs();
+        case 'dsearch':     return cmdDocSearch();
+        case 'search':      return cmdSearch();
+        case 'hsearch':     return cmdHybridSearch();
+        case 'ksearch':     return cmdKeywordSearch();
+        case 'context':     return cmdContext();
+        case 'q':
+        case 'query':       return cmdQuery();
+        case 'files':       return cmdFiles();
+        case 'stats':       return cmdStats();
+        case 'reembed':     return cmdReembed();
+        case 'reindex':     return cmdReindex();
+        case 'watch':       return cmdWatch();
+        case 'mcp':         return cmdMcp();
+        case 'mcp:export':  return cmdMcpExport();
+        case 'serve':        return cmdMcp(); // backward compat
+        case 'daemon':      return cmdDaemon();
+        case 'status':      return cmdStatus();
+        case 'help':
+        case '--help':
+        case '-h':
+            showHelp();
+            break;
+        default:
+            if (command) console.log(c.red(`Unknown command: ${command}\n`));
+            showHelp();
+            process.exit(command ? 1 : 0);
+    }
+}
+
+main().catch(err => {
+    console.error(c.red(`Error: ${err.message}`));
+    if (process.env.BRAINBANK_DEBUG) console.error(err.stack);
+    process.exit(1);
+});

package/src/cli/server-client.ts

@@ -0,0 +1,186 @@
+/**
+ * ServerClient — Lightweight HTTP client for the BrainBank daemon.
+ *
+ * Used by CLI commands to delegate to a running HTTP server
+ * instead of loading models locally. Falls back gracefully
+ * (returns null) if the server is unreachable.
+ */
+
+import type { SearchResult } from '@/types.ts';
+
+import * as http from 'node:http';
+
+import { isServerRunning } from '@/services/daemon.ts';
+
+interface ContextOptions {
+    task: string;
+    repo?: string;
+    sources?: Record<string, number>;
+    pathPrefix?: string | string[];
+    ignorePaths?: string[];
+    affectedFiles?: string[];
+    fields?: Record<string, unknown>;
+    context?: string;
+    prunerContext?: string;
+}
+
+/**
+ * Try to get context from the running HTTP server.
+ * Returns the context string if successful, null if server is unreachable.
+ */
+export async function tryServerContext(options: ContextOptions): Promise<string | null> {
+    const info = isServerRunning();
+    if (!info) return null;
+
+    try {
+        const body = JSON.stringify({
+            task: options.task,
+            repo: options.repo,
+            sources: options.sources,
+            pathPrefix: options.pathPrefix,
+            ignorePaths: options.ignorePaths,
+            affectedFiles: options.affectedFiles,
+            fields: options.fields,
+            context: options.context,
+            prunerContext: options.prunerContext,
+        });
+
+        const response = await httpPost(info.port, '/context', body);
+        const data = JSON.parse(response) as { context?: string; error?: string };
+
+        if (data.error) return null;
+        return data.context ?? null;
+    } catch {
+        // Server unreachable or error — fall back to local
+        return null;
+    }
+}
+
+interface SearchDelegateOptions {
+    query: string;
+    repo?: string;
+    sources?: Record<string, number>;
+    pathPrefix?: string | string[];
+    maxResults?: number;
+}
+
+/**
+ * Try to delegate a search to the running HTTP server.
+ * Mode: 'search' (vector), 'hybrid' (hsearch), 'keyword' (ksearch).
+ * Returns SearchResult[] if successful, null if server is unreachable.
+ */
+export async function tryServerSearch(
+    mode: 'search' | 'hybrid' | 'keyword',
+    options: SearchDelegateOptions,
+): Promise<SearchResult[] | null> {
+    const info = isServerRunning();
+    if (!info) return null;
+
+    const endpoint = mode === 'search' ? '/search' : mode === 'hybrid' ? '/hsearch' : '/ksearch';
+
+    try {
+        const body = JSON.stringify({
+            query: options.query,
+            repo: options.repo,
+            sources: options.sources,
+            pathPrefix: options.pathPrefix,
+            maxResults: options.maxResults,
+        });
+
+        const response = await httpPost(info.port, endpoint, body);
+        const data = JSON.parse(response) as { results?: SearchResult[]; error?: string };
+
+        if (data.error) return null;
+        return data.results ?? null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Try to trigger indexing on the running HTTP server.
+ * Returns the result if successful, null if server is unreachable.
+ */
+export async function tryServerIndex(repo?: string, forceReindex?: boolean): Promise<Record<string, unknown> | null> {
+    const info = isServerRunning();
+    if (!info) return null;
+
+    try {
+        const body = JSON.stringify({ repo, forceReindex });
+        const response = await httpPost(info.port, '/index', body);
+        const data = JSON.parse(response) as { result?: Record<string, unknown>; error?: string };
+
+        if (data.error) return null;
+        return data.result ?? null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Check server health. Returns health info or null.
+ */
+export async function serverHealth(): Promise<{
+    ok: boolean;
+    pid: number;
+    port: number;
+    uptime: number;
+    workspaces: number;
+} | null> {
+    const info = isServerRunning();
+    if (!info) return null;
+
+    try {
+        const response = await httpGet(info.port, '/health');
+        return JSON.parse(response) as { ok: boolean; pid: number; port: number; uptime: number; workspaces: number };
+    } catch {
+        return null;
+    }
+}
+
+// ── HTTP helpers ────────────────────────────────────
+
+function httpPost(port: number, path: string, body: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const req = http.request({
+            hostname: '127.0.0.1',
+            port,
+            path,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+            timeout: 120_000, // 2 minutes — context queries can be slow on first load
+        }, (res) => {
+            const chunks: Buffer[] = [];
+            res.on('data', (chunk: Buffer) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        });
+
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+        req.write(body);
+        req.end();
+    });
+}
+
+function httpGet(port: number, path: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const req = http.request({
+            hostname: '127.0.0.1',
+            port,
+            path,
+            method: 'GET',
+            timeout: 5_000,
+        }, (res) => {
+            const chunks: Buffer[] = [];
+            res.on('data', (chunk: Buffer) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        });
+
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+        req.end();
+    });
+}