nano-brain 2026.6.7 → 2026.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-brain",
-  "version": "2026.6.7",
+  "version": "2026.6.8",
   "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/connection-graph.ts

@@ -0,0 +1,50 @@
+import type { Store, MemoryConnection, MemoryConnectionRelationshipType } from './types.js';
+
+export function isValidRelationshipType(type: string): type is MemoryConnectionRelationshipType {
+  return (['supports', 'contradicts', 'extends', 'supersedes', 'related', 'caused_by', 'refines', 'implements'] as string[]).includes(type);
+}
+
+export interface TraversalNode {
+  docId: number;
+  depth: number;
+  path: MemoryConnection[];
+}
+
+export function traverse(
+  store: Store,
+  startDocId: number,
+  options?: { maxDepth?: number; relationshipTypes?: string[] }
+): TraversalNode[] {
+  const maxDepth = options?.maxDepth ?? 2;
+  const visited = new Set<number>();
+  const result: TraversalNode[] = [];
+  const queue: TraversalNode[] = [{ docId: startDocId, depth: 0, path: [] }];
+  visited.add(startDocId);
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    if (current.depth > 0) result.push(current);
+    if (current.depth >= maxDepth) continue;
+
+    const connections = store.getConnectionsForDocument(current.docId, {
+      relationshipType: options?.relationshipTypes?.length === 1 ? options.relationshipTypes[0] : undefined,
+    });
+
+    for (const conn of connections) {
+      if (options?.relationshipTypes && options.relationshipTypes.length > 1) {
+        if (!options.relationshipTypes.includes(conn.relationshipType)) continue;
+      }
+      const neighborId = conn.fromDocId === current.docId ? conn.toDocId : conn.fromDocId;
+      if (visited.has(neighborId)) continue;
+      visited.add(neighborId);
+      queue.push({ docId: neighborId, depth: current.depth + 1, path: [...current.path, conn] });
+    }
+  }
+
+  return result;
+}
+
+export function getRelatedDocuments(store: Store, docId: number, relationshipType?: string): number[] {
+  const connections = store.getConnectionsForDocument(docId, { relationshipType });
+  return connections.map(c => c.fromDocId === docId ? c.toDocId : c.fromDocId);
+}

package/src/consolidation.ts

@@ -169,6 +169,36 @@ Respond with ONLY a JSON array, no other text.`;
       result.overallConfidence,
       new Date().toISOString()
     );
+
+    if (result.connections.length > 0) {
+      const projectHashRow = result.sourceIds.length > 0
+        ? db.prepare('SELECT project_hash FROM documents WHERE id = ?').get(result.sourceIds[0]) as { project_hash: string } | undefined
+        : undefined;
+      const projectHash = projectHashRow?.project_hash ?? 'global';
+      let created = 0;
+      for (const conn of result.connections) {
+        if (!conn.fromId || !conn.toId || !conn.relationship) continue;
+        try {
+          if (this.store.getConnectionCount(conn.fromId) >= 50) continue;
+          this.store.insertConnection({
+            fromDocId: conn.fromId,
+            toDocId: conn.toId,
+            relationshipType: conn.relationship as any,
+            description: null,
+            strength: typeof conn.confidence === 'number' ? conn.confidence : result.overallConfidence,
+            createdBy: 'consolidation',
+            projectHash,
+          });
+          created++;
+        } catch (err) {
+          log('consolidation', 'Failed to create connection ' + conn.fromId + '->' + conn.toId + ': ' + (err instanceof Error ? err.message : String(err)), 'warn');
+        }
+      }
+      if (created > 0) {
+        log('consolidation', 'Created ' + created + ' memory connections from consolidation');
+      }
+    }
+
     log('consolidation', 'Applied consolidation for ' + result.sourceIds.length + ' memories, confidence=' + result.overallConfidence.toFixed(2));
   }
 

package/src/server.ts

@@ -11,7 +11,8 @@ import * as os from 'os';
 import * as crypto from 'crypto';
 import * as http from 'http';
 import type { Store, SearchResult, IndexHealth, Collection, StorageConfig, CodebaseConfig, EmbeddingConfig, WatcherConfig, SearchConfig, ConsolidationConfig, ProactiveConfig } from './types.js'
-import { DEFAULT_PROACTIVE_CONFIG } from './types.js'
+import { DEFAULT_PROACTIVE_CONFIG, VALID_RELATIONSHIP_TYPES } from './types.js'
+import { traverse, isValidRelationshipType } from './connection-graph.js';
 import { extractEntitiesFromMemory } from './entity-extraction.js'
 import { createLLMProvider } from './llm-provider.js';
 import { ConsolidationAgent } from './consolidation.js';
@@ -2549,6 +2550,160 @@ export function createMcpServer(deps: ServerDeps): McpServer {
       }
     }
   );
+
+  server.tool(
+    'memory_connections',
+    'Get all connections for a document. Shows how memories relate to each other.',
+    {
+      doc_id: z.string().describe('Document ID or path'),
+      relationship_type: z.string().optional().describe('Filter by type: supports, contradicts, extends, supersedes, related, caused_by, refines, implements'),
+      direction: z.enum(['incoming', 'outgoing', 'both']).optional().default('both').describe('Connection direction'),
+      workspace: z.string().optional().describe('Workspace path or hash. Required in daemon mode.'),
+    },
+    async ({ doc_id, relationship_type, direction, workspace }) => {
+      if (checkReady()) return WARMUP_ERROR;
+      log('mcp', 'memory_connections doc_id="' + doc_id + '" type="' + (relationship_type || '') + '"');
+
+      const wsResult = requireDaemonWorkspace(deps, workspace);
+      if ('error' in wsResult) {
+        return { content: [{ type: 'text', text: wsResult.error }], isError: true };
+      }
+
+      const doc = wsResult.store.findDocument(doc_id);
+      if (!doc) {
+        return { content: [{ type: 'text', text: 'Document not found: ' + doc_id }], isError: true };
+      }
+
+      if (relationship_type && !isValidRelationshipType(relationship_type)) {
+        return { content: [{ type: 'text', text: 'Invalid relationship type: ' + relationship_type + '. Valid: ' + VALID_RELATIONSHIP_TYPES.join(', ') }], isError: true };
+      }
+
+      const connections = wsResult.store.getConnectionsForDocument(doc.id, {
+        direction: direction as 'incoming' | 'outgoing' | 'both',
+        relationshipType: relationship_type,
+      });
+
+      if (connections.length === 0) {
+        return { content: [{ type: 'text', text: 'No connections found for ' + doc_id }] };
+      }
+
+      const lines: string[] = [`## Connections for ${doc.title} (${connections.length})\n`];
+      for (const conn of connections) {
+        const otherId = conn.fromDocId === doc.id ? conn.toDocId : conn.fromDocId;
+        const otherDoc = wsResult.store.findDocument(String(otherId));
+        const dir = conn.fromDocId === doc.id ? '→' : '←';
+        lines.push(`- ${dir} **${conn.relationshipType}** ${otherDoc?.title ?? 'doc#' + otherId} (strength: ${conn.strength.toFixed(2)}, by: ${conn.createdBy})`);
+        if (conn.description) lines.push(`  ${conn.description}`);
+      }
+
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+  );
+
+  server.tool(
+    'memory_traverse',
+    'Traverse the memory connection graph from a starting document. Finds related memories up to N hops away.',
+    {
+      start_doc_id: z.string().describe('Starting document ID or path'),
+      max_depth: z.number().optional().default(2).describe('Maximum traversal depth (default: 2)'),
+      relationship_types: z.array(z.string()).optional().describe('Only follow these relationship types'),
+      workspace: z.string().optional().describe('Workspace path or hash. Required in daemon mode.'),
+    },
+    async ({ start_doc_id, max_depth, relationship_types, workspace }) => {
+      if (checkReady()) return WARMUP_ERROR;
+      log('mcp', 'memory_traverse start="' + start_doc_id + '" depth=' + max_depth);
+
+      const wsResult = requireDaemonWorkspace(deps, workspace);
+      if ('error' in wsResult) {
+        return { content: [{ type: 'text', text: wsResult.error }], isError: true };
+      }
+
+      const doc = wsResult.store.findDocument(start_doc_id);
+      if (!doc) {
+        return { content: [{ type: 'text', text: 'Document not found: ' + start_doc_id }], isError: true };
+      }
+
+      if (relationship_types) {
+        for (const rt of relationship_types) {
+          if (!isValidRelationshipType(rt)) {
+            return { content: [{ type: 'text', text: 'Invalid relationship type: ' + rt + '. Valid: ' + VALID_RELATIONSHIP_TYPES.join(', ') }], isError: true };
+          }
+        }
+      }
+
+      const nodes = traverse(wsResult.store, doc.id, { maxDepth: max_depth, relationshipTypes: relationship_types });
+
+      if (nodes.length === 0) {
+        return { content: [{ type: 'text', text: 'No connected memories found within depth ' + max_depth }] };
+      }
+
+      const lines: string[] = [`## Graph traversal from: ${doc.title}\n`];
+      for (const node of nodes) {
+        const nodeDoc = wsResult.store.findDocument(String(node.docId));
+        const indent = '  '.repeat(node.depth);
+        const lastConn = node.path[node.path.length - 1];
+        lines.push(`${indent}[depth ${node.depth}] ${nodeDoc?.title ?? 'doc#' + node.docId} (via ${lastConn?.relationshipType ?? '?'})`);
+      }
+      lines.push(`\n**Total:** ${nodes.length} connected memories found`);
+
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+  );
+
+  server.tool(
+    'memory_connect',
+    'Create a connection between two memories. Defines how they relate to each other.',
+    {
+      from_doc_id: z.string().describe('Source document ID or path'),
+      to_doc_id: z.string().describe('Target document ID or path'),
+      relationship_type: z.string().describe('Type: supports, contradicts, extends, supersedes, related, caused_by, refines, implements'),
+      description: z.string().optional().describe('Description of the relationship'),
+      strength: z.number().optional().default(1.0).describe('Connection strength 0.0-1.0 (default: 1.0)'),
+      workspace: z.string().optional().describe('Workspace path or hash. Required in daemon mode.'),
+    },
+    async ({ from_doc_id, to_doc_id, relationship_type, description, strength, workspace }) => {
+      if (checkReady()) return WARMUP_ERROR;
+      log('mcp', 'memory_connect from="' + from_doc_id + '" to="' + to_doc_id + '" type="' + relationship_type + '"');
+
+      const wsResult = requireDaemonWorkspace(deps, workspace);
+      if ('error' in wsResult) {
+        return { content: [{ type: 'text', text: wsResult.error }], isError: true };
+      }
+
+      if (!isValidRelationshipType(relationship_type)) {
+        return { content: [{ type: 'text', text: 'Invalid relationship type: ' + relationship_type + '. Valid: ' + VALID_RELATIONSHIP_TYPES.join(', ') }], isError: true };
+      }
+
+      const fromDoc = wsResult.store.findDocument(from_doc_id);
+      if (!fromDoc) {
+        return { content: [{ type: 'text', text: 'Source document not found: ' + from_doc_id }], isError: true };
+      }
+
+      const toDoc = wsResult.store.findDocument(to_doc_id);
+      if (!toDoc) {
+        return { content: [{ type: 'text', text: 'Target document not found: ' + to_doc_id }], isError: true };
+      }
+
+      const count = wsResult.store.getConnectionCount(fromDoc.id);
+      if (count >= 50) {
+        return { content: [{ type: 'text', text: 'Connection limit reached (50) for document: ' + from_doc_id }], isError: true };
+      }
+
+      const id = wsResult.store.insertConnection({
+        fromDocId: fromDoc.id,
+        toDocId: toDoc.id,
+        relationshipType: relationship_type as any,
+        description: description ?? null,
+        strength: strength ?? 1.0,
+        createdBy: 'user',
+        projectHash: wsResult.projectHash,
+      });
+
+      return {
+        content: [{ type: 'text', text: `✅ Connection created (#${id}): ${fromDoc.title} —[${relationship_type}]→ ${toDoc.title}` }],
+      };
+    }
+  );
   
   return server;
 }

package/src/store.ts

@@ -80,7 +80,6 @@ export function createStore(dbPath: string): Store {
   
   const cached = storeCache.get(resolvedPath);
   if (cached) {
-    log('store', 'createStore cache hit for ' + resolvedPath, 'debug');
     return cached;
   }
   
@@ -346,7 +345,7 @@ export function createStore(dbPath: string): Store {
   
   // Schema versioning
   const currentVersion = (db.pragma('user_version') as Array<{ user_version: number }>)[0].user_version;
-  const TARGET_VERSION = 6;
+  const TARGET_VERSION = 8;
 
   if (currentVersion < 1) {
     db.exec(`
@@ -548,6 +547,29 @@ export function createStore(dbPath: string): Store {
     db.pragma(`user_version = 7`);
     log('store', 'Schema migrated to version 7 (entity pruning support)');
   }
+
+  if (currentVersion < 8) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_connections (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        from_doc_id INTEGER NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+        to_doc_id INTEGER NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+        relationship_type TEXT NOT NULL,
+        description TEXT,
+        strength REAL NOT NULL DEFAULT 1.0,
+        created_by TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        project_hash TEXT NOT NULL,
+        UNIQUE(from_doc_id, to_doc_id, relationship_type)
+      );
+      CREATE INDEX IF NOT EXISTS idx_mc_from ON memory_connections(from_doc_id);
+      CREATE INDEX IF NOT EXISTS idx_mc_to ON memory_connections(to_doc_id);
+      CREATE INDEX IF NOT EXISTS idx_mc_type ON memory_connections(relationship_type);
+      CREATE INDEX IF NOT EXISTS idx_mc_project ON memory_connections(project_hash);
+    `);
+    db.pragma(`user_version = 8`);
+    log('store', 'Schema migrated to version 8 (memory connections)');
+  }
   
   if (vecAvailable) {
     try {
@@ -596,6 +618,19 @@ export function createStore(dbPath: string): Store {
   const deactivateDocumentStmt = db.prepare(`
     UPDATE documents SET active = 0 WHERE collection = ? AND path = ?
   `);
+
+  const insertConnectionStmt = db.prepare(`
+    INSERT INTO memory_connections (from_doc_id, to_doc_id, relationship_type, description, strength, created_by, project_hash)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(from_doc_id, to_doc_id, relationship_type) DO UPDATE SET
+      description = excluded.description, strength = excluded.strength, created_by = excluded.created_by
+  `);
+  const getConnectionsFromStmt = db.prepare(`SELECT * FROM memory_connections WHERE from_doc_id = ? ORDER BY strength DESC`);
+  const getConnectionsToStmt = db.prepare(`SELECT * FROM memory_connections WHERE to_doc_id = ? ORDER BY strength DESC`);
+  const getConnectionsBothStmt = db.prepare(`SELECT * FROM memory_connections WHERE from_doc_id = ? OR to_doc_id = ? ORDER BY strength DESC`);
+  const getConnectionsByTypeStmt = db.prepare(`SELECT * FROM memory_connections WHERE (from_doc_id = ? OR to_doc_id = ?) AND relationship_type = ? ORDER BY strength DESC`);
+  const deleteConnectionStmt = db.prepare(`DELETE FROM memory_connections WHERE id = ?`);
+  const getConnectionCountStmt = db.prepare(`SELECT COUNT(*) as cnt FROM memory_connections WHERE from_doc_id = ? OR to_doc_id = ?`);
   
 
   
@@ -1197,7 +1232,7 @@ export function createStore(dbPath: string): Store {
     
     close() {
       if (_cached) {
-        log('store', 'close() skipped for cached store', 'debug');
+        // cached store — close is a no-op, real close happens via closeAllCachedStores()
         return;
       }
       try { db.pragma('wal_checkpoint(PASSIVE)'); } catch { /* ignore checkpoint errors */ }
@@ -2695,6 +2730,49 @@ export function createStore(dbPath: string): Store {
       params.push(limit);
       return db.prepare(sql).all(...params) as Array<{ id: number; path: string; body: string }>;
     },
+
+    insertConnection(conn) {
+      const result = insertConnectionStmt.run(
+        conn.fromDocId, conn.toDocId, conn.relationshipType,
+        conn.description ?? null, conn.strength, conn.createdBy, conn.projectHash
+      );
+      return Number(result.lastInsertRowid);
+    },
+
+    getConnectionsForDocument(docId, options) {
+      const dir = options?.direction ?? 'both';
+      const relType = options?.relationshipType;
+      let rows: any[];
+      if (relType) {
+        rows = getConnectionsByTypeStmt.all(docId, docId, relType);
+      } else if (dir === 'outgoing') {
+        rows = getConnectionsFromStmt.all(docId);
+      } else if (dir === 'incoming') {
+        rows = getConnectionsToStmt.all(docId);
+      } else {
+        rows = getConnectionsBothStmt.all(docId, docId);
+      }
+      return rows.map((r: any) => ({
+        id: r.id,
+        fromDocId: r.from_doc_id,
+        toDocId: r.to_doc_id,
+        relationshipType: r.relationship_type,
+        description: r.description,
+        strength: r.strength,
+        createdBy: r.created_by,
+        createdAt: r.created_at,
+        projectHash: r.project_hash,
+      }));
+    },
+
+    deleteConnection(id) {
+      deleteConnectionStmt.run(id);
+    },
+
+    getConnectionCount(docId) {
+      const row = getConnectionCountStmt.get(docId, docId) as { cnt: number } | undefined;
+      return row?.cnt ?? 0;
+    },
   };
   
   _cached = true;

package/src/types.ts

@@ -612,6 +612,26 @@ export interface RemoveWorkspaceResult {
   executionFlowsDeleted: number;
 }
 
+export type MemoryConnectionRelationshipType = 'supports' | 'contradicts' | 'extends' | 'supersedes' | 'related' | 'caused_by' | 'refines' | 'implements';
+
+export type MemoryConnectionCreatedBy = 'consolidation' | 'user' | 'extraction';
+
+export const VALID_RELATIONSHIP_TYPES: MemoryConnectionRelationshipType[] = [
+  'supports', 'contradicts', 'extends', 'supersedes', 'related', 'caused_by', 'refines', 'implements'
+];
+
+export interface MemoryConnection {
+  id: number;
+  fromDocId: number;
+  toDocId: number;
+  relationshipType: MemoryConnectionRelationshipType;
+  description: string | null;
+  strength: number;
+  createdBy: MemoryConnectionCreatedBy;
+  createdAt: string;
+  projectHash: string;
+}
+
 export interface Store {
   getDb(): import('better-sqlite3').Database;
   close(): void;
@@ -798,4 +818,9 @@ export interface Store {
   deduplicateEdges(entityId: number): void;
 
   getUncategorizedDocuments(limit: number, projectHash?: string): Array<{ id: number; path: string; body: string }>;
+
+  insertConnection(conn: Omit<MemoryConnection, 'id' | 'createdAt'>): number;
+  getConnectionsForDocument(docId: number, options?: { direction?: 'incoming' | 'outgoing' | 'both'; relationshipType?: string; projectHash?: string }): MemoryConnection[];
+  deleteConnection(id: number): void;
+  getConnectionCount(docId: number): number;
 }