ruvector 0.1.95 → 0.1.97

package/bin/mcp-server.js

@@ -24,7 +24,46 @@ const {
 } = require('@modelcontextprotocol/sdk/types.js');
 const path = require('path');
 const fs = require('fs');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
+
+// ── Security Helpers ────────────────────────────────────────────────────────
+
+/**
+ * Validate a file path argument for RVF operations.
+ * Prevents path traversal and restricts to safe locations.
+ */
+function validateRvfPath(filePath) {
+  if (typeof filePath !== 'string' || filePath.length === 0) {
+    throw new Error('Path must be a non-empty string');
+  }
+  const resolved = path.resolve(filePath);
+  // Block obvious path traversal
+  if (filePath.includes('..') || filePath.includes('\0')) {
+    throw new Error('Path traversal detected');
+  }
+  // Block sensitive system paths
+  const blocked = ['/etc', '/proc', '/sys', '/dev', '/boot', '/root', '/var/run'];
+  for (const prefix of blocked) {
+    if (resolved.startsWith(prefix)) {
+      throw new Error(`Access to ${prefix} is not allowed`);
+    }
+  }
+  return resolved;
+}
+
+/**
+ * Sanitize a shell argument to prevent command injection.
+ * Strips shell metacharacters and limits length.
+ */
+function sanitizeShellArg(arg) {
+  if (typeof arg !== 'string') return '';
+  // Remove null bytes, backticks, $(), and other shell metacharacters
+  return arg
+    .replace(/\0/g, '')
+    .replace(/[`$(){}|;&<>!]/g, '')
+    .replace(/\.\./g, '')
+    .slice(0, 4096);
+}
 
 // Try to load the full IntelligenceEngine
 let IntelligenceEngine = null;
@@ -294,7 +333,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.1.93',
+    version: '0.1.58',
   },
   {
     capabilities: {
@@ -1046,115 +1085,160 @@ const TOOLS = [
       required: []
     }
   },
-  // ============================================
-  // EDGE-NET DISTRIBUTED AGENT/WORKER TOOLS
-  // ============================================
+  // ── RVF Vector Store Tools ────────────────────────────────────────────────
   {
-    name: 'edge_net_info',
-    description: 'Get Edge-Net distributed network information and capabilities',
+    name: 'rvf_create',
+    description: 'Create a new RVF vector store (.rvf file) with specified dimensions and distance metric',
     inputSchema: {
       type: 'object',
-      properties: {},
-      required: []
+      properties: {
+        path: { type: 'string', description: 'File path for the new .rvf store' },
+        dimension: { type: 'number', description: 'Vector dimensionality (e.g. 128, 384, 768, 1536)' },
+        metric: { type: 'string', description: 'Distance metric: cosine, l2, or dotproduct', default: 'cosine' }
+      },
+      required: ['path', 'dimension']
     }
   },
   {
-    name: 'edge_net_spawn',
-    description: 'Spawn a distributed AI agent on the Edge-Net network. Agent types: researcher, coder, reviewer, tester, analyst, optimizer, coordinator, embedder',
+    name: 'rvf_open',
+    description: 'Open an existing RVF store for read-write operations',
     inputSchema: {
       type: 'object',
       properties: {
-        type: {
-          type: 'string',
-          description: 'Agent type',
-          enum: ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder']
-        },
-        task: { type: 'string', description: 'Task for the agent to perform' },
-        max_ruv: { type: 'number', description: 'Maximum rUv credits to spend', default: 20 },
-        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], default: 'medium' }
+        path: { type: 'string', description: 'Path to existing .rvf file' }
       },
-      required: ['type', 'task']
+      required: ['path']
     }
   },
   {
-    name: 'edge_net_pool_create',
-    description: 'Create a distributed worker pool on Edge-Net for parallel task execution',
+    name: 'rvf_ingest',
+    description: 'Insert vectors into an RVF store',
     inputSchema: {
       type: 'object',
       properties: {
-        min_workers: { type: 'number', description: 'Minimum workers', default: 2 },
-        max_workers: { type: 'number', description: 'Maximum workers', default: 10 }
+        path: { type: 'string', description: 'Path to .rvf store' },
+        entries: { type: 'array', description: 'Array of {id, vector, metadata?} objects', items: { type: 'object' } }
       },
-      required: []
+      required: ['path', 'entries']
     }
   },
   {
-    name: 'edge_net_pool_execute',
-    description: 'Execute a task on a distributed worker pool',
+    name: 'rvf_query',
+    description: 'Query nearest neighbors in an RVF store',
     inputSchema: {
       type: 'object',
       properties: {
-        task: { type: 'string', description: 'Task to execute' },
-        pool_id: { type: 'string', description: 'Pool ID (optional, auto-assigns if not provided)' }
+        path: { type: 'string', description: 'Path to .rvf store' },
+        vector: { type: 'array', description: 'Query vector as array of numbers', items: { type: 'number' } },
+        k: { type: 'number', description: 'Number of results to return', default: 10 }
       },
-      required: ['task']
+      required: ['path', 'vector']
     }
   },
   {
-    name: 'edge_net_workflow',
-    description: 'Run a multi-agent workflow on Edge-Net. Built-in workflows: code-review, feature-dev, bug-fix, optimization, research',
+    name: 'rvf_delete',
+    description: 'Delete vectors by ID from an RVF store',
     inputSchema: {
       type: 'object',
       properties: {
-        name: {
-          type: 'string',
-          description: 'Workflow name',
-          enum: ['code-review', 'feature-dev', 'bug-fix', 'optimization', 'research', 'custom']
-        },
-        task: { type: 'string', description: 'Custom task description (for custom workflow)' }
+        path: { type: 'string', description: 'Path to .rvf store' },
+        ids: { type: 'array', description: 'Vector IDs to delete', items: { type: 'number' } }
       },
-      required: ['name']
+      required: ['path', 'ids']
     }
   },
   {
-    name: 'edge_net_status',
-    description: 'Get Edge-Net network status including connected peers, capacity, active agents, and credits',
+    name: 'rvf_status',
+    description: 'Get status of an RVF store (vector count, dimension, metric, file size)',
     inputSchema: {
       type: 'object',
-      properties: {},
-      required: []
+      properties: {
+        path: { type: 'string', description: 'Path to .rvf store' }
+      },
+      required: ['path']
     }
   },
   {
-    name: 'agent_execute',
-    description: 'REAL agent execution using local ruvllm (default, no API key), or cloud APIs (Anthropic/OpenAI). Local runs without needing any API key.',
+    name: 'rvf_compact',
+    description: 'Compact an RVF store to reclaim space from deleted vectors',
     inputSchema: {
       type: 'object',
       properties: {
-        type: {
-          type: 'string',
-          description: 'Agent type',
-          enum: ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder']
-        },
-        task: { type: 'string', description: 'Task for the agent to execute' },
-        provider: { type: 'string', enum: ['local', 'ruvllm', 'anthropic', 'openai'], default: 'local', description: 'LLM provider (local by default, no API key needed)' },
-        model: { type: 'string', enum: ['fast', 'balanced', 'powerful'], default: 'balanced', description: 'Model tier' },
-        context: { type: 'string', description: 'Additional context for the agent' },
-        max_tokens: { type: 'number', default: 4096, description: 'Maximum tokens in response' }
+        path: { type: 'string', description: 'Path to .rvf store' }
+      },
+      required: ['path']
+    }
+  },
+  {
+    name: 'rvf_derive',
+    description: 'Derive a child RVF store from a parent using copy-on-write branching',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        parent_path: { type: 'string', description: 'Path to parent .rvf store' },
+        child_path: { type: 'string', description: 'Path for the new child .rvf store' }
+      },
+      required: ['parent_path', 'child_path']
+    }
+  },
+  {
+    name: 'rvf_segments',
+    description: 'List all segments in an RVF file (VEC, INDEX, KERNEL, EBPF, WITNESS, etc.)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to .rvf store' }
       },
-      required: ['type', 'task']
+      required: ['path']
     }
   },
   {
-    name: 'agent_balance',
-    description: 'Get rUv credit balance from relay server with multi-device sync status',
+    name: 'rvf_examples',
+    description: 'List available example .rvf files with download URLs from the ruvector repository',
     inputSchema: {
       type: 'object',
       properties: {
-        relay_url: { type: 'string', description: 'Relay server URL', default: 'ws://localhost:8080' }
+        filter: { type: 'string', description: 'Filter examples by name or description substring' }
       },
       required: []
     }
+  },
+  // ── rvlite Query Tools ──────────────────────────────────────────────────
+  {
+    name: 'rvlite_sql',
+    description: 'Execute SQL query over rvlite vector database with optional RVF backend',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'SQL query string (supports distance() and vec_search() functions)' },
+        db_path: { type: 'string', description: 'Path to database file (optional)' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'rvlite_cypher',
+    description: 'Execute Cypher graph query over rvlite property graph',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Cypher query string' },
+        db_path: { type: 'string', description: 'Path to database file (optional)' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'rvlite_sparql',
+    description: 'Execute SPARQL query over rvlite RDF triple store',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'SPARQL query string' },
+        db_path: { type: 'string', description: 'Path to database file (optional)' }
+      },
+      required: ['query']
+    }
   }
 ];
 
@@ -1764,7 +1848,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_ast_analyze': {
         try {
-          const output = execSync(`npx ruvector hooks ast-analyze "${args.file}" --json`, { encoding: 'utf-8', timeout: 30000 });
+          const safeFile = sanitizeShellArg(args.file);
+          const output = execSync(`npx ruvector hooks ast-analyze "${safeFile}" --json`, { encoding: 'utf-8', timeout: 30000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
@@ -1773,8 +1858,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_ast_complexity': {
         try {
-          const filesArg = args.files.map(f => `"${f}"`).join(' ');
-          const output = execSync(`npx ruvector hooks ast-complexity ${filesArg} --threshold ${args.threshold || 10}`, { encoding: 'utf-8', timeout: 60000 });
+          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
+          const threshold = parseInt(args.threshold, 10) || 10;
+          const output = execSync(`npx ruvector hooks ast-complexity ${filesArg} --threshold ${threshold}`, { encoding: 'utf-8', timeout: 60000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
@@ -1783,7 +1869,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_diff_analyze': {
         try {
-          const cmd = args.commit ? `npx ruvector hooks diff-analyze "${args.commit}" --json` : 'npx ruvector hooks diff-analyze --json';
+          const cmd = args.commit ? `npx ruvector hooks diff-analyze "${sanitizeShellArg(args.commit)}" --json` : 'npx ruvector hooks diff-analyze --json';
           const output = execSync(cmd, { encoding: 'utf-8', timeout: 60000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -1793,7 +1879,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_diff_classify': {
         try {
-          const cmd = args.commit ? `npx ruvector hooks diff-classify "${args.commit}"` : 'npx ruvector hooks diff-classify';
+          const cmd = args.commit ? `npx ruvector hooks diff-classify "${sanitizeShellArg(args.commit)}"` : 'npx ruvector hooks diff-classify';
           const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -1803,7 +1889,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_diff_similar': {
         try {
-          const output = execSync(`npx ruvector hooks diff-similar -k ${args.top_k || 5} --commits ${args.commits || 50}`, { encoding: 'utf-8', timeout: 120000 });
+          const topK = parseInt(args.top_k, 10) || 5;
+          const commits = parseInt(args.commits, 10) || 50;
+          const output = execSync(`npx ruvector hooks diff-similar -k ${topK} --commits ${commits}`, { encoding: 'utf-8', timeout: 120000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
@@ -1812,7 +1900,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_coverage_route': {
         try {
-          const output = execSync(`npx ruvector hooks coverage-route "${args.file}"`, { encoding: 'utf-8', timeout: 15000 });
+          const safeFile = sanitizeShellArg(args.file);
+          const output = execSync(`npx ruvector hooks coverage-route "${safeFile}"`, { encoding: 'utf-8', timeout: 15000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
@@ -1821,7 +1910,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_coverage_suggest': {
         try {
-          const filesArg = args.files.map(f => `"${f}"`).join(' ');
+          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
           const output = execSync(`npx ruvector hooks coverage-suggest ${filesArg}`, { encoding: 'utf-8', timeout: 30000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -1831,7 +1920,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_graph_mincut': {
         try {
-          const filesArg = args.files.map(f => `"${f}"`).join(' ');
+          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
           const output = execSync(`npx ruvector hooks graph-mincut ${filesArg}`, { encoding: 'utf-8', timeout: 60000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -1841,9 +1930,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_graph_cluster': {
         try {
-          const filesArg = args.files.map(f => `"${f}"`).join(' ');
-          const method = args.method || 'louvain';
-          const clusters = args.clusters || 3;
+          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
+          const method = sanitizeShellArg(args.method || 'louvain');
+          const clusters = parseInt(args.clusters, 10) || 3;
           const output = execSync(`npx ruvector hooks graph-cluster ${filesArg} --method ${method} --clusters ${clusters}`, { encoding: 'utf-8', timeout: 60000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -1853,7 +1942,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_security_scan': {
         try {
-          const filesArg = args.files.map(f => `"${f}"`).join(' ');
+          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
           const output = execSync(`npx ruvector hooks security-scan ${filesArg}`, { encoding: 'utf-8', timeout: 120000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -1863,7 +1952,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_rag_context': {
         try {
-          let cmd = `npx ruvector hooks rag-context "${args.query}" -k ${args.top_k || 5}`;
+          const safeQuery = sanitizeShellArg(args.query);
+          const topK = parseInt(args.top_k, 10) || 5;
+          let cmd = `npx ruvector hooks rag-context "${safeQuery}" -k ${topK}`;
           if (args.rerank) cmd += ' --rerank';
           const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
           return { content: [{ type: 'text', text: output }] };
@@ -1874,7 +1965,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_git_churn': {
         try {
-          const output = execSync(`npx ruvector hooks git-churn --days ${args.days || 30} --top ${args.top || 10}`, { encoding: 'utf-8', timeout: 30000 });
+          const days = parseInt(args.days, 10) || 30;
+          const top = parseInt(args.top, 10) || 10;
+          const output = execSync(`npx ruvector hooks git-churn --days ${days} --top ${top}`, { encoding: 'utf-8', timeout: 30000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
           return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
@@ -1883,8 +1976,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case 'hooks_route_enhanced': {
         try {
-          let cmd = `npx ruvector hooks route-enhanced "${args.task}"`;
-          if (args.file) cmd += ` --file "${args.file}"`;
+          const safeTask = sanitizeShellArg(args.task);
+          let cmd = `npx ruvector hooks route-enhanced "${safeTask}"`;
+          if (args.file) cmd += ` --file "${sanitizeShellArg(args.file)}"`;
           const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
           return { content: [{ type: 'text', text: output }] };
         } catch (e) {
@@ -2309,7 +2403,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // BACKGROUND WORKERS HANDLERS (via agentic-flow)
       // ============================================
       case 'workers_dispatch': {
-        const prompt = args.prompt;
+        const prompt = sanitizeShellArg(args.prompt);
         try {
           const result = execSync(`npx agentic-flow@alpha workers dispatch "${prompt.replace(/"/g, '\\"')}"`, {
             encoding: 'utf-8',
@@ -2490,8 +2584,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'workers_run': {
-        const name = args.name;
-        const targetPath = args.path || '.';
+        const name = sanitizeShellArg(args.name);
+        const targetPath = sanitizeShellArg(args.path || '.');
         try {
           const result = execSync(`npx agentic-flow@alpha workers run "${name}" --path "${targetPath}"`, {
             encoding: 'utf-8',
@@ -2557,7 +2651,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'workers_load_config': {
-        const configFile = args.file || 'workers.yaml';
+        const configFile = sanitizeShellArg(args.file || 'workers.yaml');
         try {
           const result = execSync(`npx agentic-flow@alpha workers load-config --file "${configFile}"`, {
             encoding: 'utf-8',
@@ -2578,404 +2672,241 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
-      // ============================================
-      // EDGE-NET DISTRIBUTED AGENT/WORKER TOOLS
-      // ============================================
-
-      case 'edge_net_info': {
-        const info = {
-          name: '@ruvector/edge-net',
-          version: '0.1.2',
-          description: 'Distributed AI agent and worker network',
-          capabilities: {
-            agents: ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder'],
-            workers: 'Distributed browser/node worker pools',
-            orchestration: 'Multi-agent task workflows',
-            credits: 'rUv (Resource Utility Vouchers) for compute'
-          },
-          features: [
-            'WebRTC P2P data channels',
-            'QDAG synchronization',
-            'Time Crystal coordination',
-            'Neural DAG attention',
-            'Swarm intelligence'
-          ],
-          install: 'npm install @ruvector/edge-net',
-          cli: 'npx edge-net start'
-        };
-        return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...info }, null, 2) }] };
-      }
-
-      case 'edge_net_spawn': {
-        // Input validation
-        const validAgentTypes = ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder'];
-        const validPriorities = ['low', 'medium', 'high', 'critical'];
-
-        const agentType = validAgentTypes.includes(args.type) ? args.type : 'coder';
-        const task = typeof args.task === 'string' ? args.task.slice(0, 1000).trim() : '';
-        const maxRuv = Math.min(Math.max(parseInt(args.max_ruv) || 20, 1), 1000);
-        const priority = validPriorities.includes(args.priority) ? args.priority : 'medium';
-
-        const agentTypes = {
-          researcher: { name: 'Researcher', capabilities: ['search', 'analyze', 'summarize'], baseRuv: 10 },
-          coder: { name: 'Coder', capabilities: ['code', 'refactor', 'debug'], baseRuv: 15 },
-          reviewer: { name: 'Reviewer', capabilities: ['review', 'audit', 'validate'], baseRuv: 12 },
-          tester: { name: 'Tester', capabilities: ['test', 'benchmark', 'validate'], baseRuv: 10 },
-          analyst: { name: 'Analyst', capabilities: ['analyze', 'metrics', 'report'], baseRuv: 8 },
-          optimizer: { name: 'Optimizer', capabilities: ['optimize', 'profile', 'improve'], baseRuv: 15 },
-          coordinator: { name: 'Coordinator', capabilities: ['orchestrate', 'route', 'schedule'], baseRuv: 20 },
-          embedder: { name: 'Embedder', capabilities: ['embed', 'vectorize', 'similarity'], baseRuv: 5 }
-        };
-
-        const typeInfo = agentTypes[agentType] || agentTypes.coder;
-        const agentId = `agent-${agentType}-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-
-        // Simulate agent spawn
-        const result = {
-          success: true,
-          agent: {
-            id: agentId,
-            type: agentType,
-            name: typeInfo.name,
-            capabilities: typeInfo.capabilities,
-            task,
-            priority,
-            maxRuv: parseInt(maxRuv),
-            baseRuv: typeInfo.baseRuv,
-            status: 'spawned',
-            estimatedCost: Math.ceil(typeInfo.baseRuv * (task.length / 100 + 1))
-          },
-          network: {
-            peers: Math.floor(Math.random() * 50) + 10,
-            availableWorkers: Math.floor(Math.random() * 20) + 5
-          },
-          message: `${typeInfo.name} agent spawned on edge-net`
-        };
-
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      // ── RVF Tool Handlers ─────────────────────────────────────────────────
+      case 'rvf_create': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { createRvfStore } = require('../dist/core/rvf-wrapper.js');
+          const store = await createRvfStore(safePath, { dimension: args.dimension, metric: args.metric || 'cosine' });
+          const status = store.status ? await store.status() : { dimension: args.dimension };
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, path: safePath, ...status }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message, hint: 'Install @ruvector/rvf: npm install @ruvector/rvf' }, null, 2) }], isError: true };
+        }
       }
 
-      case 'edge_net_pool_create': {
-        const poolId = `pool-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-        // Input validation with bounds
-        const minWorkers = Math.min(Math.max(parseInt(args.min_workers) || 2, 1), 50);
-        const maxWorkers = Math.min(Math.max(parseInt(args.max_workers) || 10, minWorkers), 100);
-
-        const result = {
-          success: true,
-          pool: {
-            id: poolId,
-            status: 'created',
-            minWorkers,
-            maxWorkers,
-            currentWorkers: minWorkers,
-            pendingTasks: 0
-          },
-          network: {
-            connectedPeers: Math.floor(Math.random() * 30) + 10,
-            totalCapacity: Math.floor(Math.random() * 100) + 50
-          },
-          message: 'Worker pool created on edge-net'
-        };
-
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      case 'rvf_open': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfStatus } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const status = await rvfStatus(store);
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, path: safePath, ...status }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
       }
 
-      case 'edge_net_pool_execute': {
-        // Input validation
-        const task = typeof args.task === 'string' ? args.task.slice(0, 1000).trim() : '';
-        const poolId = typeof args.pool_id === 'string' ? args.pool_id.replace(/[^a-zA-Z0-9-_]/g, '').slice(0, 50) : null;
-
-        if (!task) {
-          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Task is required' }, null, 2) }] };
+      case 'rvf_ingest': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfIngest, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const result = await rvfIngest(store, args.entries);
+          await rvfClose(store);
+          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 };
         }
-
-        const taskId = `task-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-        const result = {
-          success: true,
-          execution: {
-            taskId,
-            task,
-            poolId: poolId || 'auto-assigned',
-            status: 'queued',
-            workersAssigned: Math.floor(Math.random() * 5) + 1,
-            estimatedDuration: `${Math.floor(Math.random() * 30) + 5}s`,
-            estimatedRuv: Math.floor(Math.random() * 10) + 3
-          },
-          message: 'Task queued for distributed execution'
-        };
-
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
       }
 
-      case 'edge_net_workflow': {
-        // Input validation
-        const validWorkflows = ['code-review', 'feature-dev', 'bug-fix', 'optimization', 'research', 'custom'];
-        const name = validWorkflows.includes(args.name) ? args.name : 'custom';
-        const task = typeof args.task === 'string' ? args.task.slice(0, 1000).trim() : '';
-
-        const workflows = {
-          'code-review': {
-            steps: [
-              { agent: 'analyst', action: 'Analyze code structure' },
-              { agent: 'reviewer', action: 'Security and quality review' },
-              { agent: 'tester', action: 'Run test coverage analysis' },
-              { agent: 'optimizer', action: 'Suggest optimizations' }
-            ],
-            estimatedRuv: 45
-          },
-          'feature-dev': {
-            steps: [
-              { agent: 'researcher', action: 'Research requirements' },
-              { agent: 'coder', action: 'Implement feature' },
-              { agent: 'tester', action: 'Write and run tests' },
-              { agent: 'reviewer', action: 'Code review' }
-            ],
-            estimatedRuv: 60
-          },
-          'bug-fix': {
-            steps: [
-              { agent: 'analyst', action: 'Analyze bug report' },
-              { agent: 'coder', action: 'Implement fix' },
-              { agent: 'tester', action: 'Verify fix' }
-            ],
-            estimatedRuv: 35
-          },
-          'optimization': {
-            steps: [
-              { agent: 'analyst', action: 'Profile performance' },
-              { agent: 'optimizer', action: 'Identify bottlenecks' },
-              { agent: 'coder', action: 'Apply optimizations' },
-              { agent: 'tester', action: 'Benchmark results' }
-            ],
-            estimatedRuv: 50
-          },
-          'research': {
-            steps: [
-              { agent: 'researcher', action: 'Deep research' },
-              { agent: 'analyst', action: 'Analyze findings' },
-              { agent: 'embedder', action: 'Create knowledge embeddings' }
-            ],
-            estimatedRuv: 30
-          }
-        };
+      case 'rvf_query': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfQuery, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const results = await rvfQuery(store, args.vector, args.k || 10);
+          await rvfClose(store);
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, results }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
 
-        const workflow = workflows[name] || {
-          steps: [{ agent: 'coordinator', action: task || 'Custom task' }],
-          estimatedRuv: 20
-        };
+      case 'rvf_delete': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfDelete, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const result = await rvfDelete(store, args.ids);
+          await rvfClose(store);
+          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 };
+        }
+      }
 
-        const workflowId = `workflow-${name}-${Date.now()}`;
+      case 'rvf_status': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfStatus, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const status = await rvfStatus(store);
+          await rvfClose(store);
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...status }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
 
-        const result = {
-          success: true,
-          workflow: {
-            id: workflowId,
-            name,
-            status: 'initiated',
-            steps: workflow.steps.map((s, i) => ({
-              step: i + 1,
-              agent: s.agent,
-              action: s.action,
-              status: i === 0 ? 'in_progress' : 'pending'
-            })),
-            totalSteps: workflow.steps.length,
-            estimatedRuv: workflow.estimatedRuv
-          },
-          message: `Multi-agent workflow '${name}' initiated`
-        };
+      case 'rvf_compact': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfCompact, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const result = await rvfCompact(store);
+          await rvfClose(store);
+          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 };
+        }
+      }
 
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+      case 'rvf_derive': {
+        try {
+          const safeParent = validateRvfPath(args.parent_path);
+          const safeChild = validateRvfPath(args.child_path);
+          const { openRvfStore, rvfDerive, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safeParent);
+          await rvfDerive(store, safeChild);
+          await rvfClose(store);
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, parent: safeParent, child: safeChild }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
       }
 
-      case 'edge_net_status': {
-        const status = {
+      case 'rvf_segments': {
+        try {
+          const safePath = validateRvfPath(args.path);
+          const { openRvfStore, rvfClose } = require('../dist/core/rvf-wrapper.js');
+          const store = await openRvfStore(safePath);
+          const segs = await store.segments();
+          await rvfClose(store);
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, segments: segs }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      case 'rvf_examples': {
+        const BASE_URL = 'https://raw.githubusercontent.com/ruvnet/ruvector/main/examples/rvf/output';
+        const examples = [
+          { name: 'basic_store', size: '152 KB', desc: '1,000 vectors, dim 128' },
+          { name: 'semantic_search', size: '755 KB', desc: 'Semantic search with HNSW' },
+          { name: 'rag_pipeline', size: '303 KB', desc: 'RAG pipeline embeddings' },
+          { name: 'agent_memory', size: '32 KB', desc: 'AI agent episodic memory' },
+          { name: 'swarm_knowledge', size: '86 KB', desc: 'Multi-agent knowledge base' },
+          { name: 'self_booting', size: '31 KB', desc: 'Self-booting with kernel' },
+          { name: 'ebpf_accelerator', size: '153 KB', desc: 'eBPF distance accelerator' },
+          { name: 'tee_attestation', size: '102 KB', desc: 'TEE attestation + witnesses' },
+          { name: 'lineage_parent', size: '52 KB', desc: 'COW parent file' },
+          { name: 'lineage_child', size: '26 KB', desc: 'COW child (derived)' },
+          { name: 'claude_code_appliance', size: '17 KB', desc: 'Claude Code appliance' },
+          { name: 'progressive_index', size: '2.5 MB', desc: 'Large-scale HNSW index' },
+        ];
+        let filtered = examples;
+        if (args.filter) {
+          const f = args.filter.toLowerCase();
+          filtered = examples.filter(e => e.name.includes(f) || e.desc.toLowerCase().includes(f));
+        }
+        return { content: [{ type: 'text', text: JSON.stringify({
           success: true,
-          network: {
-            status: 'online',
-            connectedPeers: Math.floor(Math.random() * 100) + 20,
-            totalCapacity: Math.floor(Math.random() * 500) + 100,
-            activeAgents: Math.floor(Math.random() * 15) + 2,
-            pendingTasks: Math.floor(Math.random() * 10),
-            completedTasks24h: Math.floor(Math.random() * 200) + 50
-          },
-          credits: {
-            balance: Math.floor(Math.random() * 1000) + 100,
-            earned24h: Math.floor(Math.random() * 50) + 5,
-            spent24h: Math.floor(Math.random() * 30) + 2
-          },
-          nodes: {
-            genesis: 3,
-            regions: ['us-central1', 'europe-west1', 'asia-east1'],
-            p2pConnections: Math.floor(Math.random() * 50) + 10
-          },
-          webrtc: {
-            dataChannelsActive: Math.floor(Math.random() * 20) + 5,
-            avgLatency: `${Math.floor(Math.random() * 50) + 10}ms`
-          }
-        };
-
-        return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
+          total: 45,
+          shown: filtered.length,
+          examples: filtered.map(e => ({ ...e, url: `${BASE_URL}/${e.name}.rvf` })),
+          catalog: 'https://github.com/ruvnet/ruvector/tree/main/examples/rvf/output'
+        }, null, 2) }] };
       }
 
-      case 'agent_execute': {
-        // REAL agent execution with local ruvllm by default, or cloud APIs
-        const validTypes = ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder'];
-        const validModels = ['fast', 'balanced', 'powerful'];
-
-        const agentType = validTypes.includes(args.type) ? args.type : 'coder';
-        const task = typeof args.task === 'string' ? args.task.slice(0, 10000).trim() : '';
-        const model = validModels.includes(args.model) ? args.model : 'balanced';
-        const maxTokens = Math.min(Math.max(parseInt(args.max_tokens) || 4096, 100), 8192);
-
-        // Determine provider (local by default)
-        const provider = args.provider || 'local';
-        const isLocal = provider === 'local' || provider === 'ruvllm';
-
-        // Check for API key (only required for cloud providers)
-        const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
-        if (!isLocal && !apiKey && agentType !== 'embedder') {
-          return {
-            content: [{
-              type: 'text',
-              text: JSON.stringify({
-                success: false,
-                error: 'No API key configured for cloud provider',
-                message: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or use local provider (default)',
-                options: {
-                  local: 'Use provider=local (no API key needed)',
-                  anthropic: 'https://console.anthropic.com/',
-                  openai: 'https://platform.openai.com/api-keys'
-                }
-              }, null, 2)
-            }],
-            isError: true
-          };
+      // ── rvlite Query Tool Handlers ──────────────────────────────────────
+      case 'rvlite_sql': {
+        try {
+          let rvlite;
+          try {
+            rvlite = require('rvlite');
+          } catch (_e) {
+            return { content: [{ type: 'text', text: JSON.stringify({
+              success: false,
+              error: 'rvlite package not installed',
+              hint: 'Install with: npm install rvlite'
+            }, null, 2) }] };
+          }
+          const safeQuery = sanitizeShellArg(args.query);
+          const dbOpts = args.db_path ? { path: validateRvfPath(args.db_path) } : {};
+          const db = new rvlite.Database(dbOpts);
+          const results = db.sql(safeQuery);
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            query_type: 'sql',
+            results,
+            row_count: Array.isArray(results) ? results.length : 0
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: e.message
+          }, null, 2) }], isError: true };
         }
+      }
 
+      case 'rvlite_cypher': {
         try {
-          // Try to load real-agents module
-          let RealAgentManager;
+          let rvlite;
           try {
-            const realAgents = await import('@ruvector/edge-net/real-agents');
-            RealAgentManager = realAgents.RealAgentManager;
-          } catch (e) {
-            // Fallback to local path for development
-            const realAgentsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-agents.js');
-            const realAgents = await import(realAgentsPath);
-            RealAgentManager = realAgents.RealAgentManager;
+            rvlite = require('rvlite');
+          } catch (_e) {
+            return { content: [{ type: 'text', text: JSON.stringify({
+              success: false,
+              error: 'rvlite package not installed',
+              hint: 'Install with: npm install rvlite'
+            }, null, 2) }] };
           }
-
-          // Initialize manager with selected provider
-          const manager = new RealAgentManager({
-            provider: isLocal ? 'local' : (apiKey && process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai'),
-            apiKey: isLocal ? undefined : apiKey,
-          });
-          await manager.initialize();
-
-          // Spawn and execute
-          const effectiveProvider = isLocal ? 'local' : (apiKey && process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai');
-          const agent = await manager.spawn(agentType, { provider: effectiveProvider, model });
-
-          const context = {
-            model,
-            additionalContext: args.context,
-            maxTokens,
-          };
-
-          const startTime = Date.now();
-          const result = await agent.execute(task, context);
-          const duration = Date.now() - startTime;
-
-          await manager.close();
-
-          return {
-            content: [{
-              type: 'text',
-              text: JSON.stringify({
-                success: true,
-                real_execution: true,
-                local_mode: isLocal,
-                agent: {
-                  id: agent.id,
-                  type: agentType,
-                  provider: effectiveProvider,
-                  model: result.model || (isLocal ? 'ruvllm-balanced' : model)
-                },
-                execution: {
-                  duration_ms: duration,
-                  tokens: agent.cost,
-                  fallback: result.fallback || false
-                },
-                response: result.content
-              }, null, 2)
-            }]
-          };
-
-        } catch (execError) {
-          return {
-            content: [{
-              type: 'text',
-              text: JSON.stringify({
-                success: false,
-                error: execError.message,
-                real_execution: true,
-                hint: execError.message.includes('401') ? 'Check your API key is valid' : 'Check error message for details'
-              }, null, 2)
-            }],
-            isError: true
-          };
+          const safeQuery = sanitizeShellArg(args.query);
+          const dbOpts = args.db_path ? { path: validateRvfPath(args.db_path) } : {};
+          const db = new rvlite.Database(dbOpts);
+          const results = db.cypher(safeQuery);
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            query_type: 'cypher',
+            results,
+            row_count: Array.isArray(results) ? results.length : 0
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: e.message
+          }, null, 2) }], isError: true };
         }
       }
 
-      case 'agent_balance': {
-        const relayUrl = args.relay_url || 'ws://localhost:8080';
-
+      case 'rvlite_sparql': {
         try {
-          // Try to load real-agents module
-          let RelaySyncClient;
+          let rvlite;
           try {
-            const realAgents = await import('@ruvector/edge-net/real-agents');
-            RelaySyncClient = realAgents.RelaySyncClient;
-          } catch (e) {
-            const realAgentsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-agents.js');
-            const realAgents = await import(realAgentsPath);
-            RelaySyncClient = realAgents.RelaySyncClient;
+            rvlite = require('rvlite');
+          } catch (_e) {
+            return { content: [{ type: 'text', text: JSON.stringify({
+              success: false,
+              error: 'rvlite package not installed',
+              hint: 'Install with: npm install rvlite'
+            }, null, 2) }] };
           }
-
-          const client = new RelaySyncClient({ relayUrl });
-
-          await Promise.race([
-            client.connect(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 5000)),
-          ]);
-
-          const balance = {
+          const safeQuery = sanitizeShellArg(args.query);
+          const dbOpts = args.db_path ? { path: validateRvfPath(args.db_path) } : {};
+          const db = new rvlite.Database(dbOpts);
+          const results = db.sparql(safeQuery);
+          return { content: [{ type: 'text', text: JSON.stringify({
             success: true,
-            balance: client.getBalance(),
-            nodeId: client.nodeId,
-            relayUrl,
-            connected: true,
-            ledgerState: client.ledgerState
-          };
-
-          client.close();
-
-          return { content: [{ type: 'text', text: JSON.stringify(balance, null, 2) }] };
-
-        } catch (connError) {
-          return {
-            content: [{
-              type: 'text',
-              text: JSON.stringify({
-                success: false,
-                error: connError.message,
-                relayUrl,
-                hint: 'Start the relay server: cd examples/edge-net/relay && node index.js'
-              }, null, 2)
-            }],
-            isError: true
-          };
+            query_type: 'sparql',
+            results,
+            row_count: Array.isArray(results) ? results.length : 0
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: e.message
+          }, null, 2) }], isError: true };
         }
       }