ruvector 0.2.0 → 0.2.1

package/bin/mcp-server.js

@@ -363,7 +363,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.1.58',
+    version: '0.2.1',
   },
   {
     capabilities: {
@@ -1269,6 +1269,185 @@ const TOOLS = [
       },
       required: ['query']
     }
+  },
+  // ── Brain Tools (11) ── Shared intelligence via @ruvector/pi-brain ──
+  {
+    name: 'brain_search',
+    description: 'Semantic search across shared brain knowledge',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        category: { type: 'string', description: 'Filter by category (pattern, solution, architecture, convention, security, performance, tooling)' },
+        limit: { type: 'number', description: 'Max results (default 10)' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'brain_share',
+    description: 'Share a learning or pattern with the collective brain',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Title of the knowledge entry' },
+        content: { type: 'string', description: 'Content/description of the knowledge' },
+        category: { type: 'string', description: 'Category (pattern, solution, architecture, convention, security, performance, tooling)' },
+        tags: { type: 'string', description: 'Comma-separated tags' },
+        code_snippet: { type: 'string', description: 'Optional code snippet' }
+      },
+      required: ['title', 'content', 'category']
+    }
+  },
+  {
+    name: 'brain_get',
+    description: 'Retrieve a specific memory by ID with full provenance',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Memory ID' }
+      },
+      required: ['id']
+    }
+  },
+  {
+    name: 'brain_vote',
+    description: 'Quality-gate a memory with an up or down vote',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Memory ID' },
+        direction: { type: 'string', description: 'Vote direction: up or down' }
+      },
+      required: ['id', 'direction']
+    }
+  },
+  {
+    name: 'brain_list',
+    description: 'List recent shared memories filtered by category or quality',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: { type: 'string', description: 'Filter by category' },
+        limit: { type: 'number', description: 'Max results (default 20)' }
+      }
+    }
+  },
+  {
+    name: 'brain_delete',
+    description: 'Delete your own contribution from the shared brain',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Memory ID to delete' }
+      },
+      required: ['id']
+    }
+  },
+  {
+    name: 'brain_status',
+    description: 'Get shared brain system health: counts, drift, quality, graph topology',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'brain_drift',
+    description: 'Check if shared knowledge has drifted from local state',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Domain to check drift for' }
+      }
+    }
+  },
+  {
+    name: 'brain_partition',
+    description: 'Get knowledge partitioned by mincut topology into clusters',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Domain to partition' },
+        min_cluster_size: { type: 'number', description: 'Minimum cluster size (default 3)' }
+      }
+    }
+  },
+  {
+    name: 'brain_transfer',
+    description: 'Apply learned priors from one knowledge domain to another',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source_domain: { type: 'string', description: 'Source domain to transfer from' },
+        target_domain: { type: 'string', description: 'Target domain to transfer to' }
+      },
+      required: ['source_domain', 'target_domain']
+    }
+  },
+  {
+    name: 'brain_sync',
+    description: 'Synchronize LoRA weights between local and shared brain',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        direction: { type: 'string', description: 'Sync direction: pull, push, or both (default both)' }
+      }
+    }
+  },
+  // ── Edge Tools (4) ── Distributed compute via @ruvector/edge-net ──
+  {
+    name: 'edge_status',
+    description: 'Get edge compute network status (genesis, relay, nodes, rUv supply)',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'edge_join',
+    description: 'Join the edge compute network as a compute node',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contribution: { type: 'number', description: 'Contribution level 0.0-1.0 (default 0.3)' }
+      }
+    }
+  },
+  {
+    name: 'edge_balance',
+    description: 'Check rUv credit balance for current identity',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'edge_tasks',
+    description: 'List available distributed compute tasks on the edge network',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max tasks to return (default 20)' }
+      }
+    }
+  },
+  // ── Identity Tools (2) ── Pi key management ──
+  {
+    name: 'identity_generate',
+    description: 'Generate a new pi key and derive pseudonym',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'identity_show',
+    description: 'Show current pi key pseudonym and derived identities',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
   }
 ];
 
@@ -2963,6 +3142,98 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
+      // ── Brain Tool Handlers ──────────────────────────────────────────────
+      case 'brain_search':
+      case 'brain_share':
+      case 'brain_get':
+      case 'brain_vote':
+      case 'brain_list':
+      case 'brain_delete':
+      case 'brain_status':
+      case 'brain_drift':
+      case 'brain_partition':
+      case 'brain_transfer':
+      case 'brain_sync': {
+        try {
+          const { PiBrainClient } = require('@ruvector/pi-brain');
+          const client = new PiBrainClient({
+            url: process.env.BRAIN_URL || 'https://pi.ruv.io',
+            key: process.env.PI
+          });
+          const subCmd = name.replace('brain_', '');
+          let result;
+          switch (subCmd) {
+            case 'search': result = await client.search(args.query, { category: args.category, limit: args.limit || 10 }); break;
+            case 'share': result = await client.share({ title: args.title, content: args.content, category: args.category, tags: args.tags ? args.tags.split(',').map(t => t.trim()) : [], code_snippet: args.code_snippet }); break;
+            case 'get': result = await client.get(args.id); break;
+            case 'vote': result = await client.vote(args.id, args.direction); break;
+            case 'list': result = await client.list({ category: args.category, limit: args.limit || 20 }); break;
+            case 'delete': result = await client.delete(args.id); break;
+            case 'status': result = await client.status(); break;
+            case 'drift': result = await client.drift({ domain: args.domain }); break;
+            case 'partition': result = await client.partition({ domain: args.domain, min_cluster_size: args.min_cluster_size }); break;
+            case 'transfer': result = await client.transfer(args.source_domain, args.target_domain); break;
+            case 'sync': result = await client.sync(args.direction || 'both'); break;
+          }
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
+        } catch (e) {
+          if (e.code === 'MODULE_NOT_FOUND') {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Brain tools require @ruvector/pi-brain. Install with: npm install @ruvector/pi-brain' }, null, 2) }], isError: true };
+          }
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      // ── Edge Tool Handlers ───────────────────────────────────────────────
+      case 'edge_status':
+      case 'edge_join':
+      case 'edge_balance':
+      case 'edge_tasks': {
+        try {
+          const genesisUrl = process.env.EDGE_GENESIS_URL || 'https://edge-net-genesis-875130704813.us-central1.run.app';
+          const subCmd = name.replace('edge_', '');
+          let endpoint, method = 'GET', body;
+          switch (subCmd) {
+            case 'status': endpoint = '/status'; break;
+            case 'join': endpoint = '/join'; method = 'POST'; body = JSON.stringify({ contribution: args.contribution || 0.3, pi_key: process.env.PI }); break;
+            case 'balance': endpoint = `/balance/${process.env.PI || 'anonymous'}`; break;
+            case 'tasks': endpoint = `/tasks?limit=${args.limit || 20}`; break;
+          }
+          const resp = await fetch(`${genesisUrl}${endpoint}`, {
+            method,
+            headers: { 'Content-Type': 'application/json', ...(process.env.PI ? { 'Authorization': `Bearer ${process.env.PI}` } : {}) },
+            ...(body ? { body } : {})
+          });
+          const data = await resp.json();
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...data }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      // ── Identity Tool Handlers ───────────────────────────────────────────
+      case 'identity_generate': {
+        const crypto = require('crypto');
+        const key = crypto.randomBytes(32).toString('hex');
+        const hash = crypto.createHash('shake256', { outputLength: 16 });
+        hash.update(key);
+        const pseudonym = hash.digest('hex');
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true, pi_key: key, pseudonym, warning: 'Store this key securely. Set PI env var to use it.' }, null, 2) }] };
+      }
+
+      case 'identity_show': {
+        const piKey = process.env.PI;
+        if (!piKey) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'No PI environment variable set. Run identity_generate first.' }, null, 2) }], isError: true };
+        }
+        const crypto = require('crypto');
+        const hash = crypto.createHash('shake256', { outputLength: 16 });
+        hash.update(piKey);
+        const pseudonym = hash.digest('hex');
+        const mcpToken = crypto.createHmac('sha256', piKey).update('mcp').digest('hex').slice(0, 32);
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true, pseudonym, mcp_token: mcpToken, key_prefix: piKey.slice(0, 8) + '...' }, null, 2) }] };
+      }
+
       default:
         return {
           content: [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -79,12 +79,6 @@
     "@types/node": "^20.10.5",
     "typescript": "^5.3.3"
   },
-  "files": [
-    "bin/",
-    "dist/",
-    "README.md",
-    "LICENSE"
-  ],
   "peerDependencies": {
     "@ruvector/pi-brain": ">=0.1.0",
     "@ruvector/ruvllm": ">=2.0.0",
@@ -95,6 +89,12 @@
     "@ruvector/ruvllm": { "optional": true },
     "@ruvector/router": { "optional": true }
   },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
   "engines": {
     "node": ">=18.0.0"
   }