ruvector 0.2.19 → 0.2.20

package/bin/cli.js

@@ -8923,5 +8923,144 @@ routeCmd.command('info')
     console.log('');
   });
 
+// ── Decompile Command ──────────────────────────────────────────────────────
+const decompileCmd = program
+  .command('decompile [target]')
+  .description('Decompile npm packages, local JS files, or URLs into modules')
+  .option('-o, --output <dir>', 'Output directory')
+  .option('-f, --format <type>', 'Output format: modules, single, json', 'modules')
+  .option('-c, --confidence <n>', 'Minimum confidence threshold (0-1)', '0.3')
+  .option('--no-witness', 'Skip witness chain generation')
+  .option('--json', 'JSON output to stdout (for piping)')
+  .option('-q, --quiet', 'Suppress progress output')
+  .option('--version-pkg <ver>', 'Package version (alternative to @version syntax)')
+  .option('--diff <version>', 'Compare against another version')
+  .action(async (target, opts) => {
+    if (!target) {
+      console.log(chalk.cyan('\nUsage:'));
+      console.log(chalk.white('  ruvector decompile <package>           Decompile npm package'));
+      console.log(chalk.white('  ruvector decompile <pkg>@<ver>         Specific version'));
+      console.log(chalk.white('  ruvector decompile ./bundle.js         Local file'));
+      console.log(chalk.white('  ruvector decompile https://unpkg.com/x URL'));
+      console.log(chalk.dim('\nOptions:'));
+      console.log(chalk.dim('  -o, --output <dir>     Output directory'));
+      console.log(chalk.dim('  -f, --format <type>    modules | single | json'));
+      console.log(chalk.dim('  -c, --confidence <n>   Min confidence (0-1, default: 0.3)'));
+      console.log(chalk.dim('  --no-witness           Skip witness chain'));
+      console.log(chalk.dim('  --json                 JSON to stdout'));
+      console.log(chalk.dim('  --diff <version>       Diff against another version'));
+      console.log('');
+      return;
+    }
+
+    const decompiler = require('../src/decompiler/index.js');
+    const { parseTarget } = decompiler;
+    const parsed = parseTarget(target);
+    const minConfidence = parseFloat(opts.confidence);
+    const decompileOpts = { minConfidence, witness: opts.witness !== false, useRust: true };
+    const quiet = opts.quiet || opts.json;
+    let spinner = null;
+
+    if (!quiet) {
+      spinner = ora('Analyzing target...').start();
+    }
+
+    try {
+      let result;
+
+      if (parsed.type === 'npm') {
+        const version = opts.versionPkg || parsed.version;
+        if (!quiet) spinner.text = `Fetching ${parsed.name}${version ? '@' + version : ''}...`;
+        result = await decompiler.decompilePackage(parsed.name, version, decompileOpts);
+        if (!quiet) spinner.text = `Decompiled ${result.packageInfo.name}@${result.packageInfo.version}`;
+      } else if (parsed.type === 'file') {
+        if (!quiet) spinner.text = `Reading ${parsed.path}...`;
+        result = decompiler.decompileFile(parsed.path, { ...decompileOpts, filePath: parsed.path });
+      } else if (parsed.type === 'url') {
+        if (!quiet) spinner.text = `Fetching ${parsed.url}...`;
+        result = await decompiler.decompileUrl(parsed.url, decompileOpts);
+      }
+
+      if (!quiet) spinner.succeed(chalk.green('Decompilation complete'));
+
+      // Handle --diff flag
+      if (opts.diff && parsed.type === 'npm') {
+        if (!quiet) {
+          const diffSpinner = ora(`Fetching ${parsed.name}@${opts.diff} for diff...`).start();
+          try {
+            const other = await decompiler.decompilePackage(parsed.name, opts.diff, decompileOpts);
+            diffSpinner.succeed('Diff complete');
+            const resultNames = new Set(result.modules.map((m) => m.name));
+            const otherNames = new Set(other.modules.map((m) => m.name));
+            const added = [...resultNames].filter((n) => !otherNames.has(n));
+            const removed = [...otherNames].filter((n) => !resultNames.has(n));
+            const common = [...resultNames].filter((n) => otherNames.has(n));
+
+            console.log(chalk.bold.cyan('\n  Version Diff'));
+            console.log(chalk.white(`  ${opts.diff} -> ${result.packageInfo.version}`));
+            if (added.length) console.log(chalk.green(`  Added:   ${added.join(', ')}`));
+            if (removed.length) console.log(chalk.red(`  Removed: ${removed.join(', ')}`));
+            console.log(chalk.dim(`  Common:  ${common.length} modules`));
+            console.log('');
+          } catch (err) {
+            diffSpinner.fail(`Diff failed: ${err.message}`);
+          }
+        }
+      }
+
+      // Output
+      if (opts.json) {
+        const jsonOut = {
+          modules: result.modules.map((m) => ({
+            name: m.name, fragments: m.fragments, confidence: m.confidence,
+            contentLength: m.content.length,
+          })),
+          metrics: result.metrics,
+          witness: result.witness ? { root: result.witness.root, chain_length: result.witness.chain.length } : null,
+          packageInfo: result.packageInfo || null,
+        };
+        console.log(JSON.stringify(jsonOut, null, 2));
+        return;
+      }
+
+      // Determine output directory
+      let outputDir = opts.output;
+      if (!outputDir) {
+        const baseName = result.packageInfo
+          ? `${result.packageInfo.name.replace('/', '-')}@${result.packageInfo.version}`
+          : path.basename(target, '.js');
+        outputDir = path.join(process.cwd(), 'decompiled', baseName);
+      }
+
+      decompiler.writeOutput(result, outputDir, opts.format);
+
+      console.log(chalk.bold.cyan('\n  Decompilation Summary'));
+      console.log(chalk.white(`  Modules:     ${result.modules.length}`));
+      console.log(chalk.white(`  Source size:  ${(result.metrics.source.sizeBytes / 1024).toFixed(1)} KB`));
+      console.log(chalk.white(`  Functions:    ${result.metrics.source.functions}`));
+      console.log(chalk.white(`  Classes:      ${result.metrics.source.classes}`));
+      if (result.witness) {
+        const wRoot = result.witness.root || result.witness.chain_root || '';
+        console.log(chalk.white(`  Witness root: ${wRoot.slice(0, 16)}...`));
+      }
+      console.log(chalk.green(`  Output:       ${outputDir}`));
+      console.log('');
+
+      if (result.modules.length > 0) {
+        console.log(chalk.dim('  Detected modules:'));
+        for (const mod of result.modules) {
+          const conf = (mod.confidence * 100).toFixed(0);
+          console.log(chalk.dim(`    ${mod.name} (${mod.fragments} fragments, ${conf}% confidence)`));
+        }
+        console.log('');
+      }
+    } catch (err) {
+      if (spinner) spinner.fail(chalk.red('Decompilation failed'));
+      console.error(chalk.red(`  ${err.message}`));
+      process.exit(1);
+    }
+  });
+
 program.parse();
 
+

package/bin/mcp-server.js

@@ -1464,6 +1464,84 @@ const TOOLS = [
       },
       required: []
     }
+  },
+
+  // ── Decompiler Tools ───────────────────────────────────────────────────
+  {
+    name: 'decompile_package',
+    description: 'Decompile an npm package. Fetches from registry, extracts bundle, splits into modules, computes metrics and witness chain.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        package: { type: 'string', description: 'npm package name (e.g. "express", "@anthropic-ai/claude-code")' },
+        version: { type: 'string', description: 'Version (default: latest)' },
+        min_confidence: { type: 'number', description: 'Minimum confidence threshold (0-1, default: 0.3)' }
+      },
+      required: ['package']
+    }
+  },
+  {
+    name: 'decompile_file',
+    description: 'Decompile a local JavaScript file. Beautifies, splits into modules, computes metrics.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to .js file' },
+        min_confidence: { type: 'number', description: 'Minimum confidence threshold (0-1, default: 0.3)' }
+      },
+      required: ['path']
+    }
+  },
+  {
+    name: 'decompile_url',
+    description: 'Decompile JavaScript from a URL (unpkg, CDN, raw GitHub, etc).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to fetch JavaScript from' },
+        min_confidence: { type: 'number', description: 'Minimum confidence threshold (0-1, default: 0.3)' }
+      },
+      required: ['url']
+    }
+  },
+  {
+    name: 'decompile_search',
+    description: 'Search decompiled code for patterns, function names, or string literals.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query (regex supported)' },
+        package: { type: 'string', description: 'npm package to decompile and search' },
+        version: { type: 'string', description: 'Package version (default: latest)' },
+        path: { type: 'string', description: 'Local file path to decompile and search (alternative to package)' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'decompile_diff',
+    description: 'Compare decompiled output between two versions of an npm package. Shows added/removed/changed modules.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        package: { type: 'string', description: 'npm package name' },
+        version_a: { type: 'string', description: 'First version' },
+        version_b: { type: 'string', description: 'Second version' }
+      },
+      required: ['package', 'version_a', 'version_b']
+    }
+  },
+  {
+    name: 'decompile_witness',
+    description: 'Verify the cryptographic witness chain of a decompilation. Proves output derives faithfully from input.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        witness_path: { type: 'string', description: 'Path to witness.json file' },
+        source_path: { type: 'string', description: 'Path to original bundle (optional, for source hash verification)' }
+      },
+      required: ['witness_path']
+    }
   }
 ];
 
@@ -3417,6 +3495,197 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: 'text', text: JSON.stringify({ success: true, pseudonym, mcp_token: mcpToken, key_prefix: key.slice(0, 8) + '...' }, null, 2) }] };
       }
 
+      // ── Decompiler Tool Handlers ─────────────────────────────────────────
+      case 'decompile_package': {
+        const decompiler = require('../src/decompiler/index.js');
+        const result = await decompiler.decompilePackage(
+          args.package,
+          args.version || undefined,
+          { minConfidence: args.min_confidence || 0.3 }
+        );
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              packageInfo: result.packageInfo,
+              modules: result.modules.map(m => ({
+                name: m.name, fragments: m.fragments, confidence: m.confidence,
+                contentPreview: m.content.slice(0, 500) + (m.content.length > 500 ? '...' : ''),
+              })),
+              metrics: result.metrics,
+              witness_root: result.witness ? result.witness.root : null,
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'decompile_file': {
+        const decompiler = require('../src/decompiler/index.js');
+        const safePath = validateRvfPath(args.path);
+        const result = decompiler.decompileFile(safePath, {
+          minConfidence: args.min_confidence || 0.3
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              filePath: result.filePath,
+              modules: result.modules.map(m => ({
+                name: m.name, fragments: m.fragments, confidence: m.confidence,
+                contentPreview: m.content.slice(0, 500) + (m.content.length > 500 ? '...' : ''),
+              })),
+              metrics: result.metrics,
+              witness_root: result.witness ? result.witness.root : null,
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'decompile_url': {
+        const decompiler = require('../src/decompiler/index.js');
+        const urlStr = args.url;
+        // Basic URL validation
+        if (!urlStr.startsWith('http://') && !urlStr.startsWith('https://')) {
+          throw new Error('URL must start with http:// or https://');
+        }
+        const result = await decompiler.decompileUrl(urlStr, {
+          minConfidence: args.min_confidence || 0.3
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              url: result.url,
+              modules: result.modules.map(m => ({
+                name: m.name, fragments: m.fragments, confidence: m.confidence,
+                contentPreview: m.content.slice(0, 500) + (m.content.length > 500 ? '...' : ''),
+              })),
+              metrics: result.metrics,
+              witness_root: result.witness ? result.witness.root : null,
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'decompile_search': {
+        const decompiler = require('../src/decompiler/index.js');
+        let result;
+        if (args.path) {
+          const safePath = validateRvfPath(args.path);
+          result = decompiler.decompileFile(safePath);
+        } else if (args.package) {
+          result = await decompiler.decompilePackage(args.package, args.version || undefined);
+        } else {
+          throw new Error('Either "package" or "path" must be provided');
+        }
+
+        const query = args.query;
+        let regex;
+        try { regex = new RegExp(query, 'gi'); } catch { regex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'); }
+
+        const matches = [];
+        for (const mod of result.modules) {
+          const lines = mod.content.split('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              matches.push({
+                module: mod.name,
+                line: i + 1,
+                content: lines[i].trim().slice(0, 200),
+              });
+              regex.lastIndex = 0;
+            }
+            if (matches.length >= 50) break;
+          }
+          if (matches.length >= 50) break;
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              query,
+              total_matches: matches.length,
+              matches,
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'decompile_diff': {
+        const decompiler = require('../src/decompiler/index.js');
+        const [resultA, resultB] = await Promise.all([
+          decompiler.decompilePackage(args.package, args.version_a),
+          decompiler.decompilePackage(args.package, args.version_b),
+        ]);
+
+        const namesA = new Set(resultA.modules.map(m => m.name));
+        const namesB = new Set(resultB.modules.map(m => m.name));
+        const added = [...namesB].filter(n => !namesA.has(n));
+        const removed = [...namesA].filter(n => !namesB.has(n));
+        const common = [...namesA].filter(n => namesB.has(n));
+
+        // Compare declarations in common modules
+        const changedDeclarations = [];
+        for (const name of common) {
+          const modA = resultA.modules.find(m => m.name === name);
+          const modB = resultB.modules.find(m => m.name === name);
+          if (modA && modB && modA.content !== modB.content) {
+            changedDeclarations.push({
+              module: name,
+              sizeChange: modB.content.length - modA.content.length,
+              fragmentsA: modA.fragments,
+              fragmentsB: modB.fragments,
+            });
+          }
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              package: args.package,
+              version_a: args.version_a,
+              version_b: args.version_b,
+              added_modules: added,
+              removed_modules: removed,
+              common_modules: common.length,
+              changed_declarations: changedDeclarations,
+              metrics_a: resultA.metrics.source,
+              metrics_b: resultB.metrics.source,
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'decompile_witness': {
+        const decompiler = require('../src/decompiler/index.js');
+        const witnessPath = validateRvfPath(args.witness_path);
+        const witnessData = JSON.parse(fs.readFileSync(witnessPath, 'utf-8'));
+
+        let sourceContent = undefined;
+        if (args.source_path) {
+          const sourcePath = validateRvfPath(args.source_path);
+          sourceContent = fs.readFileSync(sourcePath, 'utf-8');
+        }
+
+        const verification = decompiler.verifyWitnessChain(witnessData, sourceContent);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              ...verification,
+            }, null, 2)
+          }]
+        };
+      }
+
       default:
         return {
           content: [{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "Self-learning vector database for Node.js — hybrid search, Graph RAG, FlashAttention-3, DiskANN, 50+ attention mechanisms",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -76,6 +76,7 @@
     "@ruvector/sona": "^0.1.4",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
+    "js-beautify": "^1.15.4",
     "ora": "^5.4.1"
   },
   "optionalDependencies": {
@@ -88,18 +89,25 @@
   "files": [
     "bin/",
     "dist/",
+    "src/decompiler/",
     "README.md",
     "LICENSE"
   ],
   "peerDependencies": {
     "@ruvector/pi-brain": ">=0.1.0",
-    "@ruvector/ruvllm": ">=2.0.0",
-    "@ruvector/router": ">=0.1.0"
+    "@ruvector/router": ">=0.1.0",
+    "@ruvector/ruvllm": ">=2.0.0"
   },
   "peerDependenciesMeta": {
-    "@ruvector/pi-brain": { "optional": true },
-    "@ruvector/ruvllm": { "optional": true },
-    "@ruvector/router": { "optional": true }
+    "@ruvector/pi-brain": {
+      "optional": true
+    },
+    "@ruvector/ruvllm": {
+      "optional": true
+    },
+    "@ruvector/router": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=18.0.0"