nano-brain 2026.3.1 → 2026.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-brain",
-  "version": "2026.3.1",
+  "version": "2026.3.3",
   "type": "module",
   "bin": {
     "nano-brain": "./bin/cli.js"

package/src/index.ts

@@ -1,10 +1,10 @@
 import { startServer } from './server.js';
 import { createStore, computeHash, indexDocument, extractProjectHashFromPath } from './store.js';
-import { loadCollectionConfig, addCollection, removeCollection, renameCollection, listCollections, getCollections, scanCollectionFiles, saveCollectionConfig } from './collections.js';
+import { loadCollectionConfig, addCollection, removeCollection, renameCollection, listCollections, getCollections, scanCollectionFiles, saveCollectionConfig, getWorkspaceConfig } from './collections.js';
 import { harvestSessions } from './harvester.js';
 import { createEmbeddingProvider, detectOllamaUrl, checkOllamaHealth, checkOpenAIHealth } from './embeddings.js';
 import { hybridSearch, parseSearchConfig } from './search.js';
-import { indexCodebase, embedPendingCodebase } from './codebase.js';
+import { indexCodebase, embedPendingCodebase, getCodebaseStats } from './codebase.js';
 import { findCycles } from './graph.js';
 import { handleBench } from './bench.js';
 import { resolveHostUrl } from './host.js';
@@ -12,6 +12,7 @@ import { QdrantVecStore } from './providers/qdrant.js';
 import { createVectorStore } from './vector-store.js';
 import type { SearchResult } from './types.js';
 import type { VectorPoint } from './vector-store.js';
+import Database from 'better-sqlite3';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -102,6 +103,7 @@ nano-brain - Memory system with hybrid search
     --daemon        Run as background daemon
     stop            Stop running daemon
   status            Show index health, embedding server status, and stats
+    --all           Show status for all workspaces
   collection        Manage collections
     add <name> <path> [--pattern=<glob>]
     remove <name>
@@ -164,6 +166,7 @@ nano-brain - Memory system with hybrid search
       --batch-size=<n>    Vectors per batch (default: 500)
       --dry-run           Show counts without migrating
       --activate          Switch to Qdrant provider after migration
+    verify          Compare SQLite vector counts against Qdrant
     activate        Switch config to use Qdrant as vector provider
     cleanup         Drop SQLite vector tables (requires Qdrant active with vectors)
 Logging Config (~/.nano-brain/config.yml):
@@ -328,69 +331,181 @@ async function handleCollection(globalOpts: GlobalOptions, commandArgs: string[]
   }
 }
 
-async function handleStatus(globalOpts: GlobalOptions): Promise<void> {
-  log('cli', 'status command invoked');
-  const store = createStore(globalOpts.dbPath);
-  const config = loadCollectionConfig(globalOpts.configPath);
-  const health = store.getIndexHealth();
-  console.log('nano-brain Status');
-  console.log('═══════════════════════════════════════════════════');
-  console.log('');
-  console.log('Index:');
-  console.log(`  Documents:          ${health.documentCount}`);
-  console.log(`  Embedded:           ${health.embeddedCount}`);
-  console.log(`  Pending embeddings: ${health.pendingEmbeddings}`);
-  console.log(`  Database size:      ${(health.databaseSize / 1024 / 1024).toFixed(2)} MB`);
-  console.log('');
-  
-  if (health.collections.length > 0) {
-    console.log('Collections:');
-    for (const coll of health.collections) {
-      console.log(`  ${coll.name}: ${coll.documentCount} documents`);
-    }
-    console.log('');
+function extractWorkspaceName(dbFilename: string): string {
+  const base = path.basename(dbFilename, '.sqlite');
+  const parts = base.split('-');
+  if (parts.length > 1 && parts[parts.length - 1].length === 12) {
+    return parts.slice(0, -1).join('-');
   }
-  
+  return base;
+}
+
+function formatBytes(bytes: number): string {
+  const mb = bytes / 1024 / 1024;
+  return `${mb.toFixed(1)} MB`;
+}
+
+async function printEmbeddingServerStatus(config: ReturnType<typeof loadCollectionConfig>): Promise<void> {
   const embeddingConfig = config?.embedding;
-  const ollamaUrl = embeddingConfig?.url || detectOllamaUrl();
-  const ollamaModel = embeddingConfig?.model || 'nomic-embed-text';
+  const url = embeddingConfig?.url || detectOllamaUrl();
+  const model = embeddingConfig?.model || 'nomic-embed-text';
   const provider = embeddingConfig?.provider || 'ollama';
-  
+
   console.log('Embedding Server:');
   console.log(`  Provider:  ${provider}`);
-  console.log(`  URL:       ${ollamaUrl}`);
-  console.log(`  Model:     ${ollamaModel}`);
-  
+  console.log(`  URL:       ${url}`);
+  console.log(`  Model:     ${model}`);
+
   if (provider === 'openai') {
-    const openAiHealth = await checkOpenAIHealth(ollamaUrl, embeddingConfig?.apiKey || '', ollamaModel);
+    const openAiHealth = await checkOpenAIHealth(url, embeddingConfig?.apiKey || '', model);
     if (openAiHealth.reachable) {
       console.log(`  Status:    ✅ connected`);
-      console.log(`  Model:     ✅ ${openAiHealth.model}`);
     } else {
       console.log(`  Status:    ❌ unreachable (${openAiHealth.error})`);
     }
   } else if (provider !== 'local') {
-    const ollamaHealth = await checkOllamaHealth(ollamaUrl);
+    const ollamaHealth = await checkOllamaHealth(url);
     if (ollamaHealth.reachable) {
-      const hasModel = ollamaHealth.models?.some(m => m.startsWith(ollamaModel));
       console.log(`  Status:    ✅ connected`);
-      console.log(`  Model:     ${hasModel ? '✅ available' : '❌ not found — run: ollama pull ' + ollamaModel}`);
-      if (ollamaHealth.models && ollamaHealth.models.length > 0) {
-        console.log(`  Available: ${ollamaHealth.models.join(', ')}`);
-      }
     } else {
       console.log(`  Status:    ❌ unreachable (${ollamaHealth.error})`);
-      console.log(`  Fallback:  local GGUF (node-llama-cpp)`);
     }
   } else {
     console.log(`  Status:    local GGUF mode`);
   }
+}
+
+async function handleStatus(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
+  log('cli', 'status command invoked');
+  const showAll = commandArgs.includes('--all');
+  const config = loadCollectionConfig(globalOpts.configPath);
+  const dataDir = path.dirname(globalOpts.dbPath);
+
+  if (showAll) {
+    let dbFiles: string[] = [];
+    try {
+      const files = fs.readdirSync(dataDir);
+      dbFiles = files.filter(f => f.endsWith('.sqlite')).map(f => path.join(dataDir, f));
+    } catch {
+      console.error(`Cannot read data directory: ${dataDir}`);
+      return;
+    }
+
+    if (dbFiles.length === 0) {
+      console.log('No workspaces found.');
+      return;
+    }
+
+    console.log('nano-brain Status — All Workspaces');
+    console.log('═══════════════════════════════════════════════════');
+    console.log('');
+
+    const header = '  Workspace              Documents  Embedded  Pending  DB Size';
+    const divider = '  ─────────────────────  ─────────  ────────  ───────  ───────';
+    console.log(header);
+    console.log(divider);
+
+    let totalDocs = 0;
+    let totalEmbedded = 0;
+    let totalPending = 0;
+    let totalSize = 0;
+
+    for (const dbFile of dbFiles) {
+      const workspaceName = extractWorkspaceName(dbFile);
+      let fileSize = 0;
+      try {
+        fileSize = fs.statSync(dbFile).size;
+      } catch { /* ignore */ }
+
+      let docs = 0;
+      let embedded = 0;
+      let pending = 0;
+      try {
+        const readDb = new Database(dbFile, { readonly: true });
+        try {
+          docs = (readDb.prepare('SELECT COUNT(*) as count FROM documents WHERE active = 1').get() as { count: number }).count;
+          embedded = (readDb.prepare('SELECT COUNT(*) as count FROM content_vectors').get() as { count: number }).count;
+          pending = docs - embedded;
+          if (pending < 0) pending = 0;
+        } catch {
+        }
+        readDb.close();
+      } catch { /* ignore */ }
+
+      totalDocs += docs;
+      totalEmbedded += embedded;
+      totalPending += pending;
+      totalSize += fileSize;
+
+      const name = workspaceName.padEnd(21);
+      const docsStr = docs.toLocaleString().padStart(9);
+      const embeddedStr = embedded.toLocaleString().padStart(8);
+      const pendingStr = pending.toLocaleString().padStart(7);
+      const sizeStr = formatBytes(fileSize).padStart(9);
+      console.log(`  ${name}  ${docsStr}  ${embeddedStr}  ${pendingStr}  ${sizeStr}`);
+    }
+
+    console.log('');
+    console.log(`  Total: ${dbFiles.length} workspaces, ${totalDocs.toLocaleString()} documents, ${totalPending.toLocaleString()} pending embeddings, ${formatBytes(totalSize)}`);
+    console.log('');
+
+    await printEmbeddingServerStatus(config);
+    return;
+  }
+
+  const workspaceRoot = process.cwd();
+  const resolvedDbPath = resolveDbPath(globalOpts.dbPath, workspaceRoot);
+  const workspaceName = extractWorkspaceName(resolvedDbPath);
+
+  let dbSize = 0;
+  try {
+    dbSize = fs.statSync(resolvedDbPath).size;
+  } catch { /* ignore */ }
+
+  const store = createStore(resolvedDbPath);
+  const health = store.getIndexHealth();
+
+  console.log(`nano-brain Status — ${workspaceName}`);
+  console.log('═══════════════════════════════════════════════════');
   console.log('');
-  
+
+  console.log('Database:');
+  console.log(`  Path:     ${resolvedDbPath.replace(os.homedir(), '~')}`);
+  console.log(`  Size:     ${formatBytes(dbSize)} (on disk)`);
+  console.log('');
+
+  console.log('Index:');
+  console.log(`  Documents:          ${health.documentCount.toLocaleString()}`);
+  console.log(`  Embedded:           ${health.embeddedCount.toLocaleString()}`);
+  console.log(`  Pending embeddings: ${health.pendingEmbeddings.toLocaleString()}`);
+  console.log('');
+
+  if (health.collections.length > 0) {
+    console.log('Collections:');
+    for (const coll of health.collections) {
+      console.log(`  ${coll.name.padEnd(10)} ${coll.documentCount.toLocaleString()} documents`);
+    }
+    console.log('');
+  }
+
+  const wsConfig = getWorkspaceConfig(config, workspaceRoot);
+  const codebaseStats = getCodebaseStats(store, wsConfig?.codebase, workspaceRoot);
+  if (codebaseStats) {
+    console.log('Codebase:');
+    console.log(`  Enabled:    ${codebaseStats.enabled}`);
+    console.log(`  Storage:    ${formatBytes(codebaseStats.storageUsed)} / ${formatBytes(codebaseStats.maxSize)}`);
+    console.log(`  Extensions: ${codebaseStats.extensions.join(', ') || 'auto-detect'}`);
+    console.log(`  Excludes:   ${codebaseStats.excludeCount} patterns`);
+    console.log('');
+  }
+
+  await printEmbeddingServerStatus(config);
+  console.log('');
+
   console.log('Models:');
   console.log(`  Embedding: ${health.modelStatus.embedding}`);
   console.log(`  Reranker:  ${health.modelStatus.reranker}`);
-  console.log(`  Expander: ${health.modelStatus.expander}`);
+  console.log(`  Expander:  ${health.modelStatus.expander}`);
   store.close();
 }
 
@@ -1336,7 +1451,7 @@ async function handleQdrant(globalOpts: GlobalOptions, commandArgs: string[]): P
   const subcommand = commandArgs[0];
 
   if (!subcommand) {
-    console.error('Missing qdrant subcommand (up, down, status, migrate, activate, cleanup)');
+    console.error('Missing qdrant subcommand (up, down, status, migrate, verify, activate, cleanup)');
     process.exit(1);
   }
 
@@ -1688,6 +1803,147 @@ async function handleQdrant(globalOpts: GlobalOptions, commandArgs: string[]): P
       break;
     }
 
+    case 'verify': {
+      const config = loadCollectionConfig(globalOpts.configPath);
+      const vectorConfig = config?.vector;
+      const qdrantUrl = vectorConfig?.url || 'http://localhost:6333';
+      const resolvedUrl = resolveHostUrl(qdrantUrl);
+
+      try {
+        const healthRes = await fetch(`${resolvedUrl}/healthz`);
+        if (!healthRes.ok) {
+          throw new Error(`HTTP ${healthRes.status}`);
+        }
+      } catch {
+        console.error(`❌ Qdrant is not reachable at ${resolvedUrl}.`);
+        console.error('   Run `npx nano-brain qdrant up` first.');
+        console.error('   If running inside a container, Qdrant must be accessible at host.docker.internal:6333.');
+        process.exit(1);
+      }
+
+      const dataDir = DEFAULT_DB_DIR;
+      if (!fs.existsSync(dataDir)) {
+        console.log('No databases found in ' + dataDir);
+        return;
+      }
+
+      const sqliteFiles = fs.readdirSync(dataDir).filter(f => f.endsWith('.sqlite'));
+      if (sqliteFiles.length === 0) {
+        console.log('No SQLite databases found');
+        return;
+      }
+
+      console.log('Verifying migration...');
+      console.log('═══════════════════════════════════════════════════');
+
+      const Database = (await import('better-sqlite3')).default;
+      const sqliteVec = await import('sqlite-vec');
+
+      let totalVectors = 0;
+      let dbCount = 0;
+      const uniqueKeys = new Set<string>();
+      let sawVectorTables = false;
+
+      for (const sqliteFile of sqliteFiles) {
+        const dbPath = path.join(dataDir, sqliteFile);
+        const db = new Database(dbPath);
+
+        try {
+          sqliteVec.load(db);
+        } catch {
+          console.log(`[${sqliteFile}] sqlite-vec not available, skipping`);
+          db.close();
+          continue;
+        }
+
+        let vectorCount = 0;
+        try {
+          const countStmt = db.prepare(`
+            SELECT COUNT(*) as cnt FROM content_vectors cv
+            JOIN vectors_vec vv ON cv.hash || ':' || cv.seq = vv.hash_seq
+          `);
+          const countRow = countStmt.get() as { cnt: number };
+          vectorCount = countRow.cnt;
+        } catch {
+          console.log(`[${sqliteFile}] no vector tables, skipping`);
+          db.close();
+          continue;
+        }
+
+        sawVectorTables = true;
+
+        if (vectorCount === 0) {
+          console.log(`[${sqliteFile}] 0 vectors`);
+          db.close();
+          continue;
+        }
+
+        const keyStmt = db.prepare(`
+          SELECT DISTINCT cv.hash || ':' || cv.seq as key FROM content_vectors cv
+          JOIN vectors_vec vv ON cv.hash || ':' || cv.seq = vv.hash_seq
+        `);
+        const rows = keyStmt.all() as Array<{ key: string }>;
+        for (const row of rows) {
+          uniqueKeys.add(row.key);
+        }
+
+        console.log(`[${sqliteFile}] ${vectorCount.toLocaleString()} vectors in SQLite`);
+        totalVectors += vectorCount;
+        dbCount++;
+        db.close();
+      }
+
+      if (!sawVectorTables || totalVectors === 0) {
+        let pointsCount = 0;
+        try {
+          const collectionRes = await fetch(`${resolvedUrl}/collections/nano-brain`);
+          if (collectionRes.ok) {
+            const collectionData = await collectionRes.json();
+            const result = collectionData.result || collectionData;
+            pointsCount = result.points_count ?? result.vectors_count ?? 0;
+          }
+        } catch {
+          console.error('❌ Failed to check Qdrant collection');
+          process.exit(1);
+        }
+
+        console.log('SQLite: no vector data (already cleaned up)');
+        console.log(`Qdrant: ${pointsCount.toLocaleString()} vectors`);
+        console.log(`ℹ️  Cannot verify — SQLite vectors already cleaned. Qdrant has ${pointsCount.toLocaleString()} vectors.`);
+        break;
+      }
+
+      console.log('───────────────────────────────────────────────────');
+      console.log(`SQLite total: ${totalVectors.toLocaleString()} vectors (across ${dbCount} databases)`);
+
+      let pointsCount = 0;
+      try {
+        const collectionRes = await fetch(`${resolvedUrl}/collections/nano-brain`);
+        if (collectionRes.ok) {
+          const collectionData = await collectionRes.json();
+          const result = collectionData.result || collectionData;
+          pointsCount = result.points_count ?? result.vectors_count ?? 0;
+        }
+      } catch {
+        console.error('❌ Failed to check Qdrant collection');
+        process.exit(1);
+      }
+
+      const uniqueCount = uniqueKeys.size;
+      console.log(`Qdrant total: ${pointsCount.toLocaleString()} unique vectors`);
+      const difference = totalVectors - pointsCount;
+      console.log(`Difference: ${difference.toLocaleString()} (expected — cross-workspace duplicates share the same hash:seq key)`);
+      console.log('');
+
+      if (uniqueCount > pointsCount) {
+        const missing = uniqueCount - pointsCount;
+        console.log(`⚠️  Found ${missing.toLocaleString()} vectors in SQLite not present in Qdrant. Run \`npx nano-brain qdrant migrate\` to sync.`);
+      } else {
+        console.log('✅ Migration verified: Qdrant has all unique vectors');
+      }
+      break;
+    }
+
     case 'activate': {
       const config = loadCollectionConfig(globalOpts.configPath);
       const vectorConfig = config?.vector;
@@ -1841,7 +2097,7 @@ async function handleQdrant(globalOpts: GlobalOptions, commandArgs: string[]): P
 
     default:
       console.error(`Unknown qdrant subcommand: ${subcommand}`);
-      console.error('Available: up, down, status, migrate, activate, cleanup');
+      console.error('Available: up, down, status, migrate, verify, activate, cleanup');
       process.exit(1);
   }
 }
@@ -1872,7 +2128,7 @@ async function main() {
     case 'collection':
       return handleCollection(globalOpts, commandArgs);
     case 'status':
-      return handleStatus(globalOpts);
+      return handleStatus(globalOpts, commandArgs);
     case 'update':
       return handleUpdate(globalOpts);
     case 'embed':