ruvector 0.2.8 → 0.2.9

package/bin/cli.js

@@ -159,7 +159,7 @@ async function proxyFetch(url, opts) {
 
   // Fallback: shell out to curl (which natively respects proxy env vars)
   const { execFileSync } = require('child_process');
-  const args = ['-sS', '-L', '--max-time', '30'];
+  const args = ['-sS', '-L', '--max-time', '30', '-w', '\n%{http_code}'];
   if (opts && opts.method) { args.push('-X', opts.method); }
   if (opts && opts.headers) {
     for (const [k, v] of Object.entries(opts.headers)) {
@@ -170,13 +170,16 @@ async function proxyFetch(url, opts) {
   args.push(target);
   try {
     const stdout = execFileSync('curl', args, { encoding: 'utf8', timeout: 35000 });
-    const body = stdout.trim();
+    const lines = stdout.trimEnd().split('\n');
+    const statusCode = parseInt(lines.pop(), 10) || 200;
+    const body = lines.join('\n').trim();
+    const ok = statusCode >= 200 && statusCode < 300;
     return {
-      ok: true,
-      status: 200,
-      statusText: 'OK',
+      ok,
+      status: statusCode,
+      statusText: ok ? 'OK' : `HTTP ${statusCode}`,
       text: async () => body,
-      json: async () => JSON.parse(body),
+      json: async () => body ? JSON.parse(body) : {},
       headers: new Map(),
     };
   } catch (e) {
@@ -8279,6 +8282,7 @@ async function fetchBrainEndpoint(config, endpoint) {
   if (config.key) headers['Authorization'] = `Bearer ${config.key}`;
   const resp = await proxyFetch(url, { headers, signal: AbortSignal.timeout(30000) });
   if (!resp.ok) throw new Error(`${resp.status} ${resp.statusText}`);
+  if (resp.status === 204 || resp.headers.get('content-length') === '0') return {};
   return resp.json();
 }
 

package/bin/mcp-server.js

@@ -428,7 +428,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.2.8',
+    version: '0.2.9',
   },
   {
     capabilities: {
@@ -1395,7 +1395,10 @@ const TOOLS = [
       type: 'object',
       properties: {
         category: { type: 'string', description: 'Filter by category' },
-        limit: { type: 'number', description: 'Max results (default 20)' }
+        limit: { type: 'number', description: 'Max results (default 20)' },
+        offset: { type: 'number', description: 'Skip first N results for pagination (default 0)' },
+        sort: { type: 'string', description: 'Sort by: updated_at, quality, votes (default updated_at)' },
+        tags: { type: 'string', description: 'Filter by tags (comma-separated)' }
       }
     }
   },
@@ -1492,6 +1495,117 @@ const TOOLS = [
     description: 'Show backend feature flag state (RVF, AGI, midstream flags)',
     inputSchema: { type: 'object', properties: {} }
   },
+  // ── Brainpedia Page Tools (5) ── Knowledge page management ──
+  {
+    name: 'brain_page_list',
+    description: 'List Brainpedia knowledge pages with pagination and status filter',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max pages to return (default 20)' },
+        offset: { type: 'number', description: 'Skip first N pages for pagination (default 0)' },
+        status: { type: 'string', description: 'Filter by status: draft, canonical, contested, archived' }
+      }
+    }
+  },
+  {
+    name: 'brain_page_get',
+    description: 'Get a Brainpedia page by ID with delta log and evidence links',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Page ID (UUID or slug)' }
+      },
+      required: ['id']
+    }
+  },
+  {
+    name: 'brain_page_create',
+    description: 'Create a new Brainpedia knowledge page (requires reputation >= 0.5)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Page title' },
+        content: { type: 'string', description: 'Page content body' },
+        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_page_update',
+    description: 'Submit a delta (correction, extension, evidence) to a Brainpedia page',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Page ID to update' },
+        delta_type: { type: 'string', description: 'Delta type: correction, extension, evidence, deprecation' },
+        content_diff: { type: 'string', description: 'Content diff or new content' },
+        evidence_links: { type: 'string', description: 'JSON array of evidence links' }
+      },
+      required: ['page_id', 'content_diff']
+    }
+  },
+  {
+    name: 'brain_page_delete',
+    description: 'Delete a Brainpedia page by ID',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Page ID to delete' }
+      },
+      required: ['id']
+    }
+  },
+  // ── WASM Node Tools (4) ── Executable compute node management ──
+  {
+    name: 'brain_node_list',
+    description: 'List published WASM compute nodes',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Max nodes to return (default 20)' }
+      }
+    }
+  },
+  {
+    name: 'brain_node_get',
+    description: 'Get WASM compute node metadata and conformance vectors',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Node ID' }
+      },
+      required: ['id']
+    }
+  },
+  {
+    name: 'brain_node_publish',
+    description: 'Publish a WASM compute node to the shared brain network',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Node name' },
+        wasm_base64: { type: 'string', description: 'Base64-encoded WASM binary' },
+        description: { type: 'string', description: 'Node description' },
+        conformance_vectors: { type: 'string', description: 'JSON array of conformance test vectors' }
+      },
+      required: ['name', 'wasm_base64']
+    }
+  },
+  {
+    name: 'brain_node_revoke',
+    description: 'Revoke a published WASM compute node',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Node ID to revoke' }
+      },
+      required: ['id']
+    }
+  },
   // ── Midstream Tools (6) ── Real-time streaming analysis platform ──
   {
     name: 'midstream_status',
@@ -3416,20 +3530,127 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               fetchOpts.body = JSON.stringify({ source_domain: args.source_domain, target_domain: args.target_domain });
               break;
             }
-            case 'sync': url = `${brainUrl}/v1/lora/latest`; break;
+            case 'sync': {
+              const p = new URLSearchParams();
+              if (args.direction) p.set('direction', args.direction);
+              url = `${brainUrl}/v1/lora/latest${p.toString() ? '?' + p : ''}`;
+              break;
+            }
           }
           const resp = await proxyFetch(url, fetchOpts);
           if (!resp.ok) {
             const errText = await resp.text().catch(() => resp.statusText);
             return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
           }
-          const result = await resp.json();
+          const result = (resp.status === 204 || resp.headers.get('content-length') === '0') ? {} : await resp.json();
           return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
         } catch (e) {
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
         }
       }
 
+      // ── Brainpedia Page Tool Handlers ────────────────────────────────────
+      case 'brain_page_list':
+      case 'brain_page_get':
+      case 'brain_page_create':
+      case 'brain_page_update':
+      case 'brain_page_delete': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+          let url, fetchOpts = { headers: hdrs, signal: AbortSignal.timeout(30000) };
+          const subCmd = name.replace('brain_page_', '');
+          switch (subCmd) {
+            case 'list': {
+              const p = new URLSearchParams();
+              if (args.limit) p.set('limit', String(args.limit));
+              if (args.offset) p.set('offset', String(args.offset));
+              if (args.status) p.set('status', args.status);
+              url = `${brainUrl}/v1/pages${p.toString() ? '?' + p : ''}`;
+              break;
+            }
+            case 'get': url = `${brainUrl}/v1/pages/${args.id}`; break;
+            case 'create': {
+              url = `${brainUrl}/v1/pages`;
+              fetchOpts.method = 'POST';
+              fetchOpts.body = JSON.stringify({ title: args.title, content: args.content, category: args.category, tags: args.tags ? args.tags.split(',').map(t => t.trim()) : [], code_snippet: args.code_snippet, evidence_links: [], embedding: [], witness_hash: '' });
+              break;
+            }
+            case 'update': {
+              url = `${brainUrl}/v1/pages/${args.page_id}/deltas`;
+              fetchOpts.method = 'POST';
+              let evidence = [];
+              try { if (args.evidence_links) evidence = JSON.parse(args.evidence_links); } catch {}
+              fetchOpts.body = JSON.stringify({ delta_type: args.delta_type || 'extension', content_diff: args.content_diff, evidence_links: evidence, witness_hash: '' });
+              break;
+            }
+            case 'delete': {
+              url = `${brainUrl}/v1/pages/${args.id}`;
+              fetchOpts.method = 'DELETE';
+              break;
+            }
+          }
+          const resp = await proxyFetch(url, fetchOpts);
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
+          const result = (resp.status === 204 || resp.headers.get('content-length') === '0') ? {} : await resp.json();
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      // ── WASM Node Tool Handlers ────────────────────────────────────────────
+      case 'brain_node_list':
+      case 'brain_node_get':
+      case 'brain_node_publish':
+      case 'brain_node_revoke': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+          let url, fetchOpts = { headers: hdrs, signal: AbortSignal.timeout(30000) };
+          const subCmd = name.replace('brain_node_', '');
+          switch (subCmd) {
+            case 'list': {
+              const p = new URLSearchParams();
+              if (args.limit) p.set('limit', String(args.limit));
+              url = `${brainUrl}/v1/nodes${p.toString() ? '?' + p : ''}`;
+              break;
+            }
+            case 'get': url = `${brainUrl}/v1/nodes/${args.id}`; break;
+            case 'publish': {
+              url = `${brainUrl}/v1/nodes`;
+              fetchOpts.method = 'POST';
+              let vectors = [];
+              try { if (args.conformance_vectors) vectors = JSON.parse(args.conformance_vectors); } catch {}
+              fetchOpts.body = JSON.stringify({ name: args.name, wasm_base64: args.wasm_base64, description: args.description || '', conformance_vectors: vectors });
+              break;
+            }
+            case 'revoke': {
+              url = `${brainUrl}/v1/nodes/${args.id}/revoke`;
+              fetchOpts.method = 'POST';
+              fetchOpts.body = JSON.stringify({});
+              break;
+            }
+          }
+          const resp = await proxyFetch(url, fetchOpts);
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
+          const result = (resp.status === 204 || resp.headers.get('content-length') === '0') ? {} : await resp.json();
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...(Array.isArray(result) ? { items: result, count: result.length } : result) }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
       // ── Brain AGI Tool Handlers ────────────────────────────────────────────
       case 'brain_agi_status':
       case 'brain_sona_stats':
@@ -3899,7 +4120,7 @@ async function main() {
           transport: 'sse',
           sessions: sessions.size,
           tools: 91,
-          version: '0.2.8'
+          version: '0.2.9'
         }));
 
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",