@ruvector/ruvllm 4.0.1 → 4.2.0

package/dist/esm/contrastive.js

@@ -0,0 +1,578 @@
+/**
+ * Contrastive Fine-tuning for RuvLTRA Claude Code Router
+ *
+ * Uses triplet loss to fine-tune embeddings:
+ * - Anchor: task description
+ * - Positive: correct agent description
+ * - Negative: wrong agent description (hard negative)
+ *
+ * Goal: minimize distance(anchor, positive) and maximize distance(anchor, negative)
+ *
+ * @example
+ * ```typescript
+ * import { ContrastiveTrainer, tripletLoss, infoNCELoss } from '@ruvector/ruvllm';
+ *
+ * const trainer = new ContrastiveTrainer({
+ *   epochs: 10,
+ *   batchSize: 16,
+ *   margin: 0.5,
+ * });
+ *
+ * // Add triplets
+ * trainer.addTriplet(anchorEmb, positiveEmb, negativeEmb, true);
+ *
+ * // Train and export
+ * const results = trainer.train();
+ * trainer.exportTrainingData('./output');
+ * ```
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * Default contrastive config
+ */
+const DEFAULT_CONTRASTIVE_CONFIG = {
+    epochs: 10,
+    batchSize: 16,
+    learningRate: 0.0001,
+    margin: 0.5,
+    temperature: 0.07,
+    hardNegativeRatio: 0.7,
+    outputPath: './training-output',
+};
+/**
+ * Compute cosine similarity between two embeddings
+ */
+export function cosineSimilarity(a, b) {
+    if (!a || !b || a.length !== b.length)
+        return 0;
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+}
+/**
+ * Compute triplet loss
+ * L = max(0, margin + d(anchor, positive) - d(anchor, negative))
+ */
+export function tripletLoss(anchorEmb, positiveEmb, negativeEmb, margin = 0.5) {
+    const posDist = 1 - cosineSimilarity(anchorEmb, positiveEmb);
+    const negDist = 1 - cosineSimilarity(anchorEmb, negativeEmb);
+    return Math.max(0, margin + posDist - negDist);
+}
+/**
+ * Compute InfoNCE loss (contrastive)
+ */
+export function infoNCELoss(anchorEmb, positiveEmb, negativeEmbs, temperature = 0.07) {
+    const posSim = cosineSimilarity(anchorEmb, positiveEmb) / temperature;
+    const negSims = negativeEmbs.map(neg => cosineSimilarity(anchorEmb, neg) / temperature);
+    // Softmax denominator
+    const maxSim = Math.max(posSim, ...negSims);
+    const expPos = Math.exp(posSim - maxSim);
+    const expNegs = negSims.map(sim => Math.exp(sim - maxSim));
+    const denominator = expPos + expNegs.reduce((a, b) => a + b, 0);
+    // Cross-entropy loss
+    return -Math.log(expPos / denominator);
+}
+/**
+ * Compute gradient for embedding update (simplified)
+ */
+export function computeGradient(anchorEmb, positiveEmb, negativeEmb, lr = 0.0001) {
+    const dim = anchorEmb.length;
+    const gradient = new Array(dim).fill(0);
+    // Pull anchor towards positive
+    for (let i = 0; i < dim; i++) {
+        gradient[i] += lr * (positiveEmb[i] - anchorEmb[i]);
+    }
+    // Push anchor away from negative
+    for (let i = 0; i < dim; i++) {
+        gradient[i] -= lr * 0.5 * (negativeEmb[i] - anchorEmb[i]);
+    }
+    return gradient;
+}
+/**
+ * Contrastive Trainer for RuvLTRA models
+ *
+ * Implements triplet loss and InfoNCE loss for embedding fine-tuning.
+ */
+export class ContrastiveTrainer {
+    constructor(config) {
+        this.triplets = [];
+        this.history = [];
+        this.agentEmbeddings = new Map();
+        this.config = { ...DEFAULT_CONTRASTIVE_CONFIG, ...config };
+    }
+    /**
+     * Add a training triplet
+     */
+    addTriplet(anchor, anchorEmb, positive, positiveEmb, negative, negativeEmb, isHard = false) {
+        this.triplets.push({
+            anchor,
+            anchorEmb,
+            positive,
+            positiveEmb,
+            negative,
+            negativeEmb,
+            isHard,
+        });
+    }
+    /**
+     * Add agent embedding for reference
+     */
+    addAgentEmbedding(agentName, embedding) {
+        this.agentEmbeddings.set(agentName, embedding);
+    }
+    /**
+     * Get all agent embeddings
+     */
+    getAgentEmbeddings() {
+        return this.agentEmbeddings;
+    }
+    /**
+     * Get triplet count
+     */
+    getTripletCount() {
+        return this.triplets.length;
+    }
+    /**
+     * Simulate training (compute losses without actual backprop)
+     * In a full implementation, this would use proper gradient descent
+     */
+    train() {
+        const startTime = Date.now();
+        const { epochs, batchSize, margin } = this.config;
+        if (this.triplets.length === 0) {
+            return {
+                tripletCount: 0,
+                finalLoss: 0,
+                initialLoss: 0,
+                improvement: 0,
+                history: [],
+                durationMs: 0,
+            };
+        }
+        for (let epoch = 0; epoch < epochs; epoch++) {
+            let epochLoss = 0;
+            let batchCount = 0;
+            // Shuffle triplets
+            const shuffled = [...this.triplets].sort(() => Math.random() - 0.5);
+            for (let i = 0; i < shuffled.length; i += batchSize) {
+                const batch = shuffled.slice(i, i + batchSize);
+                let batchLoss = 0;
+                for (const triplet of batch) {
+                    const loss = tripletLoss(triplet.anchorEmb, triplet.positiveEmb, triplet.negativeEmb, margin);
+                    batchLoss += loss;
+                }
+                epochLoss += batchLoss / batch.length;
+                batchCount++;
+            }
+            const avgLoss = epochLoss / batchCount;
+            this.history.push({ epoch: epoch + 1, loss: avgLoss });
+        }
+        const initialLoss = this.history[0]?.loss || 0;
+        const finalLoss = this.history[this.history.length - 1]?.loss || 0;
+        const improvement = initialLoss > 0 ? (1 - finalLoss / initialLoss) * 100 : 0;
+        return {
+            tripletCount: this.triplets.length,
+            finalLoss,
+            initialLoss,
+            improvement,
+            history: this.history,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * Export training data for external fine-tuning tools
+     */
+    exportTrainingData(outputPath) {
+        const outDir = outputPath || this.config.outputPath;
+        if (!existsSync(outDir)) {
+            mkdirSync(outDir, { recursive: true });
+        }
+        // JSONL format for fine-tuning
+        const jsonlData = this.triplets.map(t => ({
+            anchor: t.anchor,
+            positive: t.positive,
+            negative: t.negative,
+            isHard: t.isHard,
+        }));
+        // CSV format for analysis
+        const csvData = [
+            'anchor,positive,negative,is_hard',
+            ...this.triplets.map(t => `"${t.anchor.replace(/"/g, '""')}",${t.positive},${t.negative},${t.isHard}`),
+        ].join('\n');
+        // Embedding matrix for direct training
+        const embeddingData = {
+            anchors: this.triplets.map(t => t.anchorEmb),
+            positives: this.triplets.map(t => t.positiveEmb),
+            negatives: this.triplets.map(t => t.negativeEmb),
+            labels: this.triplets.map(t => t.positive),
+        };
+        writeFileSync(join(outDir, 'triplets.jsonl'), jsonlData.map(item => JSON.stringify(item)).join('\n'));
+        writeFileSync(join(outDir, 'triplets.csv'), csvData);
+        writeFileSync(join(outDir, 'embeddings.json'), JSON.stringify(embeddingData, null, 2));
+        return outDir;
+    }
+    /**
+     * Generate LoRA adapter configuration
+     */
+    generateLoRAConfig(outputPath) {
+        const outDir = outputPath || this.config.outputPath;
+        const loraConfig = {
+            model_type: 'qwen2',
+            base_model: 'Qwen/Qwen2.5-0.5B',
+            output_dir: outDir,
+            lora_r: 8,
+            lora_alpha: 16,
+            lora_dropout: 0.05,
+            target_modules: ['q_proj', 'v_proj', 'k_proj', 'o_proj'],
+            learning_rate: this.config.learningRate,
+            num_train_epochs: this.config.epochs,
+            per_device_train_batch_size: this.config.batchSize,
+            gradient_accumulation_steps: 4,
+            warmup_ratio: 0.1,
+            loss_type: 'triplet',
+            margin: this.config.margin,
+            temperature: this.config.temperature,
+            train_data: join(outDir, 'triplets.jsonl'),
+            eval_data: join(outDir, 'eval.jsonl'),
+        };
+        if (!existsSync(outDir)) {
+            mkdirSync(outDir, { recursive: true });
+        }
+        writeFileSync(join(outDir, 'lora_config.json'), JSON.stringify(loraConfig, null, 2));
+        return loraConfig;
+    }
+    /**
+     * Generate training script for external tools
+     */
+    generateTrainingScript(outputPath) {
+        const outDir = outputPath || this.config.outputPath;
+        const script = `#!/bin/bash
+# RuvLTRA Fine-tuning Script
+# Prerequisites: pip install transformers peft accelerate
+
+set -e
+
+MODEL_PATH="${outDir}"
+BASE_MODEL="Qwen/Qwen2.5-0.5B"
+
+echo "=== RuvLTRA Contrastive Fine-tuning ==="
+echo "Base model: $BASE_MODEL"
+echo "Output: $MODEL_PATH"
+
+# Check for training data
+if [ ! -f "$MODEL_PATH/triplets.jsonl" ]; then
+  echo "Error: Training data not found at $MODEL_PATH/triplets.jsonl"
+  exit 1
+fi
+
+# Install dependencies if needed
+python3 -c "import transformers, peft" 2>/dev/null || {
+  echo "Installing dependencies..."
+  pip install transformers peft accelerate sentencepiece
+}
+
+# Fine-tune with LoRA
+python3 << 'PYTHON'
+import json
+import torch
+from pathlib import Path
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import LoraConfig, get_peft_model, TaskType
+
+# Load config
+config_path = Path("${outDir}/lora_config.json")
+with open(config_path) as f:
+    config = json.load(f)
+
+print(f"Loading base model: {config['base_model']}")
+
+# Load model and tokenizer
+tokenizer = AutoTokenizer.from_pretrained(config['base_model'])
+model = AutoModelForCausalLM.from_pretrained(
+    config['base_model'],
+    torch_dtype=torch.float16,
+    device_map='auto'
+)
+
+# Configure LoRA
+lora_config = LoraConfig(
+    r=config['lora_r'],
+    lora_alpha=config['lora_alpha'],
+    lora_dropout=config['lora_dropout'],
+    target_modules=config['target_modules'],
+    task_type=TaskType.CAUSAL_LM,
+)
+
+model = get_peft_model(model, lora_config)
+model.print_trainable_parameters()
+
+print("Model ready for fine-tuning!")
+print(f"Training data: {config['train_data']}")
+print("Note: Full training requires GPU. This script validates the setup.")
+PYTHON
+
+echo ""
+echo "=== Setup Complete ==="
+echo "To train on GPU, run the full training pipeline."
+echo "Training data exported to: $MODEL_PATH/triplets.jsonl"
+`;
+        if (!existsSync(outDir)) {
+            mkdirSync(outDir, { recursive: true });
+        }
+        const scriptPath = join(outDir, 'train.sh');
+        writeFileSync(scriptPath, script);
+        return scriptPath;
+    }
+    /**
+     * Get training history
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Reset trainer
+     */
+    reset() {
+        this.triplets = [];
+        this.history = [];
+    }
+}
+/**
+ * Agent Training Data for Claude Code Router
+ */
+export const AGENT_TRAINING_DATA = {
+    coder: {
+        description: 'Implementation specialist for writing clean, efficient code. Handles coding tasks, feature implementation, and code generation.',
+        keywords: ['implement', 'code', 'write', 'build', 'create', 'develop', 'function', 'class', 'component', 'feature'],
+        examples: [
+            'Implement a binary search function',
+            'Write a React component for user registration',
+            'Create a REST API endpoint for user authentication',
+            'Build a caching layer for the database queries',
+        ],
+        confusing_with: ['refactorer', 'debugger'],
+    },
+    tester: {
+        description: 'Testing specialist for writing and maintaining tests. Creates unit tests, integration tests, and ensures code quality through testing.',
+        keywords: ['test', 'unit test', 'integration test', 'coverage', 'mock', 'assertion', 'spec', 'jest', 'pytest'],
+        examples: [
+            'Write unit tests for the authentication module',
+            'Add integration tests for the payment gateway',
+            'Create test coverage for the user service',
+            'Write e2e tests for the checkout flow',
+        ],
+        confusing_with: ['reviewer'],
+    },
+    reviewer: {
+        description: 'Code review specialist for analyzing code quality, identifying issues, and suggesting improvements.',
+        keywords: ['review', 'analyze', 'check', 'inspect', 'audit', 'evaluate', 'assess', 'critique'],
+        examples: [
+            'Review the pull request for code quality',
+            'Check the code for potential security vulnerabilities',
+            'Analyze the implementation for best practices',
+            'Evaluate the architecture decisions in this PR',
+        ],
+        confusing_with: ['tester', 'security-architect'],
+    },
+    researcher: {
+        description: 'Research specialist for investigating technologies, gathering information, and analyzing options.',
+        keywords: ['research', 'investigate', 'explore', 'analyze', 'study', 'compare', 'evaluate', 'learn'],
+        examples: [
+            'Research best practices for React state management',
+            'Investigate the performance issues in the dashboard',
+            'Compare different authentication strategies',
+            'Study the codebase architecture for the new feature',
+        ],
+        confusing_with: ['planner'],
+    },
+    architect: {
+        description: 'System architect for designing software architecture, making technical decisions, and planning system structure.',
+        keywords: ['design', 'architect', 'structure', 'plan', 'schema', 'model', 'pattern', 'system'],
+        examples: [
+            'Design the database schema for user profiles',
+            'Plan the architecture for real-time notifications',
+            'Create a system design for the microservices migration',
+            'Design the API structure for the new product catalog',
+        ],
+        confusing_with: ['planner'],
+    },
+    debugger: {
+        description: 'Debugging specialist for finding and fixing bugs, analyzing errors, and troubleshooting issues.',
+        keywords: ['debug', 'fix', 'bug', 'error', 'issue', 'crash', 'exception', 'troubleshoot'],
+        examples: [
+            'Fix the null pointer exception in the login handler',
+            'Debug the memory leak in the WebSocket handler',
+            'Troubleshoot the race condition in the payment processor',
+            'Find the root cause of the intermittent test failures',
+        ],
+        confusing_with: ['coder'],
+    },
+    'security-architect': {
+        description: 'Security specialist for auditing code security, identifying vulnerabilities, and implementing security measures.',
+        keywords: ['security', 'vulnerability', 'xss', 'sql injection', 'auth', 'encryption', 'audit', 'penetration'],
+        examples: [
+            'Audit the API endpoints for XSS vulnerabilities',
+            'Review the authentication flow for security issues',
+            'Implement input validation for the user forms',
+            'Check for SQL injection vulnerabilities in the search',
+        ],
+        confusing_with: ['reviewer'],
+    },
+    documenter: {
+        description: 'Documentation specialist for writing technical documentation, comments, and API docs.',
+        keywords: ['document', 'comment', 'jsdoc', 'readme', 'docs', 'explain', 'describe', 'annotate'],
+        examples: [
+            'Write JSDoc comments for the utility functions',
+            'Create README documentation for the new module',
+            'Document the API endpoints with examples',
+            'Add inline comments explaining the algorithm',
+        ],
+        confusing_with: ['api-docs'],
+    },
+    refactorer: {
+        description: 'Refactoring specialist for improving code structure, cleaning up technical debt, and modernizing codebases.',
+        keywords: ['refactor', 'clean', 'restructure', 'modernize', 'improve', 'simplify', 'extract', 'rename'],
+        examples: [
+            'Refactor the payment module to use async/await',
+            'Clean up the legacy authentication code',
+            'Extract common logic into a shared utility',
+            'Simplify the complex conditional logic in checkout',
+        ],
+        confusing_with: ['coder'],
+    },
+    optimizer: {
+        description: 'Performance optimization specialist for improving speed, reducing memory usage, and optimizing queries.',
+        keywords: ['optimize', 'performance', 'speed', 'memory', 'cache', 'index', 'query', 'latency'],
+        examples: [
+            'Optimize the database queries for the dashboard',
+            'Improve the page load time for the homepage',
+            'Add caching to reduce API response times',
+            'Reduce memory usage in the image processing pipeline',
+        ],
+        confusing_with: ['researcher'],
+    },
+    devops: {
+        description: 'DevOps specialist for CI/CD pipelines, deployment automation, and infrastructure management.',
+        keywords: ['deploy', 'ci/cd', 'pipeline', 'docker', 'kubernetes', 'terraform', 'aws', 'infrastructure'],
+        examples: [
+            'Set up the CI/CD pipeline for the microservices',
+            'Configure Docker containers for the application',
+            'Deploy the application to the staging environment',
+            'Create Terraform scripts for the AWS infrastructure',
+        ],
+        confusing_with: [],
+    },
+    'api-docs': {
+        description: 'API documentation specialist for creating OpenAPI specs, Swagger documentation, and API references.',
+        keywords: ['openapi', 'swagger', 'api docs', 'endpoint', 'specification', 'schema', 'rest'],
+        examples: [
+            'Generate OpenAPI documentation for the REST API',
+            'Create Swagger specs for the user endpoints',
+            'Document the API authentication requirements',
+            'Update the API reference with new endpoints',
+        ],
+        confusing_with: ['documenter'],
+    },
+    planner: {
+        description: 'Project planning specialist for creating task plans, sprint planning, and roadmap development.',
+        keywords: ['plan', 'roadmap', 'sprint', 'milestone', 'timeline', 'estimate', 'breakdown', 'prioritize'],
+        examples: [
+            'Create a sprint plan for the next two weeks',
+            'Break down the feature into smaller tasks',
+            'Estimate the effort for the migration project',
+            'Prioritize the bug fixes for the release',
+        ],
+        confusing_with: ['architect', 'researcher'],
+    },
+};
+/**
+ * Generate training dataset from agent data
+ */
+export function generateTrainingDataset() {
+    const examples = [];
+    for (const [agent, data] of Object.entries(AGENT_TRAINING_DATA)) {
+        // Add direct examples
+        for (const example of data.examples) {
+            examples.push({
+                task: example,
+                agent,
+                complexity: 'medium',
+            });
+        }
+        // Generate variations with keywords
+        for (const keyword of data.keywords) {
+            examples.push({
+                task: `${keyword} a solution for the authentication system`,
+                agent,
+                complexity: 'low',
+            });
+        }
+        // Add confusing pairs for hard negatives
+        if (data.confusing_with) {
+            for (const confusingAgent of data.confusing_with) {
+                for (const example of data.examples.slice(0, 2)) {
+                    examples.push({
+                        task: example,
+                        agent,
+                        complexity: 'hard',
+                        confusing_with: confusingAgent,
+                    });
+                }
+            }
+        }
+    }
+    return examples;
+}
+/**
+ * Generate contrastive pairs for training
+ */
+export function generateContrastivePairs() {
+    const pairs = [];
+    const agents = Object.keys(AGENT_TRAINING_DATA);
+    for (const [agent, data] of Object.entries(AGENT_TRAINING_DATA)) {
+        for (const example of data.examples) {
+            // Hard negatives from confusing agents
+            if (data.confusing_with) {
+                for (const negAgent of data.confusing_with) {
+                    pairs.push({
+                        anchor: example,
+                        positive: agent,
+                        negative: negAgent,
+                        isHard: true,
+                    });
+                }
+            }
+            // Random negatives
+            const randomNegs = agents.filter(a => a !== agent).slice(0, 2);
+            for (const negAgent of randomNegs) {
+                pairs.push({
+                    anchor: example,
+                    positive: agent,
+                    negative: negAgent,
+                    isHard: false,
+                });
+            }
+        }
+    }
+    return pairs;
+}
+/**
+ * Get dataset statistics
+ */
+export function getDatasetStats() {
+    const examples = generateTrainingDataset();
+    const pairs = generateContrastivePairs();
+    const agents = Object.keys(AGENT_TRAINING_DATA);
+    return {
+        totalExamples: examples.length,
+        contrastivePairs: pairs.length,
+        agentTypes: agents.length,
+        agents,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contrastive.js","sourceRoot":"","sources":["../../src/contrastive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Contrastive Fine-tuning for RuvLTRA Claude Code Router\n *\n * Uses triplet loss to fine-tune embeddings:\n * - Anchor: task description\n * - Positive: correct agent description\n * - Negative: wrong agent description (hard negative)\n *\n * Goal: minimize distance(anchor, positive) and maximize distance(anchor, negative)\n *\n * @example\n * ```typescript\n * import { ContrastiveTrainer, tripletLoss, infoNCELoss } from '@ruvector/ruvllm';\n *\n * const trainer = new ContrastiveTrainer({\n *   epochs: 10,\n *   batchSize: 16,\n *   margin: 0.5,\n * });\n *\n * // Add triplets\n * trainer.addTriplet(anchorEmb, positiveEmb, negativeEmb, true);\n *\n * // Train and export\n * const results = trainer.train();\n * trainer.exportTrainingData('./output');\n * ```\n */\n\nimport { writeFileSync, mkdirSync, existsSync } from 'fs';\nimport { join } from 'path';\nimport { Embedding } from './types';\n\n/**\n * Contrastive training configuration\n */\nexport interface ContrastiveConfig {\n  /** Number of training epochs (default: 10) */\n  epochs?: number;\n  /** Batch size (default: 16) */\n  batchSize?: number;\n  /** Learning rate (default: 0.0001) */\n  learningRate?: number;\n  /** Triplet loss margin (default: 0.5) */\n  margin?: number;\n  /** InfoNCE temperature (default: 0.07) */\n  temperature?: number;\n  /** Ratio of hard negatives (default: 0.7) */\n  hardNegativeRatio?: number;\n  /** Output directory for training data */\n  outputPath?: string;\n}\n\n/**\n * Training triplet\n */\nexport interface TrainingTriplet {\n  /** Anchor embedding (task) */\n  anchor: string;\n  anchorEmb: Embedding;\n  /** Positive example (correct agent) */\n  positive: string;\n  positiveEmb: Embedding;\n  /** Negative example (wrong agent) */\n  negative: string;\n  negativeEmb: Embedding;\n  /** Whether this is a hard negative */\n  isHard: boolean;\n}\n\n/**\n * Training history entry\n */\nexport interface TrainingHistoryEntry {\n  epoch: number;\n  loss: number;\n}\n\n/**\n * Contrastive training results\n */\nexport interface ContrastiveTrainingResult {\n  /** Total triplets trained on */\n  tripletCount: number;\n  /** Final loss value */\n  finalLoss: number;\n  /** Initial loss value */\n  initialLoss: number;\n  /** Improvement percentage */\n  improvement: number;\n  /** Training history */\n  history: TrainingHistoryEntry[];\n  /** Duration in ms */\n  durationMs: number;\n}\n\n/**\n * LoRA configuration for fine-tuning\n */\nexport interface LoRAExportConfig {\n  model_type: string;\n  base_model: string;\n  output_dir: string;\n  lora_r: number;\n  lora_alpha: number;\n  lora_dropout: number;\n  target_modules: string[];\n  learning_rate: number;\n  num_train_epochs: number;\n  per_device_train_batch_size: number;\n  gradient_accumulation_steps: number;\n  warmup_ratio: number;\n  loss_type: string;\n  margin: number;\n  temperature: number;\n  train_data: string;\n  eval_data: string;\n}\n\n/**\n * Default contrastive config\n */\nconst DEFAULT_CONTRASTIVE_CONFIG: Required<ContrastiveConfig> = {\n  epochs: 10,\n  batchSize: 16,\n  learningRate: 0.0001,\n  margin: 0.5,\n  temperature: 0.07,\n  hardNegativeRatio: 0.7,\n  outputPath: './training-output',\n};\n\n/**\n * Compute cosine similarity between two embeddings\n */\nexport function cosineSimilarity(a: Embedding, b: Embedding): number {\n  if (!a || !b || a.length !== b.length) return 0;\n  let dot = 0, normA = 0, normB = 0;\n  for (let i = 0; i < a.length; i++) {\n    dot += a[i] * b[i];\n    normA += a[i] * a[i];\n    normB += b[i] * b[i];\n  }\n  return dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);\n}\n\n/**\n * Compute triplet loss\n * L = max(0, margin + d(anchor, positive) - d(anchor, negative))\n */\nexport function tripletLoss(\n  anchorEmb: Embedding,\n  positiveEmb: Embedding,\n  negativeEmb: Embedding,\n  margin: number = 0.5\n): number {\n  const posDist = 1 - cosineSimilarity(anchorEmb, positiveEmb);\n  const negDist = 1 - cosineSimilarity(anchorEmb, negativeEmb);\n  return Math.max(0, margin + posDist - negDist);\n}\n\n/**\n * Compute InfoNCE loss (contrastive)\n */\nexport function infoNCELoss(\n  anchorEmb: Embedding,\n  positiveEmb: Embedding,\n  negativeEmbs: Embedding[],\n  temperature: number = 0.07\n): number {\n  const posSim = cosineSimilarity(anchorEmb, positiveEmb) / temperature;\n  const negSims = negativeEmbs.map(neg => cosineSimilarity(anchorEmb, neg) / temperature);\n\n  // Softmax denominator\n  const maxSim = Math.max(posSim, ...negSims);\n  const expPos = Math.exp(posSim - maxSim);\n  const expNegs = negSims.map(sim => Math.exp(sim - maxSim));\n  const denominator = expPos + expNegs.reduce((a, b) => a + b, 0);\n\n  // Cross-entropy loss\n  return -Math.log(expPos / denominator);\n}\n\n/**\n * Compute gradient for embedding update (simplified)\n */\nexport function computeGradient(\n  anchorEmb: Embedding,\n  positiveEmb: Embedding,\n  negativeEmb: Embedding,\n  lr: number = 0.0001\n): Embedding {\n  const dim = anchorEmb.length;\n  const gradient: number[] = new Array(dim).fill(0);\n\n  // Pull anchor towards positive\n  for (let i = 0; i < dim; i++) {\n    gradient[i] += lr * (positiveEmb[i] - anchorEmb[i]);\n  }\n\n  // Push anchor away from negative\n  for (let i = 0; i < dim; i++) {\n    gradient[i] -= lr * 0.5 * (negativeEmb[i] - anchorEmb[i]);\n  }\n\n  return gradient;\n}\n\n/**\n * Contrastive Trainer for RuvLTRA models\n *\n * Implements triplet loss and InfoNCE loss for embedding fine-tuning.\n */\nexport class ContrastiveTrainer {\n  private config: Required<ContrastiveConfig>;\n  private triplets: TrainingTriplet[] = [];\n  private history: TrainingHistoryEntry[] = [];\n  private agentEmbeddings: Map<string, Embedding> = new Map();\n\n  constructor(config?: ContrastiveConfig) {\n    this.config = { ...DEFAULT_CONTRASTIVE_CONFIG, ...config };\n  }\n\n  /**\n   * Add a training triplet\n   */\n  addTriplet(\n    anchor: string,\n    anchorEmb: Embedding,\n    positive: string,\n    positiveEmb: Embedding,\n    negative: string,\n    negativeEmb: Embedding,\n    isHard: boolean = false\n  ): void {\n    this.triplets.push({\n      anchor,\n      anchorEmb,\n      positive,\n      positiveEmb,\n      negative,\n      negativeEmb,\n      isHard,\n    });\n  }\n\n  /**\n   * Add agent embedding for reference\n   */\n  addAgentEmbedding(agentName: string, embedding: Embedding): void {\n    this.agentEmbeddings.set(agentName, embedding);\n  }\n\n  /**\n   * Get all agent embeddings\n   */\n  getAgentEmbeddings(): Map<string, Embedding> {\n    return this.agentEmbeddings;\n  }\n\n  /**\n   * Get triplet count\n   */\n  getTripletCount(): number {\n    return this.triplets.length;\n  }\n\n  /**\n   * Simulate training (compute losses without actual backprop)\n   * In a full implementation, this would use proper gradient descent\n   */\n  train(): ContrastiveTrainingResult {\n    const startTime = Date.now();\n    const { epochs, batchSize, margin } = this.config;\n\n    if (this.triplets.length === 0) {\n      return {\n        tripletCount: 0,\n        finalLoss: 0,\n        initialLoss: 0,\n        improvement: 0,\n        history: [],\n        durationMs: 0,\n      };\n    }\n\n    for (let epoch = 0; epoch < epochs; epoch++) {\n      let epochLoss = 0;\n      let batchCount = 0;\n\n      // Shuffle triplets\n      const shuffled = [...this.triplets].sort(() => Math.random() - 0.5);\n\n      for (let i = 0; i < shuffled.length; i += batchSize) {\n        const batch = shuffled.slice(i, i + batchSize);\n        let batchLoss = 0;\n\n        for (const triplet of batch) {\n          const loss = tripletLoss(\n            triplet.anchorEmb,\n            triplet.positiveEmb,\n            triplet.negativeEmb,\n            margin\n          );\n          batchLoss += loss;\n        }\n\n        epochLoss += batchLoss / batch.length;\n        batchCount++;\n      }\n\n      const avgLoss = epochLoss / batchCount;\n      this.history.push({ epoch: epoch + 1, loss: avgLoss });\n    }\n\n    const initialLoss = this.history[0]?.loss || 0;\n    const finalLoss = this.history[this.history.length - 1]?.loss || 0;\n    const improvement = initialLoss > 0 ? (1 - finalLoss / initialLoss) * 100 : 0;\n\n    return {\n      tripletCount: this.triplets.length,\n      finalLoss,\n      initialLoss,\n      improvement,\n      history: this.history,\n      durationMs: Date.now() - startTime,\n    };\n  }\n\n  /**\n   * Export training data for external fine-tuning tools\n   */\n  exportTrainingData(outputPath?: string): string {\n    const outDir = outputPath || this.config.outputPath;\n\n    if (!existsSync(outDir)) {\n      mkdirSync(outDir, { recursive: true });\n    }\n\n    // JSONL format for fine-tuning\n    const jsonlData = this.triplets.map(t => ({\n      anchor: t.anchor,\n      positive: t.positive,\n      negative: t.negative,\n      isHard: t.isHard,\n    }));\n\n    // CSV format for analysis\n    const csvData = [\n      'anchor,positive,negative,is_hard',\n      ...this.triplets.map(t =>\n        `\"${t.anchor.replace(/\"/g, '\"\"')}\",${t.positive},${t.negative},${t.isHard}`\n      ),\n    ].join('\\n');\n\n    // Embedding matrix for direct training\n    const embeddingData = {\n      anchors: this.triplets.map(t => t.anchorEmb),\n      positives: this.triplets.map(t => t.positiveEmb),\n      negatives: this.triplets.map(t => t.negativeEmb),\n      labels: this.triplets.map(t => t.positive),\n    };\n\n    writeFileSync(join(outDir, 'triplets.jsonl'), jsonlData.map(item => JSON.stringify(item)).join('\\n'));\n    writeFileSync(join(outDir, 'triplets.csv'), csvData);\n    writeFileSync(join(outDir, 'embeddings.json'), JSON.stringify(embeddingData, null, 2));\n\n    return outDir;\n  }\n\n  /**\n   * Generate LoRA adapter configuration\n   */\n  generateLoRAConfig(outputPath?: string): LoRAExportConfig {\n    const outDir = outputPath || this.config.outputPath;\n\n    const loraConfig: LoRAExportConfig = {\n      model_type: 'qwen2',\n      base_model: 'Qwen/Qwen2.5-0.5B',\n      output_dir: outDir,\n      lora_r: 8,\n      lora_alpha: 16,\n      lora_dropout: 0.05,\n      target_modules: ['q_proj', 'v_proj', 'k_proj', 'o_proj'],\n      learning_rate: this.config.learningRate,\n      num_train_epochs: this.config.epochs,\n      per_device_train_batch_size: this.config.batchSize,\n      gradient_accumulation_steps: 4,\n      warmup_ratio: 0.1,\n      loss_type: 'triplet',\n      margin: this.config.margin,\n      temperature: this.config.temperature,\n      train_data: join(outDir, 'triplets.jsonl'),\n      eval_data: join(outDir, 'eval.jsonl'),\n    };\n\n    if (!existsSync(outDir)) {\n      mkdirSync(outDir, { recursive: true });\n    }\n\n    writeFileSync(join(outDir, 'lora_config.json'), JSON.stringify(loraConfig, null, 2));\n    return loraConfig;\n  }\n\n  /**\n   * Generate training script for external tools\n   */\n  generateTrainingScript(outputPath?: string): string {\n    const outDir = outputPath || this.config.outputPath;\n\n    const script = `#!/bin/bash\n# RuvLTRA Fine-tuning Script\n# Prerequisites: pip install transformers peft accelerate\n\nset -e\n\nMODEL_PATH=\"${outDir}\"\nBASE_MODEL=\"Qwen/Qwen2.5-0.5B\"\n\necho \"=== RuvLTRA Contrastive Fine-tuning ===\"\necho \"Base model: $BASE_MODEL\"\necho \"Output: $MODEL_PATH\"\n\n# Check for training data\nif [ ! -f \"$MODEL_PATH/triplets.jsonl\" ]; then\n  echo \"Error: Training data not found at $MODEL_PATH/triplets.jsonl\"\n  exit 1\nfi\n\n# Install dependencies if needed\npython3 -c \"import transformers, peft\" 2>/dev/null || {\n  echo \"Installing dependencies...\"\n  pip install transformers peft accelerate sentencepiece\n}\n\n# Fine-tune with LoRA\npython3 << 'PYTHON'\nimport json\nimport torch\nfrom pathlib import Path\nfrom transformers import AutoModelForCausalLM, AutoTokenizer\nfrom peft import LoraConfig, get_peft_model, TaskType\n\n# Load config\nconfig_path = Path(\"${outDir}/lora_config.json\")\nwith open(config_path) as f:\n    config = json.load(f)\n\nprint(f\"Loading base model: {config['base_model']}\")\n\n# Load model and tokenizer\ntokenizer = AutoTokenizer.from_pretrained(config['base_model'])\nmodel = AutoModelForCausalLM.from_pretrained(\n    config['base_model'],\n    torch_dtype=torch.float16,\n    device_map='auto'\n)\n\n# Configure LoRA\nlora_config = LoraConfig(\n    r=config['lora_r'],\n    lora_alpha=config['lora_alpha'],\n    lora_dropout=config['lora_dropout'],\n    target_modules=config['target_modules'],\n    task_type=TaskType.CAUSAL_LM,\n)\n\nmodel = get_peft_model(model, lora_config)\nmodel.print_trainable_parameters()\n\nprint(\"Model ready for fine-tuning!\")\nprint(f\"Training data: {config['train_data']}\")\nprint(\"Note: Full training requires GPU. This script validates the setup.\")\nPYTHON\n\necho \"\"\necho \"=== Setup Complete ===\"\necho \"To train on GPU, run the full training pipeline.\"\necho \"Training data exported to: $MODEL_PATH/triplets.jsonl\"\n`;\n\n    if (!existsSync(outDir)) {\n      mkdirSync(outDir, { recursive: true });\n    }\n\n    const scriptPath = join(outDir, 'train.sh');\n    writeFileSync(scriptPath, script);\n\n    return scriptPath;\n  }\n\n  /**\n   * Get training history\n   */\n  getHistory(): TrainingHistoryEntry[] {\n    return [...this.history];\n  }\n\n  /**\n   * Reset trainer\n   */\n  reset(): void {\n    this.triplets = [];\n    this.history = [];\n  }\n}\n\n/**\n * Agent Training Data Interface\n */\nexport interface AgentTrainingData {\n  description: string;\n  keywords: string[];\n  examples: string[];\n  confusing_with?: string[];\n}\n\n/**\n * Training Example Interface\n */\nexport interface TrainingExample {\n  task: string;\n  agent: string;\n  complexity?: string;\n  confusing_with?: string;\n}\n\n/**\n * Dataset Statistics\n */\nexport interface DatasetStats {\n  totalExamples: number;\n  contrastivePairs: number;\n  agentTypes: number;\n  agents: string[];\n}\n\n/**\n * Agent Training Data for Claude Code Router\n */\nexport const AGENT_TRAINING_DATA: Record<string, AgentTrainingData> = {\n  coder: {\n    description: 'Implementation specialist for writing clean, efficient code. Handles coding tasks, feature implementation, and code generation.',\n    keywords: ['implement', 'code', 'write', 'build', 'create', 'develop', 'function', 'class', 'component', 'feature'],\n    examples: [\n      'Implement a binary search function',\n      'Write a React component for user registration',\n      'Create a REST API endpoint for user authentication',\n      'Build a caching layer for the database queries',\n    ],\n    confusing_with: ['refactorer', 'debugger'],\n  },\n  tester: {\n    description: 'Testing specialist for writing and maintaining tests. Creates unit tests, integration tests, and ensures code quality through testing.',\n    keywords: ['test', 'unit test', 'integration test', 'coverage', 'mock', 'assertion', 'spec', 'jest', 'pytest'],\n    examples: [\n      'Write unit tests for the authentication module',\n      'Add integration tests for the payment gateway',\n      'Create test coverage for the user service',\n      'Write e2e tests for the checkout flow',\n    ],\n    confusing_with: ['reviewer'],\n  },\n  reviewer: {\n    description: 'Code review specialist for analyzing code quality, identifying issues, and suggesting improvements.',\n    keywords: ['review', 'analyze', 'check', 'inspect', 'audit', 'evaluate', 'assess', 'critique'],\n    examples: [\n      'Review the pull request for code quality',\n      'Check the code for potential security vulnerabilities',\n      'Analyze the implementation for best practices',\n      'Evaluate the architecture decisions in this PR',\n    ],\n    confusing_with: ['tester', 'security-architect'],\n  },\n  researcher: {\n    description: 'Research specialist for investigating technologies, gathering information, and analyzing options.',\n    keywords: ['research', 'investigate', 'explore', 'analyze', 'study', 'compare', 'evaluate', 'learn'],\n    examples: [\n      'Research best practices for React state management',\n      'Investigate the performance issues in the dashboard',\n      'Compare different authentication strategies',\n      'Study the codebase architecture for the new feature',\n    ],\n    confusing_with: ['planner'],\n  },\n  architect: {\n    description: 'System architect for designing software architecture, making technical decisions, and planning system structure.',\n    keywords: ['design', 'architect', 'structure', 'plan', 'schema', 'model', 'pattern', 'system'],\n    examples: [\n      'Design the database schema for user profiles',\n      'Plan the architecture for real-time notifications',\n      'Create a system design for the microservices migration',\n      'Design the API structure for the new product catalog',\n    ],\n    confusing_with: ['planner'],\n  },\n  debugger: {\n    description: 'Debugging specialist for finding and fixing bugs, analyzing errors, and troubleshooting issues.',\n    keywords: ['debug', 'fix', 'bug', 'error', 'issue', 'crash', 'exception', 'troubleshoot'],\n    examples: [\n      'Fix the null pointer exception in the login handler',\n      'Debug the memory leak in the WebSocket handler',\n      'Troubleshoot the race condition in the payment processor',\n      'Find the root cause of the intermittent test failures',\n    ],\n    confusing_with: ['coder'],\n  },\n  'security-architect': {\n    description: 'Security specialist for auditing code security, identifying vulnerabilities, and implementing security measures.',\n    keywords: ['security', 'vulnerability', 'xss', 'sql injection', 'auth', 'encryption', 'audit', 'penetration'],\n    examples: [\n      'Audit the API endpoints for XSS vulnerabilities',\n      'Review the authentication flow for security issues',\n      'Implement input validation for the user forms',\n      'Check for SQL injection vulnerabilities in the search',\n    ],\n    confusing_with: ['reviewer'],\n  },\n  documenter: {\n    description: 'Documentation specialist for writing technical documentation, comments, and API docs.',\n    keywords: ['document', 'comment', 'jsdoc', 'readme', 'docs', 'explain', 'describe', 'annotate'],\n    examples: [\n      'Write JSDoc comments for the utility functions',\n      'Create README documentation for the new module',\n      'Document the API endpoints with examples',\n      'Add inline comments explaining the algorithm',\n    ],\n    confusing_with: ['api-docs'],\n  },\n  refactorer: {\n    description: 'Refactoring specialist for improving code structure, cleaning up technical debt, and modernizing codebases.',\n    keywords: ['refactor', 'clean', 'restructure', 'modernize', 'improve', 'simplify', 'extract', 'rename'],\n    examples: [\n      'Refactor the payment module to use async/await',\n      'Clean up the legacy authentication code',\n      'Extract common logic into a shared utility',\n      'Simplify the complex conditional logic in checkout',\n    ],\n    confusing_with: ['coder'],\n  },\n  optimizer: {\n    description: 'Performance optimization specialist for improving speed, reducing memory usage, and optimizing queries.',\n    keywords: ['optimize', 'performance', 'speed', 'memory', 'cache', 'index', 'query', 'latency'],\n    examples: [\n      'Optimize the database queries for the dashboard',\n      'Improve the page load time for the homepage',\n      'Add caching to reduce API response times',\n      'Reduce memory usage in the image processing pipeline',\n    ],\n    confusing_with: ['researcher'],\n  },\n  devops: {\n    description: 'DevOps specialist for CI/CD pipelines, deployment automation, and infrastructure management.',\n    keywords: ['deploy', 'ci/cd', 'pipeline', 'docker', 'kubernetes', 'terraform', 'aws', 'infrastructure'],\n    examples: [\n      'Set up the CI/CD pipeline for the microservices',\n      'Configure Docker containers for the application',\n      'Deploy the application to the staging environment',\n      'Create Terraform scripts for the AWS infrastructure',\n    ],\n    confusing_with: [],\n  },\n  'api-docs': {\n    description: 'API documentation specialist for creating OpenAPI specs, Swagger documentation, and API references.',\n    keywords: ['openapi', 'swagger', 'api docs', 'endpoint', 'specification', 'schema', 'rest'],\n    examples: [\n      'Generate OpenAPI documentation for the REST API',\n      'Create Swagger specs for the user endpoints',\n      'Document the API authentication requirements',\n      'Update the API reference with new endpoints',\n    ],\n    confusing_with: ['documenter'],\n  },\n  planner: {\n    description: 'Project planning specialist for creating task plans, sprint planning, and roadmap development.',\n    keywords: ['plan', 'roadmap', 'sprint', 'milestone', 'timeline', 'estimate', 'breakdown', 'prioritize'],\n    examples: [\n      'Create a sprint plan for the next two weeks',\n      'Break down the feature into smaller tasks',\n      'Estimate the effort for the migration project',\n      'Prioritize the bug fixes for the release',\n    ],\n    confusing_with: ['architect', 'researcher'],\n  },\n};\n\n/**\n * Generate training dataset from agent data\n */\nexport function generateTrainingDataset(): TrainingExample[] {\n  const examples: TrainingExample[] = [];\n\n  for (const [agent, data] of Object.entries(AGENT_TRAINING_DATA)) {\n    // Add direct examples\n    for (const example of data.examples) {\n      examples.push({\n        task: example,\n        agent,\n        complexity: 'medium',\n      });\n    }\n\n    // Generate variations with keywords\n    for (const keyword of data.keywords) {\n      examples.push({\n        task: `${keyword} a solution for the authentication system`,\n        agent,\n        complexity: 'low',\n      });\n    }\n\n    // Add confusing pairs for hard negatives\n    if (data.confusing_with) {\n      for (const confusingAgent of data.confusing_with) {\n        for (const example of data.examples.slice(0, 2)) {\n          examples.push({\n            task: example,\n            agent,\n            complexity: 'hard',\n            confusing_with: confusingAgent,\n          });\n        }\n      }\n    }\n  }\n\n  return examples;\n}\n\n/**\n * Generate contrastive pairs for training\n */\nexport function generateContrastivePairs(): Array<{\n  anchor: string;\n  positive: string;\n  negative: string;\n  isHard: boolean;\n}> {\n  const pairs: Array<{ anchor: string; positive: string; negative: string; isHard: boolean }> = [];\n  const agents = Object.keys(AGENT_TRAINING_DATA);\n\n  for (const [agent, data] of Object.entries(AGENT_TRAINING_DATA)) {\n    for (const example of data.examples) {\n      // Hard negatives from confusing agents\n      if (data.confusing_with) {\n        for (const negAgent of data.confusing_with) {\n          pairs.push({\n            anchor: example,\n            positive: agent,\n            negative: negAgent,\n            isHard: true,\n          });\n        }\n      }\n\n      // Random negatives\n      const randomNegs = agents.filter(a => a !== agent).slice(0, 2);\n      for (const negAgent of randomNegs) {\n        pairs.push({\n          anchor: example,\n          positive: agent,\n          negative: negAgent,\n          isHard: false,\n        });\n      }\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Get dataset statistics\n */\nexport function getDatasetStats(): DatasetStats {\n  const examples = generateTrainingDataset();\n  const pairs = generateContrastivePairs();\n  const agents = Object.keys(AGENT_TRAINING_DATA);\n\n  return {\n    totalExamples: examples.length,\n    contrastivePairs: pairs.length,\n    agentTypes: agents.length,\n    agents,\n  };\n}\n"]}