@ruv.io/* - Comprehensive Rust-to-NPM Wrapper Ecosystem

🎯 Project Overview

This monorepo contains a comprehensive ecosystem of 110 NPM packages that wrap Rust crates from crates.io/users/ruvnet using napi-rs. Each package provides high-performance Node.js bindings to powerful Rust libraries spanning AI/ML, blockchain, quantum computing, neural networks, temporal systems, and more.

🚀 Key Features

110 High-Performance Packages: Every Rust crate wrapped with native Node.js bindings
Zero-Copy Operations: Leverage Rust's memory safety with JavaScript convenience
Cross-Platform Support: Works on Linux, macOS, Windows (x64, ARM64)
TypeScript First: Full TypeScript definitions for all packages
WASM Fallback: WebAssembly builds for unsupported platforms
MCP Protocol Support: Model Context Protocol integration for AI agents
CLI Tools: Command-line interfaces for development and operations
Swarm Orchestration: Multi-agent coordination using claude-flow and agentdb

📋 SPARC Specification

S - Specification

1.1 Project Scope

Transform 110 Rust crates into production-ready NPM packages using napi-rs, providing:

Native Node.js bindings for maximum performance
TypeScript definitions for type safety
Comprehensive documentation and examples
Automated CI/CD pipelines
Cross-platform binary distribution

1.2 Architecture Categories

The 110 crates are organized into 16 major categories:

Category	Count	Description
AI/ML Systems	8	AIMDS, DAA, Veritas-Nexus, Goalie
Swarm Orchestration	16	RUV-Swarm, Code-Mesh, Synaptic systems
CLI Tools	9	Command-line interfaces for all major systems
WASM Bindings	8	WebAssembly-ready packages
MCP Protocol	5	Model Context Protocol servers and clients
Blockchain/Crypto	16	QuDAG, Claude Market, Quantum-resistant crypto
Quantum Computing	16	QVM Scheduler, ML-KEM/ML-DSA implementations
Neural Networks	17	RUV-FANN, Micro-networks, Neuro-divergent
Temporal Systems	14	Time dilation, Strange loops, Consciousness models
Mathematical	5	Geometric Langlands, Sublinear solvers
Trading/Finance	12	Neural Trader suite (backtesting, execution, portfolio)
Computer Vision	3	OpenCV bindings and WASM support
Dev Tools	7	CUDA transpiler, Jujutsu VCS, Parser utilities
Type Systems	3	Lean theorem prover, Dependent types
Networking	4	P2P, BitChat, QuDAG network layer
Databases	3	AgentDB, DHT, Persistence layers

1.3 Technical Requirements

Core Technology Stack

Build System: napi-rs with @napi-rs/cli
Language: Rust (stable) + TypeScript
Package Manager: npm/pnpm with workspaces
CI/CD: GitHub Actions with multi-platform builds
Testing: Jest + Rust cargo test
Documentation: TypeDoc + mdBook

Platform Support Matrix

├── Node.js: >= 16.x
├── Platforms:
│   ├── linux-x64-gnu
│   ├── linux-x64-musl
│   ├── linux-arm64-gnu
│   ├── darwin-x64
│   ├── darwin-arm64
│   ├── win32-x64-msvc
│   └── wasm32 (fallback)
├── Rust: >= 1.70
└── TypeScript: >= 5.0

1.4 Package Naming Convention

All packages follow the naming pattern: @ruv.io/{crate-name}

Examples:

@ruv.io/ruv-fann → Neural network library
@ruv.io/qudag → Quantum-resistant DAG platform
@ruv.io/temporal-compare → Temporal prediction benchmarking
@ruv.io/geometric-langlands → Mathematical framework

1.5 Success Criteria

All 110 crates have corresponding NPM packages
95%+ test coverage across all packages
Cross-platform binaries for 7+ platforms
< 10ms overhead for native bindings
Complete TypeScript definitions
Automated CI/CD with release automation
Comprehensive documentation (API + guides)
Working examples for each package

P - Pseudocode

2.1 Package Structure Template

@ruv.io/{crate-name}/
├── Cargo.toml              # Rust crate configuration
├── package.json            # NPM package configuration
├── build.rs                # napi-rs build script
├── src/
│   ├── lib.rs              # Rust source (napi bindings)
│   └── index.ts            # TypeScript exports
├── __test__/
│   ├── index.spec.ts       # Jest tests
│   └── integration.test.ts # Integration tests
├── examples/
│   ├── basic.js            # JavaScript example
│   └── advanced.ts         # TypeScript example
├── docs/
│   └── API.md              # API documentation
├── .github/
│   └── workflows/
│       ├── build.yml       # Build workflow
│       └── release.yml     # Release workflow
└── README.md               # Package README

2.2 Build Process Flow

// High-level pseudocode for napi-rs wrapper

#[napi]
pub struct RustStruct {
  inner: Arc<Mutex<OriginalRustType>>,
}

#[napi]
impl RustStruct {
  #[napi(constructor)]
  pub fn new(config: JsObject) -> Result<Self> {
    // 1. Parse JS config to Rust types
    let rust_config = parse_js_config(config)?;

    // 2. Initialize Rust struct
    let inner = OriginalRustType::new(rust_config)?;

    // 3. Wrap in Arc<Mutex> for thread safety
    Ok(Self {
      inner: Arc::new(Mutex::new(inner))
    })
  }

  #[napi]
  pub async fn process(&self, input: Buffer) -> Result<Buffer> {
    // 1. Convert JS Buffer to Rust bytes
    let data = input.as_ref();

    // 2. Process in Rust (async)
    let result = self.inner.lock().unwrap()
      .process(data)
      .await?;

    // 3. Convert back to JS Buffer
    Ok(Buffer::from(result))
  }
}

2.3 Orchestration Pseudocode (claude-flow)

// Agent orchestration using claude-flow and agentdb

import { AgentSwarm, AgentDB } from '@ruv.io/ruv-swarm-core'
import { ClaudeFlow } from 'claude-flow'
import { E2BSandbox } from '@e2b/sdk'

async function orchestratePackageBuilds() {
  // 1. Initialize agent database
  const agentdb = new AgentDB({
    connection: 'sqlite://agents.db',
    vectorStore: 'chroma'
  })

  // 2. Load all 110 crate specifications
  const crates = await loadCrateSpecs('/plans/*.md')

  // 3. Create agent swarm
  const swarm = new ClaudeFlow({
    agents: crates.map(crate => ({
      id: `builder-${crate.name}`,
      role: 'package-builder',
      capabilities: ['rust', 'napi', 'typescript'],
      context: crate
    })),
    coordination: 'hierarchical',
    memory: agentdb
  })

  // 4. Build dependency graph
  const graph = buildDependencyGraph(crates)

  // 5. Execute build swarm
  for (const batch of graph.topologicalBatches()) {
    await Promise.all(batch.map(async (crate) => {
      // Create E2B sandbox for isolated build
      const sandbox = await E2BSandbox.create({
        template: 'rust-napi-builder',
        envVars: {
          OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY
        }
      })

      // Execute build agent
      const agent = swarm.getAgent(`builder-${crate.name}`)
      const result = await agent.execute({
        task: 'build-napi-package',
        sandbox,
        spec: crate
      })

      // Store results in agentdb
      await agentdb.store({
        agent: agent.id,
        result,
        artifacts: result.binaries
      })

      await sandbox.close()
    }))
  }

  // 6. Generate summary report
  return swarm.generateReport()
}

A - Architecture

3.1 System Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│                     @ruv.io NPM Ecosystem                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Claude Flow Orchestration                  │   │
│  │  ┌──────────────────────────────────────────────────┐   │   │
│  │  │  Agent Swarm Manager                             │   │   │
│  │  │  - 110 Builder Agents (1 per crate)             │   │   │
│  │  │  - Dependency Resolution                          │   │   │
│  │  │  - Parallel Build Coordination                    │   │   │
│  │  └──────────────────────────────────────────────────┘   │   │
│  │                          ↓                               │   │
│  │  ┌──────────────────────────────────────────────────┐   │   │
│  │  │  AgentDB (Memory & Coordination)                 │   │   │
│  │  │  - Build State                                    │   │   │
│  │  │  - Dependency Graph                               │   │   │
│  │  │  - Artifact Registry                              │   │   │
│  │  └──────────────────────────────────────────────────┘   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                            ↓                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │           E2B Sandbox Cluster (via OpenRouter)          │   │
│  │  ┌────────┐  ┌────────┐  ┌────────┐       ┌────────┐   │   │
│  │  │Sandbox1│  │Sandbox2│  │Sandbox3│  ...  │Sandbox │   │   │
│  │  │rust    │  │rust    │  │rust    │       │  110   │   │   │
│  │  │+ napi  │  │+ napi  │  │+ napi  │       │+ napi  │   │   │
│  │  └────────┘  └────────┘  └────────┘       └────────┘   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                            ↓                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                  Build Pipeline                          │   │
│  │                                                           │   │
│  │  For each crate:                                         │   │
│  │  1. Parse Cargo.toml → Extract metadata                 │   │
│  │  2. Generate napi bindings → lib.rs                     │   │
│  │  3. Generate TypeScript defs → index.d.ts               │   │
│  │  4. Build native binaries → .node files                 │   │
│  │  5. Run tests → cargo test + jest                       │   │
│  │  6. Generate docs → API.md                              │   │
│  │  7. Package → @ruv.io/{name}@{version}.tgz             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                            ↓                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │            Distribution & Registry                       │   │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │   │
│  │  │   NPM.js     │  │  GitHub      │  │  Documentation│  │   │
│  │  │   Registry   │  │  Releases    │  │  Site         │  │   │
│  │  └──────────────┘  └──────────────┘  └──────────────┘  │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

3.2 Package Architecture Layers

┌──────────────────────────────────────────────────┐
│          Layer 4: Application Layer              │
│  User Code (JavaScript/TypeScript/WASM)         │
└──────────────────┬───────────────────────────────┘
                   │
┌──────────────────▼───────────────────────────────┐
│          Layer 3: NPM Package Layer              │
│  @ruv.io/* packages with TypeScript bindings    │
└──────────────────┬───────────────────────────────┘
                   │
┌──────────────────▼───────────────────────────────┐
│          Layer 2: NAPI Bridge Layer              │
│  napi-rs FFI bindings (zero-copy transfers)     │
└──────────────────┬───────────────────────────────┘
                   │
┌──────────────────▼───────────────────────────────┐
│          Layer 1: Rust Core Layer                │
│  Original Rust crates (110 packages)            │
└──────────────────────────────────────────────────┘

3.3 Dependency Resolution Strategy

Build Order Algorithm:

Parse all 110 Cargo.toml files
Build directed acyclic graph (DAG) of dependencies
Topological sort to determine build order
Group independent crates into parallel batches
Execute batches sequentially, crates in parallel

Example Dependency Chains:

Core Libraries (Batch 1):
  - aimds-core
  - daa-prime-core
  - ruv-swarm-core
  - micro_core
  - nt-core

Derived Libraries (Batch 2):
  - aimds-detection → aimds-core
  - aimds-analysis → aimds-core + aimds-detection
  - ruv-swarm-agents → ruv-swarm-core
  - ruv-swarm-ml → ruv-swarm-core

CLI Tools (Batch 3):
  - daa-cli → daa-orchestrator
  - qudag-cli → qudag-protocol
  - code-mesh-cli → code-mesh-core

WASM Bindings (Batch 4):
  - ruv-swarm-wasm → ruv-swarm-core
  - code-mesh-wasm → code-mesh-core
  - qudag-wasm → qudag-protocol

3.4 Cross-Platform Binary Strategy

Each package will include platform-specific binaries:

{
  "name": "@ruv.io/package-name",
  "version": "1.0.0",
  "napi": {
    "name": "package-name",
    "triples": {
      "defaults": true,
      "additional": [
        "x86_64-unknown-linux-musl",
        "aarch64-unknown-linux-gnu",
        "armv7-unknown-linux-gnueabihf",
        "aarch64-apple-darwin",
        "x86_64-apple-darwin",
        "x86_64-pc-windows-msvc",
        "i686-pc-windows-msvc",
        "aarch64-pc-windows-msvc",
        "wasm32-wasi"
      ]
    }
  },
  "optionalDependencies": {
    "@ruv.io/package-name-linux-x64-gnu": "1.0.0",
    "@ruv.io/package-name-linux-x64-musl": "1.0.0",
    "@ruv.io/package-name-linux-arm64-gnu": "1.0.0",
    "@ruv.io/package-name-darwin-x64": "1.0.0",
    "@ruv.io/package-name-darwin-arm64": "1.0.0",
    "@ruv.io/package-name-win32-x64-msvc": "1.0.0",
    "@ruv.io/package-name-wasm32": "1.0.0"
  }
}

R - Refinement

4.1 Performance Optimization

Zero-Copy Data Transfer:

// Avoid copying large buffers between Rust and JS
#[napi]
pub fn process_buffer(#[napi(external)] buffer: External<Vec<u8>>) -> Result<External<Vec<u8>>> {
  // Process buffer in-place without copying
  let mut data = buffer.clone();
  // ... process data ...
  Ok(External::new(data))
}

Async Processing:

// Use tokio for async I/O operations
#[napi]
pub async fn fetch_data(url: String) -> Result<Buffer> {
  let response = reqwest::get(&url).await?;
  let bytes = response.bytes().await?;
  Ok(Buffer::from(bytes.to_vec()))
}

Thread Pool Management:

// Share thread pools across instances
lazy_static! {
  static ref THREAD_POOL: ThreadPool = ThreadPoolBuilder::new()
    .num_threads(num_cpus::get())
    .build()
    .unwrap();
}

4.2 Error Handling Strategy

Rust → JS Error Conversion:

use napi::Error as NapiError;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum CustomError {
  #[error("Network error: {0}")]
  Network(#[from] reqwest::Error),

  #[error("Parse error: {0}")]
  Parse(String),

  #[error("Invalid state: {0}")]
  InvalidState(String),
}

impl From<CustomError> for NapiError {
  fn from(err: CustomError) -> Self {
    NapiError::from_reason(err.to_string())
  }
}

TypeScript Error Types:

export class RuvNetworkError extends Error {
  constructor(message: string, public code: string) {
    super(message)
    this.name = 'RuvNetworkError'
  }
}

export class RuvParseError extends Error {
  constructor(message: string, public input: string) {
    super(message)
    this.name = 'RuvParseError'
  }
}

4.3 Testing Strategy

Multi-Level Testing:

1. Unit Tests (Rust)
   - cargo test for Rust logic
   - Test pure Rust functions

2. Integration Tests (Rust)
   - Test napi bindings
   - Verify JS ↔ Rust conversion

3. E2E Tests (JavaScript/TypeScript)
   - Jest for Node.js tests
   - Test actual NPM package usage
   - Performance benchmarks

4. Cross-Platform Tests
   - Test on all target platforms
   - GitHub Actions matrix builds

5. Fuzzing (for critical packages)
   - cargo fuzz for parsing/crypto
   - AFL++ for binary formats

4.4 Documentation Standards

Each package includes:

README.md: Quick start, installation, basic usage
API.md: Complete API reference with TypeScript signatures
EXAMPLES.md: Code examples for common use cases
ARCHITECTURE.md: Internal design and architecture
CHANGELOG.md: Version history and breaking changes
MIGRATION.md: Migration guides between major versions

Auto-Generated Docs:

TypeScript definitions → TypeDoc
Rust code → rustdoc
Examples → Extracted from tests

C - Completion

5.1 Implementation Phases

Phase 1: Infrastructure Setup (Weeks 1-2)

Set up monorepo structure with pnpm workspaces
Configure napi-rs build system
Set up GitHub Actions CI/CD
Configure agentdb and claude-flow orchestration
Set up E2B sandbox templates
Create package templates and generators

Phase 2: Core Packages (Weeks 3-6)

Build foundational packages (15 core libraries)
- ruv-fann, ruv-swarm-core, aimds-core, etc.
Set up cross-platform builds
Create comprehensive tests
Generate documentation

Phase 3: Extended Packages (Weeks 7-12)

Build dependent packages (50 libraries)
- All *-cli, *-wasm, specialized tools
Set up package interdependencies
Performance optimization
Integration testing

Phase 4: Specialized Packages (Weeks 13-16)

Build domain-specific packages (45 libraries)
- Trading suite, quantum computing, temporal systems
Advanced features and optimizations
Security audits
Performance benchmarks

Phase 5: Release & Distribution (Weeks 17-18)

5.2 Deliverables

Code Deliverables:

110 NPM packages published to @ruv.io/* namespace
Source code in GitHub monorepo
Pre-built binaries for 7+ platforms
WASM fallback builds

Documentation Deliverables:

Main documentation site (docs.ruv.io)
API reference for all 110 packages
200+ code examples
Migration guides
Architecture documentation

Infrastructure Deliverables:

Automated CI/CD pipelines
Package publishing automation
Dependency management system
Performance monitoring dashboard

Support Deliverables:

GitHub Issues templates
Contributing guidelines
Security policy
Code of conduct

5.3 Quality Gates

Each package must pass:

✅ Build Quality:

Compiles on all target platforms
Zero compiler warnings
Passes all lint checks (clippy, eslint)

✅ Test Quality:

95%+ code coverage
All unit tests pass
All integration tests pass
Performance benchmarks meet targets

✅ Documentation Quality:

API documentation complete
Examples provided
README comprehensive
TypeScript definitions accurate

✅ Security Quality:

No known vulnerabilities
Dependency audit clean
Security policy documented

✅ Performance Quality:

< 10ms NAPI overhead
Memory leak free
Thread safe

5.4 Success Metrics

Technical Metrics:

All 110 packages published: 0/110 ✗
Test coverage: Target 95%
Platform support: 7+ platforms
Bundle size: < 5MB per package (avg)
Load time: < 100ms per package

Community Metrics:

NPM weekly downloads: Target 10K+
GitHub stars: Target 5K+
Active contributors: Target 50+
Issues resolved: Target < 48h response

Business Metrics:

Documentation site traffic: Target 100K/month
Package adoption rate: Target 20% YoY growth
Support tickets: Target < 5% of downloads

🏗️ Project Structure

ruv.io/
├── README.md                          # This file
├── ARCHITECTURE.md                    # Overall architecture
├── CONTRIBUTING.md                    # Contribution guidelines
├── LICENSE                            # MIT License
├── package.json                       # Root package.json (workspace)
├── pnpm-workspace.yaml               # pnpm workspace config
├── tsconfig.json                      # Root TypeScript config
├── .github/
│   ├── workflows/
│   │   ├── ci.yml                    # Continuous integration
│   │   ├── release.yml               # Release automation
│   │   ├── test.yml                  # Test suite
│   │   └── publish.yml               # NPM publishing
│   └── ISSUE_TEMPLATE/
│       ├── bug_report.md
│       └── feature_request.md
├── packages/                          # All 110 NPM packages
│   ├── agentic-jujutsu/
│   ├── agentic-payments/
│   ├── aimds-analysis/
│   └── ... (107 more packages)
├── plans/                             # Detailed implementation plans
│   ├── 00-overview.md
│   ├── 01-agentic-jujutsu.md
│   ├── 02-agentic-payments.md
│   └── ... (108 more plan files)
├── scripts/                           # Build and automation scripts
│   ├── bootstrap.sh                  # Initial setup
│   ├── build-all.sh                  # Build all packages
│   ├── test-all.sh                   # Test all packages
│   ├── publish-all.sh                # Publish to NPM
│   └── orchestrate.ts                # Claude-flow orchestration
├── docs/                              # Documentation
│   ├── getting-started.md
│   ├── api-reference/
│   ├── examples/
│   └── architecture/
├── tools/                             # Development tools
│   ├── template-generator/           # Package template generator
│   ├── dependency-analyzer/          # Dependency graph tools
│   └── performance-monitor/          # Performance tracking
└── e2b/                              # E2B sandbox configurations
    ├── rust-napi-builder.Dockerfile
    └── sandbox-config.json

🚀 Quick Start

Prerequisites

# Install Node.js >= 16
nvm install 16

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Install pnpm
npm install -g pnpm

# Install napi-rs CLI
npm install -g @napi-rs/cli

Setup

# Clone repository
git clone https://github.com/ruvnet/ruv.io.git
cd ruv.io

# Install dependencies
pnpm install

# Bootstrap all packages (run once)
./scripts/bootstrap.sh

Build Individual Package

# Build a single package
cd packages/ruv-fann
pnpm build

# Run tests
pnpm test

# Publish to NPM
pnpm publish

Build All Packages (with Orchestration)

# Using claude-flow orchestration
pnpm orchestrate:build

# Traditional sequential build
pnpm build:all

# Parallel build (faster)
pnpm build:parallel

🤖 Agent Orchestration

Claude Flow Integration

The project uses claude-flow for coordinating the build process across all 110 packages:

// scripts/orchestrate.ts
import { ClaudeFlow } from 'claude-flow'
import { AgentDB } from '@ruv.io/nt-agentdb-client'

const flow = new ClaudeFlow({
  agents: 110, // One per package
  coordination: 'hierarchical',
  memory: new AgentDB({
    uri: 'sqlite://agents.db'
  }),
  sandbox: {
    provider: 'e2b',
    apiKey: process.env.OPENROUTER_API_KEY
  }
})

await flow.execute('build-all-packages')

AgentDB Integration

AgentDB stores build state, dependencies, and coordination data:

import { AgentDB } from '@ruv.io/nt-agentdb-client'

const db = new AgentDB({
  connection: 'sqlite://agents.db',
  vectorStore: 'chroma'
})

// Store build results
await db.store({
  agent: 'builder-ruv-fann',
  result: buildResult,
  artifacts: ['ruv-fann.node', 'index.d.ts']
})

// Query dependencies
const deps = await db.query({
  package: 'ruv-swarm-ml',
  type: 'dependencies'
})

E2B Sandbox Strategy

Each package builds in an isolated E2B sandbox:

import { E2BSandbox } from '@e2b/sdk'

const sandbox = await E2BSandbox.create({
  template: 'rust-napi-builder',
  envVars: {
    OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
    CARGO_TARGET_DIR: '/tmp/target'
  },
  timeout: 3600 // 1 hour per package
})

// Execute build
await sandbox.process.start({
  cmd: 'cargo build --release'
})

// Download artifacts
const artifacts = await sandbox.downloadDir('./target/release')

📦 Package Categories

AI/ML Systems (8 packages)

@ruv.io/aimds-core - AI Manipulation Defense System core
@ruv.io/aimds-detection - AIMDS detection layer
@ruv.io/aimds-analysis - AIMDS analysis layer
@ruv.io/aimds-response - AIMDS response layer
@ruv.io/daa-ai - DAA AI integration layer
@ruv.io/goalie - AI research assistant with GOAP planning
@ruv.io/veritas-nexus - Multi-modal lie detection system
@ruv.io/kimi-expert-analyzer - Expert analysis for Kimi-K2

Swarm Orchestration (16 packages)

@ruv.io/ruv-swarm-core - Core orchestration
@ruv.io/ruv-swarm-agents - Specialized agents
@ruv.io/ruv-swarm-cli - CLI for swarm management
@ruv.io/ruv-swarm-ml - ML integration
@ruv.io/code-mesh-core - Distributed swarm intelligence
... (11 more packages)

Neural Networks (17 packages)

@ruv.io/ruv-fann - Fast Artificial Neural Network
@ruv.io/neuro-divergent - Neural forecasting library
@ruv.io/micro_core - Semantic Cartan Matrix implementation
@ruv.io/micro_cartan_attn - Cartan matrix attention
... (13 more packages)

Trading/Finance (12 packages)

@ruv.io/nt-core - Neural Trader core
@ruv.io/nt-backtesting - Backtesting engine
@ruv.io/nt-execution - Order execution
@ruv.io/nt-portfolio - Portfolio management
... (8 more packages)

Blockchain/Crypto (16 packages)

@ruv.io/qudag - Quantum-resistant DAG platform
@ruv.io/qudag-crypto - Quantum-resistant cryptography
@ruv.io/qudag-exchange - Token exchange
@ruv.io/claude_market - P2P Claude API token marketplace
... (12 more packages)

[See /plans directory for complete package list]

📚 Documentation

Getting Started: /docs/getting-started.md
API Reference: /docs/api-reference/
Examples: /docs/examples/
Architecture: /docs/architecture/
Individual Plans: /plans/*.md (110 detailed plans)

🧪 Testing

# Run all tests
pnpm test:all

# Test specific package
cd packages/ruv-fann
pnpm test

# Run benchmarks
pnpm bench

# Coverage report
pnpm coverage

🔒 Security

Security is a top priority. Please see SECURITY.md for:

Security policy
Vulnerability reporting
Audit results
Dependency scanning

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for:

Code of conduct
Development workflow
Coding standards
Pull request process

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

napi-rs - Amazing Rust ↔ Node.js FFI framework
Anthropic - Claude Flow orchestration
E2B - Sandbox infrastructure
crates.io - Rust package registry

📞 Contact

Author: rUv (ruvnet)
GitHub: @ruvnet
Crates.io: ruvnet
Email: [email protected]

Status: 🚧 Planning Phase - Implementation starts [DATE]

Progress: 0/110 packages completed (0%)

Last Updated: 2025-11-13

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
packages		packages
plans		plans
.gitignore		.gitignore
IMPLEMENTATION_SUMMARY.md		IMPLEMENTATION_SUMMARY.md
LICENSE		LICENSE
PACKAGE_CATALOG.md		PACKAGE_CATALOG.md
README.md		README.md

License

ruvnet/ruv.io

Folders and files

Latest commit

History

Repository files navigation