nano-brain 2026.8.5 → 2026.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-brain",
-  "version": "2026.8.5",
+  "version": "2026.8.7",
   "description": "Persistent memory and code intelligence for AI coding agents. Local MCP server with self-learning hybrid search (BM25 + vector + knowledge graph + LLM reranking), automatic session ingestion, codebase indexing, and 22 tools. Learns your preferences over time. Works with OpenCode, Claude, Cursor, Windsurf, and any MCP client.",
   "type": "module",
   "bin": {

package/src/cli/commands/status.ts

@@ -26,10 +26,25 @@ function formatBytes(bytes: number): string {
   return `${mb.toFixed(1)} MB`;
 }
 
-async function getVectorStoreHealth(config: ReturnType<typeof loadCollectionConfig>): Promise<VectorStoreHealth | null> {
+async function getVectorStoreHealth(
+  config: ReturnType<typeof loadCollectionConfig>,
+  serverRunning: boolean,
+  port: number
+): Promise<VectorStoreHealth | null> {
   const vectorConfig = config?.vector;
   if (!vectorConfig || vectorConfig.provider !== 'qdrant') return null;
 
+  // If server is running, proxy the request through it
+  if (serverRunning) {
+    try {
+      const health = await proxyGet(port, '/api/vector-health');
+      return health as VectorStoreHealth;
+    } catch (err) {
+      log('cli', 'Vector health proxy failed: ' + (err instanceof Error ? err.message : String(err)));
+      // Fall through to direct check
+    }
+  }
+
   try {
     const vectorStore = createVectorStore(vectorConfig);
     const health = await Promise.race([
@@ -110,11 +125,18 @@ async function printEmbeddingServerStatus(config: ReturnType<typeof loadCollecti
 export async function handleStatus(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
   log('cli', 'status command invoked');
   const serverRunning = await detectRunningServer(DEFAULT_HTTP_PORT);
-  let serverInfo: { uptime: number; ready: boolean } | null = null;
+  let serverInfo: { uptime: number; ready: boolean; index?: { documentCount: number; embeddedCount: number; pendingEmbeddings: number } } | null = null;
   if (serverRunning) {
     try {
-      const data = await proxyGet(DEFAULT_HTTP_PORT, '/api/status') as { uptime?: number; ready?: boolean };
+      const data = await proxyGet(DEFAULT_HTTP_PORT, '/api/status') as { uptime?: number; ready?: boolean; index?: any };
       serverInfo = { uptime: data.uptime ?? 0, ready: data.ready ?? false };
+      if (data.index) {
+        serverInfo.index = {
+          documentCount: data.index.documentCount ?? 0,
+          embeddedCount: data.index.embeddedCount ?? 0,
+          pendingEmbeddings: data.index.pendingEmbeddings ?? 0
+        };
+      }
     } catch (err) {
       log('cli', 'HTTP proxy failed for server info: ' + (err instanceof Error ? err.message : String(err)));
     }
@@ -207,7 +229,7 @@ export async function handleStatus(globalOpts: GlobalOptions, commandArgs: strin
     await printEmbeddingServerStatus(config);
     cliOutput('');
 
-    const vectorHealth = await getVectorStoreHealth(config);
+    const vectorHealth = await getVectorStoreHealth(config, serverRunning, DEFAULT_HTTP_PORT);
     printVectorStoreSection(vectorHealth);
 
     const allTokenUsage = new Map<string, { totalTokens: number; requestCount: number; lastUpdated: string }>();
@@ -272,9 +294,10 @@ export async function handleStatus(globalOpts: GlobalOptions, commandArgs: strin
   cliOutput('');
 
   cliOutput('Index:');
-  cliOutput(`  Documents:          ${health.documentCount.toLocaleString()}`);
-  cliOutput(`  Embedded:           ${health.embeddedCount.toLocaleString()}`);
-  cliOutput(`  Pending embeddings: ${health.pendingEmbeddings.toLocaleString()}`);
+  const indexData = serverInfo?.index ?? health;
+  cliOutput(`  Documents:          ${indexData.documentCount.toLocaleString()}`);
+  cliOutput(`  Embedded:           ${indexData.embeddedCount.toLocaleString()}`);
+  cliOutput(`  Pending embeddings: ${indexData.pendingEmbeddings.toLocaleString()}`);
   cliOutput('');
 
   if (health.collections.length > 0) {
@@ -319,7 +342,7 @@ export async function handleStatus(globalOpts: GlobalOptions, commandArgs: strin
   await printEmbeddingServerStatus(config);
   cliOutput('');
 
-  const vectorHealth = await getVectorStoreHealth(config);
+  const vectorHealth = await getVectorStoreHealth(config, serverRunning, DEFAULT_HTTP_PORT);
   printVectorStoreSection(vectorHealth, vectorHealth ? undefined : store.getSqliteVecCount());
 
   printTokenUsageSection(store.getTokenUsage());

package/src/http/routes.ts

@@ -140,6 +140,27 @@ export async function handleRequest(
     return;
   }
 
+  if (req.method === 'GET' && pathname === '/api/vector-health') {
+    const vectorStore = store.getVectorStore();
+    if (!vectorStore) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ provider: 'sqlite-vec', ok: true, vectorCount: store.getSqliteVecCount() }));
+      return;
+    }
+    try {
+      const health = await Promise.race([
+        vectorStore.health(),
+        new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000))
+      ]);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(health));
+    } catch (err) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, provider: 'qdrant', vectorCount: 0, error: err instanceof Error ? err.message : String(err) }));
+    }
+    return;
+  }
+
   if (req.method === 'POST' && pathname === '/api/query') {
     const body = await readBody(req);
     try {

package/src/providers/reranker.ts

@@ -9,11 +9,14 @@ export interface Reranker {
 export interface RerankerOptions {
   apiKey?: string;
   model?: string;
+  provider?: 'voyageai' | 'cohere';
   onTokenUsage?: (model: string, tokens: number) => void;
 }
 
 const VOYAGE_RERANK_URL = 'https://api.voyageai.com/v1/rerank';
+const COHERE_RERANK_URL = 'https://api.cohere.com/v2/rerank';
 const DEFAULT_MODEL = 'rerank-2.5-lite';
+const DEFAULT_COHERE_MODEL = 'rerank-v3.5';
 
 class VoyageAIReranker implements Reranker {
   private apiKey: string;
@@ -89,6 +92,79 @@ class VoyageAIReranker implements Reranker {
   dispose(): void {}
 }
 
+class CohereReranker implements Reranker {
+  private apiKey: string;
+  private model: string;
+  private onTokenUsage?: (model: string, tokens: number) => void;
+
+  constructor(apiKey: string, model: string, onTokenUsage?: (model: string, tokens: number) => void) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.onTokenUsage = onTokenUsage;
+  }
+
+  async rerank(query: string, documents: RerankDocument[]): Promise<RerankResult> {
+    if (documents.length === 0) {
+      return { results: [], model: this.model };
+    }
+
+    try {
+      const response = await fetch(COHERE_RERANK_URL, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          query,
+          documents: documents.map(d => d.text),
+          model: this.model,
+          top_n: documents.length,
+        }),
+        signal: AbortSignal.timeout(30000),
+      });
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        log('reranker', `Cohere rerank failed: HTTP ${response.status} ${body}`, 'warn');
+        return { results: [], model: this.model };
+      }
+
+      const data = await response.json() as {
+        results: Array<{ index: number; relevance_score: number }>;
+        meta?: { billed_units?: { search_units?: number } };
+      };
+
+      if (this.onTokenUsage && data.meta?.billed_units?.search_units) {
+        this.onTokenUsage(this.model, data.meta.billed_units.search_units);
+      }
+
+      if (!data.results || !Array.isArray(data.results)) {
+        log('reranker', `Cohere rerank returned unexpected response: ${JSON.stringify(data).slice(0, 200)}`, 'warn');
+        return { results: [], model: this.model };
+      }
+
+      const results = data.results
+        .filter(r => r.index >= 0 && r.index < documents.length)
+        .map(r => ({
+          file: documents[r.index].file,
+          score: r.relevance_score,
+          index: r.index,
+        }));
+
+      log('reranker', `Cohere rerank model=${this.model} docs=${documents.length} units=${data.meta?.billed_units?.search_units ?? 1}`, 'debug');
+
+      return { results, model: this.model };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log('reranker', `Cohere rerank error: ${msg}`, 'warn');
+      return { results: [], model: this.model };
+    }
+  }
+
+  dispose(): void {}
+}
+
 export async function createReranker(
   options?: RerankerOptions
 ): Promise<Reranker | null> {
@@ -98,6 +174,14 @@ export async function createReranker(
     return null;
   }
 
+  const provider = options?.provider || 'voyageai';
+
+  if (provider === 'cohere') {
+    const model = options?.model || DEFAULT_COHERE_MODEL;
+    log('reranker', `Cohere reranker initialized model=${model}`);
+    return new CohereReranker(apiKey, model, options?.onTokenUsage);
+  }
+
   const model = options?.model || DEFAULT_MODEL;
   log('reranker', `VoyageAI reranker initialized model=${model}`);
   return new VoyageAIReranker(apiKey, model, options?.onTokenUsage);

package/src/server/bootstrap.ts

@@ -362,6 +362,7 @@ export async function startServer(options: ServerOptions): Promise<void> {
     createReranker({
       apiKey: config?.reranker?.apiKey || config?.embedding?.apiKey,
       model: config?.reranker?.model,
+      provider: config?.reranker?.provider as 'voyageai' | 'cohere' | undefined,
       onTokenUsage: (model, tokens) => store.recordTokenUsage(model, tokens),
     })
       .then((loadedReranker) => {

package/src/types.ts

@@ -139,6 +139,7 @@ export interface EmbeddingConfig {
 export interface RerankerConfig {
   model?: string
   apiKey?: string
+  provider?: 'voyageai' | 'cohere'
 }
 
 export interface WatcherConfig {