ruDevolution

npx ruvector decompile @anthropic-ai/claude-code
npx ruvector decompile openai
npx ruvector decompile @google-cloud/vertexai
npx ruvector decompile @aws-sdk/client-bedrock-runtime
npx ruvector decompile @azure/openai
npx ruvector decompile @mistralai/mistralai
npx ruvector decompile replicate
npx ruvector decompile @huggingface/inference

npx ruvector decompile firebase-tools
npx ruvector decompile vercel
npx ruvector decompile netlify-cli
npx ruvector decompile wrangler
npx ruvector decompile @google-cloud/functions-framework
npx ruvector decompile @aws-sdk/client-lambda
npx ruvector decompile @azure/functions

npx ruvector decompile @modelcontextprotocol/sdk
npx ruvector decompile @copilot-extensions/preview-sdk
npx ruvector decompile typescript
npx ruvector decompile esbuild
npx ruvector decompile webpack

Step 1: Get the minified bundle

npm pack express --pack-destination /tmp/
tar xzf /tmp/express-*.tgz -C /tmp/

Step 2: Run the decompiler

use ruvector_decompiler::{decompile, DecompileConfig};
let source = std::fs::read_to_string("/tmp/package/index.js")?;
let result = decompile(&source, &DecompileConfig::default())?;

Step 3: Check the results

// How many modules were detected?
println!("Modules: {}", result.modules.len());
// What names were recovered?
for name in result.inferred_names.iter().filter(|n| n.confidence > 0.8) {
 println!("{} → {} ({}%)", name.original, name.inferred, 
 (name.confidence * 100.0) as u32);
}
// Verify the witness chain
assert!(result.witness_chain.is_valid);

Step 4: Use the source map

// In your browser console:
//# sourceMappingURL=decompiled.js.map

Compare Claude Code versions

# Build RVF corpus for all versions
./scripts/claude-code-rvf-corpus.sh
# Each version gets its own RVF container:
# versions/v0.2.x/claude-code-v0.2.rvf (300 vectors)
# versions/v1.0.x/claude-code-v1.0.rvf (482 vectors)
# versions/v2.0.x/claude-code-v2.0.rvf (785 vectors)
# versions/v2.1.x/claude-code-v2.1.rvf (2,068 vectors)

Track what changed

// Decompile two versions
let v1 = decompile(&v1_source, &config)?;
let v2 = decompile(&v2_source, &config)?;
// Functions with same structure but different minified names
// = same original function, renamed by the bundler
// This confirms name inferences across versions

Train from ground truth

use ruvector_decompiler::inferrer::NameInferrer;
let mut inferrer = NameInferrer::new();
// Provide known correct mappings
let ground_truth = vec![
 ("a$", "createRouter"),
 ("b$", "handleRequest"),
 ("c$", "sendResponse"),
];
// Train the inferrer
inferrer.learn_from_ground_truth(&ground_truth);
// Future inferences will be more accurate
// The patterns are stored and reused

Feed back real-world results

// After manual review, tell the inferrer what was correct
let feedback = vec![
 Feedback { predicted: "error_handler", actual: "McpErrorHandler", was_correct: false },
 Feedback { predicted: "route_handler", actual: "routeHandler", was_correct: true },
];
inferrer.learn_from_feedback(&feedback);

Prove decompilation is faithful

let result = decompile(&source, &config)?;
// The witness chain proves every output byte comes from the input
assert!(result.witness_chain.is_valid);
println!("Source hash: {}", result.witness_chain.source_hash_hex);
println!("Chain root: {}", result.witness_chain.chain_root_hex);
// Each module has its own witness
for witness in &result.witness_chain.module_witnesses {
 println!(" {} byte_range={}..{} hash={}",
 witness.module_name,
 witness.byte_range.0, witness.byte_range.1,
 witness.content_hash_hex);
}
// Anyone can verify: reconstruct the Merkle tree and compare roots
let verified = result.witness_chain.verify(&source);
assert!(verified);

Train a deobfuscation model

# Generate training data (10K+ minified→original pairs)
node scripts/training/generate-deobfuscation-data.mjs
# Launch GPU training on GCloud L4 (~1ドル.40, ~2 hours)
./scripts/training/launch-gpu-training.sh --cloud
# Export model to GGUF for RuvLLM
python scripts/training/export-to-rvf.py

Use the trained model

let config = DecompileConfig {
 model_path: Some("models/deobfuscator.gguf".into()),
 ..Default::default()
};
let result = decompile(&source, &config)?;
// Neural inference runs first, falls back to patterns
// Expect 60-80% name accuracy vs 5% without model

How the model works

Input: minified name "s$" + context ["tools/call", "initialize", ".client"]
 │
 ▼
 ┌──────────────┐
 │ 6M param │
 │ Transformer │ Character-level encoder
 │ (GGUF Q4) │ Trained on 100K+ pairs
 └──────┬───────┘
 │
 ▼
Output: "mcpToolDispatcher" (confidence: 0.87)

Store decompiled code in RVF

# Build RVF containers for all Claude Code versions
./scripts/claude-code-rvf-corpus.sh
# Each .rvf file contains:
# - HNSW-indexed vectors (semantic search)
# - Witness chains (provenance)
# - Manifest (metadata)
# - Module segments (source code)

Query the RVF corpus

import { RvfDatabase } from '@ruvector/rvf';
const db = await RvfDatabase.openReadonly('claude-code-v2.1.rvf');
const results = await db.search('permission system', { limit: 5 });
for (const hit of results) {
 console.log(`${hit.module} (score: ${hit.score.toFixed(3)})`);
}

DecompileConfig

let config = DecompileConfig {
 // Module detection
 target_modules: None, // Auto-detect (recommended)
 min_module_size: Some(3), // Minimum declarations per module
 
 // Name inference
 min_confidence: 0.3, // Minimum confidence to include
 model_path: None, // Path to neural model (optional)
 
 // Output
 generate_source_map: true, // V3 source maps
 beautify: true, // Indent and format output
};

Environment variables