Fix dimension/dimensions bug and positional insert/search args

.gitignore

@@ -0,0 +1,2 @@
+*.wasm
+*.db

BUGFIX-README.md

@@ -0,0 +1,33 @@
+# RuVector — Bug Fixes
+
+This is a patched version of [ruvector](https://github.com/ruvector/ruvector) with two critical bugs fixed.
+
+## Bugs Fixed
+
+### Bug 1: CLI `create` command fails with "Missing field `dimensions`"
+
+**Symptom:** `npx ruvector create ./db -d 384` fails with `Missing field 'dimensions'`
+
+**Root Cause:** The CLI passes `{ dimension: 384 }` (singular) to the `VectorDB` constructor, but the native Rust binding (`@ruvector/core`) expects `{ dimensions: 384 }` (plural).
+
+**Fix:** The `VectorDBWrapper` constructor now normalizes `dimension` → `dimensions` automatically. (`dist/index.js`)
+
+### Bug 2: JS API insert fails with "Dimension mismatch: expected 384, got 0"
+
+**Symptom:** `await db.insert([...384 floats...], metadata)` fails with dimension mismatch even though the vector has the correct length.
+
+**Root Cause:** The `insert()` method only accepted object-style args `insert({vector, metadata})`, but users naturally call it with positional args `insert(vector, metadata)`. When a Float32Array was passed as the first arg, `entry.vector` was `undefined`, creating an empty Float32Array(0).
+
+**Fix:** Both `insert()` and `search()` now accept positional arguments in addition to object-style:
+- `db.insert(vector, metadata)` — positional style (new)
+- `db.insert({vector, metadata})` — object style (still works)
+- `db.search(vector, k)` — positional style (new)
+- `db.search({vector, k})` — object style (still works)
+
+## Files Modified
+
+- `dist/index.js` — VectorDBWrapper class (constructor, insert, search methods)
+
+## Original Repository
+
+https://github.com/ruvector/ruvector

HOOKS.md

@@ -0,0 +1,221 @@
+# RuVector Hooks for Claude Code
+
+Self-learning intelligence hooks that enhance Claude Code with Q-learning, vector memory, and automatic agent routing.
+
+## Quick Start
+
+```bash
+# Full setup: hooks + pretrain + optimized agents
+npx ruvector hooks init --pretrain --build-agents quality
+
+# Or step by step:
+npx ruvector hooks init          # Setup hooks
+npx ruvector hooks pretrain      # Analyze repository
+npx ruvector hooks build-agents  # Generate agent configs
+```
+
+## What It Does
+
+RuVector hooks integrate with Claude Code to provide:
+
+| Feature | Description |
+|---------|-------------|
+| **Agent Routing** | Suggests the best agent for each file type based on learned patterns |
+| **Co-edit Patterns** | Predicts "likely next files" from git history |
+| **Vector Memory** | Semantic recall of project context |
+| **Command Analysis** | Risk assessment for bash commands |
+| **Self-Learning** | Q-learning improves suggestions over time |
+
+## Commands
+
+### Initialization
+
+```bash
+# Full configuration
+npx ruvector hooks init
+
+# With pretrain and agent building
+npx ruvector hooks init --pretrain --build-agents security
+
+# Minimal (basic hooks only)
+npx ruvector hooks init --minimal
+
+# Options
+--force           # Overwrite existing settings
+--minimal         # Basic hooks only
+--pretrain        # Run pretrain after init
+--build-agents    # Generate optimized agents (quality|speed|security|testing|fullstack)
+--no-claude-md    # Skip CLAUDE.md creation
+--no-permissions  # Skip permissions config
+--no-env          # Skip environment variables
+--no-gitignore    # Skip .gitignore update
+--no-mcp          # Skip MCP server config
+--no-statusline   # Skip status line config
+```
+
+### Pretrain
+
+Analyze your repository to bootstrap intelligence:
+
+```bash
+npx ruvector hooks pretrain
+
+# Options
+--depth <n>     # Git history depth (default: 100)
+--verbose       # Show detailed progress
+--skip-git      # Skip git history analysis
+--skip-files    # Skip file structure analysis
+```
+
+**What it learns:**
+- File type → Agent mapping (`.rs` → rust-developer)
+- Co-edit patterns from git history
+- Directory → Agent mapping
+- Project context memories
+
+### Build Agents
+
+Generate optimized `.claude/agents/` configurations:
+
+```bash
+npx ruvector hooks build-agents --focus quality
+
+# Focus modes
+--focus quality   # Code quality, best practices (default)
+--focus speed     # Rapid development, prototyping
+--focus security  # OWASP, input validation, encryption
+--focus testing   # TDD, comprehensive coverage
+--focus fullstack # Balanced frontend/backend/database
+
+# Options
+--output <dir>    # Output directory (default: .claude/agents)
+--format <fmt>    # yaml, json, or md (default: yaml)
+--include-prompts # Include system prompts in agent configs
+```
+
+### Verification & Diagnostics
+
+```bash
+# Check if hooks are working
+npx ruvector hooks verify
+
+# Diagnose and fix issues
+npx ruvector hooks doctor
+npx ruvector hooks doctor --fix
+```
+
+### Data Management
+
+```bash
+# View statistics
+npx ruvector hooks stats
+
+# Export intelligence data
+npx ruvector hooks export -o backup.json
+npx ruvector hooks export --include-all
+
+# Import intelligence data
+npx ruvector hooks import backup.json
+npx ruvector hooks import backup.json --merge
+```
+
+### Memory Operations
+
+```bash
+# Store context in vector memory
+npx ruvector hooks remember "API uses JWT auth" -t project
+
+# Semantic search memory
+npx ruvector hooks recall "authentication"
+
+# Route a task to best agent
+npx ruvector hooks route "implement user login"
+```
+
+## Hook Events
+
+| Event | Trigger | RuVector Action |
+|-------|---------|-----------------|
+| **PreToolUse** | Before Edit/Write/Bash | Agent routing, file analysis, command risk |
+| **PostToolUse** | After Edit/Write/Bash | Q-learning update, pattern recording |
+| **SessionStart** | Conversation begins | Load intelligence, display stats |
+| **Stop** | Conversation ends | Save learning data |
+| **UserPromptSubmit** | User sends message | Context suggestions |
+| **PreCompact** | Before context compaction | Preserve important context |
+| **Notification** | Any notification | Track events for learning |
+
+## Generated Files
+
+After running `hooks init`:
+
+```
+your-project/
+├── .claude/
+│   ├── settings.json      # Hooks configuration
+│   ├── statusline.sh      # Status bar script
+│   └── agents/            # Generated agents (with --build-agents)
+│       ├── rust-specialist.yaml
+│       ├── typescript-specialist.yaml
+│       ├── test-architect.yaml
+│       └── project-coordinator.yaml
+├── .ruvector/
+│   └── intelligence.json  # Learning data
+├── CLAUDE.md              # Project documentation
+└── .gitignore             # Updated with .ruvector/
+```
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `RUVECTOR_INTELLIGENCE_ENABLED` | `true` | Enable/disable intelligence |
+| `RUVECTOR_LEARNING_RATE` | `0.1` | Q-learning rate (0.0-1.0) |
+| `RUVECTOR_MEMORY_BACKEND` | `rvlite` | Memory storage backend |
+| `INTELLIGENCE_MODE` | `treatment` | A/B testing mode |
+
+## Example Output
+
+### Agent Routing
+```
+🧠 Intelligence Analysis:
+   📁 src/api/routes.ts
+   🤖 Recommended: typescript-developer (85% confidence)
+      → learned from 127 .ts files in repo
+   📎 Likely next files:
+      - src/api/handlers.ts (12 co-edits)
+      - src/types/api.ts (8 co-edits)
+```
+
+### Command Analysis
+```
+🧠 Command Analysis:
+   📦 Category: rust
+   🏷️  Type: test
+   ✅ Risk: LOW
+```
+
+## Best Practices
+
+1. **Run pretrain on existing repos** — Bootstrap intelligence before starting work
+2. **Use focus modes** — Match agent generation to your current task
+3. **Export before major changes** — Backup learning data
+4. **Let it learn** — Intelligence improves with each edit
+
+## Troubleshooting
+
+```bash
+# Check setup
+npx ruvector hooks verify
+
+# Fix common issues
+npx ruvector hooks doctor --fix
+
+# Reset and reinitialize
+npx ruvector hooks init --force --pretrain
+```
+
+## Links
+
+- [RuVector GitHub](https://github.com/ruvnet/ruvector)
+- [npm Package](https://www.npmjs.com/package/ruvector)
+- [Claude Code Documentation](https://docs.anthropic.com/claude-code)

PACKAGE_SUMMARY.md

@@ -0,0 +1,409 @@
+# ruvector Package Summary
+
+## Overview
+
+The main `ruvector` package provides a unified interface for high-performance vector database operations in Node.js, with automatic platform detection and smart fallback between native (Rust) and WASM implementations.
+
+## Package Structure
+
+```
+/workspaces/ruvector/npm/packages/ruvector/
+├── src/                    # TypeScript source
+│   ├── index.ts           # Smart loader with platform detection
+│   └── types.ts           # TypeScript type definitions
+├── dist/                   # Compiled JavaScript and types
+│   ├── index.js           # Main entry point
+│   ├── index.d.ts         # Type definitions
+│   ├── types.js           # Compiled types
+│   └── types.d.ts         # Type definitions
+├── bin/
+│   └── cli.js             # CLI tool
+├── test/
+│   ├── mock-implementation.js  # Mock VectorDB for testing
+│   ├── standalone-test.js      # Package structure tests
+│   └── integration.js          # Integration tests
+├── examples/
+│   ├── api-usage.js       # API usage examples
+│   └── cli-demo.sh        # CLI demonstration
+├── package.json           # NPM package configuration
+├── tsconfig.json          # TypeScript configuration
+└── README.md             # Package documentation
+```
+
+## Key Features
+
+### 1. Smart Platform Detection
+
+The package automatically detects and loads the best available implementation:
+
+```typescript
+// Tries to load in this order:
+// 1. @ruvector/core (native Rust, fastest)
+// 2. @ruvector/wasm (WebAssembly, universal fallback)
+
+import { VectorDB, getImplementationType, isNative, isWasm } from 'ruvector';
+
+console.log(getImplementationType()); // 'native' or 'wasm'
+console.log(isNative());              // true if using native
+console.log(isWasm());                // true if using WASM
+```
+
+### 2. Complete TypeScript Support
+
+Full type definitions for all APIs:
+
+```typescript
+interface VectorEntry {
+  id: string;
+  vector: number[];
+  metadata?: Record<string, any>;
+}
+
+interface SearchQuery {
+  vector: number[];
+  k?: number;
+  filter?: Record<string, any>;
+  threshold?: number;
+}
+
+interface SearchResult {
+  id: string;
+  score: number;
+  vector: number[];
+  metadata?: Record<string, any>;
+}
+
+interface DbOptions {
+  dimension: number;
+  metric?: 'cosine' | 'euclidean' | 'dot';
+  path?: string;
+  autoPersist?: boolean;
+  hnsw?: {
+    m?: number;
+    efConstruction?: number;
+    efSearch?: number;
+  };
+}
+```
+
+### 3. VectorDB API
+
+Comprehensive vector database operations:
+
+```typescript
+const db = new VectorDB({
+  dimension: 384,
+  metric: 'cosine'
+});
+
+// Insert operations
+db.insert({ id: 'doc1', vector: [...], metadata: {...} });
+db.insertBatch([...entries]);
+
+// Search operations
+const results = db.search({
+  vector: [...],
+  k: 10,
+  threshold: 0.7
+});
+
+// CRUD operations
+const entry = db.get('doc1');
+db.updateMetadata('doc1', { updated: true });
+db.delete('doc1');
+
+// Database management
+const stats = db.stats();
+db.save('./mydb.vec');
+db.load('./mydb.vec');
+db.buildIndex();
+db.optimize();
+```
+
+### 4. CLI Tools
+
+Command-line interface for database operations:
+
+```bash
+# Create database
+ruvector create mydb.vec --dimension 384 --metric cosine
+
+# Insert vectors
+ruvector insert mydb.vec vectors.json --batch-size 1000
+
+# Search
+ruvector search mydb.vec --vector "[0.1,0.2,...]" --top-k 10
+
+# Statistics
+ruvector stats mydb.vec
+
+# Benchmark
+ruvector benchmark --num-vectors 10000 --num-queries 1000
+
+# Info
+ruvector info
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+new VectorDB(options: DbOptions): VectorDB
+```
+
+### Methods
+
+- `insert(entry: VectorEntry): void` - Insert single vector
+- `insertBatch(entries: VectorEntry[]): void` - Batch insert
+- `search(query: SearchQuery): SearchResult[]` - Search similar vectors
+- `get(id: string): VectorEntry | null` - Get by ID
+- `delete(id: string): boolean` - Delete vector
+- `updateMetadata(id: string, metadata: Record<string, any>): void` - Update metadata
+- `stats(): DbStats` - Get database statistics
+- `save(path?: string): void` - Save to disk
+- `load(path: string): void` - Load from disk
+- `clear(): void` - Clear all vectors
+- `buildIndex(): void` - Build HNSW index
+- `optimize(): void` - Optimize database
+
+### Utility Functions
+
+- `getImplementationType(): 'native' | 'wasm'` - Get current implementation
+- `isNative(): boolean` - Check if using native
+- `isWasm(): boolean` - Check if using WASM
+- `getVersion(): { version: string, implementation: string }` - Get version info
+
+## Dependencies
+
+### Production Dependencies
+
+- `commander` (^11.1.0) - CLI framework
+- `chalk` (^4.1.2) - Terminal styling
+- `ora` (^5.4.1) - Spinners and progress
+
+### Optional Dependencies
+
+- `@ruvector/core` (^0.1.1) - Native Rust bindings (when available)
+- `@ruvector/wasm` (^0.1.1) - WebAssembly module (fallback)
+
+### Dev Dependencies
+
+- `typescript` (^5.3.3) - TypeScript compiler
+- `@types/node` (^20.10.5) - Node.js type definitions
+
+## Package.json Configuration
+
+```json
+{
+  "name": "ruvector",
+  "version": "0.1.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "ruvector": "./bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node test/standalone-test.js"
+  }
+}
+```
+
+## Build Process
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript
+npm run build
+
+# Run tests
+npm test
+
+# Package for NPM
+npm pack
+```
+
+## Testing
+
+The package includes comprehensive tests:
+
+### 1. Standalone Test (`test/standalone-test.js`)
+
+Tests package structure and API using mock implementation:
+- Package structure validation
+- TypeScript type definitions
+- VectorDB API functionality
+- CLI structure
+- Smart loader logic
+
+### 2. Integration Test (`test/integration.js`)
+
+Tests integration with real implementations when available.
+
+### 3. Mock Implementation (`test/mock-implementation.js`)
+
+JavaScript-based VectorDB implementation for testing and demonstration purposes.
+
+## Examples
+
+### API Usage (`examples/api-usage.js`)
+
+Demonstrates:
+- Basic CRUD operations
+- Batch operations
+- Semantic search
+- Different distance metrics
+- Performance benchmarking
+- Persistence
+
+### CLI Demo (`examples/cli-demo.sh`)
+
+Bash script demonstrating CLI tools.
+
+## Usage Examples
+
+### Simple Vector Search
+
+```javascript
+const { VectorDB } = require('ruvector');
+
+const db = new VectorDB({ dimension: 3 });
+
+db.insertBatch([
+  { id: 'cat', vector: [0.9, 0.1, 0.1], metadata: { animal: 'cat' } },
+  { id: 'dog', vector: [0.1, 0.9, 0.1], metadata: { animal: 'dog' } },
+  { id: 'tiger', vector: [0.8, 0.2, 0.15], metadata: { animal: 'tiger' } }
+]);
+
+const results = db.search({
+  vector: [0.9, 0.1, 0.1],
+  k: 2
+});
+
+console.log(results);
+// [
+//   { id: 'cat', score: 1.0, ... },
+//   { id: 'tiger', score: 0.97, ... }
+// ]
+```
+
+### Semantic Document Search
+
+```javascript
+const db = new VectorDB({ dimension: 768, metric: 'cosine' });
+
+// Insert documents with embeddings (from your embedding model)
+db.insertBatch([
+  { id: 'doc1', vector: embedding1, metadata: { title: 'AI Guide' } },
+  { id: 'doc2', vector: embedding2, metadata: { title: 'Web Dev' } }
+]);
+
+// Search with query embedding
+const results = db.search({
+  vector: queryEmbedding,
+  k: 10,
+  threshold: 0.7
+});
+```
+
+### Persistence
+
+```javascript
+const db = new VectorDB({
+  dimension: 384,
+  path: './vectors.db',
+  autoPersist: true
+});
+
+// Changes automatically saved
+db.insert({ id: 'doc1', vector: [...] });
+
+// Or manual save
+db.save('./backup.db');
+
+// Load from disk
+db.load('./vectors.db');
+```
+
+## Performance Characteristics
+
+### Mock Implementation (JavaScript)
+- Insert: ~1M vectors/sec (batch)
+- Search: ~400 queries/sec (1000 vectors, k=10)
+
+### Native Implementation (Rust)
+- Insert: ~10M+ vectors/sec (batch)
+- Search: ~100K+ queries/sec with HNSW index
+- 150x faster than pgvector
+
+### WASM Implementation
+- Insert: ~1M+ vectors/sec (batch)
+- Search: ~10K+ queries/sec with HNSW index
+- ~10x faster than pure JavaScript
+
+## Integration with Other Packages
+
+This package serves as the main interface and coordinates between:
+
+1. **@ruvector/core** - Native Rust bindings (napi-rs)
+   - Platform-specific native modules
+   - Maximum performance
+   - Optional dependency
+
+2. **@ruvector/wasm** - WebAssembly module
+   - Universal compatibility
+   - Near-native performance
+   - Fallback implementation
+
+## Error Handling
+
+The package provides clear error messages when implementations are unavailable:
+
+```
+Failed to load ruvector: Neither native nor WASM implementation available.
+Native error: Cannot find module '@ruvector/core'
+WASM error: Cannot find module '@ruvector/wasm'
+```
+
+## Environment Variables
+
+- `RUVECTOR_DEBUG=1` - Enable debug logging for implementation loading
+
+## Next Steps
+
+To complete the package ecosystem:
+
+1. **Create @ruvector/core**
+   - napi-rs bindings to Rust code
+   - Platform-specific builds (Linux, macOS, Windows)
+   - Native module packaging
+
+2. **Create @ruvector/wasm**
+   - wasm-pack build from Rust code
+   - WebAssembly module
+   - Universal compatibility layer
+
+3. **Update Dependencies**
+   - Add @ruvector/core as optionalDependency
+   - Add @ruvector/wasm as dependency
+   - Configure proper fallback chain
+
+4. **Publishing**
+   - Publish all three packages to npm
+   - Set up CI/CD for builds
+   - Create platform-specific releases
+
+## Version
+
+Current version: **0.1.1**
+
+## License
+
+MIT
+
+## Repository
+
+https://github.com/ruvnet/ruvector

README.md

@@ -0,0 +1,2228 @@
+# ruvector
+
+[![npm version](https://badge.fury.io/js/ruvector.svg)](https://www.npmjs.com/package/ruvector)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Node Version](https://img.shields.io/node/v/ruvector)](https://nodejs.org)
+[![Downloads](https://img.shields.io/npm/dm/ruvector)](https://www.npmjs.com/package/ruvector)
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)](https://github.com/ruvnet/ruvector)
+[![Performance](https://img.shields.io/badge/latency-<0.5ms-green.svg)](https://github.com/ruvnet/ruvector)
+[![GitHub Stars](https://img.shields.io/github/stars/ruvnet/ruvector?style=social)](https://github.com/ruvnet/ruvector)
+
+**The fastest vector database for Node.js—built in Rust, runs everywhere**
+
+Ruvector is a next-generation vector database that brings **enterprise-grade semantic search** to Node.js applications. Unlike cloud-only solutions or Python-first databases, Ruvector is designed specifically for JavaScript/TypeScript developers who need **blazing-fast vector similarity search** without the complexity of external services.
+
+> 🚀 **Sub-millisecond queries** • 🎯 **52,000+ inserts/sec** • 💾 **~50 bytes per vector** • 🌍 **Runs anywhere**
+
+Built by [rUv](https://ruv.io) with production-grade Rust performance and intelligent platform detection—**automatically uses native bindings when available, falls back to WebAssembly when needed**.
+
+🌐 **[Visit ruv.io](https://ruv.io)** | 📦 **[GitHub](https://github.com/ruvnet/ruvector)** | 📚 **[Documentation](https://github.com/ruvnet/ruvector/tree/main/docs)**
+
+---
+
+## 🧠 Claude Code Intelligence v2.0
+
+**Self-learning intelligence for Claude Code** — RuVector provides optimized hooks with ONNX embeddings, AST analysis, and coverage-aware routing.
+
+```bash
+# One-command setup with pretrain and agent generation
+npx ruvector hooks init --pretrain --build-agents quality
+```
+
+### Core Features
+- 🎯 **Smart Agent Routing** — Q-learning optimized suggestions with 80%+ accuracy
+- 📚 **9-Phase Pretrain** — AST, diff, coverage, neural, and graph analysis
+- 🤖 **Agent Builder** — Generates optimized `.claude/agents/` configs
+- 🔗 **Co-edit Patterns** — Learns file relationships from git history
+- 💾 **Vector Memory** — HNSW-indexed semantic recall (150x faster)
+
+### New in v2.0
+- ⚡ **ONNX WASM Embeddings** — all-MiniLM-L6-v2 (384d) runs locally, no API needed
+- 🌳 **AST Analysis** — Symbol extraction, complexity metrics, import graphs
+- 📊 **Diff Embeddings** — Semantic change classification with risk scoring
+- 🧪 **Coverage Routing** — Test coverage-aware agent selection
+- 🔍 **Graph Algorithms** — MinCut boundaries, Louvain communities, Spectral clustering
+- 🛡️ **Security Scanning** — Parallel vulnerability pattern detection
+- 🎯 **RAG Context** — Semantic retrieval with HNSW indexing
+
+### Performance
+| Backend | Read Time | Speedup |
+|---------|-----------|---------|
+| ONNX inference | ~400ms | baseline |
+| HNSW search | ~0.045ms | 8,800x |
+| Memory cache | ~0.01ms | **40,000x** |
+
+📖 **[Full Hooks Documentation →](https://github.com/ruvnet/ruvector/blob/main/npm/packages/ruvector/HOOKS.md)**
+
+### MCP Server Integration
+
+RuVector includes an MCP server for Claude Code with 30+ tools:
+
+```bash
+# Add to Claude Code
+claude mcp add ruvector -- npx ruvector mcp start
+```
+
+**Available MCP Tools:**
+- `hooks_route`, `hooks_route_enhanced` — Agent routing with signals
+- `hooks_ast_analyze`, `hooks_ast_complexity` — Code structure analysis
+- `hooks_diff_analyze`, `hooks_diff_classify` — Change classification
+- `hooks_coverage_route`, `hooks_coverage_suggest` — Test-aware routing
+- `hooks_graph_mincut`, `hooks_graph_cluster` — Code boundaries
+- `hooks_security_scan` — Vulnerability detection
+- `hooks_rag_context` — Semantic context retrieval
+- `hooks_attention_info`, `hooks_gnn_info` — Neural capabilities
+
+---
+
+## 🌟 Why Ruvector?
+
+### The Problem with Existing Vector Databases
+
+Most vector databases force you to choose between three painful trade-offs:
+
+1. **Cloud-Only Services** (Pinecone, Weaviate Cloud) - Expensive, vendor lock-in, latency issues, API rate limits
+2. **Python-First Solutions** (ChromaDB, Faiss) - Poor Node.js support, require separate Python processes
+3. **Self-Hosted Complexity** (Milvus, Qdrant) - Heavy infrastructure, Docker orchestration, operational overhead
+
+**Ruvector eliminates these trade-offs.**
+
+### The Ruvector Advantage
+
+Ruvector is purpose-built for **modern JavaScript/TypeScript applications** that need vector search:
+
+🎯 **Native Node.js Integration**
+- Drop-in npm package—no Docker, no Python, no external services
+- Full TypeScript support with complete type definitions
+- Automatic platform detection with native Rust bindings
+- Seamless WebAssembly fallback for universal compatibility
+
+⚡ **Production-Grade Performance**
+- **52,000+ inserts/second** with native Rust (10x faster than Python alternatives)
+- **<0.5ms query latency** with HNSW indexing and SIMD optimizations
+- **~50 bytes per vector** with advanced memory optimization
+- Scales from edge devices to millions of vectors
+
+🧠 **Built for AI Applications**
+- Optimized for LLM embeddings (OpenAI, Cohere, Hugging Face)
+- Perfect for RAG (Retrieval-Augmented Generation) systems
+- Agent memory and semantic caching
+- Real-time recommendation engines
+
+🌍 **Universal Deployment**
+- **Linux, macOS, Windows** with native performance
+- **Browser support** via WebAssembly (experimental)
+- **Edge computing** and serverless environments
+- **Alpine Linux** and non-glibc systems supported
+
+💰 **Zero Operational Costs**
+- No cloud API fees or usage limits
+- No infrastructure to manage
+- No separate database servers
+- Open source MIT license
+
+### Key Advantages
+
+- ⚡ **Blazing Fast**: <0.5ms p50 latency with native Rust, 10-50ms with WASM fallback
+- 🎯 **Automatic Platform Detection**: Uses native when available, falls back to WASM seamlessly
+- 🧠 **AI-Native**: Built specifically for embeddings, RAG, semantic search, and agent memory
+- 🔧 **CLI Tools Included**: Full command-line interface for database management
+- 🌍 **Universal Deployment**: Works on all platforms—Linux, macOS, Windows, even browsers
+- 💾 **Memory Efficient**: ~50 bytes per vector with advanced quantization
+- 🚀 **Production Ready**: Battle-tested algorithms with comprehensive benchmarks
+- 🔓 **Open Source**: MIT licensed, community-driven
+
+## 🚀 Quick Start Tutorial
+
+### Step 1: Installation
+
+Install Ruvector with a single npm command:
+
+```bash
+npm install ruvector
+```
+
+**What happens during installation:**
+- npm automatically detects your platform (Linux, macOS, Windows)
+- Downloads the correct native binary for maximum performance
+- Falls back to WebAssembly if native binaries aren't available
+- No additional setup, Docker, or external services required
+
+**Windows Installation (without build tools):**
+```bash
+# Skip native compilation, use WASM fallback
+npm install ruvector --ignore-scripts
+
+# The ONNX WASM runtime (7.4MB) works without build tools
+# Memory cache provides 40,000x speedup over inference
+```
+
+**Verify installation:**
+```bash
+npx ruvector info
+```
+
+You should see your platform and implementation type (native Rust or WASM fallback).
+
+### Step 2: Your First Vector Database
+
+Let's create a simple vector database and perform basic operations. This example demonstrates the complete CRUD (Create, Read, Update, Delete) workflow:
+
+```javascript
+const { VectorDb } = require('ruvector');
+
+async function tutorial() {
+  // Step 2.1: Create a new vector database
+  // The 'dimensions' parameter must match your embedding model
+  // Common sizes: 128, 384 (sentence-transformers), 768 (BERT), 1536 (OpenAI)
+  const db = new VectorDb({
+    dimensions: 128,           // Vector size - MUST match your embeddings
+    maxElements: 10000,        // Maximum vectors (can grow automatically)
+    storagePath: './my-vectors.db'  // Persist to disk (omit for in-memory)
+  });
+
+  console.log('✅ Database created successfully');
+
+  // Step 2.2: Insert vectors
+  // In real applications, these would come from an embedding model
+  const documents = [
+    { id: 'doc1', text: 'Artificial intelligence and machine learning' },
+    { id: 'doc2', text: 'Deep learning neural networks' },
+    { id: 'doc3', text: 'Natural language processing' },
+  ];
+
+  for (const doc of documents) {
+    // Generate random vector for demonstration
+    // In production: use OpenAI, Cohere, or sentence-transformers
+    const vector = new Float32Array(128).map(() => Math.random());
+
+    await db.insert({
+      id: doc.id,
+      vector: vector,
+      metadata: {
+        text: doc.text,
+        timestamp: Date.now(),
+        category: 'AI'
+      }
+    });
+
+    console.log(`✅ Inserted: ${doc.id}`);
+  }
+
+  // Step 2.3: Search for similar vectors
+  // Create a query vector (in production, this would be from your search query)
+  const queryVector = new Float32Array(128).map(() => Math.random());
+
+  const results = await db.search({
+    vector: queryVector,
+    k: 5,              // Return top 5 most similar vectors
+    threshold: 0.7     // Only return results with similarity > 0.7
+  });
+
+  console.log('\n🔍 Search Results:');
+  results.forEach((result, index) => {
+    console.log(`${index + 1}. ${result.id} - Score: ${result.score.toFixed(3)}`);
+    console.log(`   Text: ${result.metadata.text}`);
+  });
+
+  // Step 2.4: Retrieve a specific vector
+  const retrieved = await db.get('doc1');
+  if (retrieved) {
+    console.log('\n📄 Retrieved document:', retrieved.metadata.text);
+  }
+
+  // Step 2.5: Get database statistics
+  const count = await db.len();
+  console.log(`\n📊 Total vectors in database: ${count}`);
+
+  // Step 2.6: Delete a vector
+  const deleted = await db.delete('doc1');
+  console.log(`\n🗑️  Deleted doc1: ${deleted ? 'Success' : 'Not found'}`);
+
+  // Final count
+  const finalCount = await db.len();
+  console.log(`📊 Final count: ${finalCount}`);
+}
+
+// Run the tutorial
+tutorial().catch(console.error);
+```
+
+**Expected Output:**
+```
+✅ Database created successfully
+✅ Inserted: doc1
+✅ Inserted: doc2
+✅ Inserted: doc3
+
+🔍 Search Results:
+1. doc2 - Score: 0.892
+   Text: Deep learning neural networks
+2. doc1 - Score: 0.856
+   Text: Artificial intelligence and machine learning
+3. doc3 - Score: 0.801
+   Text: Natural language processing
+
+📄 Retrieved document: Artificial intelligence and machine learning
+
+📊 Total vectors in database: 3
+
+🗑️  Deleted doc1: Success
+📊 Final count: 2
+```
+
+### Step 3: TypeScript Tutorial
+
+Ruvector provides full TypeScript support with complete type safety. Here's how to use it:
+
+```typescript
+import { VectorDb, VectorEntry, SearchQuery, SearchResult } from 'ruvector';
+
+// Step 3.1: Define your custom metadata type
+interface DocumentMetadata {
+  title: string;
+  content: string;
+  author: string;
+  date: Date;
+  tags: string[];
+}
+
+async function typescriptTutorial() {
+  // Step 3.2: Create typed database
+  const db = new VectorDb({
+    dimensions: 384,  // sentence-transformers/all-MiniLM-L6-v2
+    maxElements: 10000,
+    storagePath: './typed-vectors.db'
+  });
+
+  // Step 3.3: Type-safe vector entry
+  const entry: VectorEntry<DocumentMetadata> = {
+    id: 'article-001',
+    vector: new Float32Array(384),  // Your embedding here
+    metadata: {
+      title: 'Introduction to Vector Databases',
+      content: 'Vector databases enable semantic search...',
+      author: 'Jane Doe',
+      date: new Date('2024-01-15'),
+      tags: ['database', 'AI', 'search']
+    }
+  };
+
+  // Step 3.4: Insert with type checking
+  await db.insert(entry);
+  console.log('✅ Inserted typed document');
+
+  // Step 3.5: Type-safe search
+  const query: SearchQuery = {
+    vector: new Float32Array(384),
+    k: 10,
+    threshold: 0.8
+  };
+
+  // Step 3.6: Fully typed results
+  const results: SearchResult<DocumentMetadata>[] = await db.search(query);
+
+  // TypeScript knows the exact shape of metadata
+  results.forEach(result => {
+    console.log(`Title: ${result.metadata.title}`);
+    console.log(`Author: ${result.metadata.author}`);
+    console.log(`Tags: ${result.metadata.tags.join(', ')}`);
+    console.log(`Similarity: ${result.score.toFixed(3)}\n`);
+  });
+
+  // Step 3.7: Type-safe retrieval
+  const doc = await db.get('article-001');
+  if (doc) {
+    // TypeScript autocomplete works perfectly here
+    const publishYear = doc.metadata.date.getFullYear();
+    console.log(`Published in ${publishYear}`);
+  }
+}
+
+typescriptTutorial().catch(console.error);
+```
+
+**TypeScript Benefits:**
+- ✅ Full autocomplete for all methods and properties
+- ✅ Compile-time type checking prevents errors
+- ✅ IDE IntelliSense shows documentation
+- ✅ Custom metadata types for your use case
+- ✅ No `any` types - fully typed throughout
+
+## 🎯 Platform Detection
+
+Ruvector automatically detects the best implementation for your platform:
+
+```javascript
+const { getImplementationType, isNative, isWasm } = require('ruvector');
+
+console.log(getImplementationType()); // 'native' or 'wasm'
+console.log(isNative()); // true if using native Rust
+console.log(isWasm()); // true if using WebAssembly fallback
+
+// Performance varies by implementation:
+// Native (Rust):  <0.5ms latency, 50K+ ops/sec
+// WASM fallback:  10-50ms latency, ~1K ops/sec
+```
+
+## 🔧 CLI Tools
+
+Ruvector includes a full command-line interface for database management:
+
+### Create Database
+
+```bash
+# Create a new vector database
+npx ruvector create mydb.vec --dimensions 384 --metric cosine
+
+# Options:
+#   --dimensions, -d  Vector dimensionality (required)
+#   --metric, -m      Distance metric (cosine, euclidean, dot)
+#   --max-elements    Maximum number of vectors (default: 10000)
+```
+
+### Insert Vectors
+
+```bash
+# Insert vectors from JSON file
+npx ruvector insert mydb.vec vectors.json
+
+# JSON format:
+# [
+#   { "id": "doc1", "vector": [0.1, 0.2, ...], "metadata": {...} },
+#   { "id": "doc2", "vector": [0.3, 0.4, ...], "metadata": {...} }
+# ]
+```
+
+### Search Vectors
+
+```bash
+# Search for similar vectors
+npx ruvector search mydb.vec --vector "[0.1,0.2,0.3,...]" --top-k 10
+
+# Options:
+#   --vector, -v   Query vector (JSON array)
+#   --top-k, -k    Number of results (default: 10)
+#   --threshold    Minimum similarity score
+```
+
+### Database Statistics
+
+```bash
+# Show database statistics
+npx ruvector stats mydb.vec
+
+# Output:
+#   Total vectors: 10,000
+#   Dimensions: 384
+#   Metric: cosine
+#   Memory usage: ~500 KB
+#   Index type: HNSW
+```
+
+### Benchmarking
+
+```bash
+# Run performance benchmark
+npx ruvector benchmark --num-vectors 10000 --num-queries 1000
+
+# Options:
+#   --num-vectors   Number of vectors to insert
+#   --num-queries   Number of search queries
+#   --dimensions    Vector dimensionality (default: 128)
+```
+
+### System Information
+
+```bash
+# Show platform and implementation info
+npx ruvector info
+
+# Output:
+#   Platform: linux-x64-gnu
+#   Implementation: native (Rust)
+#   GNN Module: Available
+#   Node.js: v18.17.0
+#   Performance: <0.5ms p50 latency
+```
+
+### Install Optional Packages
+
+Ruvector supports optional packages that extend functionality. Use the `install` command to add them:
+
+```bash
+# List available packages
+npx ruvector install
+
+# Output:
+#   Available Ruvector Packages:
+#
+#     gnn      not installed
+#              Graph Neural Network layers, tensor compression, differentiable search
+#              npm: @ruvector/gnn
+#
+#     core     ✓ installed
+#              Core vector database with native Rust bindings
+#              npm: @ruvector/core
+
+# Install specific package
+npx ruvector install gnn
+
+# Install all optional packages
+npx ruvector install --all
+
+# Interactive selection
+npx ruvector install -i
+```
+
+The install command auto-detects your package manager (npm, yarn, pnpm, bun).
+
+### GNN Commands
+
+Ruvector includes Graph Neural Network (GNN) capabilities for advanced tensor compression and differentiable search.
+
+#### GNN Info
+
+```bash
+# Show GNN module information
+npx ruvector gnn info
+
+# Output:
+#   GNN Module Information
+#     Status:         Available
+#     Platform:       linux
+#     Architecture:   x64
+#
+#   Available Features:
+#     • RuvectorLayer   - GNN layer with multi-head attention
+#     • TensorCompress  - Adaptive tensor compression (5 levels)
+#     • differentiableSearch - Soft attention-based search
+#     • hierarchicalForward  - Multi-layer GNN processing
+```
+
+#### GNN Layer
+
+```bash
+# Create and test a GNN layer
+npx ruvector gnn layer -i 128 -h 256 --test
+
+# Options:
+#   -i, --input-dim   Input dimension (required)
+#   -h, --hidden-dim  Hidden dimension (required)
+#   -a, --heads       Number of attention heads (default: 4)
+#   -d, --dropout     Dropout rate (default: 0.1)
+#   --test            Run a test forward pass
+#   -o, --output      Save layer config to JSON file
+```
+
+#### GNN Compress
+
+```bash
+# Compress embeddings using adaptive tensor compression
+npx ruvector gnn compress -f embeddings.json -l pq8 -o compressed.json
+
+# Options:
+#   -f, --file         Input JSON file with embeddings (required)
+#   -l, --level        Compression level: none|half|pq8|pq4|binary (default: auto)
+#   -a, --access-freq  Access frequency for auto compression (default: 0.5)
+#   -o, --output       Output file for compressed data
+
+# Compression levels:
+#   none   (freq > 0.8)  - Full precision, hot data
+#   half   (freq > 0.4)  - ~50% savings, warm data
+#   pq8    (freq > 0.1)  - ~8x compression, cool data
+#   pq4    (freq > 0.01) - ~16x compression, cold data
+#   binary (freq <= 0.01) - ~32x compression, archive
+```
+
+#### GNN Search
+
+```bash
+# Differentiable search with soft attention
+npx ruvector gnn search -q "[1.0,0.0,0.0]" -c candidates.json -k 5
+
+# Options:
+#   -q, --query        Query vector as JSON array (required)
+#   -c, --candidates   Candidates file - JSON array of vectors (required)
+#   -k, --top-k        Number of results (default: 5)
+#   -t, --temperature  Softmax temperature (default: 1.0)
+```
+
+### Attention Commands
+
+Ruvector includes high-performance attention mechanisms for transformer-based operations, hyperbolic embeddings, and graph attention.
+
+```bash
+# Install the attention module (optional)
+npm install @ruvector/attention
+```
+
+#### Attention Mechanisms Reference
+
+| Mechanism | Type | Complexity | When to Use |
+|-----------|------|------------|-------------|
+| **DotProductAttention** | Core | O(n²) | Standard scaled dot-product attention for transformers |
+| **MultiHeadAttention** | Core | O(n²) | Parallel attention heads for capturing different relationships |
+| **FlashAttention** | Core | O(n²) IO-optimized | Memory-efficient attention for long sequences |
+| **HyperbolicAttention** | Core | O(n²) | Hierarchical data, tree-like structures, taxonomies |
+| **LinearAttention** | Core | O(n) | Very long sequences where O(n²) is prohibitive |
+| **MoEAttention** | Core | O(n*k) | Mixture of Experts routing, specialized attention |
+| **GraphRoPeAttention** | Graph | O(n²) | Graph data with rotary position embeddings |
+| **EdgeFeaturedAttention** | Graph | O(n²) | Graphs with rich edge features/attributes |
+| **DualSpaceAttention** | Graph | O(n²) | Combined Euclidean + hyperbolic representation |
+| **LocalGlobalAttention** | Graph | O(n*k) | Large graphs with local + global context |
+
+#### Attention Info
+
+```bash
+# Show attention module information
+npx ruvector attention info
+
+# Output:
+#   Attention Module Information
+#     Status:         Available
+#     Version:        0.1.0
+#     Platform:       linux
+#     Architecture:   x64
+#
+#   Core Attention Mechanisms:
+#     • DotProductAttention  - Scaled dot-product attention
+#     • MultiHeadAttention   - Multi-head self-attention
+#     • FlashAttention       - Memory-efficient IO-aware attention
+#     • HyperbolicAttention  - Poincaré ball attention
+#     • LinearAttention      - O(n) linear complexity attention
+#     • MoEAttention         - Mixture of Experts attention
+```
+
+#### Attention List
+
+```bash
+# List all available attention mechanisms
+npx ruvector attention list
+
+# With verbose details
+npx ruvector attention list -v
+```
+
+#### Attention Benchmark
+
+```bash
+# Benchmark attention mechanisms
+npx ruvector attention benchmark -d 256 -n 100 -i 100
+
+# Options:
+#   -d, --dimension     Vector dimension (default: 256)
+#   -n, --num-vectors   Number of vectors (default: 100)
+#   -i, --iterations    Benchmark iterations (default: 100)
+#   -t, --types         Attention types to benchmark (default: dot,flash,linear)
+
+# Example output:
+#   Dimension:    256
+#   Vectors:      100
+#   Iterations:   100
+#
+#   dot:   0.012ms/op (84,386 ops/sec)
+#   flash: 0.012ms/op (82,844 ops/sec)
+#   linear: 0.066ms/op (15,259 ops/sec)
+```
+
+#### Hyperbolic Operations
+
+```bash
+# Calculate Poincaré distance between two points
+npx ruvector attention hyperbolic -a distance -v "[0.1,0.2,0.3]" -b "[0.4,0.5,0.6]"
+
+# Project vector to Poincaré ball
+npx ruvector attention hyperbolic -a project -v "[1.5,2.0,0.8]"
+
+# Möbius addition in hyperbolic space
+npx ruvector attention hyperbolic -a mobius-add -v "[0.1,0.2]" -b "[0.3,0.4]"
+
+# Exponential map (tangent space → Poincaré ball)
+npx ruvector attention hyperbolic -a exp-map -v "[0.1,0.2,0.3]"
+
+# Options:
+#   -a, --action      Action: distance|project|mobius-add|exp-map|log-map
+#   -v, --vector      Input vector as JSON array (required)
+#   -b, --vector-b    Second vector for binary operations
+#   -c, --curvature   Poincaré ball curvature (default: 1.0)
+```
+
+#### When to Use Each Attention Type
+
+| Use Case | Recommended Attention | Reason |
+|----------|----------------------|--------|
+| **Standard NLP/Transformers** | MultiHeadAttention | Industry standard, well-tested |
+| **Long Documents (>4K tokens)** | FlashAttention or LinearAttention | Memory efficient |
+| **Hierarchical Classification** | HyperbolicAttention | Captures tree-like structures |
+| **Knowledge Graphs** | GraphRoPeAttention | Position-aware graph attention |
+| **Multi-Relational Graphs** | EdgeFeaturedAttention | Leverages edge attributes |
+| **Taxonomy/Ontology Search** | DualSpaceAttention | Best of both Euclidean + hyperbolic |
+| **Large-Scale Graphs** | LocalGlobalAttention | Efficient local + global context |
+| **Model Routing/MoE** | MoEAttention | Expert selection and routing |
+
+### ⚡ ONNX WASM Embeddings (v2.0)
+
+RuVector includes a pure JavaScript ONNX runtime for local embeddings - no Python, no API calls, no build tools required.
+
+```bash
+# Embeddings work out of the box
+npx ruvector hooks remember "important context" -t project
+npx ruvector hooks recall "context query"
+npx ruvector hooks rag-context "how does auth work"
+```
+
+**Model**: all-MiniLM-L6-v2 (384 dimensions, 23MB)
+- Downloads automatically on first use
+- Cached in `.ruvector/models/`
+- SIMD-accelerated when available
+
+**Performance:**
+| Operation | Time | Notes |
+|-----------|------|-------|
+| Model load | ~2s | First use only |
+| Embedding | ~50ms | Per text chunk |
+| HNSW search | 0.045ms | 150x faster than brute force |
+| Cache hit | 0.01ms | 40,000x faster than inference |
+
+**Fallback Chain:**
+1. Native SQLite → best persistence
+2. WASM SQLite → cross-platform
+3. Memory Cache → fastest (no persistence)
+
+### 🧠 Self-Learning Hooks v2.0
+
+Ruvector includes **self-learning intelligence hooks** for Claude Code integration with ONNX embeddings, AST analysis, and coverage-aware routing.
+
+#### Initialize Hooks
+
+```bash
+# Initialize hooks in your project
+npx ruvector hooks init
+
+# Options:
+#   --force      Overwrite existing configuration
+#   --minimal    Minimal configuration (no optional hooks)
+#   --pretrain   Initialize + pretrain from git history
+#   --build-agents quality  Generate optimized agent configs
+```
+
+This creates `.claude/settings.json` with pre-configured hooks and `CLAUDE.md` with comprehensive documentation.
+
+#### Session Management
+
+```bash
+# Start a session (load intelligence data)
+npx ruvector hooks session-start
+
+# End a session (save learned patterns)
+npx ruvector hooks session-end
+```
+
+#### Pre/Post Edit Hooks
+
+```bash
+# Before editing a file - get agent recommendations
+npx ruvector hooks pre-edit src/index.ts
+# Output: 🤖 Recommended: typescript-developer (85% confidence)
+
+# After editing - record success/failure for learning
+npx ruvector hooks post-edit src/index.ts --success
+npx ruvector hooks post-edit src/index.ts --error "Type error on line 42"
+```
+
+#### Pre/Post Command Hooks
+
+```bash
+# Before running a command - risk analysis
+npx ruvector hooks pre-command "npm test"
+# Output: ✅ Risk: LOW, Category: test
+
+# After running - record outcome
+npx ruvector hooks post-command "npm test" --success
+npx ruvector hooks post-command "npm test" --error "3 tests failed"
+```
+
+#### Agent Routing
+
+```bash
+# Get agent recommendation for a task
+npx ruvector hooks route "fix the authentication bug in login.ts"
+# Output: 🤖 Recommended: security-specialist (92% confidence)
+
+npx ruvector hooks route "add unit tests for the API"
+# Output: 🤖 Recommended: tester (88% confidence)
+```
+
+#### Memory Operations
+
+```bash
+# Store context in vector memory
+npx ruvector hooks remember "API uses JWT tokens with 1h expiry" --type decision
+npx ruvector hooks remember "Database schema in docs/schema.md" --type reference
+
+# Semantic search memory
+npx ruvector hooks recall "authentication mechanism"
+# Returns relevant stored memories
+```
+
+#### Context Suggestions
+
+```bash
+# Get relevant context for current task
+npx ruvector hooks suggest-context
+# Output: Based on recent files, suggests relevant context
+```
+
+#### Intelligence Statistics
+
+```bash
+# Show learned patterns and statistics
+npx ruvector hooks stats
+
+# Output:
+#   Patterns: 156 learned
+#   Success rate: 87%
+#   Top agents: rust-developer, tester, reviewer
+#   Memory entries: 42
+```
+
+#### Swarm Recommendations
+
+```bash
+# Get agent recommendation for task type
+npx ruvector hooks swarm-recommend "code-review"
+# Output: Recommended agents for code review task
+```
+
+#### AST Analysis (v2.0)
+
+```bash
+# Analyze file structure, symbols, imports, complexity
+npx ruvector hooks ast-analyze src/index.ts --json
+
+# Get complexity metrics for multiple files
+npx ruvector hooks ast-complexity src/*.ts --threshold 15
+# Flags files exceeding cyclomatic complexity threshold
+```
+
+#### Diff & Risk Analysis (v2.0)
+
+```bash
+# Analyze commit with semantic embeddings and risk scoring
+npx ruvector hooks diff-analyze HEAD
+# Output: risk score, category, affected files
+
+# Classify change type (feature, bugfix, refactor, docs, test)
+npx ruvector hooks diff-classify
+
+# Find similar past commits via embeddings
+npx ruvector hooks diff-similar -k 5
+
+# Git churn analysis (hot spots)
+npx ruvector hooks git-churn --days 30
+```
+
+#### Coverage-Aware Routing (v2.0)
+
+```bash
+# Get coverage-aware routing for a file
+npx ruvector hooks coverage-route src/api.ts
+# Output: agent weights based on test coverage
+
+# Suggest tests for files based on coverage gaps
+npx ruvector hooks coverage-suggest src/*.ts
+```
+
+#### Graph Analysis (v2.0)
+
+```bash
+# Find optimal code boundaries (MinCut algorithm)
+npx ruvector hooks graph-mincut src/*.ts
+
+# Detect code communities (Louvain/Spectral clustering)
+npx ruvector hooks graph-cluster src/*.ts --method louvain
+```
+
+#### Security & RAG (v2.0)
+
+```bash
+# Parallel security vulnerability scan
+npx ruvector hooks security-scan src/*.ts
+
+# RAG-enhanced context retrieval
+npx ruvector hooks rag-context "how does auth work"
+
+# Enhanced routing with all signals
+npx ruvector hooks route-enhanced "fix bug" --file src/api.ts
+```
+
+#### Hooks Configuration
+
+The hooks integrate with Claude Code via `.claude/settings.json`:
+
+```json
+{
+  "env": {
+    "RUVECTOR_INTELLIGENCE_ENABLED": "true",
+    "RUVECTOR_LEARNING_RATE": "0.1",
+    "RUVECTOR_AST_ENABLED": "true",
+    "RUVECTOR_DIFF_EMBEDDINGS": "true",
+    "RUVECTOR_COVERAGE_ROUTING": "true",
+    "RUVECTOR_GRAPH_ALGORITHMS": "true",
+    "RUVECTOR_SECURITY_SCAN": "true"
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [{ "type": "command", "command": "npx ruvector hooks pre-edit \"$TOOL_INPUT_file_path\"" }]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [{ "type": "command", "command": "npx ruvector hooks pre-command \"$TOOL_INPUT_command\"" }]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [{ "type": "command", "command": "npx ruvector hooks post-edit \"$TOOL_INPUT_file_path\"" }]
+      }
+    ],
+    "SessionStart": [{ "hooks": [{ "type": "command", "command": "npx ruvector hooks session-start" }] }],
+    "Stop": [{ "hooks": [{ "type": "command", "command": "npx ruvector hooks session-end" }] }]
+  }
+}
+```
+
+#### How Self-Learning Works
+
+1. **Pattern Recording**: Every edit and command is recorded with context
+2. **Q-Learning**: Success/failure updates agent routing weights
+3. **AST Analysis**: Code complexity informs agent selection
+4. **Diff Embeddings**: Change patterns improve risk assessment
+5. **Coverage Routing**: Test coverage guides testing priorities
+6. **Vector Memory**: Decisions and references stored for semantic recall (HNSW indexed)
+7. **Continuous Improvement**: The more you use it, the smarter it gets
+
+## 📊 Performance Benchmarks
+
+Tested on AMD Ryzen 9 5950X, 128-dimensional vectors:
+
+### Native Performance (Rust)
+
+| Operation | Throughput | Latency (p50) | Latency (p99) |
+|-----------|------------|---------------|---------------|
+| Insert    | 52,341 ops/sec | 0.019 ms | 0.045 ms |
+| Search (k=10) | 11,234 ops/sec | 0.089 ms | 0.156 ms |
+| Search (k=100) | 8,932 ops/sec | 0.112 ms | 0.203 ms |
+| Delete    | 45,678 ops/sec | 0.022 ms | 0.051 ms |
+
+**Memory Usage**: ~50 bytes per 128-dim vector (including index)
+
+### Comparison with Alternatives
+
+| Database | Insert (ops/sec) | Search (ops/sec) | Memory per Vector | Node.js | Browser |
+|----------|------------------|------------------|-------------------|---------|---------|
+| **Ruvector (Native)** | **52,341** | **11,234** | **50 bytes** | ✅ | ❌ |
+| **Ruvector (WASM)** | **~1,000** | **~100** | **50 bytes** | ✅ | ✅ |
+| Faiss (HNSW) | 38,200 | 9,800 | 68 bytes | ❌ | ❌ |
+| Hnswlib | 41,500 | 10,200 | 62 bytes | ✅ | ❌ |
+| ChromaDB | ~1,000 | ~20 | 150 bytes | ✅ | ❌ |
+
+*Benchmarks measured with 100K vectors, 128 dimensions, k=10*
+
+## 🔍 Comparison with Other Vector Databases
+
+Comprehensive comparison of Ruvector against popular vector database solutions:
+
+| Feature | Ruvector | Pinecone | Qdrant | Weaviate | Milvus | ChromaDB | Faiss |
+|---------|----------|----------|--------|----------|--------|----------|-------|
+| **Deployment** |
+| Installation | `npm install` ✅ | Cloud API ☁️ | Docker 🐳 | Docker 🐳 | Docker/K8s 🐳 | `pip install` 🐍 | `pip install` 🐍 |
+| Node.js Native | ✅ First-class | ❌ API only | ⚠️ HTTP API | ⚠️ HTTP API | ⚠️ HTTP API | ❌ Python | ❌ Python |
+| Setup Time | < 1 minute | 5-10 minutes | 10-30 minutes | 15-30 minutes | 30-60 minutes | 5 minutes | 5 minutes |
+| Infrastructure | None required | Managed cloud | Self-hosted | Self-hosted | Self-hosted | Embedded | Embedded |
+| **Performance** |
+| Query Latency (p50) | **<0.5ms** | ~2-5ms | ~1-2ms | ~2-3ms | ~3-5ms | ~50ms | ~1ms |
+| Insert Throughput | **52,341 ops/sec** | ~10,000 ops/sec | ~20,000 ops/sec | ~15,000 ops/sec | ~25,000 ops/sec | ~1,000 ops/sec | ~40,000 ops/sec |
+| Memory per Vector (128d) | **50 bytes** | ~80 bytes | 62 bytes | ~100 bytes | ~70 bytes | 150 bytes | 68 bytes |
+| Recall @ k=10 | 95%+ | 93% | 94% | 92% | 96% | 85% | 97% |
+| **Platform Support** |
+| Linux | ✅ Native | ☁️ API | ✅ Docker | ✅ Docker | ✅ Docker | ✅ Python | ✅ Python |
+| macOS | ✅ Native | ☁️ API | ✅ Docker | ✅ Docker | ✅ Docker | ✅ Python | ✅ Python |
+| Windows | ✅ Native | ☁️ API | ✅ Docker | ✅ Docker | ⚠️ WSL2 | ✅ Python | ✅ Python |
+| Browser/WASM | ✅ Yes | ❌ No | ❌ No | ❌ No | ❌ No | ❌ No | ❌ No |
+| ARM64 | ✅ Native | ☁️ API | ✅ Yes | ✅ Yes | ⚠️ Limited | ✅ Yes | ✅ Yes |
+| Alpine Linux | ✅ WASM | ☁️ API | ⚠️ Build from source | ⚠️ Build from source | ❌ No | ✅ Yes | ✅ Yes |
+| **Features** |
+| Distance Metrics | Cosine, L2, Dot | Cosine, L2, Dot | 11 metrics | 10 metrics | 8 metrics | L2, Cosine, IP | L2, IP, Cosine |
+| Filtering | ✅ Metadata | ✅ Advanced | ✅ Advanced | ✅ Advanced | ✅ Advanced | ✅ Basic | ❌ Limited |
+| Persistence | ✅ File-based | ☁️ Managed | ✅ Disk | ✅ Disk | ✅ Disk | ✅ DuckDB | ❌ Memory |
+| Indexing | HNSW | Proprietary | HNSW | HNSW | IVF/HNSW | HNSW | IVF/HNSW |
+| Quantization | ✅ PQ | ✅ Yes | ✅ Scalar | ✅ PQ | ✅ PQ/SQ | ❌ No | ✅ PQ |
+| Batch Operations | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
+| **Developer Experience** |
+| TypeScript Types | ✅ Full | ✅ Generated | ⚠️ Community | ⚠️ Community | ⚠️ Community | ⚠️ Partial | ❌ No |
+| Documentation | ✅ Excellent | ✅ Excellent | ✅ Good | ✅ Good | ✅ Good | ✅ Good | ⚠️ Technical |
+| Examples | ✅ Many | ✅ Many | ✅ Good | ✅ Good | ✅ Many | ✅ Good | ⚠️ Limited |
+| CLI Tools | ✅ Included | ⚠️ Limited | ✅ Yes | ✅ Yes | ✅ Yes | ⚠️ Basic | ❌ No |
+| **Operations** |
+| Monitoring | ✅ Metrics | ✅ Dashboard | ✅ Prometheus | ✅ Prometheus | ✅ Prometheus | ⚠️ Basic | ❌ No |
+| Backups | ✅ File copy | ☁️ Automatic | ✅ Snapshots | ✅ Snapshots | ✅ Snapshots | ✅ File copy | ❌ Manual |
+| High Availability | ⚠️ App-level | ✅ Built-in | ✅ Clustering | ✅ Clustering | ✅ Clustering | ❌ No | ❌ No |
+| Auto-Scaling | ⚠️ App-level | ✅ Automatic | ⚠️ Manual | ⚠️ Manual | ⚠️ K8s HPA | ❌ No | ❌ No |
+| **Cost** |
+| Pricing Model | Free (MIT) | Pay-per-use | Free (Apache) | Free (BSD) | Free (Apache) | Free (Apache) | Free (MIT) |
+| Monthly Cost (1M vectors) | **$0** | ~$70-200 | ~$20-50 (infra) | ~$30-60 (infra) | ~$50-100 (infra) | $0 | $0 |
+| Monthly Cost (10M vectors) | **$0** | ~$500-1000 | ~$100-200 (infra) | ~$150-300 (infra) | ~$200-400 (infra) | $0 | $0 |
+| API Rate Limits | None | Yes | None | None | None | None | None |
+| **Use Cases** |
+| RAG Systems | ✅ Excellent | ✅ Excellent | ✅ Excellent | ✅ Excellent | ✅ Excellent | ✅ Good | ⚠️ Limited |
+| Serverless | ✅ Perfect | ✅ Good | ❌ No | ❌ No | ❌ No | ⚠️ Possible | ⚠️ Possible |
+| Edge Computing | ✅ Excellent | ❌ No | ❌ No | ❌ No | ❌ No | ❌ No | ⚠️ Possible |
+| Production Scale (100M+) | ⚠️ Single node | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Excellent | ⚠️ Limited | ⚠️ Manual |
+| Embedded Apps | ✅ Excellent | ❌ No | ❌ No | ❌ No | ❌ No | ⚠️ Possible | ✅ Good |
+
+### When to Choose Ruvector
+
+✅ **Perfect for:**
+- **Node.js/TypeScript applications** needing embedded vector search
+- **Serverless and edge computing** where external services aren't practical
+- **Rapid prototyping and development** with minimal setup time
+- **RAG systems** with LangChain, LlamaIndex, or custom implementations
+- **Cost-sensitive projects** that can't afford cloud API pricing
+- **Offline-first applications** requiring local vector search
+- **Browser-based AI** with WebAssembly fallback
+- **Small to medium scale** (up to 10M vectors per instance)
+
+⚠️ **Consider alternatives for:**
+- **Massive scale (100M+ vectors)** - Consider Pinecone, Milvus, or Qdrant clusters
+- **Multi-tenancy requirements** - Weaviate or Qdrant offer better isolation
+- **Distributed systems** - Milvus provides better horizontal scaling
+- **Zero-ops cloud solution** - Pinecone handles all infrastructure
+
+### Why Choose Ruvector Over...
+
+**vs Pinecone:**
+- ✅ No API costs (save $1000s/month)
+- ✅ No network latency (10x faster queries)
+- ✅ No vendor lock-in
+- ✅ Works offline and in restricted environments
+- ❌ No managed multi-region clusters
+
+**vs ChromaDB:**
+- ✅ 50x faster queries (native Rust vs Python)
+- ✅ True Node.js support (not HTTP API)
+- ✅ Better TypeScript integration
+- ✅ Lower memory usage
+- ❌ Smaller ecosystem and community
+
+**vs Qdrant:**
+- ✅ Zero infrastructure setup
+- ✅ Embedded in your app (no Docker)
+- ✅ Better for serverless environments
+- ✅ Native Node.js bindings
+- ❌ No built-in clustering or HA
+
+**vs Faiss:**
+- ✅ Full Node.js support (Faiss is Python-only)
+- ✅ Easier API and better developer experience
+- ✅ Built-in persistence and metadata
+- ⚠️ Slightly lower recall at same performance
+
+## 🎯 Real-World Tutorials
+
+### Tutorial 1: Building a RAG System with OpenAI
+
+**What you'll learn:** Create a production-ready Retrieval-Augmented Generation system that enhances LLM responses with relevant context from your documents.
+
+**Prerequisites:**
+```bash
+npm install ruvector openai
+export OPENAI_API_KEY="your-api-key-here"
+```
+
+**Complete Implementation:**
+
+```javascript
+const { VectorDb } = require('ruvector');
+const OpenAI = require('openai');
+
+class RAGSystem {
+  constructor() {
+    // Initialize OpenAI client
+    this.openai = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY
+    });
+
+    // Create vector database for OpenAI embeddings
+    // text-embedding-ada-002 produces 1536-dimensional vectors
+    this.db = new VectorDb({
+      dimensions: 1536,
+      maxElements: 100000,
+      storagePath: './rag-knowledge-base.db'
+    });
+
+    console.log('✅ RAG System initialized');
+  }
+
+  // Step 1: Index your knowledge base
+  async indexDocuments(documents) {
+    console.log(`📚 Indexing ${documents.length} documents...`);
+
+    for (let i = 0; i < documents.length; i++) {
+      const doc = documents[i];
+
+      // Generate embedding for the document
+      const response = await this.openai.embeddings.create({
+        model: 'text-embedding-ada-002',
+        input: doc.content
+      });
+
+      // Store in vector database
+      await this.db.insert({
+        id: doc.id || `doc_${i}`,
+        vector: new Float32Array(response.data[0].embedding),
+        metadata: {
+          title: doc.title,
+          content: doc.content,
+          source: doc.source,
+          date: doc.date || new Date().toISOString()
+        }
+      });
+
+      console.log(`  ✅ Indexed: ${doc.title}`);
+    }
+
+    const count = await this.db.len();
+    console.log(`\n✅ Indexed ${count} documents total`);
+  }
+
+  // Step 2: Retrieve relevant context for a query
+  async retrieveContext(query, k = 3) {
+    console.log(`🔍 Searching for: "${query}"`);
+
+    // Generate embedding for the query
+    const response = await this.openai.embeddings.create({
+      model: 'text-embedding-ada-002',
+      input: query
+    });
+
+    // Search for similar documents
+    const results = await this.db.search({
+      vector: new Float32Array(response.data[0].embedding),
+      k: k,
+      threshold: 0.7  // Only use highly relevant results
+    });
+
+    console.log(`📄 Found ${results.length} relevant documents\n`);
+
+    return results.map(r => ({
+      content: r.metadata.content,
+      title: r.metadata.title,
+      score: r.score
+    }));
+  }
+
+  // Step 3: Generate answer with retrieved context
+  async answer(question) {
+    // Retrieve relevant context
+    const context = await this.retrieveContext(question, 3);
+
+    if (context.length === 0) {
+      return "I don't have enough information to answer that question.";
+    }
+
+    // Build prompt with context
+    const contextText = context
+      .map((doc, i) => `[${i + 1}] ${doc.title}\n${doc.content}`)
+      .join('\n\n');
+
+    const prompt = `Answer the question based on the following context. If the context doesn't contain the answer, say so.
+
+Context:
+${contextText}
+
+Question: ${question}
+
+Answer:`;
+
+    console.log('🤖 Generating answer...\n');
+
+    // Generate completion
+    const completion = await this.openai.chat.completions.create({
+      model: 'gpt-4',
+      messages: [
+        { role: 'system', content: 'You are a helpful assistant that answers questions based on provided context.' },
+        { role: 'user', content: prompt }
+      ],
+      temperature: 0.3  // Lower temperature for more factual responses
+    });
+
+    return {
+      answer: completion.choices[0].message.content,
+      sources: context.map(c => c.title)
+    };
+  }
+}
+
+// Example Usage
+async function main() {
+  const rag = new RAGSystem();
+
+  // Step 1: Index your knowledge base
+  const documents = [
+    {
+      id: 'doc1',
+      title: 'Ruvector Introduction',
+      content: 'Ruvector is a high-performance vector database for Node.js built in Rust. It provides sub-millisecond query latency and supports over 52,000 inserts per second.',
+      source: 'documentation'
+    },
+    {
+      id: 'doc2',
+      title: 'Vector Databases Explained',
+      content: 'Vector databases store data as high-dimensional vectors, enabling semantic similarity search. They are essential for AI applications like RAG systems and recommendation engines.',
+      source: 'blog'
+    },
+    {
+      id: 'doc3',
+      title: 'HNSW Algorithm',
+      content: 'Hierarchical Navigable Small World (HNSW) is a graph-based algorithm for approximate nearest neighbor search. It provides excellent recall with low latency.',
+      source: 'research'
+    }
+  ];
+
+  await rag.indexDocuments(documents);
+
+  // Step 2: Ask questions
+  console.log('\n' + '='.repeat(60) + '\n');
+
+  const result = await rag.answer('What is Ruvector and what are its performance characteristics?');
+
+  console.log('📝 Answer:', result.answer);
+  console.log('\n📚 Sources:', result.sources.join(', '));
+}
+
+main().catch(console.error);
+```
+
+**Expected Output:**
+```
+✅ RAG System initialized
+📚 Indexing 3 documents...
+  ✅ Indexed: Ruvector Introduction
+  ✅ Indexed: Vector Databases Explained
+  ✅ Indexed: HNSW Algorithm
+
+✅ Indexed 3 documents total
+
+============================================================
+
+🔍 Searching for: "What is Ruvector and what are its performance characteristics?"
+📄 Found 2 relevant documents
+
+🤖 Generating answer...
+
+📝 Answer: Ruvector is a high-performance vector database built in Rust for Node.js applications. Its key performance characteristics include:
+- Sub-millisecond query latency
+- Over 52,000 inserts per second
+- Optimized for semantic similarity search
+
+📚 Sources: Ruvector Introduction, Vector Databases Explained
+```
+
+**Production Tips:**
+- ✅ Use batch embedding for better throughput (OpenAI supports up to 2048 texts)
+- ✅ Implement caching for frequently asked questions
+- ✅ Add error handling for API rate limits
+- ✅ Monitor token usage and costs
+- ✅ Regularly update your knowledge base
+
+---
+
+### Tutorial 2: Semantic Search Engine
+
+**What you'll learn:** Build a semantic search engine that understands meaning, not just keywords.
+
+**Prerequisites:**
+```bash
+npm install ruvector @xenova/transformers
+```
+
+**Complete Implementation:**
+
+```javascript
+const { VectorDb } = require('ruvector');
+const { pipeline } = require('@xenova/transformers');
+
+class SemanticSearchEngine {
+  constructor() {
+    this.db = null;
+    this.embedder = null;
+  }
+
+  // Step 1: Initialize the embedding model
+  async initialize() {
+    console.log('🚀 Initializing semantic search engine...');
+
+    // Load sentence-transformers model (runs locally, no API needed!)
+    console.log('📥 Loading embedding model...');
+    this.embedder = await pipeline(
+      'feature-extraction',
+      'Xenova/all-MiniLM-L6-v2'
+    );
+
+    // Create vector database (384 dimensions for all-MiniLM-L6-v2)
+    this.db = new VectorDb({
+      dimensions: 384,
+      maxElements: 50000,
+      storagePath: './semantic-search.db'
+    });
+
+    console.log('✅ Search engine ready!\n');
+  }
+
+  // Step 2: Generate embeddings
+  async embed(text) {
+    const output = await this.embedder(text, {
+      pooling: 'mean',
+      normalize: true
+    });
+
+    // Convert to Float32Array
+    return new Float32Array(output.data);
+  }
+
+  // Step 3: Index documents
+  async indexDocuments(documents) {
+    console.log(`📚 Indexing ${documents.length} documents...`);
+
+    for (const doc of documents) {
+      const vector = await this.embed(doc.content);
+
+      await this.db.insert({
+        id: doc.id,
+        vector: vector,
+        metadata: {
+          title: doc.title,
+          content: doc.content,
+          category: doc.category,
+          url: doc.url
+        }
+      });
+
+      console.log(`  ✅ ${doc.title}`);
+    }
+
+    const count = await this.db.len();
+    console.log(`\n✅ Indexed ${count} documents\n`);
+  }
+
+  // Step 4: Semantic search
+  async search(query, options = {}) {
+    const {
+      k = 5,
+      category = null,
+      threshold = 0.3
+    } = options;
+
+    console.log(`🔍 Searching for: "${query}"`);
+
+    // Generate query embedding
+    const queryVector = await this.embed(query);
+
+    // Search vector database
+    const results = await this.db.search({
+      vector: queryVector,
+      k: k * 2,  // Get more results for filtering
+      threshold: threshold
+    });
+
+    // Filter by category if specified
+    let filtered = results;
+    if (category) {
+      filtered = results.filter(r => r.metadata.category === category);
+    }
+
+    // Return top k after filtering
+    const final = filtered.slice(0, k);
+
+    console.log(`📄 Found ${final.length} results\n`);
+
+    return final.map(r => ({
+      id: r.id,
+      title: r.metadata.title,
+      content: r.metadata.content,
+      category: r.metadata.category,
+      score: r.score,
+      url: r.metadata.url
+    }));
+  }
+
+  // Step 5: Find similar documents
+  async findSimilar(documentId, k = 5) {
+    const doc = await this.db.get(documentId);
+
+    if (!doc) {
+      throw new Error(`Document ${documentId} not found`);
+    }
+
+    const results = await this.db.search({
+      vector: doc.vector,
+      k: k + 1  // +1 because the document itself will be included
+    });
+
+    // Remove the document itself from results
+    return results
+      .filter(r => r.id !== documentId)
+      .slice(0, k);
+  }
+}
+
+// Example Usage
+async function main() {
+  const engine = new SemanticSearchEngine();
+  await engine.initialize();
+
+  // Sample documents (in production, load from your database)
+  const documents = [
+    {
+      id: '1',
+      title: 'Understanding Neural Networks',
+      content: 'Neural networks are computing systems inspired by biological neural networks. They learn to perform tasks by considering examples.',
+      category: 'AI',
+      url: '/docs/neural-networks'
+    },
+    {
+      id: '2',
+      title: 'Introduction to Machine Learning',
+      content: 'Machine learning is a subset of artificial intelligence that provides systems the ability to learn and improve from experience.',
+      category: 'AI',
+      url: '/docs/machine-learning'
+    },
+    {
+      id: '3',
+      title: 'Web Development Best Practices',
+      content: 'Modern web development involves responsive design, performance optimization, and accessibility considerations.',
+      category: 'Web',
+      url: '/docs/web-dev'
+    },
+    {
+      id: '4',
+      title: 'Deep Learning Applications',
+      content: 'Deep learning has revolutionized computer vision, natural language processing, and speech recognition.',
+      category: 'AI',
+      url: '/docs/deep-learning'
+    }
+  ];
+
+  // Index documents
+  await engine.indexDocuments(documents);
+
+  // Example 1: Basic semantic search
+  console.log('Example 1: Basic Search\n' + '='.repeat(60));
+  const results1 = await engine.search('AI and neural nets');
+  results1.forEach((result, i) => {
+    console.log(`${i + 1}. ${result.title} (Score: ${result.score.toFixed(3)})`);
+    console.log(`   ${result.content.slice(0, 80)}...`);
+    console.log(`   Category: ${result.category}\n`);
+  });
+
+  // Example 2: Category-filtered search
+  console.log('\nExample 2: Category-Filtered Search\n' + '='.repeat(60));
+  const results2 = await engine.search('learning algorithms', {
+    category: 'AI',
+    k: 3
+  });
+  results2.forEach((result, i) => {
+    console.log(`${i + 1}. ${result.title} (Score: ${result.score.toFixed(3)})`);
+  });
+
+  // Example 3: Find similar documents
+  console.log('\n\nExample 3: Find Similar Documents\n' + '='.repeat(60));
+  const similar = await engine.findSimilar('1', 2);
+  console.log('Documents similar to "Understanding Neural Networks":');
+  similar.forEach((doc, i) => {
+    console.log(`${i + 1}. ${doc.metadata.title} (Score: ${doc.score.toFixed(3)})`);
+  });
+}
+
+main().catch(console.error);
+```
+
+**Key Features:**
+- ✅ Runs completely locally (no API keys needed)
+- ✅ Understands semantic meaning, not just keywords
+- ✅ Category filtering for better results
+- ✅ "Find similar" functionality
+- ✅ Fast: ~10ms query latency
+
+---
+
+### Tutorial 3: AI Agent Memory System
+
+**What you'll learn:** Implement a memory system for AI agents that remembers past experiences and learns from them.
+
+**Complete Implementation:**
+
+```javascript
+const { VectorDb } = require('ruvector');
+
+class AgentMemory {
+  constructor(agentId) {
+    this.agentId = agentId;
+
+    // Create separate databases for different memory types
+    this.episodicMemory = new VectorDb({
+      dimensions: 768,
+      storagePath: `./memory/${agentId}-episodic.db`
+    });
+
+    this.semanticMemory = new VectorDb({
+      dimensions: 768,
+      storagePath: `./memory/${agentId}-semantic.db`
+    });
+
+    console.log(`🧠 Memory system initialized for agent: ${agentId}`);
+  }
+
+  // Step 1: Store an experience (episodic memory)
+  async storeExperience(experience) {
+    const {
+      state,
+      action,
+      result,
+      reward,
+      embedding
+    } = experience;
+
+    const experienceId = `exp_${Date.now()}_${Math.random()}`;
+
+    await this.episodicMemory.insert({
+      id: experienceId,
+      vector: new Float32Array(embedding),
+      metadata: {
+        state: state,
+        action: action,
+        result: result,
+        reward: reward,
+        timestamp: Date.now(),
+        type: 'episodic'
+      }
+    });
+
+    console.log(`💾 Stored experience: ${action} -> ${result} (reward: ${reward})`);
+    return experienceId;
+  }
+
+  // Step 2: Store learned knowledge (semantic memory)
+  async storeKnowledge(knowledge) {
+    const {
+      concept,
+      description,
+      embedding,
+      confidence = 1.0
+    } = knowledge;
+
+    const knowledgeId = `know_${Date.now()}`;
+
+    await this.semanticMemory.insert({
+      id: knowledgeId,
+      vector: new Float32Array(embedding),
+      metadata: {
+        concept: concept,
+        description: description,
+        confidence: confidence,
+        learned: Date.now(),
+        uses: 0,
+        type: 'semantic'
+      }
+    });
+
+    console.log(`📚 Learned: ${concept}`);
+    return knowledgeId;
+  }
+
+  // Step 3: Recall similar experiences
+  async recallExperiences(currentState, k = 5) {
+    console.log(`🔍 Recalling similar experiences...`);
+
+    const results = await this.episodicMemory.search({
+      vector: new Float32Array(currentState.embedding),
+      k: k,
+      threshold: 0.6  // Only recall reasonably similar experiences
+    });
+
+    // Sort by reward to prioritize successful experiences
+    const sorted = results.sort((a, b) => b.metadata.reward - a.metadata.reward);
+
+    console.log(`📝 Recalled ${sorted.length} relevant experiences`);
+
+    return sorted.map(r => ({
+      state: r.metadata.state,
+      action: r.metadata.action,
+      result: r.metadata.result,
+      reward: r.metadata.reward,
+      similarity: r.score
+    }));
+  }
+
+  // Step 4: Query knowledge base
+  async queryKnowledge(query, k = 3) {
+    const results = await this.semanticMemory.search({
+      vector: new Float32Array(query.embedding),
+      k: k
+    });
+
+    // Update usage statistics
+    for (const result of results) {
+      const knowledge = await this.semanticMemory.get(result.id);
+      if (knowledge) {
+        knowledge.metadata.uses += 1;
+        // In production, update the entry
+      }
+    }
+
+    return results.map(r => ({
+      concept: r.metadata.concept,
+      description: r.metadata.description,
+      confidence: r.metadata.confidence,
+      relevance: r.score
+    }));
+  }
+
+  // Step 5: Reflect and learn from experiences
+  async reflect() {
+    console.log('\n🤔 Reflecting on experiences...');
+
+    // Get all experiences
+    const totalExperiences = await this.episodicMemory.len();
+    console.log(`📊 Total experiences: ${totalExperiences}`);
+
+    // Analyze success rate
+    // In production, you'd aggregate experiences and extract patterns
+    console.log('💡 Analysis complete');
+
+    return {
+      totalExperiences: totalExperiences,
+      knowledgeItems: await this.semanticMemory.len()
+    };
+  }
+
+  // Step 6: Get memory statistics
+  async getStats() {
+    return {
+      episodicMemorySize: await this.episodicMemory.len(),
+      semanticMemorySize: await this.semanticMemory.len(),
+      agentId: this.agentId
+    };
+  }
+}
+
+// Example Usage: Simulated agent learning to navigate
+async function main() {
+  const agent = new AgentMemory('agent-001');
+
+  // Simulate embedding function (in production, use a real model)
+  function embed(text) {
+    return Array(768).fill(0).map(() => Math.random());
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log('PHASE 1: Learning from experiences');
+  console.log('='.repeat(60) + '\n');
+
+  // Store some experiences
+  await agent.storeExperience({
+    state: { location: 'room1', goal: 'room3' },
+    action: 'move_north',
+    result: 'reached room2',
+    reward: 0.5,
+    embedding: embed('navigating from room1 to room2')
+  });
+
+  await agent.storeExperience({
+    state: { location: 'room2', goal: 'room3' },
+    action: 'move_east',
+    result: 'reached room3',
+    reward: 1.0,
+    embedding: embed('navigating from room2 to room3')
+  });
+
+  await agent.storeExperience({
+    state: { location: 'room1', goal: 'room3' },
+    action: 'move_south',
+    result: 'hit wall',
+    reward: -0.5,
+    embedding: embed('failed navigation attempt')
+  });
+
+  // Store learned knowledge
+  await agent.storeKnowledge({
+    concept: 'navigation_strategy',
+    description: 'Moving north then east is efficient for reaching room3 from room1',
+    embedding: embed('navigation strategy knowledge'),
+    confidence: 0.9
+  });
+
+  console.log('\n' + '='.repeat(60));
+  console.log('PHASE 2: Applying memory');
+  console.log('='.repeat(60) + '\n');
+
+  // Agent encounters a similar situation
+  const currentState = {
+    location: 'room1',
+    goal: 'room3',
+    embedding: embed('navigating from room1 to room3')
+  };
+
+  // Recall relevant experiences
+  const experiences = await agent.recallExperiences(currentState, 3);
+
+  console.log('\n📖 Recalled experiences:');
+  experiences.forEach((exp, i) => {
+    console.log(`${i + 1}. Action: ${exp.action} | Result: ${exp.result} | Reward: ${exp.reward} | Similarity: ${exp.similarity.toFixed(3)}`);
+  });
+
+  // Query relevant knowledge
+  const knowledge = await agent.queryKnowledge({
+    embedding: embed('how to navigate efficiently')
+  }, 2);
+
+  console.log('\n📚 Relevant knowledge:');
+  knowledge.forEach((k, i) => {
+    console.log(`${i + 1}. ${k.concept}: ${k.description} (confidence: ${k.confidence})`);
+  });
+
+  console.log('\n' + '='.repeat(60));
+  console.log('PHASE 3: Reflection');
+  console.log('='.repeat(60) + '\n');
+
+  // Reflect on learning
+  const stats = await agent.reflect();
+  const memoryStats = await agent.getStats();
+
+  console.log('\n📊 Memory Statistics:');
+  console.log(`   Episodic memories: ${memoryStats.episodicMemorySize}`);
+  console.log(`   Semantic knowledge: ${memoryStats.semanticMemorySize}`);
+  console.log(`   Agent ID: ${memoryStats.agentId}`);
+}
+
+main().catch(console.error);
+```
+
+**Expected Output:**
+```
+🧠 Memory system initialized for agent: agent-001
+
+============================================================
+PHASE 1: Learning from experiences
+============================================================
+
+💾 Stored experience: move_north -> reached room2 (reward: 0.5)
+💾 Stored experience: move_east -> reached room3 (reward: 1.0)
+💾 Stored experience: move_south -> hit wall (reward: -0.5)
+📚 Learned: navigation_strategy
+
+============================================================
+PHASE 2: Applying memory
+============================================================
+
+🔍 Recalling similar experiences...
+📝 Recalled 3 relevant experiences
+
+📖 Recalled experiences:
+1. Action: move_east | Result: reached room3 | Reward: 1.0 | Similarity: 0.892
+2. Action: move_north | Result: reached room2 | Reward: 0.5 | Similarity: 0.876
+3. Action: move_south | Result: hit wall | Reward: -0.5 | Similarity: 0.654
+
+📚 Relevant knowledge:
+1. navigation_strategy: Moving north then east is efficient for reaching room3 from room1 (confidence: 0.9)
+
+============================================================
+PHASE 3: Reflection
+============================================================
+
+🤔 Reflecting on experiences...
+📊 Total experiences: 3
+💡 Analysis complete
+
+📊 Memory Statistics:
+   Episodic memories: 3
+   Semantic knowledge: 1
+   Agent ID: agent-001
+```
+
+**Use Cases:**
+- ✅ Reinforcement learning agents
+- ✅ Chatbot conversation history
+- ✅ Game AI that learns from gameplay
+- ✅ Personal assistant memory
+- ✅ Robotic navigation systems
+
+## 🏗️ API Reference
+
+### Constructor
+
+```typescript
+new VectorDb(options: {
+  dimensions: number;        // Vector dimensionality (required)
+  maxElements?: number;      // Max vectors (default: 10000)
+  storagePath?: string;      // Persistent storage path
+  ef_construction?: number;  // HNSW construction parameter (default: 200)
+  m?: number;               // HNSW M parameter (default: 16)
+  distanceMetric?: string;  // 'cosine', 'euclidean', or 'dot' (default: 'cosine')
+})
+```
+
+### Methods
+
+#### insert(entry: VectorEntry): Promise<string>
+Insert a vector into the database.
+
+```javascript
+const id = await db.insert({
+  id: 'doc_1',
+  vector: new Float32Array([0.1, 0.2, 0.3, ...]),
+  metadata: { title: 'Document 1' }
+});
+```
+
+#### search(query: SearchQuery): Promise<SearchResult[]>
+Search for similar vectors.
+
+```javascript
+const results = await db.search({
+  vector: new Float32Array([0.1, 0.2, 0.3, ...]),
+  k: 10,
+  threshold: 0.7
+});
+```
+
+#### get(id: string): Promise<VectorEntry | null>
+Retrieve a vector by ID.
+
+```javascript
+const entry = await db.get('doc_1');
+if (entry) {
+  console.log(entry.vector, entry.metadata);
+}
+```
+
+#### delete(id: string): Promise<boolean>
+Remove a vector from the database.
+
+```javascript
+const deleted = await db.delete('doc_1');
+console.log(deleted ? 'Deleted' : 'Not found');
+```
+
+#### len(): Promise<number>
+Get the total number of vectors.
+
+```javascript
+const count = await db.len();
+console.log(`Total vectors: ${count}`);
+```
+
+## 🎨 Advanced Configuration
+
+### HNSW Parameters
+
+```javascript
+const db = new VectorDb({
+  dimensions: 384,
+  maxElements: 1000000,
+  ef_construction: 200,  // Higher = better recall, slower build
+  m: 16,                 // Higher = better recall, more memory
+  storagePath: './large-db.db'
+});
+```
+
+**Parameter Guidelines:**
+- `ef_construction`: 100-400 (higher = better recall, slower indexing)
+- `m`: 8-64 (higher = better recall, more memory)
+- Default values work well for most use cases
+
+### Distance Metrics
+
+```javascript
+// Cosine similarity (default, best for normalized vectors)
+const db1 = new VectorDb({
+  dimensions: 128,
+  distanceMetric: 'cosine'
+});
+
+// Euclidean distance (L2, best for spatial data)
+const db2 = new VectorDb({
+  dimensions: 128,
+  distanceMetric: 'euclidean'
+});
+
+// Dot product (best for pre-normalized vectors)
+const db3 = new VectorDb({
+  dimensions: 128,
+  distanceMetric: 'dot'
+});
+```
+
+### Persistence
+
+```javascript
+// Auto-save to disk
+const persistent = new VectorDb({
+  dimensions: 128,
+  storagePath: './persistent.db'
+});
+
+// In-memory only (faster, but data lost on exit)
+const temporary = new VectorDb({
+  dimensions: 128
+  // No storagePath = in-memory
+});
+```
+
+## 📦 Platform Support
+
+Automatically installs the correct implementation for:
+
+### Native (Rust) - Best Performance
+- **Linux**: x64, ARM64 (GNU libc)
+- **macOS**: x64 (Intel), ARM64 (Apple Silicon)
+- **Windows**: x64 (MSVC)
+
+Performance: **<0.5ms latency**, **50K+ ops/sec**
+
+### WASM Fallback - Universal Compatibility
+- Any platform where native module isn't available
+- Browser environments (experimental)
+- Alpine Linux (musl) and other non-glibc systems
+
+Performance: **10-50ms latency**, **~1K ops/sec**
+
+**Node.js 18+ required** for all platforms.
+
+## 🔧 Building from Source
+
+If you need to rebuild the native module:
+
+```bash
+# Install Rust toolchain
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Clone repository
+git clone https://github.com/ruvnet/ruvector.git
+cd ruvector
+
+# Build native module
+cd npm/packages/core
+npm run build:napi
+
+# Build wrapper package
+cd ../ruvector
+npm install
+npm run build
+
+# Run tests
+npm test
+```
+
+**Requirements:**
+- Rust 1.77+
+- Node.js 18+
+- Cargo
+
+## 🌍 Ecosystem
+
+### Related Packages
+
+- **[ruvector-core](https://www.npmjs.com/package/ruvector-core)** - Core native bindings (lower-level API)
+- **[ruvector-wasm](https://www.npmjs.com/package/ruvector-wasm)** - WebAssembly implementation for browsers
+- **[ruvector-cli](https://www.npmjs.com/package/ruvector-cli)** - Standalone CLI tools
+- **[@ruvector/rvf](https://www.npmjs.com/package/@ruvector/rvf)** - RVF cognitive container SDK
+- **[@ruvector/rvf-wasm](https://www.npmjs.com/package/@ruvector/rvf-wasm)** - RVF WASM build for browsers, Deno, and edge
+- **[rvlite](https://www.npmjs.com/package/rvlite)** - Lightweight vector database with SQL, SPARQL, and Cypher
+
+### Platform-Specific Packages (auto-installed)
+
+- **[ruvector-core-linux-x64-gnu](https://www.npmjs.com/package/ruvector-core-linux-x64-gnu)**
+- **[ruvector-core-linux-arm64-gnu](https://www.npmjs.com/package/ruvector-core-linux-arm64-gnu)**
+- **[ruvector-core-darwin-x64](https://www.npmjs.com/package/ruvector-core-darwin-x64)**
+- **[ruvector-core-darwin-arm64](https://www.npmjs.com/package/ruvector-core-darwin-arm64)**
+- **[ruvector-core-win32-x64-msvc](https://www.npmjs.com/package/ruvector-core-win32-x64-msvc)**
+
+---
+
+## RVF Cognitive Containers
+
+Ruvector integrates with [RVF (RuVector Format)](https://github.com/ruvnet/ruvector/tree/main/crates/rvf) — a universal binary substrate that stores vectors, models, graphs, compute kernels, and attestation in a single `.rvf` file.
+
+### Enable RVF Backend
+
+```bash
+# Install the optional RVF package
+npm install @ruvector/rvf
+
+# Set backend via environment variable
+export RUVECTOR_BACKEND=rvf
+
+# Or detect automatically (native -> rvf -> wasm fallback)
+npx ruvector info
+```
+
+```typescript
+import { getImplementationType, isRvf } from 'ruvector';
+
+console.log(getImplementationType()); // 'native' | 'rvf' | 'wasm'
+console.log(isRvf()); // true if RVF backend is active
+```
+
+### RVF CLI Commands
+
+8 RVF-specific subcommands are available through the ruvector CLI:
+
+```bash
+# Create an RVF store
+npx ruvector rvf create mydb.rvf -d 384 --metric cosine
+
+# Ingest vectors from JSON
+npx ruvector rvf ingest mydb.rvf --input vectors.json --format json
+
+# Query nearest neighbors
+npx ruvector rvf query mydb.rvf --vector "[0.1,0.2,...]" --k 10
+
+# File status and segment listing
+npx ruvector rvf status mydb.rvf
+npx ruvector rvf segments mydb.rvf
+
+# COW branching — derive a child file
+npx ruvector rvf derive mydb.rvf --output child.rvf
+
+# Compact and reclaim space
+npx ruvector rvf compact mydb.rvf
+
+# Export to JSON
+npx ruvector rvf export mydb.rvf --output dump.json
+```
+
+### RVF Platform Support
+
+| Platform | Runtime | Backend |
+|----------|---------|---------|
+| Linux x86_64 / aarch64 | Node.js 18+ | Native (N-API) |
+| macOS x86_64 / arm64 | Node.js 18+ | Native (N-API) |
+| Windows x86_64 | Node.js 18+ | Native (N-API) |
+| Any | Deno | WASM (`@ruvector/rvf-wasm`) |
+| Any | Browser | WASM (`@ruvector/rvf-wasm`) |
+| Any | Cloudflare Workers | WASM (`@ruvector/rvf-wasm`) |
+
+### Download Example .rvf Files
+
+45 pre-built example files are available (~11 MB total):
+
+```bash
+# Download a specific example
+curl -LO https://raw.githubusercontent.com/ruvnet/ruvector/main/examples/rvf/output/basic_store.rvf
+
+# Popular examples:
+#   basic_store.rvf (152 KB)        — 1,000 vectors, dim 128
+#   semantic_search.rvf (755 KB)    — Semantic search with HNSW
+#   rag_pipeline.rvf (303 KB)       — RAG pipeline embeddings
+#   agent_memory.rvf (32 KB)        — AI agent memory store
+#   self_booting.rvf (31 KB)        — Self-booting with kernel
+#   progressive_index.rvf (2.5 MB)  — Large-scale HNSW index
+
+# Generate all examples locally
+cd crates/rvf && cargo run --example generate_all
+```
+
+Full catalog: [examples/rvf/output/](https://github.com/ruvnet/ruvector/tree/main/examples/rvf/output)
+
+### Working Examples: Cognitive Containers
+
+#### Self-Booting Microservice
+
+A single `.rvf` file that contains vectors AND a bootable Linux kernel:
+
+```bash
+# Build and run the self-booting example
+cd crates/rvf && cargo run --example self_booting
+# Output:
+#   Ingested 50 vectors (128 dims)
+#   Pre-kernel query: top-5 results OK (nearest ID=25)
+#   Kernel: 4,640 bytes embedded (x86_64, Hermit)
+#   Witness chain: 5 entries, all verified
+#   File: bootable.rvf (31 KB) — data + runtime in one file
+```
+
+```rust
+// The pattern: vectors + kernel + witness in one file
+let mut store = RvfStore::create("bootable.rvf", options)?;
+store.ingest_batch(&vectors, &ids, None)?;
+store.embed_kernel(KernelArch::X86_64 as u8, KernelType::Hermit as u8,
+    0x0018, &kernel_image, 8080, Some("console=ttyS0 quiet"))?;
+// Result: drop on a VM and it boots as a query service
+```
+
+#### Linux Microkernel Distribution
+
+20-package Linux distro with SSH keys and kernel in a single file:
+
+```bash
+cd crates/rvf && cargo run --example linux_microkernel
+# Output:
+#   Installed 20 packages as vector embeddings
+#   Kernel embedded: Linux x86_64 (4,640 bytes)
+#   SSH keys: Ed25519, signed and verified
+#   Witness chain: 22 entries (1 per package + kernel + SSH)
+#   File: microkernel.rvf (14 KB) — immutable bootable system
+```
+
+Features: package search by embedding similarity, Ed25519 signed SSH keys, witness-audited installs, COW-derived child images for atomic updates.
+
+#### Claude Code AI Appliance
+
+A sealed, bootable AI development environment:
+
+```bash
+cd crates/rvf && cargo run --example claude_code_appliance
+# Output:
+#   20 dev packages (rust, node, python, docker, ...)
+#   Kernel: Linux x86_64 with SSH on port 2222
+#   eBPF: XDP distance program for fast-path lookups
+#   Witness chain: 6 entries, all verified
+#   Crypto: Ed25519 signature
+#   File: claude_code_appliance.rvf (17 KB)
+```
+
+#### CLI Full Lifecycle
+
+```bash
+# Create → Ingest → Query → Derive → Inspect
+rvf create vectors.rvf --dimension 384
+rvf ingest vectors.rvf --input data.json --format json
+rvf query vectors.rvf --vector "0.1,0.2,..." --k 10
+rvf derive vectors.rvf child.rvf --type filter
+rvf inspect vectors.rvf
+
+# Embed kernel and launch as microVM
+rvf embed-kernel vectors.rvf --image bzImage
+rvf launch vectors.rvf --port 8080
+
+# Verify tamper-evident witness chain
+rvf verify-witness vectors.rvf
+rvf verify-attestation vectors.rvf
+```
+
+#### Integration Tests (46 passing)
+
+```bash
+cd crates/rvf
+cargo test --workspace
+# attestation .............. 6 passed
+# crypto ................... 10 passed
+# computational_container .. 8 passed
+# cow_branching ............ 8 passed
+# cross_platform ........... 6 passed
+# lineage .................. 4 passed
+# smoke .................... 4 passed
+# Total: 46/46 passed
+```
+
+## 🐛 Troubleshooting
+
+### Native Module Not Loading
+
+If you see "Cannot find module 'ruvector-core-*'":
+
+```bash
+# Reinstall with optional dependencies
+npm install --include=optional ruvector
+
+# Verify platform
+npx ruvector info
+
+# Check Node.js version (18+ required)
+node --version
+```
+
+### WASM Fallback Performance
+
+If you're using WASM fallback and need better performance:
+
+1. **Install native toolchain** for your platform
+2. **Rebuild native module**: `npm rebuild ruvector`
+3. **Verify native**: `npx ruvector info` should show "native (Rust)"
+
+### Platform Compatibility
+
+- **Alpine Linux**: Uses WASM fallback (musl not supported)
+- **Windows ARM**: Not yet supported, uses WASM fallback
+- **Node.js < 18**: Not supported, upgrade to Node.js 18+
+
+## 📚 Documentation
+
+- 🏠 [Homepage](https://ruv.io)
+- 📦 [GitHub Repository](https://github.com/ruvnet/ruvector)
+- 📚 [Full Documentation](https://github.com/ruvnet/ruvector/tree/main/docs)
+- 🚀 [Getting Started Guide](https://github.com/ruvnet/ruvector/blob/main/docs/guide/GETTING_STARTED.md)
+- 📖 [API Reference](https://github.com/ruvnet/ruvector/blob/main/docs/api/NODEJS_API.md)
+- 🎯 [Performance Tuning](https://github.com/ruvnet/ruvector/blob/main/docs/optimization/PERFORMANCE_TUNING_GUIDE.md)
+- 🐛 [Issue Tracker](https://github.com/ruvnet/ruvector/issues)
+- 💬 [Discussions](https://github.com/ruvnet/ruvector/discussions)
+
+## 🤝 Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](https://github.com/ruvnet/ruvector/blob/main/docs/development/CONTRIBUTING.md) for guidelines.
+
+### Quick Start
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/amazing-feature`
+3. Commit changes: `git commit -m 'Add amazing feature'`
+4. Push to branch: `git push origin feature/amazing-feature`
+5. Open a Pull Request
+
+## 🌐 Community & Support
+
+- **GitHub**: [github.com/ruvnet/ruvector](https://github.com/ruvnet/ruvector) - ⭐ Star and follow
+- **Discord**: [Join our community](https://discord.gg/ruvnet) - Chat with developers
+- **Twitter**: [@ruvnet](https://twitter.com/ruvnet) - Follow for updates
+- **Issues**: [Report bugs](https://github.com/ruvnet/ruvector/issues)
+
+### Enterprise Support
+
+Need custom development or consulting?
+
+📧 [enterprise@ruv.io](mailto:enterprise@ruv.io)
+
+## 📜 License
+
+**MIT License** - see [LICENSE](https://github.com/ruvnet/ruvector/blob/main/LICENSE) for details.
+
+Free for commercial and personal use.
+
+## 🙏 Acknowledgments
+
+Built with battle-tested technologies:
+
+- **HNSW**: Hierarchical Navigable Small World graphs
+- **SIMD**: Hardware-accelerated vector operations via simsimd
+- **Rust**: Memory-safe, zero-cost abstractions
+- **NAPI-RS**: High-performance Node.js bindings
+- **WebAssembly**: Universal browser compatibility
+
+---
+
+<div align="center">
+
+**Built with ❤️ by [rUv](https://ruv.io)**
+
+[![npm](https://img.shields.io/npm/v/ruvector.svg)](https://www.npmjs.com/package/ruvector)
+[![GitHub Stars](https://img.shields.io/github/stars/ruvnet/ruvector?style=social)](https://github.com/ruvnet/ruvector)
+[![Twitter](https://img.shields.io/twitter/follow/ruvnet?style=social)](https://twitter.com/ruvnet)
+
+**[Get Started](https://github.com/ruvnet/ruvector/blob/main/docs/guide/GETTING_STARTED.md)** • **[Documentation](https://github.com/ruvnet/ruvector/tree/main/docs)** • **[API Reference](https://github.com/ruvnet/ruvector/blob/main/docs/api/NODEJS_API.md)** • **[Contributing](https://github.com/ruvnet/ruvector/blob/main/docs/development/CONTRIBUTING.md)**
+
+</div>

dist/analysis/complexity.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Complexity Analysis Module - Consolidated code complexity metrics
+ *
+ * Single source of truth for cyclomatic complexity and code metrics.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+export interface ComplexityResult {
+    file: string;
+    lines: number;
+    nonEmptyLines: number;
+    cyclomaticComplexity: number;
+    functions: number;
+    avgFunctionSize: number;
+    maxFunctionComplexity?: number;
+}
+export interface ComplexityThresholds {
+    complexity: number;
+    functions: number;
+    lines: number;
+    avgSize: number;
+}
+export declare const DEFAULT_THRESHOLDS: ComplexityThresholds;
+/**
+ * Analyze complexity of a single file
+ */
+export declare function analyzeFile(filePath: string, content?: string): ComplexityResult;
+/**
+ * Analyze complexity of multiple files
+ */
+export declare function analyzeFiles(files: string[], maxFiles?: number): ComplexityResult[];
+/**
+ * Check if complexity exceeds thresholds
+ */
+export declare function exceedsThresholds(result: ComplexityResult, thresholds?: ComplexityThresholds): boolean;
+/**
+ * Get complexity rating
+ */
+export declare function getComplexityRating(complexity: number): 'low' | 'medium' | 'high' | 'critical';
+/**
+ * Filter files exceeding thresholds
+ */
+export declare function filterComplex(results: ComplexityResult[], thresholds?: ComplexityThresholds): ComplexityResult[];
+declare const _default: {
+    DEFAULT_THRESHOLDS: ComplexityThresholds;
+    analyzeFile: typeof analyzeFile;
+    analyzeFiles: typeof analyzeFiles;
+    exceedsThresholds: typeof exceedsThresholds;
+    getComplexityRating: typeof getComplexityRating;
+    filterComplex: typeof filterComplex;
+};
+export default _default;
+//# sourceMappingURL=complexity.d.ts.map

dist/analysis/complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/analysis/complexity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,kBAAkB,EAAE,oBAKhC,CAAC;AAEF;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAsDhF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY,GAAG,gBAAgB,EAAE,CAExF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,gBAAgB,EACxB,UAAU,GAAE,oBAAyC,GACpD,OAAO,CAOT;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAK9F;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,gBAAgB,EAAE,EAC3B,UAAU,GAAE,oBAAyC,GACpD,gBAAgB,EAAE,CAEpB;;;;;;;;;AAED,wBAOE"}

dist/analysis/complexity.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Complexity Analysis Module - Consolidated code complexity metrics
+ *
+ * Single source of truth for cyclomatic complexity and code metrics.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_THRESHOLDS = void 0;
+exports.analyzeFile = analyzeFile;
+exports.analyzeFiles = analyzeFiles;
+exports.exceedsThresholds = exceedsThresholds;
+exports.getComplexityRating = getComplexityRating;
+exports.filterComplex = filterComplex;
+const fs = __importStar(require("fs"));
+exports.DEFAULT_THRESHOLDS = {
+    complexity: 10,
+    functions: 30,
+    lines: 500,
+    avgSize: 50,
+};
+/**
+ * Analyze complexity of a single file
+ */
+function analyzeFile(filePath, content) {
+    try {
+        const fileContent = content ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+        if (!fileContent) {
+            return { file: filePath, lines: 0, nonEmptyLines: 0, cyclomaticComplexity: 1, functions: 0, avgFunctionSize: 0 };
+        }
+        const lines = fileContent.split('\n');
+        const nonEmptyLines = lines.filter(l => l.trim().length > 0).length;
+        // Count branching statements for cyclomatic complexity
+        const branches = (fileContent.match(/\bif\b/g)?.length || 0) +
+            (fileContent.match(/\belse\b/g)?.length || 0) +
+            (fileContent.match(/\bfor\b/g)?.length || 0) +
+            (fileContent.match(/\bwhile\b/g)?.length || 0) +
+            (fileContent.match(/\bswitch\b/g)?.length || 0) +
+            (fileContent.match(/\bcase\b/g)?.length || 0) +
+            (fileContent.match(/\bcatch\b/g)?.length || 0) +
+            (fileContent.match(/\?\?/g)?.length || 0) +
+            (fileContent.match(/&&/g)?.length || 0) +
+            (fileContent.match(/\|\|/g)?.length || 0) +
+            (fileContent.match(/\?[^:]/g)?.length || 0); // Ternary
+        const cyclomaticComplexity = branches + 1;
+        // Count functions
+        const functionPatterns = [
+            /function\s+\w+/g,
+            /\w+\s*=\s*(?:async\s*)?\(/g,
+            /\w+\s*:\s*(?:async\s*)?\(/g,
+            /(?:async\s+)?(?:public|private|protected)?\s+\w+\s*\([^)]*\)\s*[:{]/g,
+        ];
+        let functions = 0;
+        for (const pattern of functionPatterns) {
+            functions += (fileContent.match(pattern) || []).length;
+        }
+        // Deduplicate by rough estimate
+        functions = Math.ceil(functions / 2);
+        const avgFunctionSize = functions > 0 ? Math.round(nonEmptyLines / functions) : nonEmptyLines;
+        return {
+            file: filePath,
+            lines: lines.length,
+            nonEmptyLines,
+            cyclomaticComplexity,
+            functions,
+            avgFunctionSize,
+        };
+    }
+    catch {
+        return { file: filePath, lines: 0, nonEmptyLines: 0, cyclomaticComplexity: 1, functions: 0, avgFunctionSize: 0 };
+    }
+}
+/**
+ * Analyze complexity of multiple files
+ */
+function analyzeFiles(files, maxFiles = 100) {
+    return files.slice(0, maxFiles).map(f => analyzeFile(f));
+}
+/**
+ * Check if complexity exceeds thresholds
+ */
+function exceedsThresholds(result, thresholds = exports.DEFAULT_THRESHOLDS) {
+    return (result.cyclomaticComplexity > thresholds.complexity ||
+        result.functions > thresholds.functions ||
+        result.lines > thresholds.lines ||
+        result.avgFunctionSize > thresholds.avgSize);
+}
+/**
+ * Get complexity rating
+ */
+function getComplexityRating(complexity) {
+    if (complexity <= 5)
+        return 'low';
+    if (complexity <= 10)
+        return 'medium';
+    if (complexity <= 20)
+        return 'high';
+    return 'critical';
+}
+/**
+ * Filter files exceeding thresholds
+ */
+function filterComplex(results, thresholds = exports.DEFAULT_THRESHOLDS) {
+    return results.filter(r => exceedsThresholds(r, thresholds));
+}
+exports.default = {
+    DEFAULT_THRESHOLDS: exports.DEFAULT_THRESHOLDS,
+    analyzeFile,
+    analyzeFiles,
+    exceedsThresholds,
+    getComplexityRating,
+    filterComplex,
+};

dist/analysis/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Analysis Module - Consolidated code analysis utilities
+ *
+ * Single source of truth for:
+ * - Security scanning
+ * - Complexity analysis
+ * - Pattern extraction
+ */
+export * from './security';
+export * from './complexity';
+export * from './patterns';
+export { default as security } from './security';
+export { default as complexity } from './complexity';
+export { default as patterns } from './patterns';
+//# sourceMappingURL=index.d.ts.map

dist/analysis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/analysis/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC"}

dist/analysis/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Analysis Module - Consolidated code analysis utilities
+ *
+ * Single source of truth for:
+ * - Security scanning
+ * - Complexity analysis
+ * - Pattern extraction
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patterns = exports.complexity = exports.security = void 0;
+__exportStar(require("./security"), exports);
+__exportStar(require("./complexity"), exports);
+__exportStar(require("./patterns"), exports);
+// Re-export defaults for convenience
+var security_1 = require("./security");
+Object.defineProperty(exports, "security", { enumerable: true, get: function () { return __importDefault(security_1).default; } });
+var complexity_1 = require("./complexity");
+Object.defineProperty(exports, "complexity", { enumerable: true, get: function () { return __importDefault(complexity_1).default; } });
+var patterns_1 = require("./patterns");
+Object.defineProperty(exports, "patterns", { enumerable: true, get: function () { return __importDefault(patterns_1).default; } });

dist/analysis/patterns.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pattern Extraction Module - Consolidated code pattern detection
+ *
+ * Single source of truth for extracting functions, imports, exports, etc.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+export interface PatternMatch {
+    type: 'function' | 'class' | 'import' | 'export' | 'todo' | 'variable' | 'type';
+    match: string;
+    file: string;
+    line?: number;
+}
+export interface FilePatterns {
+    file: string;
+    language: string;
+    functions: string[];
+    classes: string[];
+    imports: string[];
+    exports: string[];
+    todos: string[];
+    variables: string[];
+}
+/**
+ * Detect language from file extension
+ */
+export declare function detectLanguage(file: string): string;
+/**
+ * Extract function names from content
+ */
+export declare function extractFunctions(content: string): string[];
+/**
+ * Extract class names from content
+ */
+export declare function extractClasses(content: string): string[];
+/**
+ * Extract import statements from content
+ */
+export declare function extractImports(content: string): string[];
+/**
+ * Extract export statements from content
+ */
+export declare function extractExports(content: string): string[];
+/**
+ * Extract TODO/FIXME comments from content
+ */
+export declare function extractTodos(content: string): string[];
+/**
+ * Extract all patterns from a file
+ */
+export declare function extractAllPatterns(filePath: string, content?: string): FilePatterns;
+/**
+ * Extract patterns from multiple files
+ */
+export declare function extractFromFiles(files: string[], maxFiles?: number): FilePatterns[];
+/**
+ * Convert FilePatterns to PatternMatch array (for native-worker compatibility)
+ */
+export declare function toPatternMatches(patterns: FilePatterns): PatternMatch[];
+declare const _default: {
+    detectLanguage: typeof detectLanguage;
+    extractFunctions: typeof extractFunctions;
+    extractClasses: typeof extractClasses;
+    extractImports: typeof extractImports;
+    extractExports: typeof extractExports;
+    extractTodos: typeof extractTodos;
+    extractAllPatterns: typeof extractAllPatterns;
+    extractFromFiles: typeof extractFromFiles;
+    toPatternMatches: typeof toPatternMatches;
+};
+export default _default;
+//# sourceMappingURL=patterns.d.ts.map

dist/analysis/patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.d.ts","sourceRoot":"","sources":["../../src/analysis/patterns.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUnD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CA2B1D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAmBxD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAmBxD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAuBxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAUtD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,CA0BnF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY,GAAG,YAAY,EAAE,CAExF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,EAAE,CAoBvE;;;;;;;;;;;;AAED,wBAUE"}

dist/analysis/patterns.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Pattern Extraction Module - Consolidated code pattern detection
+ *
+ * Single source of truth for extracting functions, imports, exports, etc.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLanguage = detectLanguage;
+exports.extractFunctions = extractFunctions;
+exports.extractClasses = extractClasses;
+exports.extractImports = extractImports;
+exports.extractExports = extractExports;
+exports.extractTodos = extractTodos;
+exports.extractAllPatterns = extractAllPatterns;
+exports.extractFromFiles = extractFromFiles;
+exports.toPatternMatches = toPatternMatches;
+const fs = __importStar(require("fs"));
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(file) {
+    const ext = file.split('.').pop()?.toLowerCase() || '';
+    const langMap = {
+        ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+        rs: 'rust', py: 'python', go: 'go', java: 'java', rb: 'ruby',
+        cpp: 'cpp', c: 'c', h: 'c', hpp: 'cpp', cs: 'csharp',
+        md: 'markdown', json: 'json', yaml: 'yaml', yml: 'yaml',
+        sql: 'sql', sh: 'shell', bash: 'shell', zsh: 'shell',
+    };
+    return langMap[ext] || ext || 'unknown';
+}
+/**
+ * Extract function names from content
+ */
+function extractFunctions(content) {
+    const patterns = [
+        /function\s+(\w+)/g,
+        /const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+        /let\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+        /(?:async\s+)?(?:public|private|protected)?\s+(\w+)\s*\([^)]*\)\s*[:{]/g,
+        /(\w+)\s*:\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+        /def\s+(\w+)\s*\(/g, // Python
+        /fn\s+(\w+)\s*[<(]/g, // Rust
+        /func\s+(\w+)\s*\(/g, // Go
+    ];
+    const funcs = new Set();
+    const reserved = new Set(['if', 'for', 'while', 'switch', 'catch', 'try', 'else', 'return', 'new', 'class', 'function', 'async', 'await']);
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            if (name && !reserved.has(name) && name.length > 1) {
+                funcs.add(name);
+            }
+        }
+    }
+    return Array.from(funcs);
+}
+/**
+ * Extract class names from content
+ */
+function extractClasses(content) {
+    const patterns = [
+        /class\s+(\w+)/g,
+        /interface\s+(\w+)/g,
+        /type\s+(\w+)\s*=/g,
+        /enum\s+(\w+)/g,
+        /struct\s+(\w+)/g,
+    ];
+    const classes = new Set();
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1])
+                classes.add(match[1]);
+        }
+    }
+    return Array.from(classes);
+}
+/**
+ * Extract import statements from content
+ */
+function extractImports(content) {
+    const patterns = [
+        /import\s+.*?from\s+['"]([^'"]+)['"]/g,
+        /import\s+['"]([^'"]+)['"]/g,
+        /require\s*\(['"]([^'"]+)['"]\)/g,
+        /from\s+(\w+)\s+import/g, // Python
+        /use\s+(\w+(?:::\w+)*)/g, // Rust
+    ];
+    const imports = [];
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+    }
+    return [...new Set(imports)];
+}
+/**
+ * Extract export statements from content
+ */
+function extractExports(content) {
+    const patterns = [
+        /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+(\w+)/g,
+        /export\s*\{\s*([^}]+)\s*\}/g,
+        /module\.exports\s*=\s*(\w+)/g,
+        /exports\.(\w+)\s*=/g,
+        /pub\s+(?:fn|struct|enum|type)\s+(\w+)/g, // Rust
+    ];
+    const exports = [];
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1]) {
+                // Handle grouped exports: export { a, b, c }
+                const names = match[1].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim());
+                exports.push(...names.filter(n => n && /^\w+$/.test(n)));
+            }
+        }
+    }
+    return [...new Set(exports)];
+}
+/**
+ * Extract TODO/FIXME comments from content
+ */
+function extractTodos(content) {
+    const pattern = /\/\/\s*(TODO|FIXME|HACK|XXX|BUG|NOTE):\s*(.+)/gi;
+    const todos = [];
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        todos.push(`${match[1]}: ${match[2].trim()}`);
+    }
+    return todos;
+}
+/**
+ * Extract all patterns from a file
+ */
+function extractAllPatterns(filePath, content) {
+    try {
+        const fileContent = content ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+        return {
+            file: filePath,
+            language: detectLanguage(filePath),
+            functions: extractFunctions(fileContent),
+            classes: extractClasses(fileContent),
+            imports: extractImports(fileContent),
+            exports: extractExports(fileContent),
+            todos: extractTodos(fileContent),
+            variables: [], // Could add variable extraction if needed
+        };
+    }
+    catch {
+        return {
+            file: filePath,
+            language: detectLanguage(filePath),
+            functions: [],
+            classes: [],
+            imports: [],
+            exports: [],
+            todos: [],
+            variables: [],
+        };
+    }
+}
+/**
+ * Extract patterns from multiple files
+ */
+function extractFromFiles(files, maxFiles = 100) {
+    return files.slice(0, maxFiles).map(f => extractAllPatterns(f));
+}
+/**
+ * Convert FilePatterns to PatternMatch array (for native-worker compatibility)
+ */
+function toPatternMatches(patterns) {
+    const matches = [];
+    for (const func of patterns.functions) {
+        matches.push({ type: 'function', match: func, file: patterns.file });
+    }
+    for (const cls of patterns.classes) {
+        matches.push({ type: 'class', match: cls, file: patterns.file });
+    }
+    for (const imp of patterns.imports) {
+        matches.push({ type: 'import', match: imp, file: patterns.file });
+    }
+    for (const exp of patterns.exports) {
+        matches.push({ type: 'export', match: exp, file: patterns.file });
+    }
+    for (const todo of patterns.todos) {
+        matches.push({ type: 'todo', match: todo, file: patterns.file });
+    }
+    return matches;
+}
+exports.default = {
+    detectLanguage,
+    extractFunctions,
+    extractClasses,
+    extractImports,
+    extractExports,
+    extractTodos,
+    extractAllPatterns,
+    extractFromFiles,
+    toPatternMatches,
+};

dist/analysis/security.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Security Analysis Module - Consolidated security scanning
+ *
+ * Single source of truth for security patterns and vulnerability detection.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+export interface SecurityPattern {
+    pattern: RegExp;
+    rule: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    message: string;
+    suggestion?: string;
+}
+export interface SecurityFinding {
+    file: string;
+    line: number;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    rule: string;
+    message: string;
+    match?: string;
+    suggestion?: string;
+}
+/**
+ * Default security patterns for vulnerability detection
+ */
+export declare const SECURITY_PATTERNS: SecurityPattern[];
+/**
+ * Scan a single file for security issues
+ */
+export declare function scanFile(filePath: string, content?: string, patterns?: SecurityPattern[]): SecurityFinding[];
+/**
+ * Scan multiple files for security issues
+ */
+export declare function scanFiles(files: string[], patterns?: SecurityPattern[], maxFiles?: number): SecurityFinding[];
+/**
+ * Get severity score (for sorting/filtering)
+ */
+export declare function getSeverityScore(severity: string): number;
+/**
+ * Sort findings by severity (highest first)
+ */
+export declare function sortBySeverity(findings: SecurityFinding[]): SecurityFinding[];
+declare const _default: {
+    SECURITY_PATTERNS: SecurityPattern[];
+    scanFile: typeof scanFile;
+    scanFiles: typeof scanFiles;
+    getSeverityScore: typeof getSeverityScore;
+    sortBySeverity: typeof sortBySeverity;
+};
+export default _default;
+//# sourceMappingURL=security.d.ts.map

dist/analysis/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/analysis/security.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,EA0B9C,CAAC;AAEF;;GAEG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,GAAE,eAAe,EAAsB,GAC9C,eAAe,EAAE,CA4BnB;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,GAAE,eAAe,EAAsB,EAC/C,QAAQ,GAAE,MAAY,GACrB,eAAe,EAAE,CAQnB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAE7E;;;;;;;;AAED,wBAME"}

dist/analysis/security.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Security Analysis Module - Consolidated security scanning
+ *
+ * Single source of truth for security patterns and vulnerability detection.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECURITY_PATTERNS = void 0;
+exports.scanFile = scanFile;
+exports.scanFiles = scanFiles;
+exports.getSeverityScore = getSeverityScore;
+exports.sortBySeverity = sortBySeverity;
+const fs = __importStar(require("fs"));
+/**
+ * Default security patterns for vulnerability detection
+ */
+exports.SECURITY_PATTERNS = [
+    // Critical: Hardcoded secrets
+    { pattern: /password\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-password', severity: 'critical', message: 'Hardcoded password detected', suggestion: 'Use environment variables or secret management' },
+    { pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-apikey', severity: 'critical', message: 'Hardcoded API key detected', suggestion: 'Use environment variables' },
+    { pattern: /secret\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-secret', severity: 'critical', message: 'Hardcoded secret detected', suggestion: 'Use environment variables or secret management' },
+    { pattern: /private[_-]?key\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-private-key', severity: 'critical', message: 'Hardcoded private key detected', suggestion: 'Use secure key management' },
+    // High: Code execution risks
+    { pattern: /eval\s*\(/g, rule: 'no-eval', severity: 'high', message: 'Avoid eval() - code injection risk', suggestion: 'Use safer alternatives like JSON.parse()' },
+    { pattern: /exec\s*\(/g, rule: 'no-exec', severity: 'high', message: 'Avoid exec() - command injection risk', suggestion: 'Use execFile or spawn with args array' },
+    { pattern: /Function\s*\(/g, rule: 'no-function-constructor', severity: 'high', message: 'Avoid Function constructor - code injection risk' },
+    { pattern: /child_process.*exec\(/g, rule: 'no-shell-exec', severity: 'high', message: 'Shell execution detected', suggestion: 'Use execFile or spawn instead' },
+    // High: SQL injection
+    { pattern: /SELECT\s+.*\s+FROM.*\+/gi, rule: 'sql-injection-risk', severity: 'high', message: 'Potential SQL injection - string concatenation in query', suggestion: 'Use parameterized queries' },
+    { pattern: /`SELECT.*\$\{/gi, rule: 'sql-injection-template', severity: 'high', message: 'Template literal in SQL query', suggestion: 'Use parameterized queries' },
+    // Medium: XSS risks
+    { pattern: /dangerouslySetInnerHTML/g, rule: 'xss-risk', severity: 'medium', message: 'XSS risk: dangerouslySetInnerHTML', suggestion: 'Sanitize content before rendering' },
+    { pattern: /innerHTML\s*=/g, rule: 'no-inner-html', severity: 'medium', message: 'Avoid innerHTML - XSS risk', suggestion: 'Use textContent or sanitize content' },
+    { pattern: /document\.write\s*\(/g, rule: 'no-document-write', severity: 'medium', message: 'Avoid document.write - XSS risk' },
+    // Medium: Other risks
+    { pattern: /\$\{.*\}/g, rule: 'template-injection', severity: 'low', message: 'Template literal detected - verify no injection' },
+    { pattern: /new\s+RegExp\s*\([^)]*\+/g, rule: 'regex-injection', severity: 'medium', message: 'Dynamic RegExp - potential ReDoS risk', suggestion: 'Validate/sanitize regex input' },
+    { pattern: /\.on\s*\(\s*['"]error['"]/g, rule: 'unhandled-error', severity: 'low', message: 'Error handler detected - verify proper error handling' },
+];
+/**
+ * Scan a single file for security issues
+ */
+function scanFile(filePath, content, patterns = exports.SECURITY_PATTERNS) {
+    const findings = [];
+    try {
+        const fileContent = content ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+        if (!fileContent)
+            return findings;
+        for (const { pattern, rule, severity, message, suggestion } of patterns) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(fileContent)) !== null) {
+                const lineNum = fileContent.slice(0, match.index).split('\n').length;
+                findings.push({
+                    file: filePath,
+                    line: lineNum,
+                    severity,
+                    rule,
+                    message,
+                    match: match[0].slice(0, 50),
+                    suggestion,
+                });
+            }
+        }
+    }
+    catch {
+        // Skip unreadable files
+    }
+    return findings;
+}
+/**
+ * Scan multiple files for security issues
+ */
+function scanFiles(files, patterns = exports.SECURITY_PATTERNS, maxFiles = 100) {
+    const findings = [];
+    for (const file of files.slice(0, maxFiles)) {
+        findings.push(...scanFile(file, undefined, patterns));
+    }
+    return findings;
+}
+/**
+ * Get severity score (for sorting/filtering)
+ */
+function getSeverityScore(severity) {
+    switch (severity) {
+        case 'critical': return 4;
+        case 'high': return 3;
+        case 'medium': return 2;
+        case 'low': return 1;
+        default: return 0;
+    }
+}
+/**
+ * Sort findings by severity (highest first)
+ */
+function sortBySeverity(findings) {
+    return [...findings].sort((a, b) => getSeverityScore(b.severity) - getSeverityScore(a.severity));
+}
+exports.default = {
+    SECURITY_PATTERNS: exports.SECURITY_PATTERNS,
+    scanFile,
+    scanFiles,
+    getSeverityScore,
+    sortBySeverity,
+};

dist/core/adaptive-embedder.d.ts

@@ -0,0 +1,156 @@
+/**
+ * AdaptiveEmbedder - Micro-LoRA Style Optimization for ONNX Embeddings
+ *
+ * Applies continual learning techniques to frozen ONNX embeddings:
+ *
+ * 1. MICRO-LORA ADAPTERS
+ *    - Low-rank projection layers (rank 2-8) on top of frozen embeddings
+ *    - Domain-specific fine-tuning with minimal parameters
+ *    - ~0.1% of base model parameters
+ *
+ * 2. CONTRASTIVE LEARNING
+ *    - Files edited together → embeddings closer
+ *    - Semantic clustering from trajectories
+ *    - Online learning from user behavior
+ *
+ * 3. EWC++ (Elastic Weight Consolidation)
+ *    - Prevents catastrophic forgetting
+ *    - Consolidates important adaptations
+ *    - Fisher information regularization
+ *
+ * 4. MEMORY-AUGMENTED RETRIEVAL
+ *    - Episodic memory for context-aware embeddings
+ *    - Attention over past similar embeddings
+ *    - Domain prototype learning
+ *
+ * Architecture:
+ *   ONNX(text) → [frozen 384d] → LoRA_A → LoRA_B → [adapted 384d]
+ *                                 (384×r)   (r×384)
+ */
+export interface AdaptiveConfig {
+    /** LoRA rank (lower = fewer params, higher = more expressive) */
+    loraRank?: number;
+    /** Learning rate for online updates */
+    learningRate?: number;
+    /** EWC regularization strength */
+    ewcLambda?: number;
+    /** Number of domain prototypes to maintain */
+    numPrototypes?: number;
+    /** Enable contrastive learning from co-edits */
+    contrastiveLearning?: boolean;
+    /** Temperature for contrastive loss */
+    contrastiveTemp?: number;
+    /** Memory capacity for episodic retrieval */
+    memoryCapacity?: number;
+}
+export interface LoRAWeights {
+    A: number[][];
+    B: number[][];
+    bias?: number[];
+}
+export interface DomainPrototype {
+    domain: string;
+    centroid: number[];
+    count: number;
+    variance: number;
+}
+export interface AdaptiveStats {
+    baseModel: string;
+    dimension: number;
+    loraRank: number;
+    loraParams: number;
+    adaptations: number;
+    prototypes: number;
+    memorySize: number;
+    ewcConsolidations: number;
+    contrastiveUpdates: number;
+}
+export declare class AdaptiveEmbedder {
+    private config;
+    private lora;
+    private prototypes;
+    private episodic;
+    private onnxReady;
+    private dimension;
+    private adaptationCount;
+    private ewcCount;
+    private contrastiveCount;
+    private coEditBuffer;
+    constructor(config?: AdaptiveConfig);
+    /**
+     * Initialize ONNX backend
+     */
+    init(): Promise<void>;
+    /**
+     * Generate adaptive embedding
+     * Pipeline: ONNX → LoRA → Prototype Adjustment → Episodic Augmentation
+     */
+    embed(text: string, options?: {
+        domain?: string;
+        useEpisodic?: boolean;
+        storeInMemory?: boolean;
+    }): Promise<number[]>;
+    /**
+     * Batch embed with adaptation
+     */
+    embedBatch(texts: string[], options?: {
+        domain?: string;
+    }): Promise<number[][]>;
+    /**
+     * Learn from co-edit pattern (contrastive learning)
+     * Files edited together should have similar embeddings
+     */
+    learnCoEdit(file1: string, content1: string, file2: string, content2: string): Promise<number>;
+    /**
+     * Process co-edit batch with contrastive loss
+     */
+    private processCoEditBatch;
+    /**
+     * Learn from trajectory outcome (reinforcement-like)
+     */
+    learnFromOutcome(context: string, action: string, success: boolean, quality?: number): Promise<void>;
+    /**
+     * EWC consolidation - prevent forgetting important adaptations
+     * OPTIMIZED: Works with Float32Array episodic entries
+     */
+    consolidate(): Promise<void>;
+    /**
+     * Fallback hash embedding
+     */
+    private hashEmbed;
+    private normalize;
+    /**
+     * Get statistics
+     */
+    getStats(): AdaptiveStats;
+    /**
+     * Export learned weights
+     */
+    export(): {
+        lora: LoRAWeights;
+        prototypes: DomainPrototype[];
+        stats: AdaptiveStats;
+    };
+    /**
+     * Import learned weights
+     */
+    import(data: {
+        lora?: LoRAWeights;
+        prototypes?: DomainPrototype[];
+    }): void;
+    /**
+     * Reset adaptations
+     */
+    reset(): void;
+    /**
+     * Get LoRA cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+    };
+}
+export declare function getAdaptiveEmbedder(config?: AdaptiveConfig): AdaptiveEmbedder;
+export declare function initAdaptiveEmbedder(config?: AdaptiveConfig): Promise<AdaptiveEmbedder>;
+export default AdaptiveEmbedder;
+//# sourceMappingURL=adaptive-embedder.d.ts.map

dist/core/adaptive-embedder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-embedder.d.ts","sourceRoot":"","sources":["../../src/core/adaptive-embedder.ts"],"names":[],"mappings":"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"}

dist/core/adaptive-embedder.js

@@ -0,0 +1,837 @@
+"use strict";
+/**
+ * AdaptiveEmbedder - Micro-LoRA Style Optimization for ONNX Embeddings
+ *
+ * Applies continual learning techniques to frozen ONNX embeddings:
+ *
+ * 1. MICRO-LORA ADAPTERS
+ *    - Low-rank projection layers (rank 2-8) on top of frozen embeddings
+ *    - Domain-specific fine-tuning with minimal parameters
+ *    - ~0.1% of base model parameters
+ *
+ * 2. CONTRASTIVE LEARNING
+ *    - Files edited together → embeddings closer
+ *    - Semantic clustering from trajectories
+ *    - Online learning from user behavior
+ *
+ * 3. EWC++ (Elastic Weight Consolidation)
+ *    - Prevents catastrophic forgetting
+ *    - Consolidates important adaptations
+ *    - Fisher information regularization
+ *
+ * 4. MEMORY-AUGMENTED RETRIEVAL
+ *    - Episodic memory for context-aware embeddings
+ *    - Attention over past similar embeddings
+ *    - Domain prototype learning
+ *
+ * Architecture:
+ *   ONNX(text) → [frozen 384d] → LoRA_A → LoRA_B → [adapted 384d]
+ *                                 (384×r)   (r×384)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptiveEmbedder = void 0;
+exports.getAdaptiveEmbedder = getAdaptiveEmbedder;
+exports.initAdaptiveEmbedder = initAdaptiveEmbedder;
+const onnx_embedder_1 = require("./onnx-embedder");
+// ============================================================================
+// Optimized Micro-LoRA Layer with Float32Array and Caching
+// ============================================================================
+/**
+ * Low-rank adaptation layer for embeddings (OPTIMIZED)
+ * Implements: output = input + scale * (input @ A @ B)
+ *
+ * Optimizations:
+ * - Float32Array for 2-3x faster math operations
+ * - Flattened matrices for cache-friendly access
+ * - Pre-allocated buffers to avoid GC pressure
+ * - LRU embedding cache for repeated inputs
+ */
+class MicroLoRA {
+    constructor(dim, rank, scale = 0.1) {
+        // EWC Fisher information (importance weights)
+        this.fisherA = null;
+        this.fisherB = null;
+        this.savedA = null;
+        this.savedB = null;
+        // LRU cache for repeated embeddings (key: hash, value: output)
+        this.cache = new Map();
+        this.cacheMaxSize = 256;
+        this.dim = dim;
+        this.rank = rank;
+        this.scale = scale;
+        // Initialize with small random values (Xavier-like)
+        const stdA = Math.sqrt(2 / (dim + rank));
+        const stdB = Math.sqrt(2 / (rank + dim)) * 0.01; // B starts near zero
+        this.A = this.initFlatMatrix(dim, rank, stdA);
+        this.B = this.initFlatMatrix(rank, dim, stdB);
+        // Pre-allocate buffers
+        this.hiddenBuffer = new Float32Array(rank);
+        this.outputBuffer = new Float32Array(dim);
+    }
+    initFlatMatrix(rows, cols, std) {
+        const arr = new Float32Array(rows * cols);
+        for (let i = 0; i < arr.length; i++) {
+            arr[i] = (Math.random() - 0.5) * 2 * std;
+        }
+        return arr;
+    }
+    /**
+     * Fast hash for cache key (FNV-1a variant)
+     */
+    hashInput(input) {
+        let h = 2166136261;
+        const len = Math.min(input.length, 32); // Sample first 32 for speed
+        for (let i = 0; i < len; i++) {
+            h ^= Math.floor(input[i] * 10000);
+            h = Math.imul(h, 16777619);
+        }
+        return h.toString(36);
+    }
+    /**
+     * Forward pass: input + scale * (input @ A @ B)
+     * OPTIMIZED with Float32Array and loop unrolling
+     */
+    forward(input) {
+        // Check cache first
+        const cacheKey = this.hashInput(input);
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+            return Array.from(cached);
+        }
+        // Zero the hidden buffer
+        this.hiddenBuffer.fill(0);
+        // Compute input @ A (dim → rank) - SIMD-friendly loop
+        // Unroll by 4 for better pipelining
+        const dim4 = this.dim - (this.dim % 4);
+        for (let r = 0; r < this.rank; r++) {
+            let sum = 0;
+            const rOffset = r;
+            // Unrolled loop
+            for (let d = 0; d < dim4; d += 4) {
+                const aIdx = d * this.rank + rOffset;
+                sum += input[d] * this.A[aIdx];
+                sum += input[d + 1] * this.A[aIdx + this.rank];
+                sum += input[d + 2] * this.A[aIdx + 2 * this.rank];
+                sum += input[d + 3] * this.A[aIdx + 3 * this.rank];
+            }
+            // Remainder
+            for (let d = dim4; d < this.dim; d++) {
+                sum += input[d] * this.A[d * this.rank + rOffset];
+            }
+            this.hiddenBuffer[r] = sum;
+        }
+        // Compute hidden @ B (rank → dim) and add residual
+        // Copy input to output buffer first
+        for (let d = 0; d < this.dim; d++) {
+            this.outputBuffer[d] = input[d];
+        }
+        // Add scaled LoRA contribution
+        for (let d = 0; d < this.dim; d++) {
+            let delta = 0;
+            for (let r = 0; r < this.rank; r++) {
+                delta += this.hiddenBuffer[r] * this.B[r * this.dim + d];
+            }
+            this.outputBuffer[d] += this.scale * delta;
+        }
+        // Cache result (LRU eviction if full)
+        if (this.cache.size >= this.cacheMaxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(cacheKey, new Float32Array(this.outputBuffer));
+        return Array.from(this.outputBuffer);
+    }
+    /**
+     * Clear cache (call after weight updates)
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Backward pass with contrastive loss
+     * Pulls positive pairs closer, pushes negatives apart
+     * OPTIMIZED: Uses Float32Array buffers
+     */
+    backward(anchor, positive, negatives, lr, ewcLambda = 0) {
+        if (!positive && negatives.length === 0)
+            return 0;
+        // Clear cache since weights will change
+        this.clearCache();
+        // Compute adapted embeddings
+        const anchorOut = this.forward(anchor);
+        const positiveOut = positive ? this.forward(positive) : null;
+        const negativeOuts = negatives.map(n => this.forward(n));
+        // Contrastive loss with temperature scaling
+        const temp = 0.07;
+        let loss = 0;
+        if (positiveOut) {
+            // Positive similarity
+            const posSim = this.cosineSimilarity(anchorOut, positiveOut) / temp;
+            // Negative similarities
+            const negSims = negativeOuts.map(n => this.cosineSimilarity(anchorOut, n) / temp);
+            // InfoNCE loss
+            const maxSim = Math.max(posSim, ...negSims);
+            const expPos = Math.exp(posSim - maxSim);
+            const expNegs = negSims.reduce((sum, s) => sum + Math.exp(s - maxSim), 0);
+            loss = -Math.log(expPos / (expPos + expNegs) + 1e-8);
+            // Compute gradients (simplified)
+            const gradScale = lr * this.scale;
+            // Update A based on gradient direction (flattened access)
+            for (let d = 0; d < this.dim; d++) {
+                for (let r = 0; r < this.rank; r++) {
+                    const idx = d * this.rank + r;
+                    // Gradient from positive (pull closer)
+                    const pOutR = r < positiveOut.length ? positiveOut[r] : 0;
+                    const aOutR = r < anchorOut.length ? anchorOut[r] : 0;
+                    const gradA = anchor[d] * (pOutR - aOutR) * gradScale;
+                    this.A[idx] += gradA;
+                    // EWC regularization
+                    if (ewcLambda > 0 && this.fisherA && this.savedA) {
+                        this.A[idx] -= ewcLambda * this.fisherA[idx] * (this.A[idx] - this.savedA[idx]);
+                    }
+                }
+            }
+            // Update B (flattened access)
+            for (let r = 0; r < this.rank; r++) {
+                const anchorR = r < anchor.length ? anchor[r] : 0;
+                for (let d = 0; d < this.dim; d++) {
+                    const idx = r * this.dim + d;
+                    const gradB = anchorR * (positiveOut[d] - anchorOut[d]) * gradScale * 0.1;
+                    this.B[idx] += gradB;
+                    if (ewcLambda > 0 && this.fisherB && this.savedB) {
+                        this.B[idx] -= ewcLambda * this.fisherB[idx] * (this.B[idx] - this.savedB[idx]);
+                    }
+                }
+            }
+        }
+        return loss;
+    }
+    /**
+     * EWC consolidation - save current weights and compute Fisher information
+     * OPTIMIZED: Uses Float32Array
+     */
+    consolidate(embeddings) {
+        // Save current weights
+        this.savedA = new Float32Array(this.A);
+        this.savedB = new Float32Array(this.B);
+        // Estimate Fisher information (diagonal approximation)
+        this.fisherA = new Float32Array(this.dim * this.rank);
+        this.fisherB = new Float32Array(this.rank * this.dim);
+        const numEmb = embeddings.length;
+        for (const emb of embeddings) {
+            // Accumulate squared gradients as Fisher estimate
+            for (let d = 0; d < this.dim; d++) {
+                const embD = emb[d] * emb[d] / numEmb;
+                for (let r = 0; r < this.rank; r++) {
+                    this.fisherA[d * this.rank + r] += embD;
+                }
+            }
+        }
+        // Clear cache after consolidation
+        this.clearCache();
+    }
+    /**
+     * Optimized cosine similarity with early termination
+     */
+    cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        const len = Math.min(a.length, b.length);
+        // Unrolled loop for speed
+        const len4 = len - (len % 4);
+        for (let i = 0; i < len4; i += 4) {
+            dot += a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2] * b[i + 2] + a[i + 3] * b[i + 3];
+            normA += a[i] * a[i] + a[i + 1] * a[i + 1] + a[i + 2] * a[i + 2] + a[i + 3] * a[i + 3];
+            normB += b[i] * b[i] + b[i + 1] * b[i + 1] + b[i + 2] * b[i + 2] + b[i + 3] * b[i + 3];
+        }
+        // Remainder
+        for (let i = len4; i < len; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA * normB) + 1e-8);
+    }
+    getParams() {
+        return this.dim * this.rank + this.rank * this.dim;
+    }
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.cacheMaxSize,
+            hitRate: 0, // Would need hit counter for accurate tracking
+        };
+    }
+    /**
+     * Export weights as 2D arrays for serialization
+     */
+    export() {
+        // Convert flattened Float32Array back to 2D number[][]
+        const A = [];
+        for (let d = 0; d < this.dim; d++) {
+            const row = [];
+            for (let r = 0; r < this.rank; r++) {
+                row.push(this.A[d * this.rank + r]);
+            }
+            A.push(row);
+        }
+        const B = [];
+        for (let r = 0; r < this.rank; r++) {
+            const row = [];
+            for (let d = 0; d < this.dim; d++) {
+                row.push(this.B[r * this.dim + d]);
+            }
+            B.push(row);
+        }
+        return { A, B };
+    }
+    /**
+     * Import weights from 2D arrays
+     */
+    import(weights) {
+        // Convert 2D number[][] to flattened Float32Array
+        for (let d = 0; d < this.dim && d < weights.A.length; d++) {
+            for (let r = 0; r < this.rank && r < weights.A[d].length; r++) {
+                this.A[d * this.rank + r] = weights.A[d][r];
+            }
+        }
+        for (let r = 0; r < this.rank && r < weights.B.length; r++) {
+            for (let d = 0; d < this.dim && d < weights.B[r].length; d++) {
+                this.B[r * this.dim + d] = weights.B[r][d];
+            }
+        }
+        // Clear cache after import
+        this.clearCache();
+    }
+}
+// ============================================================================
+// Domain Prototype Learning (OPTIMIZED with Float32Array)
+// ============================================================================
+class PrototypeMemory {
+    constructor(maxPrototypes = 50, dimension = 384) {
+        this.prototypes = new Map();
+        this.maxPrototypes = maxPrototypes;
+        this.scratchBuffer = new Float32Array(dimension);
+    }
+    /**
+     * Update prototype with new embedding (online mean update)
+     * OPTIMIZED: Uses Float32Array internally
+     */
+    update(domain, embedding) {
+        const existing = this.prototypes.get(domain);
+        if (existing) {
+            // Online mean update: new_mean = old_mean + (x - old_mean) / n
+            const n = existing.count + 1;
+            const invN = 1 / n;
+            // Unrolled update loop
+            const len = Math.min(embedding.length, existing.centroid.length);
+            const len4 = len - (len % 4);
+            for (let i = 0; i < len4; i += 4) {
+                const d0 = embedding[i] - existing.centroid[i];
+                const d1 = embedding[i + 1] - existing.centroid[i + 1];
+                const d2 = embedding[i + 2] - existing.centroid[i + 2];
+                const d3 = embedding[i + 3] - existing.centroid[i + 3];
+                existing.centroid[i] += d0 * invN;
+                existing.centroid[i + 1] += d1 * invN;
+                existing.centroid[i + 2] += d2 * invN;
+                existing.centroid[i + 3] += d3 * invN;
+                existing.variance += d0 * (embedding[i] - existing.centroid[i]);
+                existing.variance += d1 * (embedding[i + 1] - existing.centroid[i + 1]);
+                existing.variance += d2 * (embedding[i + 2] - existing.centroid[i + 2]);
+                existing.variance += d3 * (embedding[i + 3] - existing.centroid[i + 3]);
+            }
+            for (let i = len4; i < len; i++) {
+                const delta = embedding[i] - existing.centroid[i];
+                existing.centroid[i] += delta * invN;
+                existing.variance += delta * (embedding[i] - existing.centroid[i]);
+            }
+            existing.count = n;
+        }
+        else {
+            // Create new prototype
+            if (this.prototypes.size >= this.maxPrototypes) {
+                // Remove least used prototype
+                let minCount = Infinity;
+                let minKey = '';
+                for (const [key, proto] of this.prototypes) {
+                    if (proto.count < minCount) {
+                        minCount = proto.count;
+                        minKey = key;
+                    }
+                }
+                this.prototypes.delete(minKey);
+            }
+            this.prototypes.set(domain, {
+                domain,
+                centroid: Array.from(embedding),
+                count: 1,
+                variance: 0,
+            });
+        }
+    }
+    /**
+     * Find closest prototype and return domain-adjusted embedding
+     * OPTIMIZED: Single-pass similarity with early exit
+     */
+    adjust(embedding) {
+        if (this.prototypes.size === 0) {
+            return { adjusted: Array.from(embedding), domain: null, confidence: 0 };
+        }
+        let bestSim = -Infinity;
+        let bestProto = null;
+        for (const proto of this.prototypes.values()) {
+            const sim = this.cosineSimilarityFast(embedding, proto.centroid);
+            if (sim > bestSim) {
+                bestSim = sim;
+                bestProto = proto;
+            }
+        }
+        if (!bestProto || bestSim < 0.5) {
+            return { adjusted: Array.from(embedding), domain: null, confidence: 0 };
+        }
+        // Adjust embedding toward prototype (soft assignment)
+        const alpha = 0.1 * bestSim;
+        const oneMinusAlpha = 1 - alpha;
+        const adjusted = new Array(embedding.length);
+        // Unrolled adjustment
+        const len = embedding.length;
+        const len4 = len - (len % 4);
+        for (let i = 0; i < len4; i += 4) {
+            adjusted[i] = embedding[i] * oneMinusAlpha + bestProto.centroid[i] * alpha;
+            adjusted[i + 1] = embedding[i + 1] * oneMinusAlpha + bestProto.centroid[i + 1] * alpha;
+            adjusted[i + 2] = embedding[i + 2] * oneMinusAlpha + bestProto.centroid[i + 2] * alpha;
+            adjusted[i + 3] = embedding[i + 3] * oneMinusAlpha + bestProto.centroid[i + 3] * alpha;
+        }
+        for (let i = len4; i < len; i++) {
+            adjusted[i] = embedding[i] * oneMinusAlpha + bestProto.centroid[i] * alpha;
+        }
+        return {
+            adjusted,
+            domain: bestProto.domain,
+            confidence: bestSim,
+        };
+    }
+    /**
+     * Fast cosine similarity with loop unrolling
+     */
+    cosineSimilarityFast(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        const len = Math.min(a.length, b.length);
+        const len4 = len - (len % 4);
+        for (let i = 0; i < len4; i += 4) {
+            dot += a[i] * b[i] + a[i + 1] * b[i + 1] + a[i + 2] * b[i + 2] + a[i + 3] * b[i + 3];
+            normA += a[i] * a[i] + a[i + 1] * a[i + 1] + a[i + 2] * a[i + 2] + a[i + 3] * a[i + 3];
+            normB += b[i] * b[i] + b[i + 1] * b[i + 1] + b[i + 2] * b[i + 2] + b[i + 3] * b[i + 3];
+        }
+        for (let i = len4; i < len; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA * normB) + 1e-8);
+    }
+    getPrototypes() {
+        return Array.from(this.prototypes.values());
+    }
+    export() {
+        return this.getPrototypes();
+    }
+    import(prototypes) {
+        this.prototypes.clear();
+        for (const p of prototypes) {
+            this.prototypes.set(p.domain, p);
+        }
+    }
+}
+class EpisodicMemory {
+    constructor(capacity = 1000, dimension = 384) {
+        this.entries = [];
+        this.capacity = capacity;
+        this.dimension = dimension;
+        this.augmentBuffer = new Float32Array(dimension);
+        this.weightsBuffer = new Float32Array(Math.min(capacity, 16)); // Max k
+    }
+    add(embedding, context) {
+        if (this.entries.length >= this.capacity) {
+            // Find and remove least used entry (O(n) but infrequent)
+            let minIdx = 0;
+            let minCount = this.entries[0].useCount;
+            for (let i = 1; i < this.entries.length; i++) {
+                if (this.entries[i].useCount < minCount) {
+                    minCount = this.entries[i].useCount;
+                    minIdx = i;
+                }
+            }
+            this.entries.splice(minIdx, 1);
+        }
+        // Convert to Float32Array and pre-compute norm
+        const emb = embedding instanceof Float32Array
+            ? new Float32Array(embedding)
+            : new Float32Array(embedding);
+        let normSq = 0;
+        for (let i = 0; i < emb.length; i++) {
+            normSq += emb[i] * emb[i];
+        }
+        this.entries.push({
+            embedding: emb,
+            context,
+            timestamp: Date.now(),
+            useCount: 0,
+            normSquared: normSq,
+        });
+    }
+    /**
+     * Retrieve similar past embeddings for context augmentation
+     * OPTIMIZED: Uses pre-computed norms for fast similarity
+     */
+    retrieve(query, k = 5) {
+        if (this.entries.length === 0)
+            return [];
+        // Pre-compute query norm
+        let queryNormSq = 0;
+        for (let i = 0; i < query.length; i++) {
+            queryNormSq += query[i] * query[i];
+        }
+        const queryNorm = Math.sqrt(queryNormSq);
+        // Score all entries
+        const scored = [];
+        for (const entry of this.entries) {
+            // Fast dot product with loop unrolling
+            let dot = 0;
+            const len = Math.min(query.length, entry.embedding.length);
+            const len4 = len - (len % 4);
+            for (let i = 0; i < len4; i += 4) {
+                dot += query[i] * entry.embedding[i];
+                dot += query[i + 1] * entry.embedding[i + 1];
+                dot += query[i + 2] * entry.embedding[i + 2];
+                dot += query[i + 3] * entry.embedding[i + 3];
+            }
+            for (let i = len4; i < len; i++) {
+                dot += query[i] * entry.embedding[i];
+            }
+            const similarity = dot / (queryNorm * Math.sqrt(entry.normSquared) + 1e-8);
+            scored.push({ entry, similarity });
+        }
+        // Partial sort for top-k (faster than full sort for large arrays)
+        if (scored.length <= k) {
+            scored.sort((a, b) => b.similarity - a.similarity);
+            for (const s of scored)
+                s.entry.useCount++;
+            return scored.map(s => s.entry);
+        }
+        // Quick select for top-k
+        scored.sort((a, b) => b.similarity - a.similarity);
+        const topK = scored.slice(0, k);
+        for (const s of topK)
+            s.entry.useCount++;
+        return topK.map(s => s.entry);
+    }
+    /**
+     * Augment embedding with episodic memory (attention-like)
+     * OPTIMIZED: Uses pre-allocated buffers
+     */
+    augment(embedding, k = 3) {
+        const similar = this.retrieve(embedding, k);
+        if (similar.length === 0)
+            return Array.from(embedding);
+        // Pre-compute query norm
+        let queryNormSq = 0;
+        for (let i = 0; i < embedding.length; i++) {
+            queryNormSq += embedding[i] * embedding[i];
+        }
+        const queryNorm = Math.sqrt(queryNormSq);
+        // Compute weights
+        let sumWeights = 1; // Start with 1 for query
+        for (let j = 0; j < similar.length; j++) {
+            // Fast dot product for similarity
+            let dot = 0;
+            const emb = similar[j].embedding;
+            const len = Math.min(embedding.length, emb.length);
+            for (let i = 0; i < len; i++) {
+                dot += embedding[i] * emb[i];
+            }
+            const sim = dot / (queryNorm * Math.sqrt(similar[j].normSquared) + 1e-8);
+            const weight = Math.exp(sim / 0.1);
+            this.weightsBuffer[j] = weight;
+            sumWeights += weight;
+        }
+        const invSumWeights = 1 / sumWeights;
+        // Weighted average
+        const dim = embedding.length;
+        for (let i = 0; i < dim; i++) {
+            let sum = embedding[i]; // Query contribution
+            for (let j = 0; j < similar.length; j++) {
+                sum += this.weightsBuffer[j] * similar[j].embedding[i];
+            }
+            this.augmentBuffer[i] = sum * invSumWeights;
+        }
+        return Array.from(this.augmentBuffer.subarray(0, dim));
+    }
+    size() {
+        return this.entries.length;
+    }
+    clear() {
+        this.entries = [];
+    }
+}
+// ============================================================================
+// Adaptive Embedder (Main Class)
+// ============================================================================
+class AdaptiveEmbedder {
+    constructor(config = {}) {
+        this.onnxReady = false;
+        this.dimension = 384;
+        // Stats
+        this.adaptationCount = 0;
+        this.ewcCount = 0;
+        this.contrastiveCount = 0;
+        // Co-edit buffer for contrastive learning
+        this.coEditBuffer = [];
+        this.config = {
+            loraRank: config.loraRank ?? 4,
+            learningRate: config.learningRate ?? 0.01,
+            ewcLambda: config.ewcLambda ?? 0.1,
+            numPrototypes: config.numPrototypes ?? 50,
+            contrastiveLearning: config.contrastiveLearning ?? true,
+            contrastiveTemp: config.contrastiveTemp ?? 0.07,
+            memoryCapacity: config.memoryCapacity ?? 1000,
+        };
+        // Pass dimension for pre-allocation of Float32Array buffers
+        this.lora = new MicroLoRA(this.dimension, this.config.loraRank);
+        this.prototypes = new PrototypeMemory(this.config.numPrototypes, this.dimension);
+        this.episodic = new EpisodicMemory(this.config.memoryCapacity, this.dimension);
+    }
+    /**
+     * Initialize ONNX backend
+     */
+    async init() {
+        if ((0, onnx_embedder_1.isOnnxAvailable)()) {
+            await (0, onnx_embedder_1.initOnnxEmbedder)();
+            this.onnxReady = true;
+        }
+    }
+    /**
+     * Generate adaptive embedding
+     * Pipeline: ONNX → LoRA → Prototype Adjustment → Episodic Augmentation
+     */
+    async embed(text, options) {
+        // Step 1: Get base ONNX embedding
+        let baseEmb;
+        if (this.onnxReady) {
+            const result = await (0, onnx_embedder_1.embed)(text);
+            baseEmb = result.embedding;
+        }
+        else {
+            // Fallback to hash embedding
+            baseEmb = this.hashEmbed(text);
+        }
+        // Step 2: Apply LoRA adaptation
+        let adapted = this.lora.forward(baseEmb);
+        // Step 3: Prototype adjustment (if domain specified)
+        if (options?.domain) {
+            this.prototypes.update(options.domain, adapted);
+        }
+        const { adjusted, domain } = this.prototypes.adjust(adapted);
+        adapted = adjusted;
+        // Step 4: Episodic memory augmentation
+        if (options?.useEpisodic !== false) {
+            adapted = this.episodic.augment(adapted);
+        }
+        // Step 5: Store in episodic memory
+        if (options?.storeInMemory !== false) {
+            this.episodic.add(adapted, text.slice(0, 100));
+        }
+        // Normalize
+        return this.normalize(adapted);
+    }
+    /**
+     * Batch embed with adaptation
+     */
+    async embedBatch(texts, options) {
+        const results = [];
+        if (this.onnxReady) {
+            const baseResults = await (0, onnx_embedder_1.embedBatch)(texts);
+            for (let i = 0; i < baseResults.length; i++) {
+                let adapted = this.lora.forward(baseResults[i].embedding);
+                if (options?.domain) {
+                    this.prototypes.update(options.domain, adapted);
+                }
+                const { adjusted } = this.prototypes.adjust(adapted);
+                results.push(this.normalize(adjusted));
+            }
+        }
+        else {
+            for (const text of texts) {
+                results.push(await this.embed(text, options));
+            }
+        }
+        return results;
+    }
+    /**
+     * Learn from co-edit pattern (contrastive learning)
+     * Files edited together should have similar embeddings
+     */
+    async learnCoEdit(file1, content1, file2, content2) {
+        if (!this.config.contrastiveLearning)
+            return 0;
+        // Get embeddings
+        const emb1 = await this.embed(content1.slice(0, 512), { storeInMemory: false });
+        const emb2 = await this.embed(content2.slice(0, 512), { storeInMemory: false });
+        // Store in buffer for batch learning
+        this.coEditBuffer.push({ file1, emb1, file2, emb2 });
+        // Process batch when buffer is full
+        if (this.coEditBuffer.length >= 16) {
+            return this.processCoEditBatch();
+        }
+        return 0;
+    }
+    /**
+     * Process co-edit batch with contrastive loss
+     */
+    processCoEditBatch() {
+        if (this.coEditBuffer.length < 2)
+            return 0;
+        let totalLoss = 0;
+        for (const { emb1, emb2 } of this.coEditBuffer) {
+            // Use other pairs as negatives
+            const negatives = this.coEditBuffer
+                .filter(p => p.emb1 !== emb1)
+                .slice(0, 4)
+                .map(p => p.emb1);
+            // Backward pass with contrastive loss
+            const loss = this.lora.backward(emb1, emb2, negatives, this.config.learningRate, this.config.ewcLambda);
+            totalLoss += loss;
+            this.contrastiveCount++;
+        }
+        this.coEditBuffer = [];
+        this.adaptationCount++;
+        return totalLoss / this.coEditBuffer.length;
+    }
+    /**
+     * Learn from trajectory outcome (reinforcement-like)
+     */
+    async learnFromOutcome(context, action, success, quality = 0.5) {
+        const contextEmb = await this.embed(context, { storeInMemory: false });
+        const actionEmb = await this.embed(action, { storeInMemory: false });
+        if (success && quality > 0.7) {
+            // Positive outcome - pull embeddings closer
+            this.lora.backward(contextEmb, actionEmb, [], this.config.learningRate * quality, this.config.ewcLambda);
+            this.adaptationCount++;
+        }
+    }
+    /**
+     * EWC consolidation - prevent forgetting important adaptations
+     * OPTIMIZED: Works with Float32Array episodic entries
+     */
+    async consolidate() {
+        // Collect current episodic memories for Fisher estimation
+        const embeddings = [];
+        const entries = this.episodic.entries || [];
+        // Get last 100 entries for Fisher estimation
+        const recentEntries = entries.slice(-100);
+        for (const entry of recentEntries) {
+            if (entry.embedding instanceof Float32Array) {
+                embeddings.push(entry.embedding);
+            }
+        }
+        if (embeddings.length > 10) {
+            this.lora.consolidate(embeddings);
+            this.ewcCount++;
+        }
+    }
+    /**
+     * Fallback hash embedding
+     */
+    hashEmbed(text) {
+        const embedding = new Array(this.dimension).fill(0);
+        const tokens = text.toLowerCase().split(/\s+/);
+        for (let t = 0; t < tokens.length; t++) {
+            const token = tokens[t];
+            const posWeight = 1 / (1 + t * 0.1);
+            for (let i = 0; i < token.length; i++) {
+                const code = token.charCodeAt(i);
+                const h1 = (code * 31 + i * 17 + t * 7) % this.dimension;
+                const h2 = (code * 37 + i * 23 + t * 11) % this.dimension;
+                embedding[h1] += posWeight;
+                embedding[h2] += posWeight * 0.5;
+            }
+        }
+        return this.normalize(embedding);
+    }
+    normalize(v) {
+        const norm = Math.sqrt(v.reduce((a, b) => a + b * b, 0));
+        return norm > 0 ? v.map(x => x / norm) : v;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            baseModel: 'all-MiniLM-L6-v2',
+            dimension: this.dimension,
+            loraRank: this.config.loraRank,
+            loraParams: this.lora.getParams(),
+            adaptations: this.adaptationCount,
+            prototypes: this.prototypes.getPrototypes().length,
+            memorySize: this.episodic.size(),
+            ewcConsolidations: this.ewcCount,
+            contrastiveUpdates: this.contrastiveCount,
+        };
+    }
+    /**
+     * Export learned weights
+     */
+    export() {
+        return {
+            lora: this.lora.export(),
+            prototypes: this.prototypes.export(),
+            stats: this.getStats(),
+        };
+    }
+    /**
+     * Import learned weights
+     */
+    import(data) {
+        if (data.lora) {
+            this.lora.import(data.lora);
+        }
+        if (data.prototypes) {
+            this.prototypes.import(data.prototypes);
+        }
+    }
+    /**
+     * Reset adaptations
+     */
+    reset() {
+        this.lora = new MicroLoRA(this.dimension, this.config.loraRank);
+        this.prototypes = new PrototypeMemory(this.config.numPrototypes, this.dimension);
+        this.episodic.clear();
+        this.adaptationCount = 0;
+        this.ewcCount = 0;
+        this.contrastiveCount = 0;
+        this.coEditBuffer = [];
+    }
+    /**
+     * Get LoRA cache statistics
+     */
+    getCacheStats() {
+        return this.lora.getCacheStats?.() ?? { size: 0, maxSize: 256 };
+    }
+}
+exports.AdaptiveEmbedder = AdaptiveEmbedder;
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+let instance = null;
+function getAdaptiveEmbedder(config) {
+    if (!instance) {
+        instance = new AdaptiveEmbedder(config);
+    }
+    return instance;
+}
+async function initAdaptiveEmbedder(config) {
+    const embedder = getAdaptiveEmbedder(config);
+    await embedder.init();
+    return embedder;
+}
+exports.default = AdaptiveEmbedder;

dist/core/agentdb-fast.d.ts

@@ -0,0 +1,149 @@
+/**
+ * AgentDB Fast - High-performance in-process alternative to AgentDB CLI
+ *
+ * The AgentDB CLI has ~2.3s startup overhead due to npx initialization.
+ * This module provides 50-200x faster operations by using in-process calls.
+ *
+ * Features:
+ * - In-memory episode storage with LRU eviction
+ * - Vector similarity search using @ruvector/core
+ * - Compatible API with AgentDB's episode/trajectory interfaces
+ */
+/**
+ * Episode entry for trajectory storage
+ */
+export interface Episode {
+    id: string;
+    state: number[];
+    action: string | number;
+    reward: number;
+    nextState: number[];
+    done: boolean;
+    metadata?: Record<string, any>;
+    timestamp?: number;
+}
+/**
+ * Trajectory (sequence of episodes)
+ */
+export interface Trajectory {
+    id: string;
+    episodes: Episode[];
+    totalReward: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Search result for episode queries
+ */
+export interface EpisodeSearchResult {
+    episode: Episode;
+    similarity: number;
+    trajectoryId?: string;
+}
+/**
+ * Fast in-memory AgentDB implementation
+ */
+export declare class FastAgentDB {
+    private episodes;
+    private trajectories;
+    private vectorDb;
+    private dimensions;
+    private maxEpisodes;
+    private episodeOrder;
+    /**
+     * Create a new FastAgentDB instance
+     *
+     * @param dimensions - Vector dimensions for state embeddings
+     * @param maxEpisodes - Maximum episodes to store (LRU eviction)
+     */
+    constructor(dimensions?: number, maxEpisodes?: number);
+    /**
+     * Initialize the vector database
+     */
+    private initVectorDb;
+    /**
+     * Store an episode
+     *
+     * @param episode - Episode to store
+     * @returns Episode ID
+     */
+    storeEpisode(episode: Omit<Episode, 'id'> & {
+        id?: string;
+    }): Promise<string>;
+    /**
+     * Store multiple episodes in batch
+     */
+    storeEpisodes(episodes: (Omit<Episode, 'id'> & {
+        id?: string;
+    })[]): Promise<string[]>;
+    /**
+     * Retrieve an episode by ID
+     */
+    getEpisode(id: string): Promise<Episode | null>;
+    /**
+     * Search for similar episodes by state
+     *
+     * @param queryState - State vector to search for
+     * @param k - Number of results to return
+     * @returns Similar episodes sorted by similarity
+     */
+    searchByState(queryState: number[] | Float32Array, k?: number): Promise<EpisodeSearchResult[]>;
+    /**
+     * Fallback similarity search using brute-force cosine similarity
+     */
+    private fallbackSearch;
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Store a trajectory (sequence of episodes)
+     */
+    storeTrajectory(episodes: (Omit<Episode, 'id'> & {
+        id?: string;
+    })[], metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Get a trajectory by ID
+     */
+    getTrajectory(id: string): Promise<Trajectory | null>;
+    /**
+     * Get top trajectories by total reward
+     */
+    getTopTrajectories(k?: number): Promise<Trajectory[]>;
+    /**
+     * Sample random episodes (for experience replay)
+     */
+    sampleEpisodes(n: number): Promise<Episode[]>;
+    /**
+     * Get database statistics
+     */
+    getStats(): {
+        episodeCount: number;
+        trajectoryCount: number;
+        dimensions: number;
+        maxEpisodes: number;
+        vectorDbAvailable: boolean;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    /**
+     * Generate a unique ID
+     */
+    private generateId;
+}
+/**
+ * Create a fast AgentDB instance
+ */
+export declare function createFastAgentDB(dimensions?: number, maxEpisodes?: number): FastAgentDB;
+/**
+ * Get the default FastAgentDB instance
+ */
+export declare function getDefaultAgentDB(): FastAgentDB;
+declare const _default: {
+    FastAgentDB: typeof FastAgentDB;
+    createFastAgentDB: typeof createFastAgentDB;
+    getDefaultAgentDB: typeof getDefaultAgentDB;
+};
+export default _default;
+//# sourceMappingURL=agentdb-fast.d.ts.map

dist/core/agentdb-fast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentdb-fast.d.ts","sourceRoot":"","sources":["../../src/core/agentdb-fast.ts"],"names":[],"mappings":"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"}

dist/core/agentdb-fast.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * AgentDB Fast - High-performance in-process alternative to AgentDB CLI
+ *
+ * The AgentDB CLI has ~2.3s startup overhead due to npx initialization.
+ * This module provides 50-200x faster operations by using in-process calls.
+ *
+ * Features:
+ * - In-memory episode storage with LRU eviction
+ * - Vector similarity search using @ruvector/core
+ * - Compatible API with AgentDB's episode/trajectory interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastAgentDB = void 0;
+exports.createFastAgentDB = createFastAgentDB;
+exports.getDefaultAgentDB = getDefaultAgentDB;
+// Lazy load ruvector core
+let coreModule = null;
+function getCoreModule() {
+    if (coreModule)
+        return coreModule;
+    try {
+        coreModule = require('@ruvector/core');
+        return coreModule;
+    }
+    catch {
+        // Fallback to ruvector if core not available
+        try {
+            coreModule = require('ruvector');
+            return coreModule;
+        }
+        catch (e) {
+            throw new Error(`Neither @ruvector/core nor ruvector is available: ${e.message}`);
+        }
+    }
+}
+/**
+ * Fast in-memory AgentDB implementation
+ */
+class FastAgentDB {
+    /**
+     * Create a new FastAgentDB instance
+     *
+     * @param dimensions - Vector dimensions for state embeddings
+     * @param maxEpisodes - Maximum episodes to store (LRU eviction)
+     */
+    constructor(dimensions = 128, maxEpisodes = 100000) {
+        this.episodes = new Map();
+        this.trajectories = new Map();
+        this.vectorDb = null;
+        this.episodeOrder = []; // For LRU eviction
+        this.dimensions = dimensions;
+        this.maxEpisodes = maxEpisodes;
+    }
+    /**
+     * Initialize the vector database
+     */
+    async initVectorDb() {
+        if (this.vectorDb)
+            return;
+        try {
+            const core = getCoreModule();
+            this.vectorDb = new core.VectorDB({
+                dimensions: this.dimensions,
+                distanceMetric: 'Cosine',
+            });
+        }
+        catch (e) {
+            // Vector DB not available, use fallback similarity
+            console.warn(`VectorDB not available, using fallback similarity: ${e.message}`);
+        }
+    }
+    /**
+     * Store an episode
+     *
+     * @param episode - Episode to store
+     * @returns Episode ID
+     */
+    async storeEpisode(episode) {
+        await this.initVectorDb();
+        const id = episode.id ?? this.generateId();
+        const fullEpisode = {
+            ...episode,
+            id,
+            timestamp: episode.timestamp ?? Date.now(),
+        };
+        // LRU eviction if needed
+        if (this.episodes.size >= this.maxEpisodes) {
+            const oldestId = this.episodeOrder.shift();
+            if (oldestId) {
+                this.episodes.delete(oldestId);
+            }
+        }
+        this.episodes.set(id, fullEpisode);
+        this.episodeOrder.push(id);
+        // Index in vector DB if available
+        if (this.vectorDb && fullEpisode.state.length === this.dimensions) {
+            try {
+                await this.vectorDb.insert({
+                    id,
+                    vector: new Float32Array(fullEpisode.state),
+                });
+            }
+            catch {
+                // Ignore indexing errors
+            }
+        }
+        return id;
+    }
+    /**
+     * Store multiple episodes in batch
+     */
+    async storeEpisodes(episodes) {
+        const ids = [];
+        for (const episode of episodes) {
+            const id = await this.storeEpisode(episode);
+            ids.push(id);
+        }
+        return ids;
+    }
+    /**
+     * Retrieve an episode by ID
+     */
+    async getEpisode(id) {
+        const episode = this.episodes.get(id);
+        if (episode) {
+            // Update LRU order
+            const idx = this.episodeOrder.indexOf(id);
+            if (idx > -1) {
+                this.episodeOrder.splice(idx, 1);
+                this.episodeOrder.push(id);
+            }
+        }
+        return episode ?? null;
+    }
+    /**
+     * Search for similar episodes by state
+     *
+     * @param queryState - State vector to search for
+     * @param k - Number of results to return
+     * @returns Similar episodes sorted by similarity
+     */
+    async searchByState(queryState, k = 10) {
+        await this.initVectorDb();
+        const query = Array.isArray(queryState) ? queryState : Array.from(queryState);
+        // Use vector DB if available
+        if (this.vectorDb && query.length === this.dimensions) {
+            try {
+                const results = await this.vectorDb.search({
+                    vector: new Float32Array(query),
+                    k,
+                });
+                return results
+                    .map((r) => {
+                    const episode = this.episodes.get(r.id);
+                    if (!episode)
+                        return null;
+                    return {
+                        episode,
+                        similarity: 1 - r.score, // Convert distance to similarity
+                    };
+                })
+                    .filter((r) => r !== null);
+            }
+            catch {
+                // Fall through to fallback
+            }
+        }
+        // Fallback: brute-force cosine similarity
+        return this.fallbackSearch(query, k);
+    }
+    /**
+     * Fallback similarity search using brute-force cosine similarity
+     */
+    fallbackSearch(query, k) {
+        const results = [];
+        for (const episode of this.episodes.values()) {
+            if (episode.state.length !== query.length)
+                continue;
+            const similarity = this.cosineSimilarity(query, episode.state);
+            results.push({ episode, similarity });
+        }
+        return results
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, k);
+    }
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(normA) * Math.sqrt(normB);
+        return denom === 0 ? 0 : dotProduct / denom;
+    }
+    /**
+     * Store a trajectory (sequence of episodes)
+     */
+    async storeTrajectory(episodes, metadata) {
+        const trajectoryId = this.generateId();
+        const storedEpisodes = [];
+        let totalReward = 0;
+        for (const episode of episodes) {
+            const id = await this.storeEpisode(episode);
+            const stored = await this.getEpisode(id);
+            if (stored) {
+                storedEpisodes.push(stored);
+                totalReward += stored.reward;
+            }
+        }
+        const trajectory = {
+            id: trajectoryId,
+            episodes: storedEpisodes,
+            totalReward,
+            metadata,
+        };
+        this.trajectories.set(trajectoryId, trajectory);
+        return trajectoryId;
+    }
+    /**
+     * Get a trajectory by ID
+     */
+    async getTrajectory(id) {
+        return this.trajectories.get(id) ?? null;
+    }
+    /**
+     * Get top trajectories by total reward
+     */
+    async getTopTrajectories(k = 10) {
+        return Array.from(this.trajectories.values())
+            .sort((a, b) => b.totalReward - a.totalReward)
+            .slice(0, k);
+    }
+    /**
+     * Sample random episodes (for experience replay)
+     */
+    async sampleEpisodes(n) {
+        const allEpisodes = Array.from(this.episodes.values());
+        const sampled = [];
+        for (let i = 0; i < Math.min(n, allEpisodes.length); i++) {
+            const idx = Math.floor(Math.random() * allEpisodes.length);
+            sampled.push(allEpisodes[idx]);
+        }
+        return sampled;
+    }
+    /**
+     * Get database statistics
+     */
+    getStats() {
+        return {
+            episodeCount: this.episodes.size,
+            trajectoryCount: this.trajectories.size,
+            dimensions: this.dimensions,
+            maxEpisodes: this.maxEpisodes,
+            vectorDbAvailable: this.vectorDb !== null,
+        };
+    }
+    /**
+     * Clear all data
+     */
+    clear() {
+        this.episodes.clear();
+        this.trajectories.clear();
+        this.episodeOrder = [];
+    }
+    /**
+     * Generate a unique ID
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.FastAgentDB = FastAgentDB;
+/**
+ * Create a fast AgentDB instance
+ */
+function createFastAgentDB(dimensions = 128, maxEpisodes = 100000) {
+    return new FastAgentDB(dimensions, maxEpisodes);
+}
+// Singleton instance for convenience
+let defaultInstance = null;
+/**
+ * Get the default FastAgentDB instance
+ */
+function getDefaultAgentDB() {
+    if (!defaultInstance) {
+        defaultInstance = new FastAgentDB();
+    }
+    return defaultInstance;
+}
+exports.default = {
+    FastAgentDB,
+    createFastAgentDB,
+    getDefaultAgentDB,
+};

dist/core/ast-parser.d.ts

@@ -0,0 +1,108 @@
+/**
+ * AST Parser - Tree-sitter based code parsing
+ *
+ * Provides real AST parsing for accurate code analysis,
+ * replacing regex-based heuristics with proper parsing.
+ *
+ * Supports: TypeScript, JavaScript, Python, Rust, Go, Java, C/C++
+ */
+export declare function isTreeSitterAvailable(): boolean;
+export interface ASTNode {
+    type: string;
+    text: string;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    children: ASTNode[];
+    parent?: string;
+}
+export interface FunctionInfo {
+    name: string;
+    params: string[];
+    returnType?: string;
+    async: boolean;
+    exported: boolean;
+    startLine: number;
+    endLine: number;
+    complexity: number;
+    calls: string[];
+}
+export interface ClassInfo {
+    name: string;
+    extends?: string;
+    implements: string[];
+    methods: FunctionInfo[];
+    properties: string[];
+    exported: boolean;
+    startLine: number;
+    endLine: number;
+}
+export interface ImportInfo {
+    source: string;
+    default?: string;
+    named: string[];
+    namespace?: string;
+    type: 'esm' | 'commonjs' | 'dynamic';
+}
+export interface ExportInfo {
+    name: string;
+    type: 'default' | 'named' | 'all';
+    source?: string;
+}
+export interface FileAnalysis {
+    file: string;
+    language: string;
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    variables: string[];
+    types: string[];
+    complexity: number;
+    lines: number;
+    parseTime: number;
+}
+export declare class CodeParser {
+    private parser;
+    private initialized;
+    init(): Promise<boolean>;
+    /**
+     * Detect language from file extension
+     */
+    detectLanguage(file: string): string;
+    /**
+     * Parse a file and return the AST
+     */
+    parse(file: string, content?: string): Promise<ASTNode | null>;
+    private convertNode;
+    /**
+     * Analyze a file for functions, classes, imports, etc.
+     */
+    analyze(file: string, content?: string): Promise<FileAnalysis>;
+    private analyzeTree;
+    private parseImport;
+    private parseExport;
+    private parseFunction;
+    private parseClass;
+    private findChild;
+    private getIdentifierName;
+    private calculateComplexity;
+    private analyzeWithRegex;
+    /**
+     * Get all symbols (functions, classes, types) in a file
+     */
+    getSymbols(file: string): Promise<string[]>;
+    /**
+     * Get the call graph for a file
+     */
+    getCallGraph(file: string): Promise<Map<string, string[]>>;
+}
+export declare function getCodeParser(): CodeParser;
+export declare function initCodeParser(): Promise<CodeParser>;
+export default CodeParser;
+//# sourceMappingURL=ast-parser.d.ts.map

dist/core/ast-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-parser.d.ts","sourceRoot":"","sources":["../../src/core/ast-parser.ts"],"names":[],"mappings":"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"}

dist/core/ast-parser.js

@@ -0,0 +1,602 @@
+"use strict";
+/**
+ * AST Parser - Tree-sitter based code parsing
+ *
+ * Provides real AST parsing for accurate code analysis,
+ * replacing regex-based heuristics with proper parsing.
+ *
+ * Supports: TypeScript, JavaScript, Python, Rust, Go, Java, C/C++
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeParser = void 0;
+exports.isTreeSitterAvailable = isTreeSitterAvailable;
+exports.getCodeParser = getCodeParser;
+exports.initCodeParser = initCodeParser;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Try to load tree-sitter
+let Parser = null;
+let languages = new Map();
+let parserError = null;
+async function loadTreeSitter() {
+    if (Parser)
+        return true;
+    if (parserError)
+        return false;
+    try {
+        // Dynamic require to avoid TypeScript errors
+        Parser = require('tree-sitter');
+        return true;
+    }
+    catch (e) {
+        parserError = new Error(`tree-sitter not installed: ${e.message}\n` +
+            `Install with: npm install tree-sitter tree-sitter-typescript tree-sitter-javascript tree-sitter-python`);
+        return false;
+    }
+}
+async function loadLanguage(lang) {
+    if (languages.has(lang))
+        return languages.get(lang);
+    const langPackages = {
+        typescript: 'tree-sitter-typescript',
+        javascript: 'tree-sitter-javascript',
+        python: 'tree-sitter-python',
+        rust: 'tree-sitter-rust',
+        go: 'tree-sitter-go',
+        java: 'tree-sitter-java',
+        c: 'tree-sitter-c',
+        cpp: 'tree-sitter-cpp',
+        ruby: 'tree-sitter-ruby',
+        php: 'tree-sitter-php',
+    };
+    const pkg = langPackages[lang];
+    if (!pkg)
+        return null;
+    try {
+        const langModule = await Promise.resolve(`${pkg}`).then(s => __importStar(require(s)));
+        const language = langModule.default || langModule;
+        // Handle TypeScript which exports tsx and typescript
+        if (lang === 'typescript' && language.typescript) {
+            languages.set(lang, language.typescript);
+            languages.set('tsx', language.tsx);
+            return language.typescript;
+        }
+        languages.set(lang, language);
+        return language;
+    }
+    catch {
+        return null;
+    }
+}
+function isTreeSitterAvailable() {
+    try {
+        require.resolve('tree-sitter');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Parser
+// ============================================================================
+class CodeParser {
+    constructor() {
+        this.parser = null;
+        this.initialized = false;
+    }
+    async init() {
+        if (this.initialized)
+            return true;
+        const loaded = await loadTreeSitter();
+        if (!loaded)
+            return false;
+        this.parser = new Parser();
+        this.initialized = true;
+        return true;
+    }
+    /**
+     * Detect language from file extension
+     */
+    detectLanguage(file) {
+        const ext = path.extname(file).toLowerCase();
+        const langMap = {
+            '.ts': 'typescript',
+            '.tsx': 'tsx',
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.mjs': 'javascript',
+            '.cjs': 'javascript',
+            '.py': 'python',
+            '.rs': 'rust',
+            '.go': 'go',
+            '.java': 'java',
+            '.c': 'c',
+            '.h': 'c',
+            '.cpp': 'cpp',
+            '.cc': 'cpp',
+            '.cxx': 'cpp',
+            '.hpp': 'cpp',
+            '.rb': 'ruby',
+            '.php': 'php',
+        };
+        return langMap[ext] || 'unknown';
+    }
+    /**
+     * Parse a file and return the AST
+     */
+    async parse(file, content) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        if (!this.parser)
+            return null;
+        const lang = this.detectLanguage(file);
+        const language = await loadLanguage(lang);
+        if (!language)
+            return null;
+        this.parser.setLanguage(language);
+        const code = content ?? (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '');
+        const tree = this.parser.parse(code);
+        return this.convertNode(tree.rootNode);
+    }
+    convertNode(node) {
+        return {
+            type: node.type,
+            text: node.text,
+            startPosition: node.startPosition,
+            endPosition: node.endPosition,
+            children: node.children?.map((c) => this.convertNode(c)) || [],
+        };
+    }
+    /**
+     * Analyze a file for functions, classes, imports, etc.
+     */
+    async analyze(file, content) {
+        const start = performance.now();
+        const lang = this.detectLanguage(file);
+        const code = content ?? (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '');
+        // Try tree-sitter first, fall back to regex
+        if (this.initialized && this.parser) {
+            const language = await loadLanguage(lang);
+            if (language) {
+                this.parser.setLanguage(language);
+                const tree = this.parser.parse(code);
+                return this.analyzeTree(file, lang, tree.rootNode, code, start);
+            }
+        }
+        // Regex fallback
+        return this.analyzeWithRegex(file, lang, code, start);
+    }
+    analyzeTree(file, lang, root, code, start) {
+        const imports = [];
+        const exports = [];
+        const functions = [];
+        const classes = [];
+        const variables = [];
+        const types = [];
+        const visit = (node) => {
+            // Imports
+            if (node.type === 'import_statement' || node.type === 'import_declaration') {
+                const imp = this.parseImport(node, lang);
+                if (imp)
+                    imports.push(imp);
+            }
+            // Exports
+            if (node.type.includes('export')) {
+                const exp = this.parseExport(node, lang);
+                if (exp)
+                    exports.push(exp);
+            }
+            // Functions
+            if (node.type.includes('function') || node.type === 'method_definition' || node.type === 'arrow_function') {
+                const fn = this.parseFunction(node, code, lang);
+                if (fn)
+                    functions.push(fn);
+            }
+            // Classes
+            if (node.type === 'class_declaration' || node.type === 'class') {
+                const cls = this.parseClass(node, code, lang);
+                if (cls)
+                    classes.push(cls);
+            }
+            // Variables
+            if (node.type === 'variable_declarator' || node.type === 'assignment') {
+                const name = this.getIdentifierName(node);
+                if (name)
+                    variables.push(name);
+            }
+            // Type definitions
+            if (node.type === 'type_alias_declaration' || node.type === 'interface_declaration') {
+                const name = this.getIdentifierName(node);
+                if (name)
+                    types.push(name);
+            }
+            // Recurse
+            for (const child of node.children || []) {
+                visit(child);
+            }
+        };
+        visit(root);
+        const lines = code.split('\n').length;
+        const complexity = this.calculateComplexity(code);
+        return {
+            file,
+            language: lang,
+            imports,
+            exports,
+            functions,
+            classes,
+            variables,
+            types,
+            complexity,
+            lines,
+            parseTime: performance.now() - start,
+        };
+    }
+    parseImport(node, lang) {
+        try {
+            const source = this.findChild(node, 'string')?.text?.replace(/['"]/g, '') || '';
+            const named = [];
+            let defaultImport;
+            let namespace;
+            // Find import specifiers
+            const specifiers = this.findChild(node, 'import_clause') || node;
+            for (const child of specifiers.children || []) {
+                if (child.type === 'identifier') {
+                    defaultImport = child.text;
+                }
+                else if (child.type === 'namespace_import') {
+                    namespace = this.getIdentifierName(child) || undefined;
+                }
+                else if (child.type === 'named_imports') {
+                    for (const spec of child.children || []) {
+                        if (spec.type === 'import_specifier') {
+                            named.push(this.getIdentifierName(spec) || '');
+                        }
+                    }
+                }
+            }
+            return {
+                source,
+                default: defaultImport,
+                named: named.filter(Boolean),
+                namespace,
+                type: 'esm',
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    parseExport(node, lang) {
+        try {
+            if (node.type === 'export_statement') {
+                const declaration = this.findChild(node, 'declaration');
+                if (declaration) {
+                    const name = this.getIdentifierName(declaration);
+                    return { name: name || 'default', type: node.text.includes('default') ? 'default' : 'named' };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    parseFunction(node, code, lang) {
+        try {
+            const name = this.getIdentifierName(node) || '<anonymous>';
+            const params = [];
+            let returnType;
+            const isAsync = node.text.includes('async');
+            const isExported = node.parent?.type?.includes('export');
+            // Get parameters
+            const paramsNode = this.findChild(node, 'formal_parameters') || this.findChild(node, 'parameters');
+            if (paramsNode) {
+                for (const param of paramsNode.children || []) {
+                    if (param.type === 'identifier' || param.type === 'required_parameter') {
+                        params.push(this.getIdentifierName(param) || '');
+                    }
+                }
+            }
+            // Get return type
+            const returnNode = this.findChild(node, 'type_annotation');
+            if (returnNode) {
+                returnType = returnNode.text.replace(/^:\s*/, '');
+            }
+            // Calculate complexity
+            const bodyText = this.findChild(node, 'statement_block')?.text || '';
+            const complexity = this.calculateComplexity(bodyText);
+            // Find function calls
+            const calls = [];
+            const callRegex = /(\w+)\s*\(/g;
+            let match;
+            while ((match = callRegex.exec(bodyText)) !== null) {
+                if (!['if', 'for', 'while', 'switch', 'catch', 'function'].includes(match[1])) {
+                    calls.push(match[1]);
+                }
+            }
+            return {
+                name,
+                params: params.filter(Boolean),
+                returnType,
+                async: isAsync,
+                exported: isExported,
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+                complexity,
+                calls: [...new Set(calls)],
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    parseClass(node, code, lang) {
+        try {
+            const name = this.getIdentifierName(node) || '<anonymous>';
+            let extendsClass;
+            const implementsList = [];
+            const methods = [];
+            const properties = [];
+            // Get extends/implements
+            const heritage = this.findChild(node, 'class_heritage');
+            if (heritage) {
+                const extendsNode = this.findChild(heritage, 'extends_clause');
+                if (extendsNode) {
+                    extendsClass = this.getIdentifierName(extendsNode) || undefined;
+                }
+            }
+            // Get methods and properties
+            const body = this.findChild(node, 'class_body');
+            if (body) {
+                for (const member of body.children || []) {
+                    if (member.type === 'method_definition') {
+                        const method = this.parseFunction(member, code, lang);
+                        if (method)
+                            methods.push(method);
+                    }
+                    else if (member.type === 'field_definition' || member.type === 'public_field_definition') {
+                        const propName = this.getIdentifierName(member);
+                        if (propName)
+                            properties.push(propName);
+                    }
+                }
+            }
+            return {
+                name,
+                extends: extendsClass,
+                implements: implementsList,
+                methods,
+                properties,
+                exported: node.parent?.type?.includes('export'),
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    findChild(node, type) {
+        if (!node.children)
+            return null;
+        for (const child of node.children) {
+            if (child.type === type)
+                return child;
+            const found = this.findChild(child, type);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    getIdentifierName(node) {
+        if (node.type === 'identifier')
+            return node.text;
+        if (!node.children)
+            return null;
+        for (const child of node.children) {
+            if (child.type === 'identifier' || child.type === 'property_identifier') {
+                return child.text;
+            }
+        }
+        return null;
+    }
+    calculateComplexity(code) {
+        const patterns = [
+            /\bif\b/g,
+            /\belse\b/g,
+            /\bfor\b/g,
+            /\bwhile\b/g,
+            /\bcase\b/g,
+            /\bcatch\b/g,
+            /\?\s*[^:]/g, // ternary
+            /&&/g,
+            /\|\|/g,
+        ];
+        let complexity = 1;
+        for (const pattern of patterns) {
+            complexity += (code.match(pattern) || []).length;
+        }
+        return complexity;
+    }
+    analyzeWithRegex(file, lang, code, start) {
+        const lines = code.split('\n');
+        const imports = [];
+        const exports = [];
+        const functions = [];
+        const classes = [];
+        const variables = [];
+        const types = [];
+        // Regex patterns
+        const importRegex = /import\s+(?:(\w+)\s*,?\s*)?(?:\{([^}]+)\}\s*)?(?:\*\s+as\s+(\w+)\s*)?from\s+['"]([^'"]+)['"]/g;
+        const requireRegex = /(?:const|let|var)\s+(?:(\w+)|\{([^}]+)\})\s*=\s*require\s*\(['"]([^'"]+)['"]\)/g;
+        const exportRegex = /export\s+(?:(default)\s+)?(?:(class|function|const|let|var|interface|type)\s+)?(\w+)?/g;
+        const functionRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
+        const arrowRegex = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g;
+        const classRegex = /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/g;
+        const typeRegex = /(?:export\s+)?(?:type|interface)\s+(\w+)/g;
+        // Parse imports
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            imports.push({
+                source: match[4],
+                default: match[1],
+                named: match[2] ? match[2].split(',').map(s => s.trim().split(/\s+as\s+/)[0]) : [],
+                namespace: match[3],
+                type: 'esm',
+            });
+        }
+        while ((match = requireRegex.exec(code)) !== null) {
+            imports.push({
+                source: match[3],
+                default: match[1],
+                named: match[2] ? match[2].split(',').map(s => s.trim()) : [],
+                type: 'commonjs',
+            });
+        }
+        // Parse exports
+        while ((match = exportRegex.exec(code)) !== null) {
+            if (match[3]) {
+                exports.push({
+                    name: match[3],
+                    type: match[1] === 'default' ? 'default' : 'named',
+                });
+            }
+        }
+        // Parse functions
+        while ((match = functionRegex.exec(code)) !== null) {
+            functions.push({
+                name: match[1],
+                params: match[2].split(',').map(p => p.trim().split(/[:\s]/)[0]).filter(Boolean),
+                async: code.substring(match.index - 10, match.index).includes('async'),
+                exported: code.substring(match.index - 10, match.index).includes('export'),
+                startLine: code.substring(0, match.index).split('\n').length,
+                endLine: 0,
+                complexity: 1,
+                calls: [],
+            });
+        }
+        while ((match = arrowRegex.exec(code)) !== null) {
+            functions.push({
+                name: match[1],
+                params: [],
+                async: code.substring(match.index, match.index + 50).includes('async'),
+                exported: false,
+                startLine: code.substring(0, match.index).split('\n').length,
+                endLine: 0,
+                complexity: 1,
+                calls: [],
+            });
+        }
+        // Parse classes
+        while ((match = classRegex.exec(code)) !== null) {
+            classes.push({
+                name: match[1],
+                extends: match[2],
+                implements: [],
+                methods: [],
+                properties: [],
+                exported: code.substring(match.index - 10, match.index).includes('export'),
+                startLine: code.substring(0, match.index).split('\n').length,
+                endLine: 0,
+            });
+        }
+        // Parse types
+        while ((match = typeRegex.exec(code)) !== null) {
+            types.push(match[1]);
+        }
+        return {
+            file,
+            language: lang,
+            imports,
+            exports,
+            functions,
+            classes,
+            variables,
+            types,
+            complexity: this.calculateComplexity(code),
+            lines: lines.length,
+            parseTime: performance.now() - start,
+        };
+    }
+    /**
+     * Get all symbols (functions, classes, types) in a file
+     */
+    async getSymbols(file) {
+        const analysis = await this.analyze(file);
+        return [
+            ...analysis.functions.map(f => f.name),
+            ...analysis.classes.map(c => c.name),
+            ...analysis.types,
+            ...analysis.variables,
+        ];
+    }
+    /**
+     * Get the call graph for a file
+     */
+    async getCallGraph(file) {
+        const analysis = await this.analyze(file);
+        const graph = new Map();
+        for (const fn of analysis.functions) {
+            graph.set(fn.name, fn.calls);
+        }
+        for (const cls of analysis.classes) {
+            for (const method of cls.methods) {
+                graph.set(`${cls.name}.${method.name}`, method.calls);
+            }
+        }
+        return graph;
+    }
+}
+exports.CodeParser = CodeParser;
+// ============================================================================
+// Singleton
+// ============================================================================
+let parserInstance = null;
+function getCodeParser() {
+    if (!parserInstance) {
+        parserInstance = new CodeParser();
+    }
+    return parserInstance;
+}
+async function initCodeParser() {
+    const parser = getCodeParser();
+    await parser.init();
+    return parser;
+}
+exports.default = CodeParser;

dist/core/attention-fallbacks.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Attention Fallbacks - Safe wrapper around @ruvector/attention with automatic array conversion
+ *
+ * This wrapper handles the array type conversion automatically, allowing users
+ * to pass either regular arrays or Float32Arrays.
+ *
+ * @ruvector/attention requires Float32Array inputs.
+ * This wrapper handles the conversion automatically.
+ */
+/**
+ * Attention output interface
+ */
+export interface AttentionOutput {
+    /** Output vector as regular array */
+    values: number[];
+    /** Output as Float32Array for performance-critical code */
+    raw: Float32Array;
+}
+/**
+ * Multi-head attention mechanism
+ *
+ * This wrapper automatically converts array inputs to Float32Array.
+ */
+export declare class MultiHeadAttention {
+    private inner;
+    readonly dim: number;
+    readonly numHeads: number;
+    /**
+     * Create a new multi-head attention instance
+     *
+     * @param dim - Embedding dimension (must be divisible by numHeads)
+     * @param numHeads - Number of attention heads
+     */
+    constructor(dim: number, numHeads: number);
+    /**
+     * Compute multi-head attention
+     *
+     * @param query - Query vector
+     * @param keys - Array of key vectors
+     * @param values - Array of value vectors
+     * @returns Attention output
+     *
+     * @example
+     * ```typescript
+     * const mha = new MultiHeadAttention(64, 4);
+     *
+     * // Works with regular arrays
+     * const result1 = mha.compute([...64 values], [[...64], [...64]], [[...64], [...64]]);
+     *
+     * // Also works with Float32Array
+     * const q = new Float32Array(64);
+     * const k = [new Float32Array(64)];
+     * const v = [new Float32Array(64)];
+     * const result2 = mha.compute(q, k, v);
+     * ```
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    /**
+     * Compute and return raw Float32Array (faster, no conversion)
+     */
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+    get headDim(): number;
+}
+/**
+ * Flash attention with tiled computation
+ */
+export declare class FlashAttention {
+    private inner;
+    readonly dim: number;
+    readonly blockSize: number;
+    /**
+     * Create a new flash attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param blockSize - Block size for tiled computation (default: 512)
+     */
+    constructor(dim: number, blockSize?: number);
+    /**
+     * Compute flash attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Hyperbolic attention in Poincare ball model
+ */
+export declare class HyperbolicAttention {
+    private inner;
+    readonly dim: number;
+    readonly curvature: number;
+    /**
+     * Create a new hyperbolic attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param curvature - Hyperbolic curvature (typically 1.0)
+     */
+    constructor(dim: number, curvature?: number);
+    /**
+     * Compute hyperbolic attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Linear attention (Performer-style) with O(n) complexity
+ */
+export declare class LinearAttention {
+    private inner;
+    readonly dim: number;
+    readonly numFeatures: number;
+    /**
+     * Create a new linear attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param numFeatures - Number of random features
+     */
+    constructor(dim: number, numFeatures: number);
+    /**
+     * Compute linear attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Local-global attention (Longformer-style)
+ */
+export declare class LocalGlobalAttention {
+    private inner;
+    readonly dim: number;
+    readonly localWindow: number;
+    readonly globalTokens: number;
+    /**
+     * Create a new local-global attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param localWindow - Size of local attention window
+     * @param globalTokens - Number of global attention tokens
+     */
+    constructor(dim: number, localWindow: number, globalTokens: number);
+    /**
+     * Compute local-global attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * MoE configuration
+ */
+export interface MoEConfig {
+    dim: number;
+    numExperts: number;
+    topK: number;
+    expertCapacity?: number;
+}
+/**
+ * Mixture of Experts attention
+ */
+export declare class MoEAttention {
+    private inner;
+    readonly config: MoEConfig;
+    /**
+     * Create a new MoE attention instance
+     *
+     * @param config - MoE configuration
+     */
+    constructor(config: MoEConfig);
+    /**
+     * Create with simple parameters
+     */
+    static simple(dim: number, numExperts: number, topK: number): MoEAttention;
+    /**
+     * Compute MoE attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Project a vector into the Poincare ball
+ */
+export declare function projectToPoincareBall(vector: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Compute hyperbolic (Poincare) distance between two points
+ */
+export declare function poincareDistance(a: number[] | Float32Array, b: number[] | Float32Array, curvature?: number): number;
+/**
+ * Mobius addition in hyperbolic space
+ */
+export declare function mobiusAddition(a: number[] | Float32Array, b: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Exponential map from tangent space to hyperbolic space
+ */
+export declare function expMap(base: number[] | Float32Array, tangent: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Logarithmic map from hyperbolic space to tangent space
+ */
+export declare function logMap(base: number[] | Float32Array, point: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Check if attention module is available
+ */
+export declare function isAttentionAvailable(): boolean;
+/**
+ * Get attention module version
+ */
+export declare function getAttentionVersion(): string | null;
+/**
+ * Graph attention with Rotary Position Embeddings
+ * Excellent for code AST and dependency graphs
+ */
+export declare class GraphRoPeAttention {
+    private inner;
+    readonly dim: number;
+    readonly numHeads: number;
+    readonly maxSeqLen: number;
+    constructor(dim: number, numHeads?: number, maxSeqLen?: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], positions?: number[]): AttentionOutput;
+}
+/**
+ * Edge-featured attention for graphs with edge attributes
+ * Useful for weighted dependency graphs
+ */
+export declare class EdgeFeaturedAttention {
+    private inner;
+    readonly dim: number;
+    readonly edgeDim: number;
+    constructor(dim: number, edgeDim?: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], edgeFeatures?: (number[] | Float32Array)[]): AttentionOutput;
+}
+/**
+ * Dual-space attention (Euclidean + Hyperbolic)
+ * Best of both worlds for hierarchical + semantic similarity
+ */
+export declare class DualSpaceAttention {
+    private inner;
+    readonly dim: number;
+    readonly curvature: number;
+    readonly alpha: number;
+    constructor(dim: number, curvature?: number, alpha?: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+}
+/**
+ * Basic dot-product attention
+ */
+export declare class DotProductAttention {
+    private inner;
+    readonly dim: number;
+    constructor(dim: number);
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+}
+/**
+ * Compute attention in parallel across multiple queries
+ */
+export declare function parallelAttentionCompute(queries: (number[] | Float32Array)[], keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], attentionType?: 'dot' | 'multi-head' | 'flash' | 'hyperbolic' | 'linear'): Promise<number[][]>;
+/**
+ * Batch attention compute for multiple query-key-value sets
+ */
+export declare function batchAttentionCompute(batches: Array<{
+    query: number[] | Float32Array;
+    keys: (number[] | Float32Array)[];
+    values: (number[] | Float32Array)[];
+}>, attentionType?: 'dot' | 'multi-head' | 'flash' | 'hyperbolic' | 'linear'): Promise<number[][]>;
+/**
+ * Async flash attention with callback
+ */
+export declare function computeFlashAttentionAsync(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): Promise<number[]>;
+/**
+ * Async hyperbolic attention
+ */
+export declare function computeHyperbolicAttentionAsync(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[], curvature?: number): Promise<number[]>;
+/**
+ * Adam optimizer for attention training
+ */
+export declare class AdamOptimizer {
+    private inner;
+    constructor(learningRate?: number, beta1?: number, beta2?: number);
+    step(gradients: number[] | Float32Array, params: number[] | Float32Array): number[];
+}
+/**
+ * InfoNCE contrastive loss
+ */
+export declare function infoNceLoss(anchor: number[] | Float32Array, positive: number[] | Float32Array, negatives: (number[] | Float32Array)[], temperature?: number): number;
+/**
+ * Hard negative mining for contrastive learning
+ */
+export declare function mineHardNegatives(anchor: number[] | Float32Array, candidates: (number[] | Float32Array)[], topK?: number): number[][];
+/**
+ * Benchmark attention implementations
+ */
+export declare function benchmarkAttention(dim: number, seqLen: number, iterations?: number): Promise<Record<string, {
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+}>>;
+declare const _default: {
+    DotProductAttention: typeof DotProductAttention;
+    MultiHeadAttention: typeof MultiHeadAttention;
+    FlashAttention: typeof FlashAttention;
+    HyperbolicAttention: typeof HyperbolicAttention;
+    LinearAttention: typeof LinearAttention;
+    LocalGlobalAttention: typeof LocalGlobalAttention;
+    MoEAttention: typeof MoEAttention;
+    GraphRoPeAttention: typeof GraphRoPeAttention;
+    EdgeFeaturedAttention: typeof EdgeFeaturedAttention;
+    DualSpaceAttention: typeof DualSpaceAttention;
+    parallelAttentionCompute: typeof parallelAttentionCompute;
+    batchAttentionCompute: typeof batchAttentionCompute;
+    computeFlashAttentionAsync: typeof computeFlashAttentionAsync;
+    computeHyperbolicAttentionAsync: typeof computeHyperbolicAttentionAsync;
+    AdamOptimizer: typeof AdamOptimizer;
+    infoNceLoss: typeof infoNceLoss;
+    mineHardNegatives: typeof mineHardNegatives;
+    projectToPoincareBall: typeof projectToPoincareBall;
+    poincareDistance: typeof poincareDistance;
+    mobiusAddition: typeof mobiusAddition;
+    expMap: typeof expMap;
+    logMap: typeof logMap;
+    isAttentionAvailable: typeof isAttentionAvailable;
+    getAttentionVersion: typeof getAttentionVersion;
+    benchmarkAttention: typeof benchmarkAttention;
+};
+export default _default;
+//# sourceMappingURL=attention-fallbacks.d.ts.map

dist/core/attention-fallbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attention-fallbacks.d.ts","sourceRoot":"","sources":["../../src/core/attention-fallbacks.ts"],"names":[],"mappings":"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"}

dist/core/attention-fallbacks.js

@@ -0,0 +1,552 @@
+"use strict";
+/**
+ * Attention Fallbacks - Safe wrapper around @ruvector/attention with automatic array conversion
+ *
+ * This wrapper handles the array type conversion automatically, allowing users
+ * to pass either regular arrays or Float32Arrays.
+ *
+ * @ruvector/attention requires Float32Array inputs.
+ * This wrapper handles the conversion automatically.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdamOptimizer = exports.DotProductAttention = exports.DualSpaceAttention = exports.EdgeFeaturedAttention = exports.GraphRoPeAttention = exports.MoEAttention = exports.LocalGlobalAttention = exports.LinearAttention = exports.HyperbolicAttention = exports.FlashAttention = exports.MultiHeadAttention = void 0;
+exports.projectToPoincareBall = projectToPoincareBall;
+exports.poincareDistance = poincareDistance;
+exports.mobiusAddition = mobiusAddition;
+exports.expMap = expMap;
+exports.logMap = logMap;
+exports.isAttentionAvailable = isAttentionAvailable;
+exports.getAttentionVersion = getAttentionVersion;
+exports.parallelAttentionCompute = parallelAttentionCompute;
+exports.batchAttentionCompute = batchAttentionCompute;
+exports.computeFlashAttentionAsync = computeFlashAttentionAsync;
+exports.computeHyperbolicAttentionAsync = computeHyperbolicAttentionAsync;
+exports.infoNceLoss = infoNceLoss;
+exports.mineHardNegatives = mineHardNegatives;
+exports.benchmarkAttention = benchmarkAttention;
+// Lazy load to avoid import errors if not installed
+let attentionModule = null;
+let loadError = null;
+function getAttentionModule() {
+    if (attentionModule)
+        return attentionModule;
+    if (loadError)
+        throw loadError;
+    try {
+        attentionModule = require('@ruvector/attention');
+        return attentionModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/attention is not installed or failed to load: ${e.message}\n` +
+            `Install with: npm install @ruvector/attention`);
+        throw loadError;
+    }
+}
+/**
+ * Convert any array-like input to Float32Array
+ */
+function toFloat32Array(input) {
+    if (input instanceof Float32Array) {
+        return input;
+    }
+    return new Float32Array(input);
+}
+/**
+ * Convert nested arrays to Float32Arrays
+ */
+function toFloat32Arrays(inputs) {
+    return inputs.map(arr => toFloat32Array(arr));
+}
+/**
+ * Convert Float32Array result back to regular array if needed
+ */
+function fromFloat32Array(input) {
+    return Array.from(input);
+}
+/**
+ * Multi-head attention mechanism
+ *
+ * This wrapper automatically converts array inputs to Float32Array.
+ */
+class MultiHeadAttention {
+    /**
+     * Create a new multi-head attention instance
+     *
+     * @param dim - Embedding dimension (must be divisible by numHeads)
+     * @param numHeads - Number of attention heads
+     */
+    constructor(dim, numHeads) {
+        const attention = getAttentionModule();
+        this.inner = new attention.MultiHeadAttention(dim, numHeads);
+        this.dim = dim;
+        this.numHeads = numHeads;
+    }
+    /**
+     * Compute multi-head attention
+     *
+     * @param query - Query vector
+     * @param keys - Array of key vectors
+     * @param values - Array of value vectors
+     * @returns Attention output
+     *
+     * @example
+     * ```typescript
+     * const mha = new MultiHeadAttention(64, 4);
+     *
+     * // Works with regular arrays
+     * const result1 = mha.compute([...64 values], [[...64], [...64]], [[...64], [...64]]);
+     *
+     * // Also works with Float32Array
+     * const q = new Float32Array(64);
+     * const k = [new Float32Array(64)];
+     * const v = [new Float32Array(64)];
+     * const result2 = mha.compute(q, k, v);
+     * ```
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    /**
+     * Compute and return raw Float32Array (faster, no conversion)
+     */
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+    get headDim() {
+        return this.dim / this.numHeads;
+    }
+}
+exports.MultiHeadAttention = MultiHeadAttention;
+/**
+ * Flash attention with tiled computation
+ */
+class FlashAttention {
+    /**
+     * Create a new flash attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param blockSize - Block size for tiled computation (default: 512)
+     */
+    constructor(dim, blockSize = 512) {
+        const attention = getAttentionModule();
+        this.inner = new attention.FlashAttention(dim, blockSize);
+        this.dim = dim;
+        this.blockSize = blockSize;
+    }
+    /**
+     * Compute flash attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.FlashAttention = FlashAttention;
+/**
+ * Hyperbolic attention in Poincare ball model
+ */
+class HyperbolicAttention {
+    /**
+     * Create a new hyperbolic attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param curvature - Hyperbolic curvature (typically 1.0)
+     */
+    constructor(dim, curvature = 1.0) {
+        const attention = getAttentionModule();
+        this.inner = new attention.HyperbolicAttention(dim, curvature);
+        this.dim = dim;
+        this.curvature = curvature;
+    }
+    /**
+     * Compute hyperbolic attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.HyperbolicAttention = HyperbolicAttention;
+/**
+ * Linear attention (Performer-style) with O(n) complexity
+ */
+class LinearAttention {
+    /**
+     * Create a new linear attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param numFeatures - Number of random features
+     */
+    constructor(dim, numFeatures) {
+        const attention = getAttentionModule();
+        this.inner = new attention.LinearAttention(dim, numFeatures);
+        this.dim = dim;
+        this.numFeatures = numFeatures;
+    }
+    /**
+     * Compute linear attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.LinearAttention = LinearAttention;
+/**
+ * Local-global attention (Longformer-style)
+ */
+class LocalGlobalAttention {
+    /**
+     * Create a new local-global attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param localWindow - Size of local attention window
+     * @param globalTokens - Number of global attention tokens
+     */
+    constructor(dim, localWindow, globalTokens) {
+        const attention = getAttentionModule();
+        this.inner = new attention.LocalGlobalAttention(dim, localWindow, globalTokens);
+        this.dim = dim;
+        this.localWindow = localWindow;
+        this.globalTokens = globalTokens;
+    }
+    /**
+     * Compute local-global attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.LocalGlobalAttention = LocalGlobalAttention;
+/**
+ * Mixture of Experts attention
+ */
+class MoEAttention {
+    /**
+     * Create a new MoE attention instance
+     *
+     * @param config - MoE configuration
+     */
+    constructor(config) {
+        const attention = getAttentionModule();
+        this.inner = new attention.MoEAttention({
+            dim: config.dim,
+            num_experts: config.numExperts,
+            top_k: config.topK,
+            expert_capacity: config.expertCapacity ?? 1.25,
+        });
+        this.config = config;
+    }
+    /**
+     * Create with simple parameters
+     */
+    static simple(dim, numExperts, topK) {
+        return new MoEAttention({ dim, numExperts, topK });
+    }
+    /**
+     * Compute MoE attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.MoEAttention = MoEAttention;
+// Hyperbolic math utilities
+/**
+ * Project a vector into the Poincare ball
+ */
+function projectToPoincareBall(vector, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.projectToPoincareBall(toFloat32Array(vector), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Compute hyperbolic (Poincare) distance between two points
+ */
+function poincareDistance(a, b, curvature = 1.0) {
+    const attention = getAttentionModule();
+    return attention.poincareDistance(toFloat32Array(a), toFloat32Array(b), curvature);
+}
+/**
+ * Mobius addition in hyperbolic space
+ */
+function mobiusAddition(a, b, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.mobiusAddition(toFloat32Array(a), toFloat32Array(b), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Exponential map from tangent space to hyperbolic space
+ */
+function expMap(base, tangent, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.expMap(toFloat32Array(base), toFloat32Array(tangent), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Logarithmic map from hyperbolic space to tangent space
+ */
+function logMap(base, point, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.logMap(toFloat32Array(base), toFloat32Array(point), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Check if attention module is available
+ */
+function isAttentionAvailable() {
+    try {
+        getAttentionModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get attention module version
+ */
+function getAttentionVersion() {
+    try {
+        const attention = getAttentionModule();
+        return attention.version?.() ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Graph-based Attention (for code structure)
+// ============================================================================
+/**
+ * Graph attention with Rotary Position Embeddings
+ * Excellent for code AST and dependency graphs
+ */
+class GraphRoPeAttention {
+    constructor(dim, numHeads = 4, maxSeqLen = 4096) {
+        const attention = getAttentionModule();
+        this.inner = new attention.GraphRoPeAttention(dim, numHeads, maxSeqLen);
+        this.dim = dim;
+        this.numHeads = numHeads;
+        this.maxSeqLen = maxSeqLen;
+    }
+    compute(query, keys, values, positions) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), positions ? new Int32Array(positions) : undefined);
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.GraphRoPeAttention = GraphRoPeAttention;
+/**
+ * Edge-featured attention for graphs with edge attributes
+ * Useful for weighted dependency graphs
+ */
+class EdgeFeaturedAttention {
+    constructor(dim, edgeDim = 16) {
+        const attention = getAttentionModule();
+        this.inner = new attention.EdgeFeaturedAttention(dim, edgeDim);
+        this.dim = dim;
+        this.edgeDim = edgeDim;
+    }
+    compute(query, keys, values, edgeFeatures) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), edgeFeatures ? toFloat32Arrays(edgeFeatures) : undefined);
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.EdgeFeaturedAttention = EdgeFeaturedAttention;
+/**
+ * Dual-space attention (Euclidean + Hyperbolic)
+ * Best of both worlds for hierarchical + semantic similarity
+ */
+class DualSpaceAttention {
+    constructor(dim, curvature = 1.0, alpha = 0.5) {
+        const attention = getAttentionModule();
+        this.inner = new attention.DualSpaceAttention(dim, curvature, alpha);
+        this.dim = dim;
+        this.curvature = curvature;
+        this.alpha = alpha;
+    }
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.DualSpaceAttention = DualSpaceAttention;
+/**
+ * Basic dot-product attention
+ */
+class DotProductAttention {
+    constructor(dim) {
+        const attention = getAttentionModule();
+        this.inner = new attention.DotProductAttention(dim);
+        this.dim = dim;
+    }
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.DotProductAttention = DotProductAttention;
+// ============================================================================
+// Parallel/Batch Attention Compute
+// ============================================================================
+/**
+ * Compute attention in parallel across multiple queries
+ */
+async function parallelAttentionCompute(queries, keys, values, attentionType = 'multi-head') {
+    const attention = getAttentionModule();
+    const results = await attention.parallelAttentionCompute(toFloat32Arrays(queries), toFloat32Arrays(keys), toFloat32Arrays(values), attentionType);
+    return results.map((r) => fromFloat32Array(r));
+}
+/**
+ * Batch attention compute for multiple query-key-value sets
+ */
+async function batchAttentionCompute(batches, attentionType = 'multi-head') {
+    const attention = getAttentionModule();
+    const nativeBatches = batches.map(b => ({
+        query: toFloat32Array(b.query),
+        keys: toFloat32Arrays(b.keys),
+        values: toFloat32Arrays(b.values),
+    }));
+    const results = await attention.batchAttentionCompute(nativeBatches, attentionType);
+    return results.map((r) => fromFloat32Array(r));
+}
+/**
+ * Async flash attention with callback
+ */
+function computeFlashAttentionAsync(query, keys, values) {
+    const attention = getAttentionModule();
+    return new Promise((resolve, reject) => {
+        attention.computeFlashAttentionAsync(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(fromFloat32Array(result));
+        });
+    });
+}
+/**
+ * Async hyperbolic attention
+ */
+function computeHyperbolicAttentionAsync(query, keys, values, curvature = 1.0) {
+    const attention = getAttentionModule();
+    return new Promise((resolve, reject) => {
+        attention.computeHyperbolicAttentionAsync(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), curvature, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(fromFloat32Array(result));
+        });
+    });
+}
+// ============================================================================
+// Training Utilities (for SONA integration)
+// ============================================================================
+/**
+ * Adam optimizer for attention training
+ */
+class AdamOptimizer {
+    constructor(learningRate = 0.001, beta1 = 0.9, beta2 = 0.999) {
+        const attention = getAttentionModule();
+        this.inner = new attention.AdamOptimizer(learningRate, beta1, beta2);
+    }
+    step(gradients, params) {
+        const result = this.inner.step(toFloat32Array(gradients), toFloat32Array(params));
+        return fromFloat32Array(result);
+    }
+}
+exports.AdamOptimizer = AdamOptimizer;
+/**
+ * InfoNCE contrastive loss
+ */
+function infoNceLoss(anchor, positive, negatives, temperature = 0.07) {
+    const attention = getAttentionModule();
+    return attention.InfoNceLoss.compute(toFloat32Array(anchor), toFloat32Array(positive), toFloat32Arrays(negatives), temperature);
+}
+/**
+ * Hard negative mining for contrastive learning
+ */
+function mineHardNegatives(anchor, candidates, topK = 5) {
+    const attention = getAttentionModule();
+    const miner = new attention.HardNegativeMiner(topK);
+    const results = miner.mine(toFloat32Array(anchor), toFloat32Arrays(candidates));
+    return results.map((r) => fromFloat32Array(r));
+}
+// ============================================================================
+// Benchmarking
+// ============================================================================
+/**
+ * Benchmark attention implementations
+ */
+async function benchmarkAttention(dim, seqLen, iterations = 100) {
+    const attention = getAttentionModule();
+    return attention.benchmarkAttention(dim, seqLen, iterations);
+}
+exports.default = {
+    // Core attention types
+    DotProductAttention,
+    MultiHeadAttention,
+    FlashAttention,
+    HyperbolicAttention,
+    LinearAttention,
+    LocalGlobalAttention,
+    MoEAttention,
+    // Graph attention types
+    GraphRoPeAttention,
+    EdgeFeaturedAttention,
+    DualSpaceAttention,
+    // Parallel/batch compute
+    parallelAttentionCompute,
+    batchAttentionCompute,
+    computeFlashAttentionAsync,
+    computeHyperbolicAttentionAsync,
+    // Training utilities
+    AdamOptimizer,
+    infoNceLoss,
+    mineHardNegatives,
+    // Hyperbolic math
+    projectToPoincareBall,
+    poincareDistance,
+    mobiusAddition,
+    expMap,
+    logMap,
+    // Utilities
+    isAttentionAvailable,
+    getAttentionVersion,
+    benchmarkAttention,
+};

dist/core/cluster-wrapper.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Cluster Wrapper - Distributed coordination for multi-agent systems
+ *
+ * Wraps @ruvector/cluster for Raft consensus, auto-sharding,
+ * and distributed memory across agents.
+ */
+export declare function isClusterAvailable(): boolean;
+export interface ClusterNode {
+    id: string;
+    address: string;
+    role: 'leader' | 'follower' | 'candidate';
+    status: 'healthy' | 'unhealthy' | 'unknown';
+    lastHeartbeat: number;
+}
+export interface ShardInfo {
+    id: number;
+    range: [number, number];
+    node: string;
+    size: number;
+    status: 'active' | 'migrating' | 'offline';
+}
+export interface ClusterConfig {
+    nodeId: string;
+    address: string;
+    peers?: string[];
+    shards?: number;
+    replicationFactor?: number;
+}
+/**
+ * Distributed cluster for multi-agent coordination
+ */
+export declare class RuvectorCluster {
+    private inner;
+    private nodeId;
+    private isLeader;
+    constructor(config: ClusterConfig);
+    /**
+     * Start the cluster node
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the cluster node gracefully
+     */
+    stop(): Promise<void>;
+    /**
+     * Join an existing cluster
+     */
+    join(peerAddress: string): Promise<boolean>;
+    /**
+     * Leave the cluster
+     */
+    leave(): Promise<void>;
+    /**
+     * Get current node info
+     */
+    getNodeInfo(): ClusterNode;
+    /**
+     * Get all cluster nodes
+     */
+    getNodes(): ClusterNode[];
+    /**
+     * Check if this node is the leader
+     */
+    isClusterLeader(): boolean;
+    /**
+     * Get the current leader
+     */
+    getLeader(): ClusterNode | null;
+    /**
+     * Put a value in distributed storage
+     */
+    put(key: string, value: any): Promise<boolean>;
+    /**
+     * Get a value from distributed storage
+     */
+    get(key: string): Promise<any | null>;
+    /**
+     * Delete a value from distributed storage
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Atomic compare-and-swap
+     */
+    compareAndSwap(key: string, expected: any, newValue: any): Promise<boolean>;
+    /**
+     * Get shard information
+     */
+    getShards(): ShardInfo[];
+    /**
+     * Get the shard for a key
+     */
+    getShardForKey(key: string): ShardInfo;
+    /**
+     * Trigger shard rebalancing
+     */
+    rebalance(): Promise<void>;
+    /**
+     * Acquire a distributed lock
+     */
+    lock(name: string, timeout?: number): Promise<string | null>;
+    /**
+     * Release a distributed lock
+     */
+    unlock(name: string, token: string): Promise<boolean>;
+    /**
+     * Extend a lock's TTL
+     */
+    extendLock(name: string, token: string, extension?: number): Promise<boolean>;
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(channel: string, callback: (message: any) => void): () => void;
+    /**
+     * Publish to a channel
+     */
+    publish(channel: string, message: any): Promise<number>;
+    /**
+     * Register an agent with the cluster
+     */
+    registerAgent(agentId: string, capabilities: string[]): Promise<boolean>;
+    /**
+     * Find agents with a capability
+     */
+    findAgents(capability: string): Promise<string[]>;
+    /**
+     * Assign a task to an agent
+     */
+    assignTask(taskId: string, agentId: string, task: any): Promise<boolean>;
+    /**
+     * Complete a task
+     */
+    completeTask(taskId: string, result: any): Promise<boolean>;
+    /**
+     * Get cluster statistics
+     */
+    stats(): {
+        nodes: number;
+        shards: number;
+        leader: string | null;
+        healthy: boolean;
+    };
+}
+/**
+ * Create a cluster node for agent coordination
+ */
+export declare function createCluster(config: ClusterConfig): RuvectorCluster;
+export default RuvectorCluster;
+//# sourceMappingURL=cluster-wrapper.d.ts.map

dist/core/cluster-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-wrapper.d.ts","sourceRoot":"","sources":["../../src/core/cluster-wrapper.ts"],"names":[],"mappings":"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"}

dist/core/cluster-wrapper.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Cluster Wrapper - Distributed coordination for multi-agent systems
+ *
+ * Wraps @ruvector/cluster for Raft consensus, auto-sharding,
+ * and distributed memory across agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuvectorCluster = void 0;
+exports.isClusterAvailable = isClusterAvailable;
+exports.createCluster = createCluster;
+let clusterModule = null;
+let loadError = null;
+function getClusterModule() {
+    if (clusterModule)
+        return clusterModule;
+    if (loadError)
+        throw loadError;
+    try {
+        clusterModule = require('@ruvector/cluster');
+        return clusterModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/cluster not installed: ${e.message}\n` +
+            `Install with: npm install @ruvector/cluster`);
+        throw loadError;
+    }
+}
+function isClusterAvailable() {
+    try {
+        getClusterModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Distributed cluster for multi-agent coordination
+ */
+class RuvectorCluster {
+    constructor(config) {
+        this.isLeader = false;
+        const cluster = getClusterModule();
+        this.nodeId = config.nodeId;
+        this.inner = new cluster.Cluster({
+            nodeId: config.nodeId,
+            address: config.address,
+            peers: config.peers ?? [],
+            shards: config.shards ?? 16,
+            replicationFactor: config.replicationFactor ?? 2,
+        });
+    }
+    // ===========================================================================
+    // Cluster Lifecycle
+    // ===========================================================================
+    /**
+     * Start the cluster node
+     */
+    async start() {
+        await this.inner.start();
+    }
+    /**
+     * Stop the cluster node gracefully
+     */
+    async stop() {
+        await this.inner.stop();
+    }
+    /**
+     * Join an existing cluster
+     */
+    async join(peerAddress) {
+        return this.inner.join(peerAddress);
+    }
+    /**
+     * Leave the cluster
+     */
+    async leave() {
+        await this.inner.leave();
+    }
+    // ===========================================================================
+    // Node Management
+    // ===========================================================================
+    /**
+     * Get current node info
+     */
+    getNodeInfo() {
+        return this.inner.getNodeInfo();
+    }
+    /**
+     * Get all cluster nodes
+     */
+    getNodes() {
+        return this.inner.getNodes();
+    }
+    /**
+     * Check if this node is the leader
+     */
+    isClusterLeader() {
+        this.isLeader = this.inner.isLeader();
+        return this.isLeader;
+    }
+    /**
+     * Get the current leader
+     */
+    getLeader() {
+        return this.inner.getLeader();
+    }
+    // ===========================================================================
+    // Distributed Operations
+    // ===========================================================================
+    /**
+     * Put a value in distributed storage
+     */
+    async put(key, value) {
+        return this.inner.put(key, JSON.stringify(value));
+    }
+    /**
+     * Get a value from distributed storage
+     */
+    async get(key) {
+        const result = await this.inner.get(key);
+        return result ? JSON.parse(result) : null;
+    }
+    /**
+     * Delete a value from distributed storage
+     */
+    async delete(key) {
+        return this.inner.delete(key);
+    }
+    /**
+     * Atomic compare-and-swap
+     */
+    async compareAndSwap(key, expected, newValue) {
+        return this.inner.compareAndSwap(key, JSON.stringify(expected), JSON.stringify(newValue));
+    }
+    // ===========================================================================
+    // Sharding
+    // ===========================================================================
+    /**
+     * Get shard information
+     */
+    getShards() {
+        return this.inner.getShards();
+    }
+    /**
+     * Get the shard for a key
+     */
+    getShardForKey(key) {
+        return this.inner.getShardForKey(key);
+    }
+    /**
+     * Trigger shard rebalancing
+     */
+    async rebalance() {
+        await this.inner.rebalance();
+    }
+    // ===========================================================================
+    // Distributed Locks
+    // ===========================================================================
+    /**
+     * Acquire a distributed lock
+     */
+    async lock(name, timeout = 30000) {
+        return this.inner.lock(name, timeout);
+    }
+    /**
+     * Release a distributed lock
+     */
+    async unlock(name, token) {
+        return this.inner.unlock(name, token);
+    }
+    /**
+     * Extend a lock's TTL
+     */
+    async extendLock(name, token, extension = 30000) {
+        return this.inner.extendLock(name, token, extension);
+    }
+    // ===========================================================================
+    // Pub/Sub
+    // ===========================================================================
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(channel, callback) {
+        return this.inner.subscribe(channel, (msg) => {
+            callback(JSON.parse(msg));
+        });
+    }
+    /**
+     * Publish to a channel
+     */
+    async publish(channel, message) {
+        return this.inner.publish(channel, JSON.stringify(message));
+    }
+    // ===========================================================================
+    // Agent Coordination
+    // ===========================================================================
+    /**
+     * Register an agent with the cluster
+     */
+    async registerAgent(agentId, capabilities) {
+        return this.put(`agent:${agentId}`, {
+            id: agentId,
+            capabilities,
+            node: this.nodeId,
+            registeredAt: Date.now(),
+        });
+    }
+    /**
+     * Find agents with a capability
+     */
+    async findAgents(capability) {
+        const agents = await this.inner.scan('agent:*');
+        const matching = [];
+        for (const key of agents) {
+            const agent = await this.get(key);
+            if (agent?.capabilities?.includes(capability)) {
+                matching.push(agent.id);
+            }
+        }
+        return matching;
+    }
+    /**
+     * Assign a task to an agent
+     */
+    async assignTask(taskId, agentId, task) {
+        const assigned = await this.put(`task:${taskId}`, {
+            id: taskId,
+            agent: agentId,
+            task,
+            status: 'assigned',
+            assignedAt: Date.now(),
+        });
+        if (assigned) {
+            await this.publish(`agent:${agentId}:tasks`, { type: 'new_task', taskId });
+        }
+        return assigned;
+    }
+    /**
+     * Complete a task
+     */
+    async completeTask(taskId, result) {
+        const task = await this.get(`task:${taskId}`);
+        if (!task)
+            return false;
+        return this.put(`task:${taskId}`, {
+            ...task,
+            status: 'completed',
+            result,
+            completedAt: Date.now(),
+        });
+    }
+    // ===========================================================================
+    // Stats
+    // ===========================================================================
+    /**
+     * Get cluster statistics
+     */
+    stats() {
+        return this.inner.stats();
+    }
+}
+exports.RuvectorCluster = RuvectorCluster;
+/**
+ * Create a cluster node for agent coordination
+ */
+function createCluster(config) {
+    return new RuvectorCluster(config);
+}
+exports.default = RuvectorCluster;

dist/core/coverage-router.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Coverage Router - Test coverage-aware agent routing
+ *
+ * Uses test coverage data to make smarter routing decisions:
+ * - Prioritize testing for uncovered code
+ * - Route to tester agent for low-coverage files
+ * - Suggest test files for modified code
+ */
+export interface CoverageData {
+    file: string;
+    lines: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    functions: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    branches: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    uncoveredLines: number[];
+    uncoveredFunctions: string[];
+}
+export interface CoverageSummary {
+    files: Map<string, CoverageData>;
+    overall: {
+        lines: number;
+        functions: number;
+        branches: number;
+    };
+    lowCoverageFiles: string[];
+    uncoveredFiles: string[];
+}
+export interface TestSuggestion {
+    file: string;
+    testFile: string;
+    reason: string;
+    priority: 'high' | 'medium' | 'low';
+    coverage: number;
+    uncoveredFunctions: string[];
+}
+/**
+ * Parse Istanbul/NYC JSON coverage report
+ */
+export declare function parseIstanbulCoverage(coveragePath: string): CoverageSummary;
+/**
+ * Find coverage report in project
+ */
+export declare function findCoverageReport(projectRoot?: string): string | null;
+/**
+ * Get coverage data for a specific file
+ */
+export declare function getFileCoverage(file: string, summary?: CoverageSummary): CoverageData | null;
+/**
+ * Suggest tests for files based on coverage
+ */
+export declare function suggestTests(files: string[], summary?: CoverageSummary): TestSuggestion[];
+/**
+ * Determine if a file needs the tester agent based on coverage
+ */
+export declare function shouldRouteToTester(file: string, summary?: CoverageSummary): {
+    route: boolean;
+    reason: string;
+    coverage: number;
+};
+/**
+ * Get coverage-aware routing weight for agent selection
+ */
+export declare function getCoverageRoutingWeight(file: string, summary?: CoverageSummary): {
+    coder: number;
+    tester: number;
+    reviewer: number;
+};
+declare const _default: {
+    parseIstanbulCoverage: typeof parseIstanbulCoverage;
+    findCoverageReport: typeof findCoverageReport;
+    getFileCoverage: typeof getFileCoverage;
+    suggestTests: typeof suggestTests;
+    shouldRouteToTester: typeof shouldRouteToTester;
+    getCoverageRoutingWeight: typeof getCoverageRoutingWeight;
+};
+export default _default;
+//# sourceMappingURL=coverage-router.d.ts.map

dist/core/coverage-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-router.d.ts","sourceRoot":"","sources":["../../src/core/coverage-router.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACjC,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,CA0F3E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAiBrF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,CAqB5F;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,EAAE,CAwEzF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IAC5E,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAgCA;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAuBA;;;;;;;;;AAED,wBAOE"}

dist/core/coverage-router.js

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * Coverage Router - Test coverage-aware agent routing
+ *
+ * Uses test coverage data to make smarter routing decisions:
+ * - Prioritize testing for uncovered code
+ * - Route to tester agent for low-coverage files
+ * - Suggest test files for modified code
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIstanbulCoverage = parseIstanbulCoverage;
+exports.findCoverageReport = findCoverageReport;
+exports.getFileCoverage = getFileCoverage;
+exports.suggestTests = suggestTests;
+exports.shouldRouteToTester = shouldRouteToTester;
+exports.getCoverageRoutingWeight = getCoverageRoutingWeight;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse Istanbul/NYC JSON coverage report
+ */
+function parseIstanbulCoverage(coveragePath) {
+    const files = new Map();
+    const lowCoverageFiles = [];
+    const uncoveredFiles = [];
+    let totalLines = 0, coveredLines = 0;
+    let totalFunctions = 0, coveredFunctions = 0;
+    let totalBranches = 0, coveredBranches = 0;
+    try {
+        const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
+        for (const [file, data] of Object.entries(coverage)) {
+            // Skip test files
+            if (file.includes('.test.') || file.includes('.spec.') || file.includes('__tests__')) {
+                continue;
+            }
+            // Parse statement coverage
+            const statements = Object.values(data.s || {});
+            const linesCovered = statements.filter(n => n > 0).length;
+            const linesTotal = statements.length;
+            // Parse function coverage
+            const functions = Object.values(data.f || {});
+            const fnCovered = functions.filter(n => n > 0).length;
+            const fnTotal = functions.length;
+            // Parse branch coverage
+            const branches = Object.values(data.b || {}).flat();
+            const brCovered = branches.filter(n => n > 0).length;
+            const brTotal = branches.length;
+            // Find uncovered lines
+            const uncoveredLines = [];
+            for (const [line, count] of Object.entries(data.s || {})) {
+                if (count === 0) {
+                    uncoveredLines.push(parseInt(line));
+                }
+            }
+            // Find uncovered functions
+            const uncoveredFunctions = [];
+            const fnMap = data.fnMap || {};
+            for (const [fnId, count] of Object.entries(data.f || {})) {
+                if (count === 0 && fnMap[fnId]) {
+                    uncoveredFunctions.push(fnMap[fnId].name || `function_${fnId}`);
+                }
+            }
+            const linePercentage = linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 100;
+            const fnPercentage = fnTotal > 0 ? (fnCovered / fnTotal) * 100 : 100;
+            const brPercentage = brTotal > 0 ? (brCovered / brTotal) * 100 : 100;
+            files.set(file, {
+                file,
+                lines: { total: linesTotal, covered: linesCovered, percentage: linePercentage },
+                functions: { total: fnTotal, covered: fnCovered, percentage: fnPercentage },
+                branches: { total: brTotal, covered: brCovered, percentage: brPercentage },
+                uncoveredLines,
+                uncoveredFunctions,
+            });
+            totalLines += linesTotal;
+            coveredLines += linesCovered;
+            totalFunctions += fnTotal;
+            coveredFunctions += fnCovered;
+            totalBranches += brTotal;
+            coveredBranches += brCovered;
+            if (linePercentage < 50) {
+                lowCoverageFiles.push(file);
+            }
+            if (linePercentage === 0 && linesTotal > 0) {
+                uncoveredFiles.push(file);
+            }
+        }
+    }
+    catch (e) {
+        // Return empty summary on error
+    }
+    return {
+        files,
+        overall: {
+            lines: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
+            functions: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
+            branches: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
+        },
+        lowCoverageFiles,
+        uncoveredFiles,
+    };
+}
+/**
+ * Find coverage report in project
+ */
+function findCoverageReport(projectRoot = process.cwd()) {
+    const possiblePaths = [
+        'coverage/coverage-final.json',
+        'coverage/coverage-summary.json',
+        '.nyc_output/coverage.json',
+        'coverage.json',
+        'coverage/lcov.info',
+    ];
+    for (const p of possiblePaths) {
+        const fullPath = path.join(projectRoot, p);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+/**
+ * Get coverage data for a specific file
+ */
+function getFileCoverage(file, summary) {
+    if (!summary) {
+        const reportPath = findCoverageReport();
+        if (!reportPath)
+            return null;
+        summary = parseIstanbulCoverage(reportPath);
+    }
+    // Try exact match first
+    if (summary.files.has(file)) {
+        return summary.files.get(file);
+    }
+    // Try matching by basename
+    const basename = path.basename(file);
+    for (const [key, data] of summary.files) {
+        if (key.endsWith(file) || key.endsWith(basename)) {
+            return data;
+        }
+    }
+    return null;
+}
+/**
+ * Suggest tests for files based on coverage
+ */
+function suggestTests(files, summary) {
+    if (!summary) {
+        const reportPath = findCoverageReport();
+        if (reportPath) {
+            summary = parseIstanbulCoverage(reportPath);
+        }
+    }
+    const suggestions = [];
+    for (const file of files) {
+        const coverage = summary ? getFileCoverage(file, summary) : null;
+        // Determine test file path
+        const ext = path.extname(file);
+        const base = path.basename(file, ext);
+        const dir = path.dirname(file);
+        const possibleTestFiles = [
+            path.join(dir, `${base}.test${ext}`),
+            path.join(dir, `${base}.spec${ext}`),
+            path.join(dir, '__tests__', `${base}.test${ext}`),
+            path.join('test', `${base}.test${ext}`),
+            path.join('tests', `${base}.test${ext}`),
+        ];
+        const existingTestFile = possibleTestFiles.find(t => fs.existsSync(t));
+        const testFile = existingTestFile || possibleTestFiles[0];
+        if (!coverage) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: 'No coverage data - needs test file',
+                priority: 'high',
+                coverage: 0,
+                uncoveredFunctions: [],
+            });
+        }
+        else if (coverage.lines.percentage < 30) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: `Very low coverage (${coverage.lines.percentage.toFixed(1)}%)`,
+                priority: 'high',
+                coverage: coverage.lines.percentage,
+                uncoveredFunctions: coverage.uncoveredFunctions,
+            });
+        }
+        else if (coverage.lines.percentage < 70) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: `Low coverage (${coverage.lines.percentage.toFixed(1)}%)`,
+                priority: 'medium',
+                coverage: coverage.lines.percentage,
+                uncoveredFunctions: coverage.uncoveredFunctions,
+            });
+        }
+        else if (coverage.uncoveredFunctions.length > 0) {
+            suggestions.push({
+                file,
+                testFile,
+                reason: `${coverage.uncoveredFunctions.length} untested functions`,
+                priority: 'low',
+                coverage: coverage.lines.percentage,
+                uncoveredFunctions: coverage.uncoveredFunctions,
+            });
+        }
+    }
+    return suggestions.sort((a, b) => {
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        return priorityOrder[a.priority] - priorityOrder[b.priority];
+    });
+}
+/**
+ * Determine if a file needs the tester agent based on coverage
+ */
+function shouldRouteToTester(file, summary) {
+    const coverage = getFileCoverage(file, summary);
+    if (!coverage) {
+        return {
+            route: true,
+            reason: 'No test coverage data available',
+            coverage: 0,
+        };
+    }
+    if (coverage.lines.percentage < 50) {
+        return {
+            route: true,
+            reason: `Low coverage: ${coverage.lines.percentage.toFixed(1)}%`,
+            coverage: coverage.lines.percentage,
+        };
+    }
+    if (coverage.uncoveredFunctions.length > 3) {
+        return {
+            route: true,
+            reason: `${coverage.uncoveredFunctions.length} untested functions`,
+            coverage: coverage.lines.percentage,
+        };
+    }
+    return {
+        route: false,
+        reason: `Adequate coverage: ${coverage.lines.percentage.toFixed(1)}%`,
+        coverage: coverage.lines.percentage,
+    };
+}
+/**
+ * Get coverage-aware routing weight for agent selection
+ */
+function getCoverageRoutingWeight(file, summary) {
+    const coverage = getFileCoverage(file, summary);
+    if (!coverage) {
+        // No coverage = prioritize testing
+        return { coder: 0.3, tester: 0.5, reviewer: 0.2 };
+    }
+    const pct = coverage.lines.percentage;
+    if (pct < 30) {
+        // Very low - strongly prioritize testing
+        return { coder: 0.2, tester: 0.6, reviewer: 0.2 };
+    }
+    else if (pct < 60) {
+        // Low - moderate testing priority
+        return { coder: 0.4, tester: 0.4, reviewer: 0.2 };
+    }
+    else if (pct < 80) {
+        // Okay - balanced
+        return { coder: 0.5, tester: 0.3, reviewer: 0.2 };
+    }
+    else {
+        // Good - focus on code quality
+        return { coder: 0.5, tester: 0.2, reviewer: 0.3 };
+    }
+}
+exports.default = {
+    parseIstanbulCoverage,
+    findCoverageReport,
+    getFileCoverage,
+    suggestTests,
+    shouldRouteToTester,
+    getCoverageRoutingWeight,
+};

dist/core/diff-embeddings.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Diff Embeddings - Semantic encoding of git diffs
+ *
+ * Generates embeddings for code changes to enable:
+ * - Change classification (feature, bugfix, refactor)
+ * - Similar change detection
+ * - Risk assessment
+ * - Review prioritization
+ */
+export interface DiffHunk {
+    file: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    content: string;
+    additions: string[];
+    deletions: string[];
+}
+export interface DiffAnalysis {
+    file: string;
+    hunks: DiffHunk[];
+    totalAdditions: number;
+    totalDeletions: number;
+    complexity: number;
+    riskScore: number;
+    category: 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
+    embedding?: number[];
+}
+export interface CommitAnalysis {
+    hash: string;
+    message: string;
+    author: string;
+    date: string;
+    files: DiffAnalysis[];
+    totalAdditions: number;
+    totalDeletions: number;
+    riskScore: number;
+    embedding?: number[];
+}
+/**
+ * Parse a unified diff into hunks
+ */
+export declare function parseDiff(diff: string): DiffHunk[];
+/**
+ * Classify a change based on patterns
+ */
+export declare function classifyChange(diff: string, message?: string): 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
+/**
+ * Calculate risk score for a diff
+ */
+export declare function calculateRiskScore(analysis: DiffAnalysis): number;
+/**
+ * Analyze a single file diff
+ */
+export declare function analyzeFileDiff(file: string, diff: string, message?: string): Promise<DiffAnalysis>;
+/**
+ * Get diff for a commit
+ */
+export declare function getCommitDiff(commitHash?: string): string;
+/**
+ * Get diff for staged changes
+ */
+export declare function getStagedDiff(): string;
+/**
+ * Get diff for unstaged changes
+ */
+export declare function getUnstagedDiff(): string;
+/**
+ * Analyze a commit
+ */
+export declare function analyzeCommit(commitHash?: string): Promise<CommitAnalysis>;
+/**
+ * Find similar past commits based on diff embeddings
+ */
+export declare function findSimilarCommits(currentDiff: string, recentCommits?: number, topK?: number): Promise<Array<{
+    hash: string;
+    similarity: number;
+    message: string;
+}>>;
+declare const _default: {
+    parseDiff: typeof parseDiff;
+    classifyChange: typeof classifyChange;
+    calculateRiskScore: typeof calculateRiskScore;
+    analyzeFileDiff: typeof analyzeFileDiff;
+    analyzeCommit: typeof analyzeCommit;
+    getCommitDiff: typeof getCommitDiff;
+    getStagedDiff: typeof getStagedDiff;
+    getUnstagedDiff: typeof getUnstagedDiff;
+    findSimilarCommits: typeof findSimilarCommits;
+};
+export default _default;
+//# sourceMappingURL=diff-embeddings.d.ts.map

dist/core/diff-embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-embeddings.d.ts","sourceRoot":"","sources":["../../src/core/diff-embeddings.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACrF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAsDlD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAsB7I;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CA2BjE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAsC7G;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,GAAE,MAAe,GAAG,MAAM,CASjE;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAStC;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CASxC;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,UAAU,GAAE,MAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAwDxF;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EACnB,aAAa,GAAE,MAAW,EAC1B,IAAI,GAAE,MAAU,GACf,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAgCvE;;;;;;;;;;;;AAmBD,wBAUE"}

dist/core/diff-embeddings.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Diff Embeddings - Semantic encoding of git diffs
+ *
+ * Generates embeddings for code changes to enable:
+ * - Change classification (feature, bugfix, refactor)
+ * - Similar change detection
+ * - Risk assessment
+ * - Review prioritization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiff = parseDiff;
+exports.classifyChange = classifyChange;
+exports.calculateRiskScore = calculateRiskScore;
+exports.analyzeFileDiff = analyzeFileDiff;
+exports.getCommitDiff = getCommitDiff;
+exports.getStagedDiff = getStagedDiff;
+exports.getUnstagedDiff = getUnstagedDiff;
+exports.analyzeCommit = analyzeCommit;
+exports.findSimilarCommits = findSimilarCommits;
+const child_process_1 = require("child_process");
+const onnx_embedder_1 = require("./onnx-embedder");
+/**
+ * Parse a unified diff into hunks
+ */
+function parseDiff(diff) {
+    const hunks = [];
+    const lines = diff.split('\n');
+    let currentFile = '';
+    let currentHunk = null;
+    for (const line of lines) {
+        // File header
+        if (line.startsWith('diff --git')) {
+            const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+            if (match) {
+                currentFile = match[2];
+            }
+        }
+        // Hunk header
+        if (line.startsWith('@@')) {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+            }
+            const match = line.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
+            if (match) {
+                currentHunk = {
+                    file: currentFile,
+                    oldStart: parseInt(match[1]),
+                    oldLines: parseInt(match[2] || '1'),
+                    newStart: parseInt(match[3]),
+                    newLines: parseInt(match[4] || '1'),
+                    content: '',
+                    additions: [],
+                    deletions: [],
+                };
+            }
+        }
+        else if (currentHunk) {
+            // Content lines
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                currentHunk.additions.push(line.substring(1));
+                currentHunk.content += line + '\n';
+            }
+            else if (line.startsWith('-') && !line.startsWith('---')) {
+                currentHunk.deletions.push(line.substring(1));
+                currentHunk.content += line + '\n';
+            }
+            else if (line.startsWith(' ')) {
+                currentHunk.content += line + '\n';
+            }
+        }
+    }
+    if (currentHunk) {
+        hunks.push(currentHunk);
+    }
+    return hunks;
+}
+/**
+ * Classify a change based on patterns
+ */
+function classifyChange(diff, message = '') {
+    const lowerMessage = message.toLowerCase();
+    const lowerDiff = diff.toLowerCase();
+    // Check message patterns
+    if (/\b(fix|bug|issue|error|crash|patch)\b/.test(lowerMessage))
+        return 'bugfix';
+    if (/\b(feat|feature|add|new|implement)\b/.test(lowerMessage))
+        return 'feature';
+    if (/\b(refactor|clean|improve|optimize)\b/.test(lowerMessage))
+        return 'refactor';
+    if (/\b(doc|readme|comment|jsdoc)\b/.test(lowerMessage))
+        return 'docs';
+    if (/\b(test|spec|coverage)\b/.test(lowerMessage))
+        return 'test';
+    if (/\b(config|ci|cd|build|deps)\b/.test(lowerMessage))
+        return 'config';
+    // Check diff patterns
+    if (/\.(md|txt|rst)$/.test(diff))
+        return 'docs';
+    if (/\.(test|spec)\.[jt]sx?/.test(diff))
+        return 'test';
+    if (/\.(json|ya?ml|toml|ini)$/.test(diff))
+        return 'config';
+    // Check content patterns
+    if (/\bcatch\b|\btry\b|\berror\b/.test(lowerDiff) && /\bfix\b/.test(lowerDiff))
+        return 'bugfix';
+    if (/\bfunction\b|\bclass\b|\bexport\b/.test(lowerDiff))
+        return 'feature';
+    return 'unknown';
+}
+/**
+ * Calculate risk score for a diff
+ */
+function calculateRiskScore(analysis) {
+    let risk = 0;
+    // Size risk
+    const totalChanges = analysis.totalAdditions + analysis.totalDeletions;
+    if (totalChanges > 500)
+        risk += 0.3;
+    else if (totalChanges > 200)
+        risk += 0.2;
+    else if (totalChanges > 50)
+        risk += 0.1;
+    // Complexity risk
+    if (analysis.complexity > 20)
+        risk += 0.2;
+    else if (analysis.complexity > 10)
+        risk += 0.1;
+    // File type risk
+    if (analysis.file.includes('auth') || analysis.file.includes('security'))
+        risk += 0.2;
+    if (analysis.file.includes('database') || analysis.file.includes('migration'))
+        risk += 0.15;
+    if (analysis.file.includes('api') || analysis.file.includes('endpoint'))
+        risk += 0.1;
+    // Pattern risk (deletions of error handling, etc.)
+    for (const hunk of analysis.hunks) {
+        for (const del of hunk.deletions) {
+            if (/\bcatch\b|\berror\b|\bvalidat/.test(del))
+                risk += 0.1;
+            if (/\bif\b.*\bnull\b|\bundefined\b/.test(del))
+                risk += 0.05;
+        }
+    }
+    return Math.min(1, risk);
+}
+/**
+ * Analyze a single file diff
+ */
+async function analyzeFileDiff(file, diff, message = '') {
+    const hunks = parseDiff(diff).filter(h => h.file === file || h.file === '');
+    const totalAdditions = hunks.reduce((sum, h) => sum + h.additions.length, 0);
+    const totalDeletions = hunks.reduce((sum, h) => sum + h.deletions.length, 0);
+    // Calculate complexity (branch keywords in additions)
+    let complexity = 0;
+    for (const hunk of hunks) {
+        for (const add of hunk.additions) {
+            if (/\bif\b|\belse\b|\bfor\b|\bwhile\b|\bswitch\b|\bcatch\b|\?/.test(add)) {
+                complexity++;
+            }
+        }
+    }
+    const category = classifyChange(diff, message);
+    const analysis = {
+        file,
+        hunks,
+        totalAdditions,
+        totalDeletions,
+        complexity,
+        riskScore: 0,
+        category,
+    };
+    analysis.riskScore = calculateRiskScore(analysis);
+    // Generate embedding for the diff
+    if ((0, onnx_embedder_1.isReady)()) {
+        const diffText = hunks.map(h => h.content).join('\n');
+        const result = await (0, onnx_embedder_1.embed)(`${category} change in ${file}: ${diffText.substring(0, 500)}`);
+        analysis.embedding = result.embedding;
+    }
+    return analysis;
+}
+/**
+ * Get diff for a commit
+ */
+function getCommitDiff(commitHash = 'HEAD') {
+    try {
+        return (0, child_process_1.execSync)(`git show ${commitHash} --format="" 2>/dev/null`, {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Get diff for staged changes
+ */
+function getStagedDiff() {
+    try {
+        return (0, child_process_1.execSync)('git diff --cached 2>/dev/null', {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Get diff for unstaged changes
+ */
+function getUnstagedDiff() {
+    try {
+        return (0, child_process_1.execSync)('git diff 2>/dev/null', {
+            encoding: 'utf8',
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Analyze a commit
+ */
+async function analyzeCommit(commitHash = 'HEAD') {
+    const diff = getCommitDiff(commitHash);
+    // Get commit metadata
+    let message = '', author = '', date = '';
+    try {
+        const info = (0, child_process_1.execSync)(`git log -1 --format="%s|%an|%aI" ${commitHash} 2>/dev/null`, {
+            encoding: 'utf8',
+        }).trim();
+        [message, author, date] = info.split('|');
+    }
+    catch { }
+    // Parse hunks and group by file
+    const hunks = parseDiff(diff);
+    const fileHunks = new Map();
+    for (const hunk of hunks) {
+        if (!fileHunks.has(hunk.file)) {
+            fileHunks.set(hunk.file, []);
+        }
+        fileHunks.get(hunk.file).push(hunk);
+    }
+    // Analyze each file
+    const files = [];
+    for (const [file, fileHunkList] of fileHunks) {
+        const fileDiff = fileHunkList.map(h => h.content).join('\n');
+        const analysis = await analyzeFileDiff(file, diff, message);
+        files.push(analysis);
+    }
+    const totalAdditions = files.reduce((sum, f) => sum + f.totalAdditions, 0);
+    const totalDeletions = files.reduce((sum, f) => sum + f.totalDeletions, 0);
+    const riskScore = files.length > 0
+        ? files.reduce((sum, f) => sum + f.riskScore, 0) / files.length
+        : 0;
+    // Generate commit embedding
+    let embedding;
+    if ((0, onnx_embedder_1.isReady)()) {
+        const commitText = `${message}\n\nFiles changed: ${files.map(f => f.file).join(', ')}\n+${totalAdditions} -${totalDeletions}`;
+        const result = await (0, onnx_embedder_1.embed)(commitText);
+        embedding = result.embedding;
+    }
+    return {
+        hash: commitHash,
+        message,
+        author,
+        date,
+        files,
+        totalAdditions,
+        totalDeletions,
+        riskScore,
+        embedding,
+    };
+}
+/**
+ * Find similar past commits based on diff embeddings
+ */
+async function findSimilarCommits(currentDiff, recentCommits = 50, topK = 5) {
+    if (!(0, onnx_embedder_1.isReady)()) {
+        await (0, onnx_embedder_1.initOnnxEmbedder)();
+    }
+    // Get current diff embedding
+    const currentEmbedding = (await (0, onnx_embedder_1.embed)(currentDiff.substring(0, 1000))).embedding;
+    // Get recent commits
+    let commits = [];
+    try {
+        commits = (0, child_process_1.execSync)(`git log -${recentCommits} --format="%H" 2>/dev/null`, {
+            encoding: 'utf8',
+        }).trim().split('\n');
+    }
+    catch {
+        return [];
+    }
+    // Analyze and compare
+    const results = [];
+    for (const hash of commits.slice(0, Math.min(commits.length, recentCommits))) {
+        const analysis = await analyzeCommit(hash);
+        if (analysis.embedding) {
+            const similarity = cosineSimilarity(currentEmbedding, analysis.embedding);
+            results.push({ hash, similarity, message: analysis.message });
+        }
+    }
+    return results
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, topK);
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+exports.default = {
+    parseDiff,
+    classifyChange,
+    calculateRiskScore,
+    analyzeFileDiff,
+    analyzeCommit,
+    getCommitDiff,
+    getStagedDiff,
+    getUnstagedDiff,
+    findSimilarCommits,
+};

dist/core/gnn-wrapper.d.ts

@@ -0,0 +1,143 @@
+/**
+ * GNN Wrapper - Safe wrapper around @ruvector/gnn with automatic array conversion
+ *
+ * This wrapper handles the array type conversion automatically, allowing users
+ * to pass either regular arrays or Float32Arrays.
+ *
+ * The native @ruvector/gnn requires Float32Array for maximum performance.
+ * This wrapper converts any input type to Float32Array automatically.
+ *
+ * Performance Tips:
+ * - Pass Float32Array directly for zero-copy performance
+ * - Use toFloat32Array/toFloat32ArrayBatch for pre-conversion
+ * - Avoid repeated conversions in hot paths
+ */
+/**
+ * Convert any array-like input to Float32Array (native requires Float32Array)
+ * Optimized paths:
+ * - Float32Array: zero-copy return
+ * - Float64Array: efficient typed array copy
+ * - Array: direct Float32Array construction
+ */
+export declare function toFloat32Array(input: number[] | Float32Array | Float64Array): Float32Array;
+/**
+ * Convert array of arrays to array of Float32Arrays
+ */
+export declare function toFloat32ArrayBatch(input: (number[] | Float32Array | Float64Array)[]): Float32Array[];
+/**
+ * Search result from differentiable search
+ */
+export interface DifferentiableSearchResult {
+    /** Indices of top-k candidates */
+    indices: number[];
+    /** Soft weights for top-k candidates */
+    weights: number[];
+}
+/**
+ * Differentiable search using soft attention mechanism
+ *
+ * This wrapper automatically converts Float32Array inputs to regular arrays.
+ *
+ * @param query - Query vector (array or Float32Array)
+ * @param candidates - List of candidate vectors (arrays or Float32Arrays)
+ * @param k - Number of top results to return
+ * @param temperature - Temperature for softmax (lower = sharper, higher = smoother)
+ * @returns Search result with indices and soft weights
+ *
+ * @example
+ * ```typescript
+ * import { differentiableSearch } from 'ruvector/core/gnn-wrapper';
+ *
+ * // Works with regular arrays (auto-converted to Float32Array)
+ * const result1 = differentiableSearch([1, 0, 0], [[1, 0, 0], [0, 1, 0]], 2, 1.0);
+ *
+ * // For best performance, use Float32Array directly (zero-copy)
+ * const query = new Float32Array([1, 0, 0]);
+ * const candidates = [new Float32Array([1, 0, 0]), new Float32Array([0, 1, 0])];
+ * const result2 = differentiableSearch(query, candidates, 2, 1.0);
+ * ```
+ */
+export declare function differentiableSearch(query: number[] | Float32Array | Float64Array, candidates: (number[] | Float32Array | Float64Array)[], k: number, temperature?: number): DifferentiableSearchResult;
+/**
+ * GNN Layer for HNSW topology
+ */
+export declare class RuvectorLayer {
+    private inner;
+    /**
+     * Create a new Ruvector GNN layer
+     *
+     * @param inputDim - Dimension of input node embeddings
+     * @param hiddenDim - Dimension of hidden representations
+     * @param heads - Number of attention heads
+     * @param dropout - Dropout rate (0.0 to 1.0)
+     */
+    constructor(inputDim: number, hiddenDim: number, heads: number, dropout?: number);
+    /**
+     * Forward pass through the GNN layer
+     *
+     * @param nodeEmbedding - Current node's embedding
+     * @param neighborEmbeddings - Embeddings of neighbor nodes
+     * @param edgeWeights - Weights of edges to neighbors
+     * @returns Updated node embedding as Float32Array
+     */
+    forward(nodeEmbedding: number[] | Float32Array, neighborEmbeddings: (number[] | Float32Array)[], edgeWeights: number[] | Float32Array): Float32Array;
+    /**
+     * Serialize the layer to JSON
+     */
+    toJson(): string;
+    /**
+     * Deserialize the layer from JSON
+     */
+    static fromJson(json: string): RuvectorLayer;
+}
+/**
+ * Tensor compressor with adaptive level selection
+ */
+export declare class TensorCompress {
+    private inner;
+    constructor();
+    /**
+     * Compress an embedding based on access frequency
+     *
+     * @param embedding - Input embedding vector
+     * @param accessFreq - Access frequency (0.0 to 1.0)
+     * @returns Compressed tensor as JSON string
+     */
+    compress(embedding: number[] | Float32Array, accessFreq: number): string;
+    /**
+     * Decompress a compressed tensor
+     *
+     * @param compressedJson - Compressed tensor JSON
+     * @returns Decompressed embedding
+     */
+    decompress(compressedJson: string): number[];
+}
+/**
+ * Hierarchical forward pass through GNN layers
+ *
+ * @param query - Query vector
+ * @param layerEmbeddings - Embeddings organized by layer
+ * @param gnnLayersJson - JSON array of serialized GNN layers
+ * @returns Final embedding after hierarchical processing as Float32Array
+ */
+export declare function hierarchicalForward(query: number[] | Float32Array, layerEmbeddings: (number[] | Float32Array)[][], gnnLayersJson: string[]): Float32Array;
+/**
+ * Get compression level for a given access frequency
+ */
+export declare function getCompressionLevel(accessFreq: number): string;
+/**
+ * Check if GNN module is available
+ */
+export declare function isGnnAvailable(): boolean;
+declare const _default: {
+    differentiableSearch: typeof differentiableSearch;
+    RuvectorLayer: typeof RuvectorLayer;
+    TensorCompress: typeof TensorCompress;
+    hierarchicalForward: typeof hierarchicalForward;
+    getCompressionLevel: typeof getCompressionLevel;
+    isGnnAvailable: typeof isGnnAvailable;
+    toFloat32Array: typeof toFloat32Array;
+    toFloat32ArrayBatch: typeof toFloat32ArrayBatch;
+};
+export default _default;
+//# sourceMappingURL=gnn-wrapper.d.ts.map

dist/core/gnn-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gnn-wrapper.d.ts","sourceRoot":"","sources":["../../src/core/gnn-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAsBH;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,CAK1F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,GAAG,YAAY,GAAG,YAAY,CAAC,EAAE,GAAG,YAAY,EAAE,CAMrG;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,kCAAkC;IAClC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,wCAAwC;IACxC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,GAAG,YAAY,EAC7C,UAAU,EAAE,CAAC,MAAM,EAAE,GAAG,YAAY,GAAG,YAAY,CAAC,EAAE,EACtD,CAAC,EAAE,MAAM,EACT,WAAW,GAAE,MAAY,GACxB,0BAA0B,CAQ5B;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAM;IAEnB;;;;;;;OAOG;gBACS,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,MAAY;IAKrF;;;;;;;OAOG;IACH,OAAO,CACL,aAAa,EAAE,MAAM,EAAE,GAAG,YAAY,EACtC,kBAAkB,EAAE,CAAC,MAAM,EAAE,GAAG,YAAY,CAAC,EAAE,EAC/C,WAAW,EAAE,MAAM,EAAE,GAAG,YAAY,GACnC,YAAY;IAQf;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa;CAM7C;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAM;;IAOnB;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAIxE;;;;;OAKG;IACH,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE;CAG7C;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,EAC9B,eAAe,EAAE,CAAC,MAAM,EAAE,GAAG,YAAY,CAAC,EAAE,EAAE,EAC9C,aAAa,EAAE,MAAM,EAAE,GACtB,YAAY,CAOd;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAOxC;;;;;;;;;;;AAED,wBAUE"}

dist/core/gnn-wrapper.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * GNN Wrapper - Safe wrapper around @ruvector/gnn with automatic array conversion
+ *
+ * This wrapper handles the array type conversion automatically, allowing users
+ * to pass either regular arrays or Float32Arrays.
+ *
+ * The native @ruvector/gnn requires Float32Array for maximum performance.
+ * This wrapper converts any input type to Float32Array automatically.
+ *
+ * Performance Tips:
+ * - Pass Float32Array directly for zero-copy performance
+ * - Use toFloat32Array/toFloat32ArrayBatch for pre-conversion
+ * - Avoid repeated conversions in hot paths
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TensorCompress = exports.RuvectorLayer = void 0;
+exports.toFloat32Array = toFloat32Array;
+exports.toFloat32ArrayBatch = toFloat32ArrayBatch;
+exports.differentiableSearch = differentiableSearch;
+exports.hierarchicalForward = hierarchicalForward;
+exports.getCompressionLevel = getCompressionLevel;
+exports.isGnnAvailable = isGnnAvailable;
+// Lazy load to avoid import errors if not installed
+let gnnModule = null;
+let loadError = null;
+function getGnnModule() {
+    if (gnnModule)
+        return gnnModule;
+    if (loadError)
+        throw loadError;
+    try {
+        gnnModule = require('@ruvector/gnn');
+        return gnnModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/gnn is not installed or failed to load: ${e.message}\n` +
+            `Install with: npm install @ruvector/gnn`);
+        throw loadError;
+    }
+}
+/**
+ * Convert any array-like input to Float32Array (native requires Float32Array)
+ * Optimized paths:
+ * - Float32Array: zero-copy return
+ * - Float64Array: efficient typed array copy
+ * - Array: direct Float32Array construction
+ */
+function toFloat32Array(input) {
+    if (input instanceof Float32Array)
+        return input;
+    if (input instanceof Float64Array)
+        return new Float32Array(input);
+    if (Array.isArray(input))
+        return new Float32Array(input);
+    return new Float32Array(Array.from(input));
+}
+/**
+ * Convert array of arrays to array of Float32Arrays
+ */
+function toFloat32ArrayBatch(input) {
+    const result = new Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+        result[i] = toFloat32Array(input[i]);
+    }
+    return result;
+}
+/**
+ * Differentiable search using soft attention mechanism
+ *
+ * This wrapper automatically converts Float32Array inputs to regular arrays.
+ *
+ * @param query - Query vector (array or Float32Array)
+ * @param candidates - List of candidate vectors (arrays or Float32Arrays)
+ * @param k - Number of top results to return
+ * @param temperature - Temperature for softmax (lower = sharper, higher = smoother)
+ * @returns Search result with indices and soft weights
+ *
+ * @example
+ * ```typescript
+ * import { differentiableSearch } from 'ruvector/core/gnn-wrapper';
+ *
+ * // Works with regular arrays (auto-converted to Float32Array)
+ * const result1 = differentiableSearch([1, 0, 0], [[1, 0, 0], [0, 1, 0]], 2, 1.0);
+ *
+ * // For best performance, use Float32Array directly (zero-copy)
+ * const query = new Float32Array([1, 0, 0]);
+ * const candidates = [new Float32Array([1, 0, 0]), new Float32Array([0, 1, 0])];
+ * const result2 = differentiableSearch(query, candidates, 2, 1.0);
+ * ```
+ */
+function differentiableSearch(query, candidates, k, temperature = 1.0) {
+    const gnn = getGnnModule();
+    // Convert to Float32Array (native Rust expects Float32Array for performance)
+    const queryFloat32 = toFloat32Array(query);
+    const candidatesFloat32 = toFloat32ArrayBatch(candidates);
+    return gnn.differentiableSearch(queryFloat32, candidatesFloat32, k, temperature);
+}
+/**
+ * GNN Layer for HNSW topology
+ */
+class RuvectorLayer {
+    /**
+     * Create a new Ruvector GNN layer
+     *
+     * @param inputDim - Dimension of input node embeddings
+     * @param hiddenDim - Dimension of hidden representations
+     * @param heads - Number of attention heads
+     * @param dropout - Dropout rate (0.0 to 1.0)
+     */
+    constructor(inputDim, hiddenDim, heads, dropout = 0.1) {
+        const gnn = getGnnModule();
+        this.inner = new gnn.RuvectorLayer(inputDim, hiddenDim, heads, dropout);
+    }
+    /**
+     * Forward pass through the GNN layer
+     *
+     * @param nodeEmbedding - Current node's embedding
+     * @param neighborEmbeddings - Embeddings of neighbor nodes
+     * @param edgeWeights - Weights of edges to neighbors
+     * @returns Updated node embedding as Float32Array
+     */
+    forward(nodeEmbedding, neighborEmbeddings, edgeWeights) {
+        return this.inner.forward(toFloat32Array(nodeEmbedding), toFloat32ArrayBatch(neighborEmbeddings), toFloat32Array(edgeWeights));
+    }
+    /**
+     * Serialize the layer to JSON
+     */
+    toJson() {
+        return this.inner.toJson();
+    }
+    /**
+     * Deserialize the layer from JSON
+     */
+    static fromJson(json) {
+        const gnn = getGnnModule();
+        const layer = new RuvectorLayer(1, 1, 1, 0); // Dummy constructor
+        layer.inner = gnn.RuvectorLayer.fromJson(json);
+        return layer;
+    }
+}
+exports.RuvectorLayer = RuvectorLayer;
+/**
+ * Tensor compressor with adaptive level selection
+ */
+class TensorCompress {
+    constructor() {
+        const gnn = getGnnModule();
+        this.inner = new gnn.TensorCompress();
+    }
+    /**
+     * Compress an embedding based on access frequency
+     *
+     * @param embedding - Input embedding vector
+     * @param accessFreq - Access frequency (0.0 to 1.0)
+     * @returns Compressed tensor as JSON string
+     */
+    compress(embedding, accessFreq) {
+        return this.inner.compress(toFloat32Array(embedding), accessFreq);
+    }
+    /**
+     * Decompress a compressed tensor
+     *
+     * @param compressedJson - Compressed tensor JSON
+     * @returns Decompressed embedding
+     */
+    decompress(compressedJson) {
+        return this.inner.decompress(compressedJson);
+    }
+}
+exports.TensorCompress = TensorCompress;
+/**
+ * Hierarchical forward pass through GNN layers
+ *
+ * @param query - Query vector
+ * @param layerEmbeddings - Embeddings organized by layer
+ * @param gnnLayersJson - JSON array of serialized GNN layers
+ * @returns Final embedding after hierarchical processing as Float32Array
+ */
+function hierarchicalForward(query, layerEmbeddings, gnnLayersJson) {
+    const gnn = getGnnModule();
+    return gnn.hierarchicalForward(toFloat32Array(query), layerEmbeddings.map(layer => toFloat32ArrayBatch(layer)), gnnLayersJson);
+}
+/**
+ * Get compression level for a given access frequency
+ */
+function getCompressionLevel(accessFreq) {
+    const gnn = getGnnModule();
+    return gnn.getCompressionLevel(accessFreq);
+}
+/**
+ * Check if GNN module is available
+ */
+function isGnnAvailable() {
+    try {
+        getGnnModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.default = {
+    differentiableSearch,
+    RuvectorLayer,
+    TensorCompress,
+    hierarchicalForward,
+    getCompressionLevel,
+    isGnnAvailable,
+    // Export conversion helpers for performance optimization
+    toFloat32Array,
+    toFloat32ArrayBatch,
+};

dist/core/graph-algorithms.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Graph Algorithms - MinCut, Spectral Clustering, Community Detection
+ *
+ * Provides graph partitioning and clustering algorithms for:
+ * - Code module detection
+ * - Dependency clustering
+ * - Architecture analysis
+ * - Refactoring suggestions
+ */
+export interface Graph {
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+        weight?: number;
+    }>;
+    adjacency: Map<string, Map<string, number>>;
+}
+export interface Partition {
+    groups: string[][];
+    cutWeight: number;
+    modularity: number;
+}
+export interface SpectralResult {
+    clusters: Map<string, number>;
+    eigenvalues: number[];
+    coordinates: Map<string, number[]>;
+}
+/**
+ * Build adjacency representation from edges
+ */
+export declare function buildGraph(nodes: string[], edges: Array<{
+    from: string;
+    to: string;
+    weight?: number;
+}>): Graph;
+/**
+ * Minimum Cut (Stoer-Wagner algorithm)
+ *
+ * Finds the minimum weight cut that partitions the graph into two parts.
+ * Useful for finding loosely coupled module boundaries.
+ */
+export declare function minCut(graph: Graph): Partition;
+/**
+ * Spectral Clustering (using power iteration)
+ *
+ * Uses graph Laplacian eigenvectors for clustering.
+ * Good for finding natural clusters in code dependencies.
+ */
+export declare function spectralClustering(graph: Graph, k?: number): SpectralResult;
+/**
+ * Louvain Community Detection
+ *
+ * Greedy modularity optimization for finding communities.
+ * Good for detecting natural module boundaries.
+ */
+export declare function louvainCommunities(graph: Graph): Map<string, number>;
+/**
+ * Calculate modularity of a partition
+ */
+export declare function calculateModularity(graph: Graph, partition: string[][]): number;
+/**
+ * Find bridges (edges whose removal disconnects components)
+ */
+export declare function findBridges(graph: Graph): Array<{
+    from: string;
+    to: string;
+}>;
+/**
+ * Find articulation points (nodes whose removal disconnects components)
+ */
+export declare function findArticulationPoints(graph: Graph): string[];
+declare const _default: {
+    buildGraph: typeof buildGraph;
+    minCut: typeof minCut;
+    spectralClustering: typeof spectralClustering;
+    louvainCommunities: typeof louvainCommunities;
+    calculateModularity: typeof calculateModularity;
+    findBridges: typeof findBridges;
+    findArticulationPoints: typeof findArticulationPoints;
+};
+export default _default;
+//# sourceMappingURL=graph-algorithms.d.ts.map

dist/core/graph-algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-algorithms.d.ts","sourceRoot":"","sources":["../../src/core/graph-algorithms.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5D,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAC1D,KAAK,CAiBP;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAwG9C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,GAAE,MAAU,GAAG,cAAc,CA0G9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAiGpE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAgC/E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAsC7E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CA+C7D;;;;;;;;;;AA+FD,wBAQE"}

dist/core/graph-algorithms.js

@@ -0,0 +1,514 @@
+"use strict";
+/**
+ * Graph Algorithms - MinCut, Spectral Clustering, Community Detection
+ *
+ * Provides graph partitioning and clustering algorithms for:
+ * - Code module detection
+ * - Dependency clustering
+ * - Architecture analysis
+ * - Refactoring suggestions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraph = buildGraph;
+exports.minCut = minCut;
+exports.spectralClustering = spectralClustering;
+exports.louvainCommunities = louvainCommunities;
+exports.calculateModularity = calculateModularity;
+exports.findBridges = findBridges;
+exports.findArticulationPoints = findArticulationPoints;
+/**
+ * Build adjacency representation from edges
+ */
+function buildGraph(nodes, edges) {
+    const adjacency = new Map();
+    for (const node of nodes) {
+        adjacency.set(node, new Map());
+    }
+    for (const { from, to, weight = 1 } of edges) {
+        if (!adjacency.has(from))
+            adjacency.set(from, new Map());
+        if (!adjacency.has(to))
+            adjacency.set(to, new Map());
+        // Undirected graph - add both directions
+        adjacency.get(from).set(to, weight);
+        adjacency.get(to).set(from, weight);
+    }
+    return { nodes, edges, adjacency };
+}
+/**
+ * Minimum Cut (Stoer-Wagner algorithm)
+ *
+ * Finds the minimum weight cut that partitions the graph into two parts.
+ * Useful for finding loosely coupled module boundaries.
+ */
+function minCut(graph) {
+    const n = graph.nodes.length;
+    if (n < 2) {
+        return { groups: [graph.nodes], cutWeight: 0, modularity: 0 };
+    }
+    // Copy adjacency for modification
+    const adj = new Map();
+    for (const [node, neighbors] of graph.adjacency) {
+        adj.set(node, new Map(neighbors));
+    }
+    let minCutWeight = Infinity;
+    let bestPartition = [];
+    const merged = new Map(); // Track merged nodes
+    for (const node of graph.nodes) {
+        merged.set(node, [node]);
+    }
+    let remaining = [...graph.nodes];
+    // Stoer-Wagner phases
+    while (remaining.length > 1) {
+        // Maximum adjacency search
+        const inA = new Set([remaining[0]]);
+        const weights = new Map();
+        for (const node of remaining) {
+            if (!inA.has(node)) {
+                weights.set(node, adj.get(remaining[0])?.get(node) || 0);
+            }
+        }
+        let lastAdded = remaining[0];
+        let beforeLast = remaining[0];
+        while (inA.size < remaining.length) {
+            // Find node with maximum weight to A
+            let maxWeight = -Infinity;
+            let maxNode = '';
+            for (const [node, weight] of weights) {
+                if (!inA.has(node) && weight > maxWeight) {
+                    maxWeight = weight;
+                    maxNode = node;
+                }
+            }
+            if (!maxNode)
+                break;
+            beforeLast = lastAdded;
+            lastAdded = maxNode;
+            inA.add(maxNode);
+            // Update weights
+            for (const [neighbor, w] of adj.get(maxNode) || []) {
+                if (!inA.has(neighbor)) {
+                    weights.set(neighbor, (weights.get(neighbor) || 0) + w);
+                }
+            }
+        }
+        // Cut of the phase
+        const cutWeight = weights.get(lastAdded) || 0;
+        if (cutWeight < minCutWeight) {
+            minCutWeight = cutWeight;
+            const lastGroup = merged.get(lastAdded) || [lastAdded];
+            const otherNodes = remaining.filter(n => n !== lastAdded).flatMap(n => merged.get(n) || [n]);
+            bestPartition = [lastGroup, otherNodes];
+        }
+        // Merge last two nodes
+        if (remaining.length > 1) {
+            // Merge lastAdded into beforeLast
+            const mergedNodes = [...(merged.get(beforeLast) || []), ...(merged.get(lastAdded) || [])];
+            merged.set(beforeLast, mergedNodes);
+            // Update adjacency
+            for (const [neighbor, w] of adj.get(lastAdded) || []) {
+                if (neighbor !== beforeLast) {
+                    const current = adj.get(beforeLast)?.get(neighbor) || 0;
+                    adj.get(beforeLast)?.set(neighbor, current + w);
+                    adj.get(neighbor)?.set(beforeLast, current + w);
+                }
+            }
+            // Remove lastAdded
+            remaining = remaining.filter(n => n !== lastAdded);
+            adj.delete(lastAdded);
+            for (const [, neighbors] of adj) {
+                neighbors.delete(lastAdded);
+            }
+        }
+    }
+    const modularity = calculateModularity(graph, bestPartition);
+    return {
+        groups: bestPartition.filter(g => g.length > 0),
+        cutWeight: minCutWeight,
+        modularity,
+    };
+}
+/**
+ * Spectral Clustering (using power iteration)
+ *
+ * Uses graph Laplacian eigenvectors for clustering.
+ * Good for finding natural clusters in code dependencies.
+ */
+function spectralClustering(graph, k = 2) {
+    const n = graph.nodes.length;
+    const nodeIndex = new Map(graph.nodes.map((node, i) => [node, i]));
+    const clusters = new Map();
+    if (n === 0) {
+        return { clusters, eigenvalues: [], coordinates: new Map() };
+    }
+    // Build Laplacian matrix (D - A)
+    const degree = new Float64Array(n);
+    const laplacian = Array(n).fill(null).map(() => Array(n).fill(0));
+    for (const [node, neighbors] of graph.adjacency) {
+        const i = nodeIndex.get(node);
+        let d = 0;
+        for (const [neighbor, weight] of neighbors) {
+            const j = nodeIndex.get(neighbor);
+            laplacian[i][j] = -weight;
+            d += weight;
+        }
+        degree[i] = d;
+        laplacian[i][i] = d;
+    }
+    // Normalized Laplacian: D^(-1/2) L D^(-1/2)
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            if (degree[i] > 0 && degree[j] > 0) {
+                laplacian[i][j] /= Math.sqrt(degree[i] * degree[j]);
+            }
+        }
+    }
+    // Power iteration to find eigenvectors
+    const eigenvectors = [];
+    const eigenvalues = [];
+    for (let ev = 0; ev < Math.min(k, n); ev++) {
+        let vector = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            vector[i] = Math.random();
+        }
+        normalize(vector);
+        // Deflation: orthogonalize against previous eigenvectors
+        for (const prev of eigenvectors) {
+            const dot = dotProduct(vector, new Float64Array(prev));
+            for (let i = 0; i < n; i++) {
+                vector[i] -= dot * prev[i];
+            }
+        }
+        normalize(vector);
+        // Power iteration
+        for (let iter = 0; iter < 100; iter++) {
+            const newVector = new Float64Array(n);
+            for (let i = 0; i < n; i++) {
+                for (let j = 0; j < n; j++) {
+                    newVector[i] += laplacian[i][j] * vector[j];
+                }
+            }
+            // Deflation
+            for (const prev of eigenvectors) {
+                const dot = dotProduct(newVector, new Float64Array(prev));
+                for (let i = 0; i < n; i++) {
+                    newVector[i] -= dot * prev[i];
+                }
+            }
+            normalize(newVector);
+            vector = newVector;
+        }
+        // Compute eigenvalue
+        let eigenvalue = 0;
+        for (let i = 0; i < n; i++) {
+            let sum = 0;
+            for (let j = 0; j < n; j++) {
+                sum += laplacian[i][j] * vector[j];
+            }
+            eigenvalue += vector[i] * sum;
+        }
+        eigenvectors.push(Array.from(vector));
+        eigenvalues.push(eigenvalue);
+    }
+    // K-means clustering on eigenvector coordinates
+    const coordinates = new Map();
+    for (let i = 0; i < n; i++) {
+        coordinates.set(graph.nodes[i], eigenvectors.map(ev => ev[i]));
+    }
+    // Simple k-means
+    const clusterAssignment = kMeans(graph.nodes.map(node => coordinates.get(node)), k);
+    for (let i = 0; i < n; i++) {
+        clusters.set(graph.nodes[i], clusterAssignment[i]);
+    }
+    return { clusters, eigenvalues, coordinates };
+}
+/**
+ * Louvain Community Detection
+ *
+ * Greedy modularity optimization for finding communities.
+ * Good for detecting natural module boundaries.
+ */
+function louvainCommunities(graph) {
+    const communities = new Map();
+    let communityId = 0;
+    // Initialize: each node in its own community
+    for (const node of graph.nodes) {
+        communities.set(node, communityId++);
+    }
+    // Total edge weight
+    let m = 0;
+    for (const { weight = 1 } of graph.edges) {
+        m += weight;
+    }
+    m /= 2; // Undirected
+    if (m === 0)
+        return communities;
+    // Node weights (sum of edge weights)
+    const nodeWeight = new Map();
+    for (const node of graph.nodes) {
+        let w = 0;
+        for (const [, weight] of graph.adjacency.get(node) || []) {
+            w += weight;
+        }
+        nodeWeight.set(node, w);
+    }
+    // Community weights
+    const communityWeight = new Map();
+    for (const node of graph.nodes) {
+        const c = communities.get(node);
+        communityWeight.set(c, (communityWeight.get(c) || 0) + (nodeWeight.get(node) || 0));
+    }
+    // Iterate until no improvement
+    let improved = true;
+    while (improved) {
+        improved = false;
+        for (const node of graph.nodes) {
+            const currentCommunity = communities.get(node);
+            const ki = nodeWeight.get(node) || 0;
+            // Calculate modularity gain for moving to neighbor communities
+            let bestCommunity = currentCommunity;
+            let bestGain = 0;
+            const neighborCommunities = new Set();
+            for (const [neighbor] of graph.adjacency.get(node) || []) {
+                neighborCommunities.add(communities.get(neighbor));
+            }
+            for (const targetCommunity of neighborCommunities) {
+                if (targetCommunity === currentCommunity)
+                    continue;
+                // Calculate edge weight to target community
+                let ki_in = 0;
+                for (const [neighbor, weight] of graph.adjacency.get(node) || []) {
+                    if (communities.get(neighbor) === targetCommunity) {
+                        ki_in += weight;
+                    }
+                }
+                const sumTot = communityWeight.get(targetCommunity) || 0;
+                const gain = ki_in / m - (ki * sumTot) / (2 * m * m);
+                if (gain > bestGain) {
+                    bestGain = gain;
+                    bestCommunity = targetCommunity;
+                }
+            }
+            // Move node if beneficial
+            if (bestCommunity !== currentCommunity) {
+                communities.set(node, bestCommunity);
+                // Update community weights
+                communityWeight.set(currentCommunity, (communityWeight.get(currentCommunity) || 0) - ki);
+                communityWeight.set(bestCommunity, (communityWeight.get(bestCommunity) || 0) + ki);
+                improved = true;
+            }
+        }
+    }
+    // Renumber communities to be contiguous
+    const renumber = new Map();
+    let newId = 0;
+    for (const [node, c] of communities) {
+        if (!renumber.has(c)) {
+            renumber.set(c, newId++);
+        }
+        communities.set(node, renumber.get(c));
+    }
+    return communities;
+}
+/**
+ * Calculate modularity of a partition
+ */
+function calculateModularity(graph, partition) {
+    let m = 0;
+    for (const { weight = 1 } of graph.edges) {
+        m += weight;
+    }
+    m /= 2;
+    if (m === 0)
+        return 0;
+    let modularity = 0;
+    for (const group of partition) {
+        const groupSet = new Set(group);
+        // Edges within group
+        let inGroup = 0;
+        let degreeSum = 0;
+        for (const node of group) {
+            for (const [neighbor, weight] of graph.adjacency.get(node) || []) {
+                if (groupSet.has(neighbor)) {
+                    inGroup += weight;
+                }
+                degreeSum += weight;
+            }
+        }
+        inGroup /= 2; // Count each edge once
+        modularity += inGroup / m - Math.pow(degreeSum / (2 * m), 2);
+    }
+    return modularity;
+}
+/**
+ * Find bridges (edges whose removal disconnects components)
+ */
+function findBridges(graph) {
+    const bridges = [];
+    const visited = new Set();
+    const discovery = new Map();
+    const low = new Map();
+    const parent = new Map();
+    let time = 0;
+    function dfs(node) {
+        visited.add(node);
+        discovery.set(node, time);
+        low.set(node, time);
+        time++;
+        for (const [neighbor] of graph.adjacency.get(node) || []) {
+            if (!visited.has(neighbor)) {
+                parent.set(neighbor, node);
+                dfs(neighbor);
+                low.set(node, Math.min(low.get(node), low.get(neighbor)));
+                if (low.get(neighbor) > discovery.get(node)) {
+                    bridges.push({ from: node, to: neighbor });
+                }
+            }
+            else if (neighbor !== parent.get(node)) {
+                low.set(node, Math.min(low.get(node), discovery.get(neighbor)));
+            }
+        }
+    }
+    for (const node of graph.nodes) {
+        if (!visited.has(node)) {
+            parent.set(node, null);
+            dfs(node);
+        }
+    }
+    return bridges;
+}
+/**
+ * Find articulation points (nodes whose removal disconnects components)
+ */
+function findArticulationPoints(graph) {
+    const points = [];
+    const visited = new Set();
+    const discovery = new Map();
+    const low = new Map();
+    const parent = new Map();
+    let time = 0;
+    function dfs(node) {
+        visited.add(node);
+        discovery.set(node, time);
+        low.set(node, time);
+        time++;
+        let children = 0;
+        for (const [neighbor] of graph.adjacency.get(node) || []) {
+            if (!visited.has(neighbor)) {
+                children++;
+                parent.set(neighbor, node);
+                dfs(neighbor);
+                low.set(node, Math.min(low.get(node), low.get(neighbor)));
+                // Root with 2+ children or non-root with low[v] >= disc[u]
+                if ((parent.get(node) === null && children > 1) ||
+                    (parent.get(node) !== null && low.get(neighbor) >= discovery.get(node))) {
+                    if (!points.includes(node)) {
+                        points.push(node);
+                    }
+                }
+            }
+            else if (neighbor !== parent.get(node)) {
+                low.set(node, Math.min(low.get(node), discovery.get(neighbor)));
+            }
+        }
+    }
+    for (const node of graph.nodes) {
+        if (!visited.has(node)) {
+            parent.set(node, null);
+            dfs(node);
+        }
+    }
+    return points;
+}
+// Helper functions
+function normalize(v) {
+    let sum = 0;
+    for (let i = 0; i < v.length; i++) {
+        sum += v[i] * v[i];
+    }
+    const norm = Math.sqrt(sum);
+    if (norm > 0) {
+        for (let i = 0; i < v.length; i++) {
+            v[i] /= norm;
+        }
+    }
+}
+function dotProduct(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        sum += a[i] * b[i];
+    }
+    return sum;
+}
+function kMeans(points, k, maxIter = 100) {
+    const n = points.length;
+    if (n === 0 || k === 0)
+        return [];
+    const dim = points[0].length;
+    // Random initialization
+    const centroids = [];
+    const used = new Set();
+    while (centroids.length < Math.min(k, n)) {
+        const idx = Math.floor(Math.random() * n);
+        if (!used.has(idx)) {
+            used.add(idx);
+            centroids.push([...points[idx]]);
+        }
+    }
+    const assignment = new Array(n).fill(0);
+    for (let iter = 0; iter < maxIter; iter++) {
+        // Assign points to nearest centroid
+        let changed = false;
+        for (let i = 0; i < n; i++) {
+            let minDist = Infinity;
+            let minC = 0;
+            for (let c = 0; c < centroids.length; c++) {
+                let dist = 0;
+                for (let d = 0; d < dim; d++) {
+                    dist += Math.pow(points[i][d] - centroids[c][d], 2);
+                }
+                if (dist < minDist) {
+                    minDist = dist;
+                    minC = c;
+                }
+            }
+            if (assignment[i] !== minC) {
+                assignment[i] = minC;
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+        // Update centroids
+        const counts = new Array(k).fill(0);
+        for (let c = 0; c < centroids.length; c++) {
+            for (let d = 0; d < dim; d++) {
+                centroids[c][d] = 0;
+            }
+        }
+        for (let i = 0; i < n; i++) {
+            const c = assignment[i];
+            counts[c]++;
+            for (let d = 0; d < dim; d++) {
+                centroids[c][d] += points[i][d];
+            }
+        }
+        for (let c = 0; c < centroids.length; c++) {
+            if (counts[c] > 0) {
+                for (let d = 0; d < dim; d++) {
+                    centroids[c][d] /= counts[c];
+                }
+            }
+        }
+    }
+    return assignment;
+}
+exports.default = {
+    buildGraph,
+    minCut,
+    spectralClustering,
+    louvainCommunities,
+    calculateModularity,
+    findBridges,
+    findArticulationPoints,
+};

dist/core/graph-wrapper.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Graph Wrapper - Hypergraph database for code relationships
+ *
+ * Wraps @ruvector/graph-node for dependency analysis, co-edit patterns,
+ * and code structure understanding.
+ */
+export declare function isGraphAvailable(): boolean;
+export interface Node {
+    id: string;
+    labels: string[];
+    properties: Record<string, any>;
+}
+export interface Edge {
+    id?: string;
+    from: string;
+    to: string;
+    type: string;
+    properties?: Record<string, any>;
+}
+export interface Hyperedge {
+    id?: string;
+    nodes: string[];
+    type: string;
+    properties?: Record<string, any>;
+}
+export interface CypherResult {
+    columns: string[];
+    rows: any[][];
+}
+export interface PathResult {
+    nodes: Node[];
+    edges: Edge[];
+    length: number;
+}
+/**
+ * Graph Database for code relationships
+ */
+export declare class CodeGraph {
+    private inner;
+    private storagePath?;
+    constructor(options?: {
+        storagePath?: string;
+        inMemory?: boolean;
+    });
+    /**
+     * Create a node (file, function, class, etc.)
+     */
+    createNode(id: string, labels: string[], properties?: Record<string, any>): Node;
+    /**
+     * Get a node by ID
+     */
+    getNode(id: string): Node | null;
+    /**
+     * Update node properties
+     */
+    updateNode(id: string, properties: Record<string, any>): boolean;
+    /**
+     * Delete a node
+     */
+    deleteNode(id: string): boolean;
+    /**
+     * Find nodes by label
+     */
+    findNodesByLabel(label: string): Node[];
+    /**
+     * Create an edge (import, call, reference, etc.)
+     */
+    createEdge(from: string, to: string, type: string, properties?: Record<string, any>): Edge;
+    /**
+     * Get edges from a node
+     */
+    getOutgoingEdges(nodeId: string, type?: string): Edge[];
+    /**
+     * Get edges to a node
+     */
+    getIncomingEdges(nodeId: string, type?: string): Edge[];
+    /**
+     * Delete an edge
+     */
+    deleteEdge(edgeId: string): boolean;
+    /**
+     * Create a hyperedge connecting multiple nodes
+     */
+    createHyperedge(nodes: string[], type: string, properties?: Record<string, any>): Hyperedge;
+    /**
+     * Get hyperedges containing a node
+     */
+    getHyperedges(nodeId: string, type?: string): Hyperedge[];
+    /**
+     * Execute a Cypher query
+     */
+    cypher(query: string, params?: Record<string, any>): CypherResult;
+    /**
+     * Find shortest path between nodes
+     */
+    shortestPath(from: string, to: string, maxDepth?: number): PathResult | null;
+    /**
+     * Get all paths between nodes (up to maxPaths)
+     */
+    allPaths(from: string, to: string, maxDepth?: number, maxPaths?: number): PathResult[];
+    /**
+     * Get neighbors of a node
+     */
+    neighbors(nodeId: string, depth?: number): Node[];
+    /**
+     * Calculate PageRank for nodes
+     */
+    pageRank(iterations?: number, dampingFactor?: number): Map<string, number>;
+    /**
+     * Find connected components
+     */
+    connectedComponents(): string[][];
+    /**
+     * Detect communities (Louvain algorithm)
+     */
+    communities(): Map<string, number>;
+    /**
+     * Calculate betweenness centrality
+     */
+    betweennessCentrality(): Map<string, number>;
+    /**
+     * Save graph to storage
+     */
+    save(): void;
+    /**
+     * Load graph from storage
+     */
+    load(): void;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    /**
+     * Get graph statistics
+     */
+    stats(): {
+        nodes: number;
+        edges: number;
+        hyperedges: number;
+    };
+}
+/**
+ * Create a code dependency graph from file analysis
+ */
+export declare function createCodeDependencyGraph(storagePath?: string): CodeGraph;
+export default CodeGraph;
+//# sourceMappingURL=graph-wrapper.d.ts.map

dist/core/graph-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-wrapper.d.ts","sourceRoot":"","sources":["../../src/core/graph-wrapper.ts"],"names":[],"mappings":"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"}

dist/core/graph-wrapper.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * Graph Wrapper - Hypergraph database for code relationships
+ *
+ * Wraps @ruvector/graph-node for dependency analysis, co-edit patterns,
+ * and code structure understanding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGraph = void 0;
+exports.isGraphAvailable = isGraphAvailable;
+exports.createCodeDependencyGraph = createCodeDependencyGraph;
+let graphModule = null;
+let loadError = null;
+function getGraphModule() {
+    if (graphModule)
+        return graphModule;
+    if (loadError)
+        throw loadError;
+    try {
+        graphModule = require('@ruvector/graph-node');
+        return graphModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/graph-node not installed: ${e.message}\n` +
+            `Install with: npm install @ruvector/graph-node`);
+        throw loadError;
+    }
+}
+function isGraphAvailable() {
+    try {
+        getGraphModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Graph Database for code relationships
+ */
+class CodeGraph {
+    constructor(options = {}) {
+        const graph = getGraphModule();
+        this.storagePath = options.storagePath;
+        this.inner = new graph.GraphDatabase({
+            storagePath: options.storagePath,
+            inMemory: options.inMemory ?? true,
+        });
+    }
+    // ===========================================================================
+    // Node Operations
+    // ===========================================================================
+    /**
+     * Create a node (file, function, class, etc.)
+     */
+    createNode(id, labels, properties = {}) {
+        this.inner.createNode(id, labels, JSON.stringify(properties));
+        return { id, labels, properties };
+    }
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        const result = this.inner.getNode(id);
+        if (!result)
+            return null;
+        return {
+            id: result.id,
+            labels: result.labels,
+            properties: result.properties ? JSON.parse(result.properties) : {},
+        };
+    }
+    /**
+     * Update node properties
+     */
+    updateNode(id, properties) {
+        return this.inner.updateNode(id, JSON.stringify(properties));
+    }
+    /**
+     * Delete a node
+     */
+    deleteNode(id) {
+        return this.inner.deleteNode(id);
+    }
+    /**
+     * Find nodes by label
+     */
+    findNodesByLabel(label) {
+        const results = this.inner.findNodesByLabel(label);
+        return results.map((r) => ({
+            id: r.id,
+            labels: r.labels,
+            properties: r.properties ? JSON.parse(r.properties) : {},
+        }));
+    }
+    // ===========================================================================
+    // Edge Operations
+    // ===========================================================================
+    /**
+     * Create an edge (import, call, reference, etc.)
+     */
+    createEdge(from, to, type, properties = {}) {
+        const id = this.inner.createEdge(from, to, type, JSON.stringify(properties));
+        return { id, from, to, type, properties };
+    }
+    /**
+     * Get edges from a node
+     */
+    getOutgoingEdges(nodeId, type) {
+        const results = this.inner.getOutgoingEdges(nodeId, type);
+        return results.map((r) => ({
+            id: r.id,
+            from: r.from,
+            to: r.to,
+            type: r.type,
+            properties: r.properties ? JSON.parse(r.properties) : {},
+        }));
+    }
+    /**
+     * Get edges to a node
+     */
+    getIncomingEdges(nodeId, type) {
+        const results = this.inner.getIncomingEdges(nodeId, type);
+        return results.map((r) => ({
+            id: r.id,
+            from: r.from,
+            to: r.to,
+            type: r.type,
+            properties: r.properties ? JSON.parse(r.properties) : {},
+        }));
+    }
+    /**
+     * Delete an edge
+     */
+    deleteEdge(edgeId) {
+        return this.inner.deleteEdge(edgeId);
+    }
+    // ===========================================================================
+    // Hyperedge Operations (for co-edit patterns)
+    // ===========================================================================
+    /**
+     * Create a hyperedge connecting multiple nodes
+     */
+    createHyperedge(nodes, type, properties = {}) {
+        const id = this.inner.createHyperedge(nodes, type, JSON.stringify(properties));
+        return { id, nodes, type, properties };
+    }
+    /**
+     * Get hyperedges containing a node
+     */
+    getHyperedges(nodeId, type) {
+        const results = this.inner.getHyperedges(nodeId, type);
+        return results.map((r) => ({
+            id: r.id,
+            nodes: r.nodes,
+            type: r.type,
+            properties: r.properties ? JSON.parse(r.properties) : {},
+        }));
+    }
+    // ===========================================================================
+    // Query Operations
+    // ===========================================================================
+    /**
+     * Execute a Cypher query
+     */
+    cypher(query, params = {}) {
+        const result = this.inner.cypher(query, JSON.stringify(params));
+        return {
+            columns: result.columns,
+            rows: result.rows,
+        };
+    }
+    /**
+     * Find shortest path between nodes
+     */
+    shortestPath(from, to, maxDepth = 10) {
+        const result = this.inner.shortestPath(from, to, maxDepth);
+        if (!result)
+            return null;
+        return {
+            nodes: result.nodes.map((n) => ({
+                id: n.id,
+                labels: n.labels,
+                properties: n.properties ? JSON.parse(n.properties) : {},
+            })),
+            edges: result.edges.map((e) => ({
+                id: e.id,
+                from: e.from,
+                to: e.to,
+                type: e.type,
+                properties: e.properties ? JSON.parse(e.properties) : {},
+            })),
+            length: result.length,
+        };
+    }
+    /**
+     * Get all paths between nodes (up to maxPaths)
+     */
+    allPaths(from, to, maxDepth = 5, maxPaths = 10) {
+        const results = this.inner.allPaths(from, to, maxDepth, maxPaths);
+        return results.map((r) => ({
+            nodes: r.nodes.map((n) => ({
+                id: n.id,
+                labels: n.labels,
+                properties: n.properties ? JSON.parse(n.properties) : {},
+            })),
+            edges: r.edges.map((e) => ({
+                id: e.id,
+                from: e.from,
+                to: e.to,
+                type: e.type,
+                properties: e.properties ? JSON.parse(e.properties) : {},
+            })),
+            length: r.length,
+        }));
+    }
+    /**
+     * Get neighbors of a node
+     */
+    neighbors(nodeId, depth = 1) {
+        const results = this.inner.neighbors(nodeId, depth);
+        return results.map((n) => ({
+            id: n.id,
+            labels: n.labels,
+            properties: n.properties ? JSON.parse(n.properties) : {},
+        }));
+    }
+    // ===========================================================================
+    // Graph Algorithms
+    // ===========================================================================
+    /**
+     * Calculate PageRank for nodes
+     */
+    pageRank(iterations = 20, dampingFactor = 0.85) {
+        const result = this.inner.pageRank(iterations, dampingFactor);
+        return new Map(Object.entries(result));
+    }
+    /**
+     * Find connected components
+     */
+    connectedComponents() {
+        return this.inner.connectedComponents();
+    }
+    /**
+     * Detect communities (Louvain algorithm)
+     */
+    communities() {
+        const result = this.inner.communities();
+        return new Map(Object.entries(result));
+    }
+    /**
+     * Calculate betweenness centrality
+     */
+    betweennessCentrality() {
+        const result = this.inner.betweennessCentrality();
+        return new Map(Object.entries(result));
+    }
+    // ===========================================================================
+    // Persistence
+    // ===========================================================================
+    /**
+     * Save graph to storage
+     */
+    save() {
+        if (!this.storagePath) {
+            throw new Error('No storage path configured');
+        }
+        this.inner.save();
+    }
+    /**
+     * Load graph from storage
+     */
+    load() {
+        if (!this.storagePath) {
+            throw new Error('No storage path configured');
+        }
+        this.inner.load();
+    }
+    /**
+     * Clear all data
+     */
+    clear() {
+        this.inner.clear();
+    }
+    /**
+     * Get graph statistics
+     */
+    stats() {
+        return this.inner.stats();
+    }
+}
+exports.CodeGraph = CodeGraph;
+/**
+ * Create a code dependency graph from file analysis
+ */
+function createCodeDependencyGraph(storagePath) {
+    return new CodeGraph({ storagePath, inMemory: !storagePath });
+}
+exports.default = CodeGraph;

dist/core/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Core module exports
+ *
+ * These wrappers provide safe, type-flexible interfaces to the underlying
+ * native packages, handling array type conversions automatically.
+ */
+export * from './gnn-wrapper';
+export * from './attention-fallbacks';
+export * from './agentdb-fast';
+export * from './sona-wrapper';
+export * from './intelligence-engine';
+export * from './onnx-embedder';
+export * from './onnx-optimized';
+export * from './parallel-intelligence';
+export * from './parallel-workers';
+export * from './router-wrapper';
+export * from './graph-wrapper';
+export * from './cluster-wrapper';
+export * from './ast-parser';
+export * from './diff-embeddings';
+export * from './coverage-router';
+export * from './graph-algorithms';
+export * from './tensor-compress';
+export * from './learning-engine';
+export * from './adaptive-embedder';
+export * from './neural-embeddings';
+export * from './neural-perf';
+export * from './rvf-wrapper';
+export * from '../analysis';
+export { default as gnnWrapper } from './gnn-wrapper';
+export { default as attentionFallbacks } from './attention-fallbacks';
+export { default as agentdbFast } from './agentdb-fast';
+export { default as Sona } from './sona-wrapper';
+export { default as IntelligenceEngine } from './intelligence-engine';
+export { default as OnnxEmbedder } from './onnx-embedder';
+export { default as OptimizedOnnxEmbedder } from './onnx-optimized';
+export { default as ParallelIntelligence } from './parallel-intelligence';
+export { default as ExtendedWorkerPool } from './parallel-workers';
+export { default as SemanticRouter } from './router-wrapper';
+export { default as CodeGraph } from './graph-wrapper';
+export { default as RuvectorCluster } from './cluster-wrapper';
+export { default as CodeParser } from './ast-parser';
+export { CodeParser as ASTParser } from './ast-parser';
+export { default as TensorCompress } from './tensor-compress';
+export { default as LearningEngine } from './learning-engine';
+export { default as AdaptiveEmbedder } from './adaptive-embedder';
+export { default as NeuralSubstrate } from './neural-embeddings';
+//# sourceMappingURL=index.d.ts.map