ruvector 0.1.64 → 0.1.65

package/bin/cli.js

@@ -2844,6 +2844,14 @@ fi
       }]
     }];
     console.log(chalk.blue('  ✓ Advanced hooks (UserPromptSubmit, PreCompact, Notification)'));
+
+    // Extended environment variables for new capabilities
+    settings.env.RUVECTOR_AST_ENABLED = settings.env.RUVECTOR_AST_ENABLED || 'true';
+    settings.env.RUVECTOR_DIFF_EMBEDDINGS = settings.env.RUVECTOR_DIFF_EMBEDDINGS || 'true';
+    settings.env.RUVECTOR_COVERAGE_ROUTING = settings.env.RUVECTOR_COVERAGE_ROUTING || 'true';
+    settings.env.RUVECTOR_GRAPH_ALGORITHMS = settings.env.RUVECTOR_GRAPH_ALGORITHMS || 'true';
+    settings.env.RUVECTOR_SECURITY_SCAN = settings.env.RUVECTOR_SECURITY_SCAN || 'true';
+    console.log(chalk.blue('  ✓ Extended capabilities (AST, Diff, Coverage, Graph, Security)'));
   }
 
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
@@ -2854,19 +2862,27 @@ fi
   if (opts.claudeMd !== false && (!fs.existsSync(claudeMdPath) || opts.force)) {
     const claudeMdContent = `# Claude Code Project Configuration
 
-## RuVector Self-Learning Intelligence
+## RuVector Self-Learning Intelligence v2.0
 
-This project uses RuVector's self-learning intelligence hooks for enhanced AI-assisted development with Q-learning, vector memory, and automatic agent routing.
+This project uses RuVector's self-learning intelligence hooks with advanced capabilities:
+- **Q-learning** for agent routing optimization
+- **Vector memory** with HNSW indexing (150x faster search)
+- **AST parsing** for code complexity analysis
+- **Diff embeddings** for change classification and risk scoring
+- **Coverage routing** for test-aware agent selection
+- **Graph algorithms** for code structure analysis
+- **Security scanning** for vulnerability detection
+- **10 attention mechanisms** including hyperbolic and graph attention
 
 ### Active Hooks
 
 | Hook | Trigger | Purpose |
 |------|---------|---------|
-| **PreToolUse** | Before Edit/Write/Bash | Agent routing, file analysis, command risk assessment |
-| **PostToolUse** | After Edit/Write/Bash | Q-learning update, pattern recording, outcome tracking |
+| **PreToolUse** | Before Edit/Write/Bash | Agent routing, AST analysis, command risk assessment |
+| **PostToolUse** | After Edit/Write/Bash | Q-learning update, diff embeddings, outcome tracking |
 | **SessionStart** | Conversation begins | Load intelligence state, display learning stats |
 | **Stop** | Conversation ends | Save learning data, export metrics |
-| **UserPromptSubmit** | User sends message | Context suggestions, pattern recommendations |
+| **UserPromptSubmit** | User sends message | RAG context suggestions, pattern recommendations |
 | **PreCompact** | Before context compaction | Preserve important context and memories |
 | **Notification** | Any notification | Track events for learning |
 
@@ -2878,8 +2894,13 @@ This project uses RuVector's self-learning intelligence hooks for enhanced AI-as
 | \`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 (treatment/control) |
+| \`RUVECTOR_AST_ENABLED\` | \`true\` | Enable AST parsing and complexity analysis |
+| \`RUVECTOR_DIFF_EMBEDDINGS\` | \`true\` | Enable diff embeddings and risk scoring |
+| \`RUVECTOR_COVERAGE_ROUTING\` | \`true\` | Enable test coverage-aware routing |
+| \`RUVECTOR_GRAPH_ALGORITHMS\` | \`true\` | Enable graph algorithms (MinCut, Louvain) |
+| \`RUVECTOR_SECURITY_SCAN\` | \`true\` | Enable security vulnerability scanning |
 
-### Commands
+### Core Commands
 
 \`\`\`bash
 # Initialize hooks in a project
@@ -2891,48 +2912,146 @@ npx ruvector hooks stats
 # Route a task to best agent
 npx ruvector hooks route "implement feature X"
 
+# Enhanced routing with AST/coverage/diff signals
+npx ruvector hooks route-enhanced "fix bug" --file src/api.ts
+
 # Store context in vector memory
 npx ruvector hooks remember "important context" -t project
 
 # Recall from memory (semantic search)
 npx ruvector hooks recall "context query"
+\`\`\`
+
+### AST Analysis Commands
+
+\`\`\`bash
+# Analyze file structure, symbols, imports, complexity
+npx ruvector hooks ast-analyze src/index.ts
+
+# Get complexity metrics for multiple files
+npx ruvector hooks ast-complexity src/*.ts --threshold 15
+\`\`\`
+
+### Diff & Risk Analysis Commands
+
+\`\`\`bash
+# Analyze commit with semantic embeddings and risk scoring
+npx ruvector hooks diff-analyze HEAD
+
+# Classify change type (feature, bugfix, refactor, etc.)
+npx ruvector hooks diff-classify
+
+# Find similar past commits
+npx ruvector hooks diff-similar -k 5
+
+# Get risk score only
+npx ruvector hooks diff-analyze --risk-only
+\`\`\`
+
+### Coverage & Testing Commands
 
-# Manual session management
-npx ruvector hooks session-start
-npx ruvector hooks session-end
+\`\`\`bash
+# Get coverage-aware routing for a file
+npx ruvector hooks coverage-route src/api.ts
+
+# Suggest tests for files based on coverage
+npx ruvector hooks coverage-suggest src/*.ts
+\`\`\`
+
+### Graph Analysis Commands
+
+\`\`\`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 Commands
+
+\`\`\`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"
+
+# Git churn analysis (hot spots)
+npx ruvector hooks git-churn --days 30
 \`\`\`
 
+### MCP Tools (via Claude Code)
+
+When using the RuVector MCP server, these tools are available:
+
+| Tool | Description |
+|------|-------------|
+| \`hooks_stats\` | Get intelligence statistics |
+| \`hooks_route\` | Route task to best agent |
+| \`hooks_route_enhanced\` | Enhanced routing with AST/coverage signals |
+| \`hooks_remember\` / \`hooks_recall\` | Vector memory operations |
+| \`hooks_ast_analyze\` | Parse AST and extract symbols |
+| \`hooks_ast_complexity\` | Get complexity metrics |
+| \`hooks_diff_analyze\` | Analyze changes with embeddings |
+| \`hooks_diff_classify\` | Classify change types |
+| \`hooks_coverage_route\` | Coverage-aware routing |
+| \`hooks_coverage_suggest\` | Suggest needed tests |
+| \`hooks_graph_mincut\` | Find code boundaries |
+| \`hooks_graph_cluster\` | Detect communities |
+| \`hooks_security_scan\` | Security vulnerability scan |
+| \`hooks_rag_context\` | RAG context retrieval |
+| \`hooks_git_churn\` | Hot spot analysis |
+| \`hooks_attention_info\` | Available attention mechanisms |
+| \`hooks_gnn_info\` | GNN layer capabilities |
+
+### Attention Mechanisms
+
+RuVector includes 10 attention mechanisms:
+
+1. **DotProductAttention** - Scaled dot-product attention
+2. **MultiHeadAttention** - Parallel attention heads
+3. **FlashAttention** - Memory-efficient tiled attention
+4. **HyperbolicAttention** - Poincaré ball hyperbolic space
+5. **LinearAttention** - O(n) linear complexity
+6. **MoEAttention** - Mixture-of-Experts sparse attention
+7. **GraphRoPeAttention** - Rotary position for graphs
+8. **EdgeFeaturedAttention** - Edge-aware graph attention
+9. **DualSpaceAttention** - Euclidean + Hyperbolic hybrid
+10. **LocalGlobalAttention** - Sliding window + global tokens
+
 ### How It Works
 
-1. **Pre-edit hooks** analyze files and suggest the best agent based on learned patterns
-2. **Post-edit hooks** record outcomes to improve future suggestions via Q-learning
-3. **Memory hooks** store and retrieve context using vector embeddings (cosine similarity)
-4. **Session hooks** manage learning state across conversations
-5. **UserPromptSubmit** provides context suggestions on each message
-6. **PreCompact** preserves critical context before conversation compaction
-7. **Notification** tracks all events for continuous learning
+1. **Pre-edit hooks** analyze files via AST and suggest agents based on Q-learned patterns
+2. **Post-edit hooks** generate diff embeddings to improve future routing
+3. **Coverage routing** adjusts agent weights based on test coverage
+4. **Graph algorithms** detect code communities for module boundaries
+5. **Security scanning** identifies common vulnerability patterns
+6. **RAG context** retrieves relevant memories using HNSW search
+7. **Attention mechanisms** provide advanced embedding transformations
 
 ### Learning Data
 
 Stored in \`.ruvector/intelligence.json\`:
 - **Q-table patterns**: State-action values for agent routing
-- **Vector memories**: Embeddings for semantic recall
-- **Trajectories**: Learning history for improvement tracking
+- **Vector memories**: ONNX embeddings with HNSW indexing
+- **Trajectories**: SONA trajectory tracking for meta-learning
+- **Co-edit patterns**: File relationship graphs
 - **Error patterns**: Known issues and suggested fixes
+- **Diff embeddings**: Change classification patterns
 
 ### Init Options
 
 \`\`\`bash
-npx ruvector hooks init              # Full configuration
+npx ruvector hooks init              # Full configuration with all capabilities
 npx ruvector hooks init --minimal    # Basic hooks only
-npx ruvector hooks init --no-env     # Skip environment variables
-npx ruvector hooks init --no-permissions  # Skip permissions
-npx ruvector hooks init --no-claude-md    # Skip this file
-npx ruvector hooks init --force      # Overwrite existing
+npx ruvector hooks init --pretrain   # Initialize + pretrain from git history
+npx ruvector hooks init --build-agents quality  # Generate optimized agents
+npx ruvector hooks init --force      # Overwrite existing configuration
 \`\`\`
 
 ---
-*Powered by [RuVector](https://github.com/ruvnet/ruvector) self-learning intelligence*
+*Powered by [RuVector](https://github.com/ruvnet/ruvector) self-learning intelligence v2.0*
 `;
     fs.writeFileSync(claudeMdPath, claudeMdContent);
     console.log(chalk.green('✅ CLAUDE.md created in project root'));
@@ -3294,6 +3413,513 @@ hooksCmd.command('force-learn')
     console.log(JSON.stringify({ success: true, result: 'Learning cycle triggered', stats: intel.stats() }));
   });
 
+// ============================================
+// NEW CAPABILITY COMMANDS (AST, Diff, Coverage, Graph, Security, RAG)
+// ============================================
+
+// Lazy load new modules
+let ASTParser, DiffEmbeddings, CoverageRouter, GraphAlgorithms, ExtendedWorkerPool;
+let newModulesLoaded = false;
+
+function loadNewModules() {
+  if (newModulesLoaded) return true;
+  try {
+    const core = require('../dist/core/index.js');
+    // CodeParser is exported as both CodeParser and ASTParser
+    ASTParser = core.CodeParser || core.ASTParser;
+    DiffEmbeddings = core.default?.parseDiff ? core : require('../dist/core/diff-embeddings.js');
+    CoverageRouter = core.default?.parseIstanbulCoverage ? core : require('../dist/core/coverage-router.js');
+    GraphAlgorithms = core.default?.minCut ? core : require('../dist/core/graph-algorithms.js');
+    ExtendedWorkerPool = core.ExtendedWorkerPool;
+    newModulesLoaded = true;
+    return true;
+  } catch (e) {
+    console.error('loadNewModules error:', e.message);
+    return false;
+  }
+}
+
+// AST Analysis Commands
+hooksCmd.command('ast-analyze')
+  .description('Parse file AST and extract symbols, imports, complexity')
+  .argument('<file>', 'File path to analyze')
+  .option('--json', 'Output as JSON')
+  .option('--symbols', 'Show only symbols')
+  .option('--imports', 'Show only imports')
+  .action(async (file, opts) => {
+    if (!loadNewModules() || !ASTParser) {
+      console.log(JSON.stringify({ success: false, error: 'AST parser not available. Run npm run build.' }));
+      return;
+    }
+    try {
+      const parser = new ASTParser();
+      // CodeParser uses analyze() which returns FileAnalysis
+      const analysis = await parser.analyze(file);
+
+      // Get symbols list
+      const symbols = await parser.getSymbols(file);
+
+      if (opts.json) {
+        console.log(JSON.stringify({
+          success: true,
+          file,
+          language: analysis.language,
+          symbols: symbols.map(s => ({ name: s })),
+          imports: analysis.imports,
+          complexity: { cyclomatic: analysis.complexity, lines: analysis.lines },
+          functions: analysis.functions.length,
+          classes: analysis.classes.length
+        }));
+      } else if (opts.symbols) {
+        console.log(chalk.bold.cyan(`\n📊 Symbols in ${path.basename(file)}:\n`));
+        analysis.functions.forEach(f => console.log(`  function: ${f.name} (line ${f.startLine})`));
+        analysis.classes.forEach(c => console.log(`  class: ${c.name} (line ${c.startLine})`));
+        analysis.types.forEach(t => console.log(`  type: ${t}`));
+      } else if (opts.imports) {
+        console.log(chalk.bold.cyan(`\n📦 Imports in ${path.basename(file)}:\n`));
+        analysis.imports.forEach(i => console.log(`  ${i.source} (${i.type})`));
+      } else {
+        console.log(chalk.bold.cyan(`\n📊 AST Analysis: ${path.basename(file)}\n`));
+        console.log(`  Language: ${analysis.language}`);
+        console.log(`  Functions: ${analysis.functions.length}`);
+        console.log(`  Classes: ${analysis.classes.length}`);
+        console.log(`  Imports: ${analysis.imports.length}`);
+        console.log(`  Complexity: ${analysis.complexity}`);
+        console.log(`  Lines: ${analysis.lines}`);
+        console.log(`  Parse time: ${analysis.parseTime.toFixed(2)}ms`);
+      }
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+hooksCmd.command('ast-complexity')
+  .description('Get complexity metrics for files')
+  .argument('<files...>', 'Files to analyze')
+  .option('--threshold <n>', 'Warn if complexity exceeds threshold', '10')
+  .action(async (files, opts) => {
+    if (!loadNewModules() || !ASTParser) {
+      console.log(JSON.stringify({ success: false, error: 'AST parser not available' }));
+      return;
+    }
+    const parser = new ASTParser();
+    const threshold = parseInt(opts.threshold);
+    const results = [];
+
+    for (const file of files) {
+      try {
+        if (!fs.existsSync(file)) continue;
+        const analysis = await parser.analyze(file);
+        const warning = analysis.complexity > threshold;
+        results.push({
+          file,
+          cyclomatic: analysis.complexity,
+          lines: analysis.lines,
+          functions: analysis.functions.length,
+          classes: analysis.classes.length,
+          warning
+        });
+      } catch (e) {
+        results.push({ file, error: e.message });
+      }
+    }
+
+    console.log(JSON.stringify({ success: true, results, threshold }));
+  });
+
+// Diff Embedding Commands
+hooksCmd.command('diff-analyze')
+  .description('Analyze git diff with semantic embeddings and risk scoring')
+  .argument('[commit]', 'Commit hash (defaults to staged changes)')
+  .option('--json', 'Output as JSON')
+  .option('--risk-only', 'Show only risk score')
+  .action(async (commit, opts) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Diff embeddings not available' }));
+      return;
+    }
+    try {
+      const diffMod = require('../dist/core/diff-embeddings.js');
+      let analysis;
+      if (commit) {
+        analysis = await diffMod.analyzeCommit(commit);
+      } else {
+        const stagedDiff = diffMod.getStagedDiff();
+        if (!stagedDiff) {
+          console.log(JSON.stringify({ success: false, error: 'No staged changes' }));
+          return;
+        }
+        const hunks = diffMod.parseDiff(stagedDiff);
+        const files = [...new Set(hunks.map(h => h.file))];
+        analysis = {
+          hash: 'staged',
+          message: 'Staged changes',
+          files: await Promise.all(files.map(f => diffMod.analyzeFileDiff(f, stagedDiff))),
+          totalAdditions: hunks.reduce((s, h) => s + h.additions.length, 0),
+          totalDeletions: hunks.reduce((s, h) => s + h.deletions.length, 0),
+          riskScore: 0
+        };
+        analysis.riskScore = analysis.files.reduce((s, f) => s + f.riskScore, 0) / Math.max(1, analysis.files.length);
+      }
+
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, ...analysis }));
+      } else if (opts.riskOnly) {
+        const risk = analysis.riskScore;
+        const level = risk > 0.7 ? 'HIGH' : risk > 0.4 ? 'MEDIUM' : 'LOW';
+        console.log(JSON.stringify({ success: true, riskScore: risk, riskLevel: level }));
+      } else {
+        console.log(chalk.bold.cyan(`\n📊 Diff Analysis: ${analysis.hash}\n`));
+        console.log(`  Message: ${analysis.message || 'N/A'}`);
+        console.log(`  Files: ${analysis.files.length}`);
+        console.log(`  Changes: +${analysis.totalAdditions} -${analysis.totalDeletions}`);
+        const risk = analysis.riskScore;
+        const riskColor = risk > 0.7 ? chalk.red : risk > 0.4 ? chalk.yellow : chalk.green;
+        console.log(`  Risk: ${riskColor((risk * 100).toFixed(0) + '%')}`);
+        analysis.files.forEach(f => {
+          console.log(`    ${f.file}: ${f.category} (+${f.totalAdditions}/-${f.totalDeletions})`);
+        });
+      }
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+hooksCmd.command('diff-classify')
+  .description('Classify a change type (feature, bugfix, refactor, etc.)')
+  .argument('[commit]', 'Commit hash')
+  .action(async (commit) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Diff embeddings not available' }));
+      return;
+    }
+    try {
+      const diffMod = require('../dist/core/diff-embeddings.js');
+      const analysis = await diffMod.analyzeCommit(commit || 'HEAD');
+      const categories = {};
+      analysis.files.forEach(f => {
+        categories[f.category] = (categories[f.category] || 0) + 1;
+      });
+      const primary = Object.entries(categories).sort((a, b) => b[1] - a[1])[0];
+      console.log(JSON.stringify({
+        success: true,
+        commit: analysis.hash,
+        message: analysis.message,
+        primaryCategory: primary ? primary[0] : 'unknown',
+        categories
+      }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+hooksCmd.command('diff-similar')
+  .description('Find similar past commits based on diff embeddings')
+  .option('-k, --top-k <n>', 'Number of results', '5')
+  .option('--commits <n>', 'How many recent commits to search', '50')
+  .action(async (opts) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Diff embeddings not available' }));
+      return;
+    }
+    try {
+      const diffMod = require('../dist/core/diff-embeddings.js');
+      const stagedDiff = diffMod.getStagedDiff() || diffMod.getUnstagedDiff();
+      if (!stagedDiff) {
+        console.log(JSON.stringify({ success: false, error: 'No current changes to compare' }));
+        return;
+      }
+      const similar = await diffMod.findSimilarCommits(stagedDiff, parseInt(opts.commits), parseInt(opts.topK));
+      console.log(JSON.stringify({ success: true, similar }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+// Coverage Routing Commands
+hooksCmd.command('coverage-route')
+  .description('Get coverage-aware agent routing for a file')
+  .argument('<file>', 'File to analyze')
+  .action((file) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Coverage router not available' }));
+      return;
+    }
+    try {
+      const covMod = require('../dist/core/coverage-router.js');
+      const reportPath = covMod.findCoverageReport();
+      const summary = reportPath ? covMod.parseIstanbulCoverage(reportPath) : null;
+      const routing = covMod.shouldRouteToTester(file, summary);
+      const weights = covMod.getCoverageRoutingWeight(file, summary);
+      console.log(JSON.stringify({
+        success: true,
+        file,
+        coverageReport: reportPath || 'not found',
+        routeToTester: routing.route,
+        reason: routing.reason,
+        coverage: routing.coverage,
+        agentWeights: weights
+      }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+hooksCmd.command('coverage-suggest')
+  .description('Suggest tests for files based on coverage data')
+  .argument('<files...>', 'Files to analyze')
+  .action((files) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Coverage router not available' }));
+      return;
+    }
+    try {
+      const covMod = require('../dist/core/coverage-router.js');
+      const suggestions = covMod.suggestTests(files);
+      console.log(JSON.stringify({ success: true, suggestions }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+// Graph Algorithm Commands
+hooksCmd.command('graph-mincut')
+  .description('Find optimal code boundaries using MinCut algorithm')
+  .argument('<files...>', 'Files to analyze')
+  .option('--partitions <n>', 'Number of partitions', '2')
+  .action(async (files, opts) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Graph algorithms not available' }));
+      return;
+    }
+    try {
+      const graphMod = require('../dist/core/graph-algorithms.js');
+      // Build dependency graph from files
+      const nodes = files.map(f => path.basename(f, path.extname(f)));
+      const edges = [];
+      // Simple edge detection based on imports
+      for (const file of files) {
+        if (!fs.existsSync(file)) continue;
+        const content = fs.readFileSync(file, 'utf-8');
+        const imports = content.match(/from ['"]\.\/([^'"]+)['"]/g) || [];
+        imports.forEach(imp => {
+          const target = imp.match(/from ['"]\.\/([^'"]+)['"]/)?.[1];
+          if (target && nodes.includes(target)) {
+            edges.push({ source: path.basename(file, path.extname(file)), target, weight: 1 });
+          }
+        });
+      }
+      const result = graphMod.minCut(nodes, edges);
+      console.log(JSON.stringify({ success: true, nodes: nodes.length, edges: edges.length, ...result }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+hooksCmd.command('graph-cluster')
+  .description('Detect code communities using spectral/Louvain clustering')
+  .argument('<files...>', 'Files to analyze')
+  .option('--method <type>', 'Clustering method: spectral, louvain', 'louvain')
+  .option('--clusters <n>', 'Number of clusters (spectral only)', '3')
+  .action(async (files, opts) => {
+    if (!loadNewModules()) {
+      console.log(JSON.stringify({ success: false, error: 'Graph algorithms not available' }));
+      return;
+    }
+    try {
+      const graphMod = require('../dist/core/graph-algorithms.js');
+      const nodes = files.map(f => path.basename(f, path.extname(f)));
+      const edges = [];
+      for (const file of files) {
+        if (!fs.existsSync(file)) continue;
+        const content = fs.readFileSync(file, 'utf-8');
+        const imports = content.match(/from ['"]\.\/([^'"]+)['"]/g) || [];
+        imports.forEach(imp => {
+          const target = imp.match(/from ['"]\.\/([^'"]+)['"]/)?.[1];
+          if (target && nodes.includes(target)) {
+            edges.push({ source: path.basename(file, path.extname(file)), target, weight: 1 });
+          }
+        });
+      }
+      let result;
+      if (opts.method === 'spectral') {
+        result = graphMod.spectralClustering(nodes, edges, parseInt(opts.clusters));
+      } else {
+        result = graphMod.louvainCommunities(nodes, edges);
+      }
+      console.log(JSON.stringify({ success: true, method: opts.method, ...result }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+// Security Scan Command
+hooksCmd.command('security-scan')
+  .description('Parallel security vulnerability scan')
+  .argument('<files...>', 'Files to scan')
+  .option('--json', 'Output as JSON')
+  .action(async (files, opts) => {
+    if (!loadNewModules() || !ExtendedWorkerPool) {
+      // Fallback to basic pattern matching
+      const patterns = [
+        { pattern: /eval\s*\(/g, severity: 'high', message: 'eval() usage detected' },
+        { pattern: /innerHTML\s*=/g, severity: 'medium', message: 'innerHTML assignment (XSS risk)' },
+        { pattern: /document\.write/g, severity: 'medium', message: 'document.write usage' },
+        { pattern: /password\s*=\s*['"][^'"]+['"]/gi, severity: 'critical', message: 'Hardcoded password' },
+        { pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/gi, severity: 'critical', message: 'Hardcoded API key' },
+        { pattern: /exec\s*\(/g, severity: 'high', message: 'exec() usage (command injection risk)' },
+        { pattern: /dangerouslySetInnerHTML/g, severity: 'medium', message: 'React dangerouslySetInnerHTML' },
+        { pattern: /SELECT.*FROM.*WHERE.*\+/gi, severity: 'high', message: 'SQL injection risk' },
+      ];
+
+      const findings = [];
+      for (const file of files) {
+        if (!fs.existsSync(file)) continue;
+        try {
+          const content = fs.readFileSync(file, 'utf-8');
+          const lines = content.split('\n');
+          patterns.forEach(p => {
+            let match;
+            lines.forEach((line, idx) => {
+              if (p.pattern.test(line)) {
+                findings.push({ file, line: idx + 1, severity: p.severity, message: p.message });
+              }
+              p.pattern.lastIndex = 0;
+            });
+          });
+        } catch (e) {}
+      }
+      console.log(JSON.stringify({ success: true, findings, scanned: files.length }));
+      return;
+    }
+    // Use parallel worker if available
+    try {
+      const pool = new ExtendedWorkerPool();
+      const results = await pool.securityScan(files);
+      console.log(JSON.stringify({ success: true, ...results }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+// RAG Context Command
+hooksCmd.command('rag-context')
+  .description('Get RAG-enhanced context for a query')
+  .argument('<query...>', 'Query for context')
+  .option('-k, --top-k <n>', 'Number of results', '5')
+  .option('--rerank', 'Rerank results by relevance')
+  .action(async (query, opts) => {
+    const intel = new Intelligence();
+    const queryStr = query.join(' ');
+
+    // Use async recall with engine (VectorDB + HNSW)
+    const memories = await intel.recallAsync(queryStr, parseInt(opts.topK));
+
+    // Rerank if requested
+    let results = memories;
+    if (opts.rerank && ExtendedWorkerPool) {
+      try {
+        const pool = new ExtendedWorkerPool();
+        results = await pool.rankContext(queryStr, memories.map(m => m.content || m));
+      } catch (e) {}
+    }
+
+    console.log(JSON.stringify({ success: true, query: queryStr, results }));
+  });
+
+// Git Churn Analysis Command
+hooksCmd.command('git-churn')
+  .description('Analyze git churn to find hot spots')
+  .option('--days <n>', 'Number of days to analyze', '30')
+  .option('--top <n>', 'Top N files', '10')
+  .action((opts) => {
+    try {
+      const { execSync } = require('child_process');
+      const since = new Date(Date.now() - parseInt(opts.days) * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+      const log = execSync(`git log --since="${since}" --name-only --format="" 2>/dev/null`, { encoding: 'utf-8' });
+      const files = log.trim().split('\n').filter(Boolean);
+      const counts = {};
+      files.forEach(f => { counts[f] = (counts[f] || 0) + 1; });
+      const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]).slice(0, parseInt(opts.top));
+      const hotSpots = sorted.map(([file, count]) => ({ file, changes: count }));
+      console.log(JSON.stringify({ success: true, days: parseInt(opts.days), hotSpots }));
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: e.message }));
+    }
+  });
+
+// Enhanced route command that uses new capabilities
+hooksCmd.command('route-enhanced')
+  .description('Enhanced routing using AST, coverage, and diff analysis')
+  .argument('<task...>', 'Task description')
+  .option('--file <file>', 'File context')
+  .action(async (task, opts) => {
+    const intel = new Intelligence();
+    const taskStr = task.join(' ');
+
+    // Base routing
+    const baseRoute = await intel.routeAsync(taskStr, opts.file, null, 'edit');
+
+    // Enhance with coverage if available
+    let coverageWeight = null;
+    if (opts.file && loadNewModules()) {
+      try {
+        const covMod = require('../dist/core/coverage-router.js');
+        const reportPath = covMod.findCoverageReport();
+        if (reportPath) {
+          coverageWeight = covMod.getCoverageRoutingWeight(opts.file);
+        }
+      } catch (e) {}
+    }
+
+    // Enhance with AST complexity if available
+    let complexity = null;
+    if (opts.file && loadNewModules() && ASTParser) {
+      try {
+        const parser = new ASTParser();
+        const code = fs.readFileSync(opts.file, 'utf-8');
+        const ext = path.extname(opts.file).slice(1);
+        const result = parser.parse(code, ext);
+        complexity = parser.calculateComplexity(result);
+      } catch (e) {}
+    }
+
+    // Adjust routing based on signals
+    let finalAgent = baseRoute.agent;
+    let adjustedConfidence = baseRoute.confidence;
+    const signals = [];
+
+    if (coverageWeight && coverageWeight.tester > 0.4) {
+      signals.push('low coverage detected');
+      if (coverageWeight.tester > adjustedConfidence * 0.5) {
+        finalAgent = 'tester';
+        adjustedConfidence = coverageWeight.tester;
+      }
+    }
+
+    if (complexity && complexity.cyclomatic > 15) {
+      signals.push('high complexity detected');
+      if (finalAgent === 'coder') {
+        finalAgent = 'reviewer';
+        adjustedConfidence = Math.max(adjustedConfidence, 0.7);
+      }
+    }
+
+    console.log(JSON.stringify({
+      success: true,
+      agent: finalAgent,
+      confidence: adjustedConfidence,
+      reason: baseRoute.reason,
+      signals,
+      coverageWeight,
+      complexity
+    }));
+  });
+
+// ============================================
+// END NEW CAPABILITY COMMANDS
+// ============================================
+
 // Verify hooks are working
 hooksCmd.command('verify')
   .description('Verify hooks are working correctly')
@@ -3841,9 +4467,187 @@ hooksCmd.command('pretrain')
       console.log(chalk.yellow(`  ⚠ Directory analysis skipped: ${e.message}`));
     }
 
+    // Phase 5: Analyze code complexity with AST
+    console.log(chalk.yellow('\n📊 Phase 5: Analyzing code complexity via AST...\n'));
+
+    try {
+      if (loadNewModules() && ASTParser) {
+        const parser = new ASTParser();
+        const codeFiles = (intel.data.fileList || []).filter(f =>
+          ['.ts', '.js', '.tsx', '.jsx', '.py', '.rs', '.go'].includes(path.extname(f))
+        ).slice(0, 50); // Analyze up to 50 files
+
+        let complexityStats = { high: 0, medium: 0, low: 0, total: 0 };
+
+        for (const file of codeFiles) {
+          try {
+            if (!fs.existsSync(file)) continue;
+            const code = fs.readFileSync(file, 'utf-8');
+            const ext = path.extname(file).slice(1);
+            const lang = { ts: 'typescript', tsx: 'typescript', js: 'javascript', py: 'python', rs: 'rust', go: 'go' }[ext];
+            if (!lang) continue;
+
+            const result = parser.parse(code, lang);
+            const complexity = parser.calculateComplexity(result);
+
+            // Store complexity data
+            intel.data.complexity = intel.data.complexity || {};
+            intel.data.complexity[file] = complexity;
+
+            if (complexity.cyclomatic > 15) complexityStats.high++;
+            else if (complexity.cyclomatic > 8) complexityStats.medium++;
+            else complexityStats.low++;
+            complexityStats.total++;
+          } catch (e) { /* skip errors */ }
+        }
+
+        stats.complexity = complexityStats;
+        console.log(chalk.green(`  ✓ Analyzed ${complexityStats.total} files`));
+        console.log(chalk.green(`  ✓ Complexity: ${complexityStats.high} high, ${complexityStats.medium} medium, ${complexityStats.low} low`));
+      } else {
+        console.log(chalk.dim('  ⏭️  AST parser not available, skipping'));
+      }
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Complexity analysis skipped: ${e.message}`));
+    }
+
+    // Phase 6: Analyze diff patterns from recent commits
+    console.log(chalk.yellow('\n🔄 Phase 6: Analyzing diff patterns for change classification...\n'));
+
+    try {
+      const diffMod = require('../dist/core/diff-embeddings.js');
+      const recentCommits = execSync(`git log --format="%H" -n 20 2>/dev/null`, { encoding: 'utf-8' }).trim().split('\n').filter(h => h);
+
+      let changeTypes = { feature: 0, bugfix: 0, refactor: 0, docs: 0, test: 0, config: 0, unknown: 0 };
+
+      for (const hash of recentCommits.slice(0, 10)) {
+        try {
+          const analysis = await diffMod.analyzeCommit(hash);
+          analysis.files.forEach(f => {
+            changeTypes[f.category] = (changeTypes[f.category] || 0) + 1;
+          });
+        } catch (e) { /* skip */ }
+      }
+
+      intel.data.changePatterns = changeTypes;
+      stats.changePatterns = changeTypes;
+      console.log(chalk.green(`  ✓ Analyzed ${recentCommits.length} commits`));
+      console.log(chalk.green(`  ✓ Change types: ${Object.entries(changeTypes).filter(([,v]) => v > 0).map(([k,v]) => `${k}:${v}`).join(', ')}`));
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Diff analysis skipped: ${e.message}`));
+    }
+
+    // Phase 7: Check test coverage if available
+    console.log(chalk.yellow('\n🧪 Phase 7: Checking test coverage data...\n'));
+
+    try {
+      const covMod = require('../dist/core/coverage-router.js');
+      const reportPath = covMod.findCoverageReport();
+
+      if (reportPath) {
+        const summary = covMod.parseIstanbulCoverage(reportPath);
+        intel.data.coverage = {
+          overall: summary.overall,
+          lowCoverageFiles: summary.lowCoverageFiles.slice(0, 20),
+          uncoveredFiles: summary.uncoveredFiles.slice(0, 10)
+        };
+        stats.coverage = summary.overall;
+        console.log(chalk.green(`  ✓ Found coverage report: ${reportPath}`));
+        console.log(chalk.green(`  ✓ Overall: Lines ${summary.overall.lines.toFixed(1)}%, Functions ${summary.overall.functions.toFixed(1)}%`));
+        console.log(chalk.green(`  ✓ ${summary.lowCoverageFiles.length} low-coverage files, ${summary.uncoveredFiles.length} uncovered`));
+      } else {
+        console.log(chalk.dim('  ⏭️  No coverage report found'));
+      }
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Coverage check skipped: ${e.message}`));
+    }
+
+    // Phase 8: Detect available attention/GNN capabilities
+    console.log(chalk.yellow('\n🧠 Phase 8: Detecting neural capabilities...\n'));
+
+    try {
+      let capabilities = { attention: false, gnn: false, mechanisms: [] };
+
+      try {
+        const attention = require('@ruvector/attention');
+        capabilities.attention = true;
+        capabilities.mechanisms = [
+          'DotProductAttention', 'MultiHeadAttention', 'FlashAttention',
+          'HyperbolicAttention', 'LinearAttention', 'MoEAttention',
+          'GraphRoPeAttention', 'DualSpaceAttention', 'LocalGlobalAttention'
+        ];
+        console.log(chalk.green(`  ✓ Attention: 10 mechanisms available`));
+      } catch (e) {
+        console.log(chalk.dim('  ⏭️  @ruvector/attention not installed'));
+      }
+
+      try {
+        const gnn = require('@ruvector/gnn');
+        capabilities.gnn = true;
+        console.log(chalk.green(`  ✓ GNN: RuvectorLayer, TensorCompress available`));
+      } catch (e) {
+        console.log(chalk.dim('  ⏭️  @ruvector/gnn not installed'));
+      }
+
+      intel.data.neuralCapabilities = capabilities;
+      stats.neural = capabilities;
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Neural detection skipped: ${e.message}`));
+    }
+
+    // Phase 9: Build code graph for community detection
+    console.log(chalk.yellow('\n🔗 Phase 9: Building code relationship graph...\n'));
+
+    try {
+      const graphMod = require('../dist/core/graph-algorithms.js');
+      const codeFiles = execSync('git ls-files "*.ts" "*.js" 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim().split('\n').filter(f => f);
+
+      if (codeFiles.length > 5 && codeFiles.length < 200) {
+        const nodes = codeFiles.map(f => path.basename(f, path.extname(f)));
+        const edges = [];
+
+        for (const file of codeFiles.slice(0, 100)) {
+          try {
+            if (!fs.existsSync(file)) continue;
+            const content = fs.readFileSync(file, 'utf-8');
+            const imports = content.match(/from ['"]\.\/([^'"]+)['"]/g) || [];
+            imports.forEach(imp => {
+              const target = imp.match(/from ['"]\.\/([^'"]+)['"]/)?.[1];
+              if (target) {
+                const targetBase = path.basename(target, path.extname(target));
+                if (nodes.includes(targetBase)) {
+                  edges.push({ source: path.basename(file, path.extname(file)), target: targetBase, weight: 1 });
+                }
+              }
+            });
+          } catch (e) { /* skip */ }
+        }
+
+        if (edges.length > 0) {
+          const communities = graphMod.louvainCommunities(nodes, edges);
+          intel.data.codeGraph = {
+            nodes: nodes.length,
+            edges: edges.length,
+            communities: communities.numCommunities,
+            modularity: communities.modularity
+          };
+          stats.graph = intel.data.codeGraph;
+          console.log(chalk.green(`  ✓ Built graph: ${nodes.length} nodes, ${edges.length} edges`));
+          console.log(chalk.green(`  ✓ Found ${communities.numCommunities} communities (modularity: ${communities.modularity.toFixed(3)})`));
+        } else {
+          console.log(chalk.dim('  ⏭️  Not enough import relationships found'));
+        }
+      } else {
+        console.log(chalk.dim(`  ⏭️  Skipped (${codeFiles.length} files - need 5-200)`));
+      }
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Graph analysis skipped: ${e.message}`));
+    }
+
     // Save all learning data
     intel.data.pretrained = {
       date: new Date().toISOString(),
+      version: '2.0',
       stats: stats
     };
     intel.save();
@@ -3855,6 +4659,11 @@ hooksCmd.command('pretrain')
     console.log(`  🧠 ${stats.patterns} agent routing patterns`);
     console.log(`  🔗 ${stats.coedits} co-edit patterns`);
     console.log(`  💾 ${stats.memories} memory entries`);
+    if (stats.complexity) console.log(`  📊 ${stats.complexity.total} files analyzed for complexity`);
+    if (stats.changePatterns) console.log(`  🔄 Change patterns detected`);
+    if (stats.coverage) console.log(`  🧪 Coverage: ${stats.coverage.lines.toFixed(1)}% lines`);
+    if (stats.neural?.attention) console.log(`  🧠 10 attention mechanisms available`);
+    if (stats.graph) console.log(`  🔗 ${stats.graph.communities} code communities detected`);
     console.log(chalk.dim('\nThe intelligence layer will now provide better recommendations.'));
   });