dearsky/wifi-densepose
1
0
Fork 0
Code Issues 20 Pull Requests 5 Actions Packages Projects Releases 1 Wiki Activity

Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

Browse Source
This commit is contained in:
ruv
2026-02-28 14:39:40 -05:00
parent 7885bf6278 d803bfe2b1
commit cd5943df23
7854 changed files with 3522914 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

550
vendor/ruvector/.claude/skills/agentdb-advanced/SKILL.md vendored Normal file
View File

@@ -0,0 +1,550 @@
---
name: "AgentDB Advanced Features"
description: "Master advanced AgentDB features including QUIC synchronization, multi-database management, custom distance metrics, hybrid search, and distributed systems integration. Use when building distributed AI systems, multi-agent coordination, or advanced vector search applications."
---
# AgentDB Advanced Features
## What This Skill Does
Covers advanced AgentDB capabilities for distributed systems, multi-database coordination, custom distance metrics, hybrid search (vector + metadata), QUIC synchronization, and production deployment patterns. Enables building sophisticated AI systems with sub-millisecond cross-node communication and advanced search capabilities.
**Performance**: <1ms QUIC sync, hybrid search with filters, custom distance metrics.
## Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow)
- Understanding of distributed systems (for QUIC sync)
- Vector search fundamentals
---
## QUIC Synchronization
### What is QUIC Sync?
QUIC (Quick UDP Internet Connections) enables sub-millisecond latency synchronization between AgentDB instances across network boundaries with automatic retry, multiplexing, and encryption.
**Benefits**:
- <1ms latency between nodes
- Multiplexed streams (multiple operations simultaneously)
- Built-in encryption (TLS 1.3)
- Automatic retry and recovery
- Event-based broadcasting
### Enable QUIC Sync
```typescript
import { createAgentDBAdapter } from 'agentic-flow/reasoningbank';
// Initialize with QUIC synchronization
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/distributed.db',
enableQUICSync: true,
syncPort: 4433,
syncPeers: [
'192.168.1.10:4433',
'192.168.1.11:4433',
'192.168.1.12:4433',
],
});
// Patterns automatically sync across all peers
await adapter.insertPattern({
// ... pattern data
});
// Available on all peers within ~1ms
```
### QUIC Configuration
```typescript
const adapter = await createAgentDBAdapter({
enableQUICSync: true,
syncPort: 4433, // QUIC server port
syncPeers: ['host1:4433'], // Peer addresses
syncInterval: 1000, // Sync interval (ms)
syncBatchSize: 100, // Patterns per batch
maxRetries: 3, // Retry failed syncs
compression: true, // Enable compression
});
```
### Multi-Node Deployment
```bash
# Node 1 (192.168.1.10)
AGENTDB_QUIC_SYNC=true \
AGENTDB_QUIC_PORT=4433 \
AGENTDB_QUIC_PEERS=192.168.1.11:4433,192.168.1.12:4433 \
node server.js
# Node 2 (192.168.1.11)
AGENTDB_QUIC_SYNC=true \
AGENTDB_QUIC_PORT=4433 \
AGENTDB_QUIC_PEERS=192.168.1.10:4433,192.168.1.12:4433 \
node server.js
# Node 3 (192.168.1.12)
AGENTDB_QUIC_SYNC=true \
AGENTDB_QUIC_PORT=4433 \
AGENTDB_QUIC_PEERS=192.168.1.10:4433,192.168.1.11:4433 \
node server.js
```
---
## Distance Metrics
### Cosine Similarity (Default)
Best for normalized vectors, semantic similarity:
```bash
# CLI
npx agentdb@latest query ./vectors.db "[0.1,0.2,...]" -m cosine
# API
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
metric: 'cosine',
k: 10,
});
```
**Use Cases**:
- Text embeddings (BERT, GPT, etc.)
- Semantic search
- Document similarity
- Most general-purpose applications
**Formula**: `cos(θ) = (A · B) / (||A|| × ||B||)`
**Range**: [-1, 1] (1 = identical, -1 = opposite)
### Euclidean Distance (L2)
Best for spatial data, geometric similarity:
```bash
# CLI
npx agentdb@latest query ./vectors.db "[0.1,0.2,...]" -m euclidean
# API
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
metric: 'euclidean',
k: 10,
});
```
**Use Cases**:
- Image embeddings
- Spatial data
- Computer vision
- When vector magnitude matters
**Formula**: `d = √(Σ(ai - bi)²)`
**Range**: [0, ∞] (0 = identical, ∞ = very different)
### Dot Product
Best for pre-normalized vectors, fast computation:
```bash
# CLI
npx agentdb@latest query ./vectors.db "[0.1,0.2,...]" -m dot
# API
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
metric: 'dot',
k: 10,
});
```
**Use Cases**:
- Pre-normalized embeddings
- Fast similarity computation
- When vectors are already unit-length
**Formula**: `dot = Σ(ai × bi)`
**Range**: [-∞, ∞] (higher = more similar)
### Custom Distance Metrics
```typescript
// Implement custom distance function
function customDistance(vec1: number[], vec2: number[]): number {
// Weighted Euclidean distance
const weights = [1.0, 2.0, 1.5, ...];
let sum = 0;
for (let i = 0; i < vec1.length; i++) {
sum += weights[i] * Math.pow(vec1[i] - vec2[i], 2);
}
return Math.sqrt(sum);
}
// Use in search (requires custom implementation)
```
---
## Hybrid Search (Vector + Metadata)
### Basic Hybrid Search
Combine vector similarity with metadata filtering:
```typescript
// Store documents with metadata
await adapter.insertPattern({
id: '',
type: 'document',
domain: 'research-papers',
pattern_data: JSON.stringify({
embedding: documentEmbedding,
text: documentText,
metadata: {
author: 'Jane Smith',
year: 2025,
category: 'machine-learning',
citations: 150,
}
}),
confidence: 1.0,
usage_count: 0,
success_count: 0,
created_at: Date.now(),
last_used: Date.now(),
});
// Hybrid search: vector similarity + metadata filters
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'research-papers',
k: 20,
filters: {
year: { $gte: 2023 }, // Published 2023 or later
category: 'machine-learning', // ML papers only
citations: { $gte: 50 }, // Highly cited
},
});
```
### Advanced Filtering
```typescript
// Complex metadata queries
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'products',
k: 50,
filters: {
price: { $gte: 10, $lte: 100 }, // Price range
category: { $in: ['electronics', 'gadgets'] }, // Multiple categories
rating: { $gte: 4.0 }, // High rated
inStock: true, // Available
tags: { $contains: 'wireless' }, // Has tag
},
});
```
### Weighted Hybrid Search
Combine vector and metadata scores:
```typescript
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'content',
k: 20,
hybridWeights: {
vectorSimilarity: 0.7, // 70% weight on semantic similarity
metadataScore: 0.3, // 30% weight on metadata match
},
filters: {
category: 'technology',
recency: { $gte: Date.now() - 30 * 24 * 3600000 }, // Last 30 days
},
});
```
---
## Multi-Database Management
### Multiple Databases
```typescript
// Separate databases for different domains
const knowledgeDB = await createAgentDBAdapter({
dbPath: '.agentdb/knowledge.db',
});
const conversationDB = await createAgentDBAdapter({
dbPath: '.agentdb/conversations.db',
});
const codeDB = await createAgentDBAdapter({
dbPath: '.agentdb/code.db',
});
// Use appropriate database for each task
await knowledgeDB.insertPattern({ /* knowledge */ });
await conversationDB.insertPattern({ /* conversation */ });
await codeDB.insertPattern({ /* code */ });
```
### Database Sharding
```typescript
// Shard by domain for horizontal scaling
const shards = {
'domain-a': await createAgentDBAdapter({ dbPath: '.agentdb/shard-a.db' }),
'domain-b': await createAgentDBAdapter({ dbPath: '.agentdb/shard-b.db' }),
'domain-c': await createAgentDBAdapter({ dbPath: '.agentdb/shard-c.db' }),
};
// Route queries to appropriate shard
function getDBForDomain(domain: string) {
const shardKey = domain.split('-')[0]; // Extract shard key
return shards[shardKey] || shards['domain-a'];
}
// Insert to correct shard
const db = getDBForDomain('domain-a-task');
await db.insertPattern({ /* ... */ });
```
---
## MMR (Maximal Marginal Relevance)
Retrieve diverse results to avoid redundancy:
```typescript
// Without MMR: Similar results may be redundant
const standardResults = await adapter.retrieveWithReasoning(queryEmbedding, {
k: 10,
useMMR: false,
});
// With MMR: Diverse, non-redundant results
const diverseResults = await adapter.retrieveWithReasoning(queryEmbedding, {
k: 10,
useMMR: true,
mmrLambda: 0.5, // Balance relevance (0) vs diversity (1)
});
```
**MMR Parameters**:
- `mmrLambda = 0`: Maximum relevance (may be redundant)
- `mmrLambda = 0.5`: Balanced (default)
- `mmrLambda = 1`: Maximum diversity (may be less relevant)
**Use Cases**:
- Search result diversification
- Recommendation systems
- Avoiding echo chambers
- Exploratory search
---
## Context Synthesis
Generate rich context from multiple memories:
```typescript
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'problem-solving',
k: 10,
synthesizeContext: true, // Enable context synthesis
});
// ContextSynthesizer creates coherent narrative
console.log('Synthesized Context:', result.context);
// "Based on 10 similar problem-solving attempts, the most effective
// approach involves: 1) analyzing root cause, 2) brainstorming solutions,
// 3) evaluating trade-offs, 4) implementing incrementally. Success rate: 85%"
console.log('Patterns:', result.patterns);
// Extracted common patterns across memories
```
---
## Production Patterns
### Connection Pooling
```typescript
// Singleton pattern for shared adapter
class AgentDBPool {
private static instance: AgentDBAdapter;
static async getInstance() {
if (!this.instance) {
this.instance = await createAgentDBAdapter({
dbPath: '.agentdb/production.db',
quantizationType: 'scalar',
cacheSize: 2000,
});
}
return this.instance;
}
}
// Use in application
const db = await AgentDBPool.getInstance();
const results = await db.retrieveWithReasoning(queryEmbedding, { k: 10 });
```
### Error Handling
```typescript
async function safeRetrieve(queryEmbedding: number[], options: any) {
try {
const result = await adapter.retrieveWithReasoning(queryEmbedding, options);
return result;
} catch (error) {
if (error.code === 'DIMENSION_MISMATCH') {
console.error('Query embedding dimension mismatch');
// Handle dimension error
} else if (error.code === 'DATABASE_LOCKED') {
// Retry with exponential backoff
await new Promise(resolve => setTimeout(resolve, 100));
return safeRetrieve(queryEmbedding, options);
}
throw error;
}
}
```
### Monitoring and Logging
```typescript
// Performance monitoring
const startTime = Date.now();
const result = await adapter.retrieveWithReasoning(queryEmbedding, { k: 10 });
const latency = Date.now() - startTime;
if (latency > 100) {
console.warn('Slow query detected:', latency, 'ms');
}
// Log statistics
const stats = await adapter.getStats();
console.log('Database Stats:', {
totalPatterns: stats.totalPatterns,
dbSize: stats.dbSize,
cacheHitRate: stats.cacheHitRate,
avgSearchLatency: stats.avgSearchLatency,
});
```
---
## CLI Advanced Operations
### Database Import/Export
```bash
# Export with compression
npx agentdb@latest export ./vectors.db ./backup.json.gz --compress
# Import from backup
npx agentdb@latest import ./backup.json.gz --decompress
# Merge databases
npx agentdb@latest merge ./db1.sqlite ./db2.sqlite ./merged.sqlite
```
### Database Optimization
```bash
# Vacuum database (reclaim space)
sqlite3 .agentdb/vectors.db "VACUUM;"
# Analyze for query optimization
sqlite3 .agentdb/vectors.db "ANALYZE;"
# Rebuild indices
npx agentdb@latest reindex ./vectors.db
```
---
## Environment Variables
```bash
# AgentDB configuration
AGENTDB_PATH=.agentdb/reasoningbank.db
AGENTDB_ENABLED=true
# Performance tuning
AGENTDB_QUANTIZATION=binary # binary|scalar|product|none
AGENTDB_CACHE_SIZE=2000
AGENTDB_HNSW_M=16
AGENTDB_HNSW_EF=100
# Learning plugins
AGENTDB_LEARNING=true
# Reasoning agents
AGENTDB_REASONING=true
# QUIC synchronization
AGENTDB_QUIC_SYNC=true
AGENTDB_QUIC_PORT=4433
AGENTDB_QUIC_PEERS=host1:4433,host2:4433
```
---
## Troubleshooting
### Issue: QUIC sync not working
```bash
# Check firewall allows UDP port 4433
sudo ufw allow 4433/udp
# Verify peers are reachable
ping host1
# Check QUIC logs
DEBUG=agentdb:quic node server.js
```
### Issue: Hybrid search returns no results
```typescript
// Relax filters
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
k: 100, // Increase k
filters: {
// Remove or relax filters
},
});
```
### Issue: Memory consolidation too aggressive
```typescript
// Disable automatic optimization
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
optimizeMemory: false, // Disable auto-consolidation
k: 10,
});
```
---
## Learn More
- **QUIC Protocol**: docs/quic-synchronization.pdf
- **Hybrid Search**: docs/hybrid-search-guide.md
- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
- **Website**: https://agentdb.ruv.io
---
**Category**: Advanced / Distributed Systems
**Difficulty**: Advanced
**Estimated Time**: 45-60 minutes

545
vendor/ruvector/.claude/skills/agentdb-learning/SKILL.md vendored Normal file
View File

@@ -0,0 +1,545 @@
---
name: "AgentDB Learning Plugins"
description: "Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms. Includes Decision Transformer, Q-Learning, SARSA, Actor-Critic, and more. Use when building self-learning agents, implementing RL, or optimizing agent behavior through experience."
---
# AgentDB Learning Plugins
## What This Skill Does
Provides access to 9 reinforcement learning algorithms via AgentDB's plugin system. Create, train, and deploy learning plugins for autonomous agents that improve through experience. Includes offline RL (Decision Transformer), value-based learning (Q-Learning), policy gradients (Actor-Critic), and advanced techniques.
**Performance**: Train models 10-100x faster with WASM-accelerated neural inference.
## Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow)
- Basic understanding of reinforcement learning (recommended)
---
## Quick Start with CLI
### Create Learning Plugin
```bash
# Interactive wizard
npx agentdb@latest create-plugin
# Use specific template
npx agentdb@latest create-plugin -t decision-transformer -n my-agent
# Preview without creating
npx agentdb@latest create-plugin -t q-learning --dry-run
# Custom output directory
npx agentdb@latest create-plugin -t actor-critic -o ./plugins
```
### List Available Templates
```bash
# Show all plugin templates
npx agentdb@latest list-templates
# Available templates:
# - decision-transformer (sequence modeling RL - recommended)
# - q-learning (value-based learning)
# - sarsa (on-policy TD learning)
# - actor-critic (policy gradient with baseline)
# - curiosity-driven (exploration-based)
```
### Manage Plugins
```bash
# List installed plugins
npx agentdb@latest list-plugins
# Get plugin information
npx agentdb@latest plugin-info my-agent
# Shows: algorithm, configuration, training status
```
---
## Quick Start with API
```typescript
import { createAgentDBAdapter } from 'agentic-flow/reasoningbank';
// Initialize with learning enabled
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/learning.db',
enableLearning: true, // Enable learning plugins
enableReasoning: true,
cacheSize: 1000,
});
// Store training experience
await adapter.insertPattern({
id: '',
type: 'experience',
domain: 'game-playing',
pattern_data: JSON.stringify({
embedding: await computeEmbedding('state-action-reward'),
pattern: {
state: [0.1, 0.2, 0.3],
action: 2,
reward: 1.0,
next_state: [0.15, 0.25, 0.35],
done: false
}
}),
confidence: 0.9,
usage_count: 1,
success_count: 1,
created_at: Date.now(),
last_used: Date.now(),
});
// Train learning model
const metrics = await adapter.train({
epochs: 50,
batchSize: 32,
});
console.log('Training Loss:', metrics.loss);
console.log('Duration:', metrics.duration, 'ms');
```
---
## Available Learning Algorithms (9 Total)
### 1. Decision Transformer (Recommended)
**Type**: Offline Reinforcement Learning
**Best For**: Learning from logged experiences, imitation learning
**Strengths**: No online interaction needed, stable training
```bash
npx agentdb@latest create-plugin -t decision-transformer -n dt-agent
```
**Use Cases**:
- Learn from historical data
- Imitation learning from expert demonstrations
- Safe learning without environment interaction
- Sequence modeling tasks
**Configuration**:
```json
{
"algorithm": "decision-transformer",
"model_size": "base",
"context_length": 20,
"embed_dim": 128,
"n_heads": 8,
"n_layers": 6
}
```
### 2. Q-Learning
**Type**: Value-Based RL (Off-Policy)
**Best For**: Discrete action spaces, sample efficiency
**Strengths**: Proven, simple, works well for small/medium problems
```bash
npx agentdb@latest create-plugin -t q-learning -n q-agent
```
**Use Cases**:
- Grid worlds, board games
- Navigation tasks
- Resource allocation
- Discrete decision-making
**Configuration**:
```json
{
"algorithm": "q-learning",
"learning_rate": 0.001,
"gamma": 0.99,
"epsilon": 0.1,
"epsilon_decay": 0.995
}
```
### 3. SARSA
**Type**: Value-Based RL (On-Policy)
**Best For**: Safe exploration, risk-sensitive tasks
**Strengths**: More conservative than Q-Learning, better for safety
```bash
npx agentdb@latest create-plugin -t sarsa -n sarsa-agent
```
**Use Cases**:
- Safety-critical applications
- Risk-sensitive decision-making
- Online learning with exploration
**Configuration**:
```json
{
"algorithm": "sarsa",
"learning_rate": 0.001,
"gamma": 0.99,
"epsilon": 0.1
}
```
### 4. Actor-Critic
**Type**: Policy Gradient with Value Baseline
**Best For**: Continuous actions, variance reduction
**Strengths**: Stable, works for continuous/discrete actions
```bash
npx agentdb@latest create-plugin -t actor-critic -n ac-agent
```
**Use Cases**:
- Continuous control (robotics, simulations)
- Complex action spaces
- Multi-agent coordination
**Configuration**:
```json
{
"algorithm": "actor-critic",
"actor_lr": 0.001,
"critic_lr": 0.002,
"gamma": 0.99,
"entropy_coef": 0.01
}
```
### 5. Active Learning
**Type**: Query-Based Learning
**Best For**: Label-efficient learning, human-in-the-loop
**Strengths**: Minimizes labeling cost, focuses on uncertain samples
**Use Cases**:
- Human feedback incorporation
- Label-efficient training
- Uncertainty sampling
- Annotation cost reduction
### 6. Adversarial Training
**Type**: Robustness Enhancement
**Best For**: Safety, robustness to perturbations
**Strengths**: Improves model robustness, adversarial defense
**Use Cases**:
- Security applications
- Robust decision-making
- Adversarial defense
- Safety testing
### 7. Curriculum Learning
**Type**: Progressive Difficulty Training
**Best For**: Complex tasks, faster convergence
**Strengths**: Stable learning, faster convergence on hard tasks
**Use Cases**:
- Complex multi-stage tasks
- Hard exploration problems
- Skill composition
- Transfer learning
### 8. Federated Learning
**Type**: Distributed Learning
**Best For**: Privacy, distributed data
**Strengths**: Privacy-preserving, scalable
**Use Cases**:
- Multi-agent systems
- Privacy-sensitive data
- Distributed training
- Collaborative learning
### 9. Multi-Task Learning
**Type**: Transfer Learning
**Best For**: Related tasks, knowledge sharing
**Strengths**: Faster learning on new tasks, better generalization
**Use Cases**:
- Task families
- Transfer learning
- Domain adaptation
- Meta-learning
---
## Training Workflow
### 1. Collect Experiences
```typescript
// Store experiences during agent execution
for (let i = 0; i < numEpisodes; i++) {
const episode = runEpisode();
for (const step of episode.steps) {
await adapter.insertPattern({
id: '',
type: 'experience',
domain: 'task-domain',
pattern_data: JSON.stringify({
embedding: await computeEmbedding(JSON.stringify(step)),
pattern: {
state: step.state,
action: step.action,
reward: step.reward,
next_state: step.next_state,
done: step.done
}
}),
confidence: step.reward > 0 ? 0.9 : 0.5,
usage_count: 1,
success_count: step.reward > 0 ? 1 : 0,
created_at: Date.now(),
last_used: Date.now(),
});
}
}
```
### 2. Train Model
```typescript
// Train on collected experiences
const trainingMetrics = await adapter.train({
epochs: 100,
batchSize: 64,
learningRate: 0.001,
validationSplit: 0.2,
});
console.log('Training Metrics:', trainingMetrics);
// {
// loss: 0.023,
// valLoss: 0.028,
// duration: 1523,
// epochs: 100
// }
```
### 3. Evaluate Performance
```typescript
// Retrieve similar successful experiences
const testQuery = await computeEmbedding(JSON.stringify(testState));
const result = await adapter.retrieveWithReasoning(testQuery, {
domain: 'task-domain',
k: 10,
synthesizeContext: true,
});
// Evaluate action quality
const suggestedAction = result.memories[0].pattern.action;
const confidence = result.memories[0].similarity;
console.log('Suggested Action:', suggestedAction);
console.log('Confidence:', confidence);
```
---
## Advanced Training Techniques
### Experience Replay
```typescript
// Store experiences in buffer
const replayBuffer = [];
// Sample random batch for training
const batch = sampleRandomBatch(replayBuffer, batchSize: 32);
// Train on batch
await adapter.train({
data: batch,
epochs: 1,
batchSize: 32,
});
```
### Prioritized Experience Replay
```typescript
// Store experiences with priority (TD error)
await adapter.insertPattern({
// ... standard fields
confidence: tdError, // Use TD error as confidence/priority
// ...
});
// Retrieve high-priority experiences
const highPriority = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'task-domain',
k: 32,
minConfidence: 0.7, // Only high TD-error experiences
});
```
### Multi-Agent Training
```typescript
// Collect experiences from multiple agents
for (const agent of agents) {
const experience = await agent.step();
await adapter.insertPattern({
// ... store experience with agent ID
domain: `multi-agent/${agent.id}`,
});
}
// Train shared model
await adapter.train({
epochs: 50,
batchSize: 64,
});
```
---
## Performance Optimization
### Batch Training
```typescript
// Collect batch of experiences
const experiences = collectBatch(size: 1000);
// Batch insert (500x faster)
for (const exp of experiences) {
await adapter.insertPattern({ /* ... */ });
}
// Train on batch
await adapter.train({
epochs: 10,
batchSize: 128, // Larger batch for efficiency
});
```
### Incremental Learning
```typescript
// Train incrementally as new data arrives
setInterval(async () => {
const newExperiences = getNewExperiences();
if (newExperiences.length > 100) {
await adapter.train({
epochs: 5,
batchSize: 32,
});
}
}, 60000); // Every minute
```
---
## Integration with Reasoning Agents
Combine learning with reasoning for better performance:
```typescript
// Train learning model
await adapter.train({ epochs: 50, batchSize: 32 });
// Use reasoning agents for inference
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'decision-making',
k: 10,
useMMR: true, // Diverse experiences
synthesizeContext: true, // Rich context
optimizeMemory: true, // Consolidate patterns
});
// Make decision based on learned experiences + reasoning
const decision = result.context.suggestedAction;
const confidence = result.memories[0].similarity;
```
---
## CLI Operations
```bash
# Create plugin
npx agentdb@latest create-plugin -t decision-transformer -n my-plugin
# List plugins
npx agentdb@latest list-plugins
# Get plugin info
npx agentdb@latest plugin-info my-plugin
# List templates
npx agentdb@latest list-templates
```
---
## Troubleshooting
### Issue: Training not converging
```typescript
// Reduce learning rate
await adapter.train({
epochs: 100,
batchSize: 32,
learningRate: 0.0001, // Lower learning rate
});
```
### Issue: Overfitting
```typescript
// Use validation split
await adapter.train({
epochs: 50,
batchSize: 64,
validationSplit: 0.2, // 20% validation
});
// Enable memory optimization
await adapter.retrieveWithReasoning(queryEmbedding, {
optimizeMemory: true, // Consolidate, reduce overfitting
});
```
### Issue: Slow training
```bash
# Enable quantization for faster inference
# Use binary quantization (32x faster)
```
---
## Learn More
- **Algorithm Papers**: See docs/algorithms/ for detailed papers
- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
- **MCP Integration**: `npx agentdb@latest mcp`
- **Website**: https://agentdb.ruv.io
---
**Category**: Machine Learning / Reinforcement Learning
**Difficulty**: Intermediate to Advanced
**Estimated Time**: 30-60 minutes

339
vendor/ruvector/.claude/skills/agentdb-memory-patterns/SKILL.md vendored Normal file
View File

@@ -0,0 +1,339 @@
---
name: "AgentDB Memory Patterns"
description: "Implement persistent memory patterns for AI agents using AgentDB. Includes session memory, long-term storage, pattern learning, and context management. Use when building stateful agents, chat systems, or intelligent assistants."
---
# AgentDB Memory Patterns
## What This Skill Does
Provides memory management patterns for AI agents using AgentDB's persistent storage and ReasoningBank integration. Enables agents to remember conversations, learn from interactions, and maintain context across sessions.
**Performance**: 150x-12,500x faster than traditional solutions with 100% backward compatibility.
## Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow or standalone)
- Understanding of agent architectures
## Quick Start with CLI
### Initialize AgentDB
```bash
# Initialize vector database
npx agentdb@latest init ./agents.db
# Or with custom dimensions
npx agentdb@latest init ./agents.db --dimension 768
# Use preset configurations
npx agentdb@latest init ./agents.db --preset large
# In-memory database for testing
npx agentdb@latest init ./memory.db --in-memory
```
### Start MCP Server for Claude Code
```bash
# Start MCP server (integrates with Claude Code)
npx agentdb@latest mcp
# Add to Claude Code (one-time setup)
claude mcp add agentdb npx agentdb@latest mcp
```
### Create Learning Plugin
```bash
# Interactive plugin wizard
npx agentdb@latest create-plugin
# Use template directly
npx agentdb@latest create-plugin -t decision-transformer -n my-agent
# Available templates:
# - decision-transformer (sequence modeling RL)
# - q-learning (value-based learning)
# - sarsa (on-policy TD learning)
# - actor-critic (policy gradient)
# - curiosity-driven (exploration-based)
```
## Quick Start with API
```typescript
import { createAgentDBAdapter } from 'agentic-flow/reasoningbank';
// Initialize with default configuration
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/reasoningbank.db',
enableLearning: true, // Enable learning plugins
enableReasoning: true, // Enable reasoning agents
quantizationType: 'scalar', // binary | scalar | product | none
cacheSize: 1000, // In-memory cache
});
// Store interaction memory
const patternId = await adapter.insertPattern({
id: '',
type: 'pattern',
domain: 'conversation',
pattern_data: JSON.stringify({
embedding: await computeEmbedding('What is the capital of France?'),
pattern: {
user: 'What is the capital of France?',
assistant: 'The capital of France is Paris.',
timestamp: Date.now()
}
}),
confidence: 0.95,
usage_count: 1,
success_count: 1,
created_at: Date.now(),
last_used: Date.now(),
});
// Retrieve context with reasoning
const context = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'conversation',
k: 10,
useMMR: true, // Maximal Marginal Relevance
synthesizeContext: true, // Generate rich context
});
```
## Memory Patterns
### 1. Session Memory
```typescript
class SessionMemory {
async storeMessage(role: string, content: string) {
return await db.storeMemory({
sessionId: this.sessionId,
role,
content,
timestamp: Date.now()
});
}
async getSessionHistory(limit = 20) {
return await db.query({
filters: { sessionId: this.sessionId },
orderBy: 'timestamp',
limit
});
}
}
```
### 2. Long-Term Memory
```typescript
// Store important facts
await db.storeFact({
category: 'user_preference',
key: 'language',
value: 'English',
confidence: 1.0,
source: 'explicit'
});
// Retrieve facts
const prefs = await db.getFacts({
category: 'user_preference'
});
```
### 3. Pattern Learning
```typescript
// Learn from successful interactions
await db.storePattern({
trigger: 'user_asks_time',
response: 'provide_formatted_time',
success: true,
context: { timezone: 'UTC' }
});
// Apply learned patterns
const pattern = await db.matchPattern(currentContext);
```
## Advanced Patterns
### Hierarchical Memory
```typescript
// Organize memory in hierarchy
await memory.organize({
immediate: recentMessages, // Last 10 messages
shortTerm: sessionContext, // Current session
longTerm: importantFacts, // Persistent facts
semantic: embeddedKnowledge // Vector search
});
```
### Memory Consolidation
```typescript
// Periodically consolidate memories
await memory.consolidate({
strategy: 'importance', // Keep important memories
maxSize: 10000, // Size limit
minScore: 0.5 // Relevance threshold
});
```
## CLI Operations
### Query Database
```bash
# Query with vector embedding
npx agentdb@latest query ./agents.db "[0.1,0.2,0.3,...]"
# Top-k results
npx agentdb@latest query ./agents.db "[0.1,0.2,0.3]" -k 10
# With similarity threshold
npx agentdb@latest query ./agents.db "0.1 0.2 0.3" -t 0.75
# JSON output
npx agentdb@latest query ./agents.db "[...]" -f json
```
### Import/Export Data
```bash
# Export vectors to file
npx agentdb@latest export ./agents.db ./backup.json
# Import vectors from file
npx agentdb@latest import ./backup.json
# Get database statistics
npx agentdb@latest stats ./agents.db
```
### Performance Benchmarks
```bash
# Run performance benchmarks
npx agentdb@latest benchmark
# Results show:
# - Pattern Search: 150x faster (100µs vs 15ms)
# - Batch Insert: 500x faster (2ms vs 1s)
# - Large-scale Query: 12,500x faster (8ms vs 100s)
```
## Integration with ReasoningBank
```typescript
import { createAgentDBAdapter, migrateToAgentDB } from 'agentic-flow/reasoningbank';
// Migrate from legacy ReasoningBank
const result = await migrateToAgentDB(
'.swarm/memory.db', // Source (legacy)
'.agentdb/reasoningbank.db' // Destination (AgentDB)
);
console.log(`✅ Migrated ${result.patternsMigrated} patterns`);
// Train learning model
const adapter = await createAgentDBAdapter({
enableLearning: true,
});
await adapter.train({
epochs: 50,
batchSize: 32,
});
// Get optimal strategy with reasoning
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'task-planning',
synthesizeContext: true,
optimizeMemory: true,
});
```
## Learning Plugins
### Available Algorithms (9 Total)
1. **Decision Transformer** - Sequence modeling RL (recommended)
2. **Q-Learning** - Value-based learning
3. **SARSA** - On-policy TD learning
4. **Actor-Critic** - Policy gradient with baseline
5. **Active Learning** - Query selection
6. **Adversarial Training** - Robustness
7. **Curriculum Learning** - Progressive difficulty
8. **Federated Learning** - Distributed learning
9. **Multi-task Learning** - Transfer learning
### List and Manage Plugins
```bash
# List available plugins
npx agentdb@latest list-plugins
# List plugin templates
npx agentdb@latest list-templates
# Get plugin info
npx agentdb@latest plugin-info <name>
```
## Reasoning Agents (4 Modules)
1. **PatternMatcher** - Find similar patterns with HNSW indexing
2. **ContextSynthesizer** - Generate rich context from multiple sources
3. **MemoryOptimizer** - Consolidate similar patterns, prune low-quality
4. **ExperienceCurator** - Quality-based experience filtering
## Best Practices
1. **Enable quantization**: Use scalar/binary for 4-32x memory reduction
2. **Use caching**: 1000 pattern cache for <1ms retrieval
3. **Batch operations**: 500x faster than individual inserts
4. **Train regularly**: Update learning models with new experiences
5. **Enable reasoning**: Automatic context synthesis and optimization
6. **Monitor metrics**: Use `stats` command to track performance
## Troubleshooting
### Issue: Memory growing too large
```bash
# Check database size
npx agentdb@latest stats ./agents.db
# Enable quantization
# Use 'binary' (32x smaller) or 'scalar' (4x smaller)
```
### Issue: Slow search performance
```bash
# Enable HNSW indexing and caching
# Results: <100µs search time
```
### Issue: Migration from legacy ReasoningBank
```bash
# Automatic migration with validation
npx agentdb@latest migrate --source .swarm/memory.db
```
## Performance Characteristics
- **Vector Search**: <100µs (HNSW indexing)
- **Pattern Retrieval**: <1ms (with cache)
- **Batch Insert**: 2ms for 100 patterns
- **Memory Efficiency**: 4-32x reduction with quantization
- **Backward Compatibility**: 100% compatible with ReasoningBank API
## Learn More
- GitHub: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
- Documentation: node_modules/agentic-flow/docs/AGENTDB_INTEGRATION.md
- MCP Integration: `npx agentdb@latest mcp` for Claude Code
- Website: https://agentdb.ruv.io

509
vendor/ruvector/.claude/skills/agentdb-optimization/SKILL.md vendored Normal file
View File

@@ -0,0 +1,509 @@
---
name: "AgentDB Performance Optimization"
description: "Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching, and batch operations. Use when optimizing memory usage, improving search speed, or scaling to millions of vectors."
---
# AgentDB Performance Optimization
## What This Skill Does
Provides comprehensive performance optimization techniques for AgentDB vector databases. Achieve 150x-12,500x performance improvements through quantization, HNSW indexing, caching strategies, and batch operations. Reduce memory usage by 4-32x while maintaining accuracy.
**Performance**: <100µs vector search, <1ms pattern retrieval, 2ms batch insert for 100 vectors.
## Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow)
- Existing AgentDB database or application
---
## Quick Start
### Run Performance Benchmarks
```bash
# Comprehensive performance benchmarking
npx agentdb@latest benchmark
# Results show:
# ✅ Pattern Search: 150x faster (100µs vs 15ms)
# ✅ Batch Insert: 500x faster (2ms vs 1s for 100 vectors)
# ✅ Large-scale Query: 12,500x faster (8ms vs 100s at 1M vectors)
# ✅ Memory Efficiency: 4-32x reduction with quantization
```
### Enable Optimizations
```typescript
import { createAgentDBAdapter } from 'agentic-flow/reasoningbank';
// Optimized configuration
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/optimized.db',
quantizationType: 'binary', // 32x memory reduction
cacheSize: 1000, // In-memory cache
enableLearning: true,
enableReasoning: true,
});
```
---
## Quantization Strategies
### 1. Binary Quantization (32x Reduction)
**Best For**: Large-scale deployments (1M+ vectors), memory-constrained environments
**Trade-off**: ~2-5% accuracy loss, 32x memory reduction, 10x faster
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'binary',
// 768-dim float32 (3072 bytes) → 96 bytes binary
// 1M vectors: 3GB → 96MB
});
```
**Use Cases**:
- Mobile/edge deployment
- Large-scale vector storage (millions of vectors)
- Real-time search with memory constraints
**Performance**:
- Memory: 32x smaller
- Search Speed: 10x faster (bit operations)
- Accuracy: 95-98% of original
### 2. Scalar Quantization (4x Reduction)
**Best For**: Balanced performance/accuracy, moderate datasets
**Trade-off**: ~1-2% accuracy loss, 4x memory reduction, 3x faster
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'scalar',
// 768-dim float32 (3072 bytes) → 768 bytes (uint8)
// 1M vectors: 3GB → 768MB
});
```
**Use Cases**:
- Production applications requiring high accuracy
- Medium-scale deployments (10K-1M vectors)
- General-purpose optimization
**Performance**:
- Memory: 4x smaller
- Search Speed: 3x faster
- Accuracy: 98-99% of original
### 3. Product Quantization (8-16x Reduction)
**Best For**: High-dimensional vectors, balanced compression
**Trade-off**: ~3-7% accuracy loss, 8-16x memory reduction, 5x faster
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'product',
// 768-dim float32 (3072 bytes) → 48-96 bytes
// 1M vectors: 3GB → 192MB
});
```
**Use Cases**:
- High-dimensional embeddings (>512 dims)
- Image/video embeddings
- Large-scale similarity search
**Performance**:
- Memory: 8-16x smaller
- Search Speed: 5x faster
- Accuracy: 93-97% of original
### 4. No Quantization (Full Precision)
**Best For**: Maximum accuracy, small datasets
**Trade-off**: No accuracy loss, full memory usage
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'none',
// Full float32 precision
});
```
---
## HNSW Indexing
**Hierarchical Navigable Small World** - O(log n) search complexity
### Automatic HNSW
AgentDB automatically builds HNSW indices:
```typescript
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/vectors.db',
// HNSW automatically enabled
});
// Search with HNSW (100µs vs 15ms linear scan)
const results = await adapter.retrieveWithReasoning(queryEmbedding, {
k: 10,
});
```
### HNSW Parameters
```typescript
// Advanced HNSW configuration
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/vectors.db',
hnswM: 16, // Connections per layer (default: 16)
hnswEfConstruction: 200, // Build quality (default: 200)
hnswEfSearch: 100, // Search quality (default: 100)
});
```
**Parameter Tuning**:
- **M** (connections): Higher = better recall, more memory
- Small datasets (<10K): M = 8
- Medium datasets (10K-100K): M = 16
- Large datasets (>100K): M = 32
- **efConstruction**: Higher = better index quality, slower build
- Fast build: 100
- Balanced: 200 (default)
- High quality: 400
- **efSearch**: Higher = better recall, slower search
- Fast search: 50
- Balanced: 100 (default)
- High recall: 200
---
## Caching Strategies
### In-Memory Pattern Cache
```typescript
const adapter = await createAgentDBAdapter({
cacheSize: 1000, // Cache 1000 most-used patterns
});
// First retrieval: ~2ms (database)
// Subsequent: <1ms (cache hit)
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
k: 10,
});
```
**Cache Tuning**:
- Small applications: 100-500 patterns
- Medium applications: 500-2000 patterns
- Large applications: 2000-5000 patterns
### LRU Cache Behavior
```typescript
// Cache automatically evicts least-recently-used patterns
// Most frequently accessed patterns stay in cache
// Monitor cache performance
const stats = await adapter.getStats();
console.log('Cache Hit Rate:', stats.cacheHitRate);
// Aim for >80% hit rate
```
---
## Batch Operations
### Batch Insert (500x Faster)
```typescript
// ❌ SLOW: Individual inserts
for (const doc of documents) {
await adapter.insertPattern({ /* ... */ }); // 1s for 100 docs
}
// ✅ FAST: Batch insert
const patterns = documents.map(doc => ({
id: '',
type: 'document',
domain: 'knowledge',
pattern_data: JSON.stringify({
embedding: doc.embedding,
text: doc.text,
}),
confidence: 1.0,
usage_count: 0,
success_count: 0,
created_at: Date.now(),
last_used: Date.now(),
}));
// Insert all at once (2ms for 100 docs)
for (const pattern of patterns) {
await adapter.insertPattern(pattern);
}
```
### Batch Retrieval
```typescript
// Retrieve multiple queries efficiently
const queries = [queryEmbedding1, queryEmbedding2, queryEmbedding3];
// Parallel retrieval
const results = await Promise.all(
queries.map(q => adapter.retrieveWithReasoning(q, { k: 5 }))
);
```
---
## Memory Optimization
### Automatic Consolidation
```typescript
// Enable automatic pattern consolidation
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'documents',
optimizeMemory: true, // Consolidate similar patterns
k: 10,
});
console.log('Optimizations:', result.optimizations);
// {
// consolidated: 15, // Merged 15 similar patterns
// pruned: 3, // Removed 3 low-quality patterns
// improved_quality: 0.12 // 12% quality improvement
// }
```
### Manual Optimization
```typescript
// Manually trigger optimization
await adapter.optimize();
// Get statistics
const stats = await adapter.getStats();
console.log('Before:', stats.totalPatterns);
console.log('After:', stats.totalPatterns); // Reduced by ~10-30%
```
### Pruning Strategies
```typescript
// Prune low-confidence patterns
await adapter.prune({
minConfidence: 0.5, // Remove confidence < 0.5
minUsageCount: 2, // Remove usage_count < 2
maxAge: 30 * 24 * 3600, // Remove >30 days old
});
```
---
## Performance Monitoring
### Database Statistics
```bash
# Get comprehensive stats
npx agentdb@latest stats .agentdb/vectors.db
# Output:
# Total Patterns: 125,430
# Database Size: 47.2 MB (with binary quantization)
# Avg Confidence: 0.87
# Domains: 15
# Cache Hit Rate: 84%
# Index Type: HNSW
```
### Runtime Metrics
```typescript
const stats = await adapter.getStats();
console.log('Performance Metrics:');
console.log('Total Patterns:', stats.totalPatterns);
console.log('Database Size:', stats.dbSize);
console.log('Avg Confidence:', stats.avgConfidence);
console.log('Cache Hit Rate:', stats.cacheHitRate);
console.log('Search Latency (avg):', stats.avgSearchLatency);
console.log('Insert Latency (avg):', stats.avgInsertLatency);
```
---
## Optimization Recipes
### Recipe 1: Maximum Speed (Sacrifice Accuracy)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'binary', // 32x memory reduction
cacheSize: 5000, // Large cache
hnswM: 8, // Fewer connections = faster
hnswEfSearch: 50, // Low search quality = faster
});
// Expected: <50µs search, 90-95% accuracy
```
### Recipe 2: Balanced Performance
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'scalar', // 4x memory reduction
cacheSize: 1000, // Standard cache
hnswM: 16, // Balanced connections
hnswEfSearch: 100, // Balanced quality
});
// Expected: <100µs search, 98-99% accuracy
```
### Recipe 3: Maximum Accuracy
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'none', // No quantization
cacheSize: 2000, // Large cache
hnswM: 32, // Many connections
hnswEfSearch: 200, // High search quality
});
// Expected: <200µs search, 100% accuracy
```
### Recipe 4: Memory-Constrained (Mobile/Edge)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'binary', // 32x memory reduction
cacheSize: 100, // Small cache
hnswM: 8, // Minimal connections
});
// Expected: <100µs search, ~10MB for 100K vectors
```
---
## Scaling Strategies
### Small Scale (<10K vectors)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'none', // Full precision
cacheSize: 500,
hnswM: 8,
});
```
### Medium Scale (10K-100K vectors)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'scalar', // 4x reduction
cacheSize: 1000,
hnswM: 16,
});
```
### Large Scale (100K-1M vectors)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'binary', // 32x reduction
cacheSize: 2000,
hnswM: 32,
});
```
### Massive Scale (>1M vectors)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'product', // 8-16x reduction
cacheSize: 5000,
hnswM: 48,
hnswEfConstruction: 400,
});
```
---
## Troubleshooting
### Issue: High memory usage
```bash
# Check database size
npx agentdb@latest stats .agentdb/vectors.db
# Enable quantization
# Use 'binary' for 32x reduction
```
### Issue: Slow search performance
```typescript
// Increase cache size
const adapter = await createAgentDBAdapter({
cacheSize: 2000, // Increase from 1000
});
// Reduce search quality (faster)
const result = await adapter.retrieveWithReasoning(queryEmbedding, {
k: 5, // Reduce from 10
});
```
### Issue: Low accuracy
```typescript
// Disable or use lighter quantization
const adapter = await createAgentDBAdapter({
quantizationType: 'scalar', // Instead of 'binary'
hnswEfSearch: 200, // Higher search quality
});
```
---
## Performance Benchmarks
**Test System**: AMD Ryzen 9 5950X, 64GB RAM
| Operation | Vector Count | No Optimization | Optimized | Improvement |
|-----------|-------------|-----------------|-----------|-------------|
| Search | 10K | 15ms | 100µs | 150x |
| Search | 100K | 150ms | 120µs | 1,250x |
| Search | 1M | 100s | 8ms | 12,500x |
| Batch Insert (100) | - | 1s | 2ms | 500x |
| Memory Usage | 1M | 3GB | 96MB | 32x (binary) |
---
## Learn More
- **Quantization Paper**: docs/quantization-techniques.pdf
- **HNSW Algorithm**: docs/hnsw-index.pdf
- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
- **Website**: https://agentdb.ruv.io
---
**Category**: Performance / Optimization
**Difficulty**: Intermediate
**Estimated Time**: 20-30 minutes

339
vendor/ruvector/.claude/skills/agentdb-vector-search/SKILL.md vendored Normal file
View File

@@ -0,0 +1,339 @@
---
name: "AgentDB Vector Search"
description: "Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying. Use when building RAG systems, semantic search engines, or intelligent knowledge bases."
---
# AgentDB Vector Search
## What This Skill Does
Implements vector-based semantic search using AgentDB's high-performance vector database with **150x-12,500x faster** operations than traditional solutions. Features HNSW indexing, quantization, and sub-millisecond search (<100µs).
## Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow or standalone)
- OpenAI API key (for embeddings) or custom embedding model
## Quick Start with CLI
### Initialize Vector Database
```bash
# Initialize with default dimensions (1536 for OpenAI ada-002)
npx agentdb@latest init ./vectors.db
# Custom dimensions for different embedding models
npx agentdb@latest init ./vectors.db --dimension 768 # sentence-transformers
npx agentdb@latest init ./vectors.db --dimension 384 # all-MiniLM-L6-v2
# Use preset configurations
npx agentdb@latest init ./vectors.db --preset small # <10K vectors
npx agentdb@latest init ./vectors.db --preset medium # 10K-100K vectors
npx agentdb@latest init ./vectors.db --preset large # >100K vectors
# In-memory database for testing
npx agentdb@latest init ./vectors.db --in-memory
```
### Query Vector Database
```bash
# Basic similarity search
npx agentdb@latest query ./vectors.db "[0.1,0.2,0.3,...]"
# Top-k results
npx agentdb@latest query ./vectors.db "[0.1,0.2,0.3]" -k 10
# With similarity threshold (cosine similarity)
npx agentdb@latest query ./vectors.db "0.1 0.2 0.3" -t 0.75 -m cosine
# Different distance metrics
npx agentdb@latest query ./vectors.db "[...]" -m euclidean # L2 distance
npx agentdb@latest query ./vectors.db "[...]" -m dot # Dot product
# JSON output for automation
npx agentdb@latest query ./vectors.db "[...]" -f json -k 5
# Verbose output with distances
npx agentdb@latest query ./vectors.db "[...]" -v
```
### Import/Export Vectors
```bash
# Export vectors to JSON
npx agentdb@latest export ./vectors.db ./backup.json
# Import vectors from JSON
npx agentdb@latest import ./backup.json
# Get database statistics
npx agentdb@latest stats ./vectors.db
```
## Quick Start with API
```typescript
import { createAgentDBAdapter, computeEmbedding } from 'agentic-flow/reasoningbank';
// Initialize with vector search optimizations
const adapter = await createAgentDBAdapter({
dbPath: '.agentdb/vectors.db',
enableLearning: false, // Vector search only
enableReasoning: true, // Enable semantic matching
quantizationType: 'binary', // 32x memory reduction
cacheSize: 1000, // Fast retrieval
});
// Store document with embedding
const text = "The quantum computer achieved 100 qubits";
const embedding = await computeEmbedding(text);
await adapter.insertPattern({
id: '',
type: 'document',
domain: 'technology',
pattern_data: JSON.stringify({
embedding,
text,
metadata: { category: "quantum", date: "2025-01-15" }
}),
confidence: 1.0,
usage_count: 0,
success_count: 0,
created_at: Date.now(),
last_used: Date.now(),
});
// Semantic search with MMR (Maximal Marginal Relevance)
const queryEmbedding = await computeEmbedding("quantum computing advances");
const results = await adapter.retrieveWithReasoning(queryEmbedding, {
domain: 'technology',
k: 10,
useMMR: true, // Diverse results
synthesizeContext: true, // Rich context
});
```
## Core Features
### 1. Vector Storage
```typescript
// Store with automatic embedding
await db.storeWithEmbedding({
content: "Your document text",
metadata: { source: "docs", page: 42 }
});
```
### 2. Similarity Search
```typescript
// Find similar documents
const similar = await db.findSimilar("quantum computing", {
limit: 5,
minScore: 0.75
});
```
### 3. Hybrid Search (Vector + Metadata)
```typescript
// Combine vector similarity with metadata filtering
const results = await db.hybridSearch({
query: "machine learning models",
filters: {
category: "research",
date: { $gte: "2024-01-01" }
},
limit: 20
});
```
## Advanced Usage
### RAG (Retrieval Augmented Generation)
```typescript
// Build RAG pipeline
async function ragQuery(question: string) {
// 1. Get relevant context
const context = await db.searchSimilar(
await embed(question),
{ limit: 5, threshold: 0.7 }
);
// 2. Generate answer with context
const prompt = `Context: ${context.map(c => c.text).join('\n')}
Question: ${question}`;
return await llm.generate(prompt);
}
```
### Batch Operations
```typescript
// Efficient batch storage
await db.batchStore(documents.map(doc => ({
text: doc.content,
embedding: doc.vector,
metadata: doc.meta
})));
```
## MCP Server Integration
```bash
# Start AgentDB MCP server for Claude Code
npx agentdb@latest mcp
# Add to Claude Code (one-time setup)
claude mcp add agentdb npx agentdb@latest mcp
# Now use MCP tools in Claude Code:
# - agentdb_query: Semantic vector search
# - agentdb_store: Store documents with embeddings
# - agentdb_stats: Database statistics
```
## Performance Benchmarks
```bash
# Run comprehensive benchmarks
npx agentdb@latest benchmark
# Results:
# ✅ Pattern Search: 150x faster (100µs vs 15ms)
# ✅ Batch Insert: 500x faster (2ms vs 1s for 100 vectors)
# ✅ Large-scale Query: 12,500x faster (8ms vs 100s at 1M vectors)
# ✅ Memory Efficiency: 4-32x reduction with quantization
```
## Quantization Options
AgentDB provides multiple quantization strategies for memory efficiency:
### Binary Quantization (32x reduction)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'binary', // 768-dim → 96 bytes
});
```
### Scalar Quantization (4x reduction)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'scalar', // 768-dim → 768 bytes
});
```
### Product Quantization (8-16x reduction)
```typescript
const adapter = await createAgentDBAdapter({
quantizationType: 'product', // 768-dim → 48-96 bytes
});
```
## Distance Metrics
```bash
# Cosine similarity (default, best for most use cases)
npx agentdb@latest query ./db.sqlite "[...]" -m cosine
# Euclidean distance (L2 norm)
npx agentdb@latest query ./db.sqlite "[...]" -m euclidean
# Dot product (for normalized vectors)
npx agentdb@latest query ./db.sqlite "[...]" -m dot
```
## Advanced Features
### HNSW Indexing
- **O(log n) search complexity**
- **Sub-millisecond retrieval** (<100µs)
- **Automatic index building**
### Caching
- **1000 pattern in-memory cache**
- **<1ms pattern retrieval**
- **Automatic cache invalidation**
### MMR (Maximal Marginal Relevance)
- **Diverse result sets**
- **Avoid redundancy**
- **Balance relevance and diversity**
## Performance Tips
1. **Enable HNSW indexing**: Automatic with AgentDB, 10-100x faster
2. **Use quantization**: Binary (32x), Scalar (4x), Product (8-16x) memory reduction
3. **Batch operations**: 500x faster for bulk inserts
4. **Match dimensions**: 1536 (OpenAI), 768 (sentence-transformers), 384 (MiniLM)
5. **Similarity threshold**: Start at 0.7 for quality, adjust based on use case
6. **Enable caching**: 1000 pattern cache for frequent queries
## Troubleshooting
### Issue: Slow search performance
```bash
# Check if HNSW indexing is enabled (automatic)
npx agentdb@latest stats ./vectors.db
# Expected: <100µs search time
```
### Issue: High memory usage
```bash
# Enable binary quantization (32x reduction)
# Use in adapter: quantizationType: 'binary'
```
### Issue: Poor relevance
```bash
# Adjust similarity threshold
npx agentdb@latest query ./db.sqlite "[...]" -t 0.8 # Higher threshold
# Or use MMR for diverse results
# Use in adapter: useMMR: true
```
### Issue: Wrong dimensions
```bash
# Check embedding model dimensions:
# - OpenAI ada-002: 1536
# - sentence-transformers: 768
# - all-MiniLM-L6-v2: 384
npx agentdb@latest init ./db.sqlite --dimension 768
```
## Database Statistics
```bash
# Get comprehensive stats
npx agentdb@latest stats ./vectors.db
# Shows:
# - Total patterns/vectors
# - Database size
# - Average confidence
# - Domains distribution
# - Index status
```
## Performance Characteristics
- **Vector Search**: <100µs (HNSW indexing)
- **Pattern Retrieval**: <1ms (with cache)
- **Batch Insert**: 2ms for 100 vectors
- **Memory Efficiency**: 4-32x reduction with quantization
- **Scalability**: Handles 1M+ vectors efficiently
- **Latency**: Sub-millisecond for most operations
## Learn More
- GitHub: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
- Documentation: node_modules/agentic-flow/docs/AGENTDB_INTEGRATION.md
- MCP Integration: `npx agentdb@latest mcp` for Claude Code
- Website: https://agentdb.ruv.io
- CLI Help: `npx agentdb@latest --help`
- Command Help: `npx agentdb@latest help <command>`

662
vendor/ruvector/.claude/skills/agentic-jujutsu/SKILL.md vendored Normal file
View File

@@ -0,0 +1,662 @@
---
name: agentic-jujutsu
version: 2.3.2
description: Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination
hooks:
pre: |
echo "🧠 Agentic Jujutsu activated"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js pre-edit "$FILE" 2>/dev/null || true
fi
post: |
echo "✅ Agentic Jujutsu complete"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js post-edit "$FILE" "true" 2>/dev/null || true
fi
---
# Agentic Jujutsu - AI Agent Version Control
> Quantum-ready, self-learning version control designed for multiple AI agents working simultaneously without conflicts.
## 🧠 Self-Learning Intelligence
Integrates with RuVector's Q-learning and vector memory for improved performance.
CLI: `node .claude/intelligence/cli.js stats`
## When to Use This Skill
Use **agentic-jujutsu** when you need:
- ✅ Multiple AI agents modifying code simultaneously
- ✅ Lock-free version control (23x faster than Git)
- ✅ Self-learning AI that improves from experience
- ✅ Quantum-resistant security for future-proof protection
- ✅ Automatic conflict resolution (87% success rate)
- ✅ Pattern recognition and intelligent suggestions
- ✅ Multi-agent coordination without blocking
## Quick Start
### Installation
```bash
npx agentic-jujutsu
```
### Basic Usage
```javascript
const { JjWrapper } = require('agentic-jujutsu');
const jj = new JjWrapper();
// Basic operations
await jj.status();
await jj.newCommit('Add feature');
await jj.log(10);
// Self-learning trajectory
const id = jj.startTrajectory('Implement authentication');
await jj.branchCreate('feature/auth');
await jj.newCommit('Add auth');
jj.addToTrajectory();
jj.finalizeTrajectory(0.9, 'Clean implementation');
// Get AI suggestions
const suggestion = JSON.parse(jj.getSuggestion('Add logout feature'));
console.log(`Confidence: ${suggestion.confidence}`);
```
## Core Capabilities
### 1. Self-Learning with ReasoningBank
Track operations, learn patterns, and get intelligent suggestions:
```javascript
// Start learning trajectory
const trajectoryId = jj.startTrajectory('Deploy to production');
// Perform operations (automatically tracked)
await jj.execute(['git', 'push', 'origin', 'main']);
await jj.branchCreate('release/v1.0');
await jj.newCommit('Release v1.0');
// Record operations to trajectory
jj.addToTrajectory();
// Finalize with success score (0.0-1.0) and critique
jj.finalizeTrajectory(0.95, 'Deployment successful, no issues');
// Later: Get AI-powered suggestions for similar tasks
const suggestion = JSON.parse(jj.getSuggestion('Deploy to staging'));
console.log('AI Recommendation:', suggestion.reasoning);
console.log('Confidence:', (suggestion.confidence * 100).toFixed(1) + '%');
console.log('Expected Success:', (suggestion.expectedSuccessRate * 100).toFixed(1) + '%');
```
**Validation (v2.3.1)**:
- ✅ Tasks must be non-empty (max 10KB)
- ✅ Success scores must be 0.0-1.0
- ✅ Must have operations before finalizing
- ✅ Contexts cannot be empty
### 2. Pattern Discovery
Automatically identify successful operation sequences:
```javascript
// Get discovered patterns
const patterns = JSON.parse(jj.getPatterns());
patterns.forEach(pattern => {
console.log(`Pattern: ${pattern.name}`);
console.log(` Success rate: ${(pattern.successRate * 100).toFixed(1)}%`);
console.log(` Used ${pattern.observationCount} times`);
console.log(` Operations: ${pattern.operationSequence.join(' → ')}`);
console.log(` Confidence: ${(pattern.confidence * 100).toFixed(1)}%`);
});
```
### 3. Learning Statistics
Track improvement over time:
```javascript
const stats = JSON.parse(jj.getLearningStats());
console.log('Learning Progress:');
console.log(` Total trajectories: ${stats.totalTrajectories}`);
console.log(` Patterns discovered: ${stats.totalPatterns}`);
console.log(` Average success: ${(stats.avgSuccessRate * 100).toFixed(1)}%`);
console.log(` Improvement rate: ${(stats.improvementRate * 100).toFixed(1)}%`);
console.log(` Prediction accuracy: ${(stats.predictionAccuracy * 100).toFixed(1)}%`);
```
### 4. Multi-Agent Coordination
Multiple agents work concurrently without conflicts:
```javascript
// Agent 1: Developer
const dev = new JjWrapper();
dev.startTrajectory('Implement feature');
await dev.newCommit('Add feature X');
dev.addToTrajectory();
dev.finalizeTrajectory(0.85);
// Agent 2: Reviewer (learns from Agent 1)
const reviewer = new JjWrapper();
const suggestion = JSON.parse(reviewer.getSuggestion('Review feature X'));
if (suggestion.confidence > 0.7) {
console.log('High confidence approach:', suggestion.reasoning);
}
// Agent 3: Tester (benefits from both)
const tester = new JjWrapper();
const similar = JSON.parse(tester.queryTrajectories('test feature', 5));
console.log(`Found ${similar.length} similar test approaches`);
```
### 5. Quantum-Resistant Security (v2.3.0+)
Fast integrity verification with quantum-resistant cryptography:
```javascript
const { generateQuantumFingerprint, verifyQuantumFingerprint } = require('agentic-jujutsu');
// Generate SHA3-512 fingerprint (NIST FIPS 202)
const data = Buffer.from('commit-data');
const fingerprint = generateQuantumFingerprint(data);
console.log('Fingerprint:', fingerprint.toString('hex'));
// Verify integrity (<1ms)
const isValid = verifyQuantumFingerprint(data, fingerprint);
console.log('Valid:', isValid);
// HQC-128 encryption for trajectories
const crypto = require('crypto');
const key = crypto.randomBytes(32).toString('base64');
jj.enableEncryption(key);
```
### 6. Operation Tracking with AgentDB
Automatic tracking of all operations:
```javascript
// Operations are tracked automatically
await jj.status();
await jj.newCommit('Fix bug');
await jj.rebase('main');
// Get operation statistics
const stats = JSON.parse(jj.getStats());
console.log(`Total operations: ${stats.total_operations}`);
console.log(`Success rate: ${(stats.success_rate * 100).toFixed(1)}%`);
console.log(`Avg duration: ${stats.avg_duration_ms.toFixed(2)}ms`);
// Query recent operations
const ops = jj.getOperations(10);
ops.forEach(op => {
console.log(`${op.operationType}: ${op.command}`);
console.log(` Duration: ${op.durationMs}ms, Success: ${op.success}`);
});
// Get user operations (excludes snapshots)
const userOps = jj.getUserOperations(20);
```
## Advanced Use Cases
### Use Case 1: Adaptive Workflow Optimization
Learn and improve deployment workflows:
```javascript
async function adaptiveDeployment(jj, environment) {
// Get AI suggestion based on past deployments
const suggestion = JSON.parse(jj.getSuggestion(`Deploy to ${environment}`));
console.log(`Deploying with ${(suggestion.confidence * 100).toFixed(0)}% confidence`);
console.log(`Expected duration: ${suggestion.estimatedDurationMs}ms`);
// Start tracking
jj.startTrajectory(`Deploy to ${environment}`);
// Execute recommended operations
for (const op of suggestion.recommendedOperations) {
console.log(`Executing: ${op}`);
await executeOperation(op);
}
jj.addToTrajectory();
// Record outcome
const success = await verifyDeployment();
jj.finalizeTrajectory(
success ? 0.95 : 0.5,
success ? 'Deployment successful' : 'Issues detected'
);
}
```
### Use Case 2: Multi-Agent Code Review
Coordinate review across multiple agents:
```javascript
async function coordinatedReview(agents) {
const reviews = await Promise.all(agents.map(async (agent) => {
const jj = new JjWrapper();
// Start review trajectory
jj.startTrajectory(`Review by ${agent.name}`);
// Get AI suggestion for review approach
const suggestion = JSON.parse(jj.getSuggestion('Code review'));
// Perform review
const diff = await jj.diff('@', '@-');
const issues = await agent.analyze(diff);
jj.addToTrajectory();
jj.finalizeTrajectory(
issues.length === 0 ? 0.9 : 0.6,
`Found ${issues.length} issues`
);
return { agent: agent.name, issues, suggestion };
}));
// Aggregate learning from all agents
return reviews;
}
```
### Use Case 3: Error Pattern Detection
Learn from failures to prevent future issues:
```javascript
async function smartMerge(jj, branch) {
// Query similar merge attempts
const similar = JSON.parse(jj.queryTrajectories(`merge ${branch}`, 10));
// Analyze past failures
const failures = similar.filter(t => t.successScore < 0.5);
if (failures.length > 0) {
console.log('⚠️ Similar merges failed in the past:');
failures.forEach(f => {
if (f.critique) {
console.log(` - ${f.critique}`);
}
});
}
// Get AI recommendation
const suggestion = JSON.parse(jj.getSuggestion(`merge ${branch}`));
if (suggestion.confidence < 0.7) {
console.log('⚠️ Low confidence. Recommended steps:');
suggestion.recommendedOperations.forEach(op => console.log(` - ${op}`));
}
// Execute merge with tracking
jj.startTrajectory(`Merge ${branch}`);
try {
await jj.execute(['merge', branch]);
jj.addToTrajectory();
jj.finalizeTrajectory(0.9, 'Merge successful');
} catch (err) {
jj.addToTrajectory();
jj.finalizeTrajectory(0.3, `Merge failed: ${err.message}`);
throw err;
}
}
```
### Use Case 4: Continuous Learning Loop
Implement a self-improving agent:
```javascript
class SelfImprovingAgent {
constructor() {
this.jj = new JjWrapper();
}
async performTask(taskDescription) {
// Get AI suggestion
const suggestion = JSON.parse(this.jj.getSuggestion(taskDescription));
console.log(`Task: ${taskDescription}`);
console.log(`AI Confidence: ${(suggestion.confidence * 100).toFixed(1)}%`);
console.log(`Expected Success: ${(suggestion.expectedSuccessRate * 100).toFixed(1)}%`);
// Start trajectory
this.jj.startTrajectory(taskDescription);
// Execute with recommended approach
const startTime = Date.now();
let success = false;
try {
for (const op of suggestion.recommendedOperations) {
await this.execute(op);
}
success = true;
} catch (err) {
console.error('Task failed:', err.message);
}
const duration = Date.now() - startTime;
// Record learning
this.jj.addToTrajectory();
this.jj.finalizeTrajectory(
success ? 0.9 : 0.4,
success
? `Completed in ${duration}ms using ${suggestion.recommendedOperations.length} operations`
: `Failed after ${duration}ms`
);
// Check improvement
const stats = JSON.parse(this.jj.getLearningStats());
console.log(`Improvement rate: ${(stats.improvementRate * 100).toFixed(1)}%`);
return success;
}
async execute(operation) {
// Execute operation logic
}
}
// Usage
const agent = new SelfImprovingAgent();
// Agent improves over time
for (let i = 1; i <= 10; i++) {
console.log(`\n--- Attempt ${i} ---`);
await agent.performTask('Deploy application');
}
```
## API Reference
### Core Methods
| Method | Description | Returns |
|--------|-------------|---------|
| `new JjWrapper()` | Create wrapper instance | JjWrapper |
| `status()` | Get repository status | Promise<JjResult> |
| `newCommit(msg)` | Create new commit | Promise<JjResult> |
| `log(limit)` | Show commit history | Promise<JjCommit[]> |
| `diff(from, to)` | Show differences | Promise<JjDiff> |
| `branchCreate(name, rev?)` | Create branch | Promise<JjResult> |
| `rebase(source, dest)` | Rebase commits | Promise<JjResult> |
### ReasoningBank Methods
| Method | Description | Returns |
|--------|-------------|---------|
| `startTrajectory(task)` | Begin learning trajectory | string (trajectory ID) |
| `addToTrajectory()` | Add recent operations | void |
| `finalizeTrajectory(score, critique?)` | Complete trajectory (score: 0.0-1.0) | void |
| `getSuggestion(task)` | Get AI recommendation | JSON: DecisionSuggestion |
| `getLearningStats()` | Get learning metrics | JSON: LearningStats |
| `getPatterns()` | Get discovered patterns | JSON: Pattern[] |
| `queryTrajectories(task, limit)` | Find similar trajectories | JSON: Trajectory[] |
| `resetLearning()` | Clear learned data | void |
### AgentDB Methods
| Method | Description | Returns |
|--------|-------------|---------|
| `getStats()` | Get operation statistics | JSON: Stats |
| `getOperations(limit)` | Get recent operations | JjOperation[] |
| `getUserOperations(limit)` | Get user operations only | JjOperation[] |
| `clearLog()` | Clear operation log | void |
### Quantum Security Methods (v2.3.0+)
| Method | Description | Returns |
|--------|-------------|---------|
| `generateQuantumFingerprint(data)` | Generate SHA3-512 fingerprint | Buffer (64 bytes) |
| `verifyQuantumFingerprint(data, fp)` | Verify fingerprint | boolean |
| `enableEncryption(key, pubKey?)` | Enable HQC-128 encryption | void |
| `disableEncryption()` | Disable encryption | void |
| `isEncryptionEnabled()` | Check encryption status | boolean |
## Performance Characteristics
| Metric | Git | Agentic Jujutsu |
|--------|-----|-----------------|
| Concurrent commits | 15 ops/s | 350 ops/s (23x) |
| Context switching | 500-1000ms | 50-100ms (10x) |
| Conflict resolution | 30-40% auto | 87% auto (2.5x) |
| Lock waiting | 50 min/day | 0 min (∞) |
| Quantum fingerprints | N/A | <1ms |
## Best Practices
### 1. Trajectory Management
```javascript
// ✅ Good: Meaningful task descriptions
jj.startTrajectory('Implement user authentication with JWT');
// ❌ Bad: Vague descriptions
jj.startTrajectory('fix stuff');
// ✅ Good: Honest success scores
jj.finalizeTrajectory(0.7, 'Works but needs refactoring');
// ❌ Bad: Always 1.0
jj.finalizeTrajectory(1.0, 'Perfect!'); // Prevents learning
```
### 2. Pattern Recognition
```javascript
// ✅ Good: Let patterns emerge naturally
for (let i = 0; i < 10; i++) {
jj.startTrajectory('Deploy feature');
await deploy();
jj.addToTrajectory();
jj.finalizeTrajectory(wasSuccessful ? 0.9 : 0.5);
}
// ❌ Bad: Not recording outcomes
await deploy(); // No learning
```
### 3. Multi-Agent Coordination
```javascript
// ✅ Good: Concurrent operations
const agents = ['agent1', 'agent2', 'agent3'];
await Promise.all(agents.map(async (agent) => {
const jj = new JjWrapper();
// Each agent works independently
await jj.newCommit(`Changes by ${agent}`);
}));
// ❌ Bad: Sequential with locks
for (const agent of agents) {
await agent.waitForLock(); // Not needed!
await agent.commit();
}
```
### 4. Error Handling
```javascript
// ✅ Good: Record failures with details
try {
await jj.execute(['complex-operation']);
jj.finalizeTrajectory(0.9);
} catch (err) {
jj.finalizeTrajectory(0.3, `Failed: ${err.message}. Root cause: ...`);
}
// ❌ Bad: Silent failures
try {
await jj.execute(['operation']);
} catch (err) {
// No learning from failure
}
```
## Validation Rules (v2.3.1+)
### Task Description
- ✅ Cannot be empty or whitespace-only
- ✅ Maximum length: 10,000 bytes
- ✅ Automatically trimmed
### Success Score
- ✅ Must be finite (not NaN or Infinity)
- ✅ Must be between 0.0 and 1.0 (inclusive)
### Operations
- ✅ Must have at least one operation before finalizing
### Context
- ✅ Cannot be empty
- ✅ Keys cannot be empty or whitespace-only
- ✅ Keys max 1,000 bytes, values max 10,000 bytes
## Troubleshooting
### Issue: Low Confidence Suggestions
```javascript
const suggestion = JSON.parse(jj.getSuggestion('new task'));
if (suggestion.confidence < 0.5) {
// Not enough data - check learning stats
const stats = JSON.parse(jj.getLearningStats());
console.log(`Need more data. Current trajectories: ${stats.totalTrajectories}`);
// Recommend: Record 5-10 trajectories first
}
```
### Issue: Validation Errors
```javascript
try {
jj.startTrajectory(''); // Empty task
} catch (err) {
if (err.message.includes('Validation error')) {
console.log('Invalid input:', err.message);
// Use non-empty, meaningful task description
}
}
try {
jj.finalizeTrajectory(1.5); // Score > 1.0
} catch (err) {
// Use score between 0.0 and 1.0
jj.finalizeTrajectory(Math.max(0, Math.min(1, score)));
}
```
### Issue: No Patterns Discovered
```javascript
const patterns = JSON.parse(jj.getPatterns());
if (patterns.length === 0) {
// Need more trajectories with >70% success
// Record at least 3-5 successful trajectories
}
```
## Examples
### Example 1: Simple Learning Workflow
```javascript
const { JjWrapper } = require('agentic-jujutsu');
async function learnFromWork() {
const jj = new JjWrapper();
// Start tracking
jj.startTrajectory('Add user profile feature');
// Do work
await jj.branchCreate('feature/user-profile');
await jj.newCommit('Add user profile model');
await jj.newCommit('Add profile API endpoints');
await jj.newCommit('Add profile UI');
// Record operations
jj.addToTrajectory();
// Finalize with result
jj.finalizeTrajectory(0.85, 'Feature complete, minor styling issues remain');
// Next time, get suggestions
const suggestion = JSON.parse(jj.getSuggestion('Add settings page'));
console.log('AI suggests:', suggestion.reasoning);
}
```
### Example 2: Multi-Agent Swarm
```javascript
async function agentSwarm(taskList) {
const agents = taskList.map((task, i) => ({
name: `agent-${i}`,
jj: new JjWrapper(),
task
}));
// All agents work concurrently (no conflicts!)
const results = await Promise.all(agents.map(async (agent) => {
agent.jj.startTrajectory(agent.task);
// Get AI suggestion
const suggestion = JSON.parse(agent.jj.getSuggestion(agent.task));
// Execute task
const success = await executeTask(agent, suggestion);
agent.jj.addToTrajectory();
agent.jj.finalizeTrajectory(success ? 0.9 : 0.5);
return { agent: agent.name, success };
}));
console.log('Results:', results);
}
```
## Related Documentation
- **NPM Package**: https://npmjs.com/package/agentic-jujutsu
- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentic-jujutsu
- **Full README**: See package README.md
- **Validation Guide**: docs/VALIDATION_FIXES_v2.3.1.md
- **AgentDB Guide**: docs/AGENTDB_GUIDE.md
## Version History
- **v2.3.2** - Documentation updates
- **v2.3.1** - Validation fixes for ReasoningBank
- **v2.3.0** - Quantum-resistant security with @qudag/napi-core
- **v2.1.0** - Self-learning AI with ReasoningBank
- **v2.0.0** - Zero-dependency installation with embedded jj binary
---
**Status**: ✅ Production Ready
**License**: MIT
**Maintained**: Active

204
vendor/ruvector/.claude/skills/browser/SKILL.md vendored Normal file
View File

@@ -0,0 +1,204 @@
---
name: browser
description: Web browser automation with AI-optimized snapshots for claude-flow agents
version: 1.0.0
triggers:
- /browser
- browse
- web automation
- scrape
- navigate
- screenshot
tools:
- browser/open
- browser/snapshot
- browser/click
- browser/fill
- browser/screenshot
- browser/close
---
# Browser Automation Skill
Web browser automation using agent-browser with AI-optimized snapshots. Reduces context by 93% using element refs (@e1, @e2) instead of full DOM.
## Core Workflow
```bash
# 1. Navigate to page
agent-browser open <url>
# 2. Get accessibility tree with element refs
agent-browser snapshot -i # -i = interactive elements only
# 3. Interact using refs from snapshot
agent-browser click @e2
agent-browser fill @e3 "text"
# 4. Re-snapshot after page changes
agent-browser snapshot -i
```
## Quick Reference
### Navigation
| Command | Description |
|---------|-------------|
| `open <url>` | Navigate to URL |
| `back` | Go back |
| `forward` | Go forward |
| `reload` | Reload page |
| `close` | Close browser |
### Snapshots (AI-Optimized)
| Command | Description |
|---------|-------------|
| `snapshot` | Full accessibility tree |
| `snapshot -i` | Interactive elements only (buttons, links, inputs) |
| `snapshot -c` | Compact (remove empty elements) |
| `snapshot -d 3` | Limit depth to 3 levels |
| `screenshot [path]` | Capture screenshot (base64 if no path) |
### Interaction
| Command | Description |
|---------|-------------|
| `click <sel>` | Click element |
| `fill <sel> <text>` | Clear and fill input |
| `type <sel> <text>` | Type with key events |
| `press <key>` | Press key (Enter, Tab, etc.) |
| `hover <sel>` | Hover element |
| `select <sel> <val>` | Select dropdown option |
| `check/uncheck <sel>` | Toggle checkbox |
| `scroll <dir> [px]` | Scroll page |
### Get Info
| Command | Description |
|---------|-------------|
| `get text <sel>` | Get text content |
| `get html <sel>` | Get innerHTML |
| `get value <sel>` | Get input value |
| `get attr <sel> <attr>` | Get attribute |
| `get title` | Get page title |
| `get url` | Get current URL |
### Wait
| Command | Description |
|---------|-------------|
| `wait <selector>` | Wait for element |
| `wait <ms>` | Wait milliseconds |
| `wait --text "text"` | Wait for text |
| `wait --url "pattern"` | Wait for URL |
| `wait --load networkidle` | Wait for load state |
### Sessions
| Command | Description |
|---------|-------------|
| `--session <name>` | Use isolated session |
| `session list` | List active sessions |
## Selectors
### Element Refs (Recommended)
```bash
# Get refs from snapshot
agent-browser snapshot -i
# Output: button "Submit" [ref=e2]
# Use ref to interact
agent-browser click @e2
```
### CSS Selectors
```bash
agent-browser click "#submit"
agent-browser fill ".email-input" "test@test.com"
```
### Semantic Locators
```bash
agent-browser find role button click --name "Submit"
agent-browser find label "Email" fill "test@test.com"
agent-browser find testid "login-btn" click
```
## Examples
### Login Flow
```bash
agent-browser open https://example.com/login
agent-browser snapshot -i
agent-browser fill @e2 "user@example.com"
agent-browser fill @e3 "password123"
agent-browser click @e4
agent-browser wait --url "**/dashboard"
```
### Form Submission
```bash
agent-browser open https://example.com/contact
agent-browser snapshot -i
agent-browser fill @e1 "John Doe"
agent-browser fill @e2 "john@example.com"
agent-browser fill @e3 "Hello, this is my message"
agent-browser click @e4
agent-browser wait --text "Thank you"
```
### Data Extraction
```bash
agent-browser open https://example.com/products
agent-browser snapshot -i
# Iterate through product refs
agent-browser get text @e1 # Product name
agent-browser get text @e2 # Price
agent-browser get attr @e3 href # Link
```
### Multi-Session (Swarm)
```bash
# Session 1: Navigator
agent-browser --session nav open https://example.com
agent-browser --session nav state save auth.json
# Session 2: Scraper (uses same auth)
agent-browser --session scrape state load auth.json
agent-browser --session scrape open https://example.com/data
agent-browser --session scrape snapshot -i
```
## Integration with Claude Flow
### MCP Tools
All browser operations are available as MCP tools with `browser/` prefix:
- `browser/open`
- `browser/snapshot`
- `browser/click`
- `browser/fill`
- `browser/screenshot`
- etc.
### Memory Integration
```bash
# Store successful patterns
npx @claude-flow/cli memory store --namespace browser-patterns --key "login-flow" --value "snapshot->fill->click->wait"
# Retrieve before similar task
npx @claude-flow/cli memory search --query "login automation"
```
### Hooks
```bash
# Pre-browse hook (get context)
npx @claude-flow/cli hooks pre-edit --file "browser-task.ts"
# Post-browse hook (record success)
npx @claude-flow/cli hooks post-task --task-id "browse-1" --success true
```
## Tips
1. **Always use snapshots** - They're optimized for AI with refs
2. **Prefer `-i` flag** - Gets only interactive elements, smaller output
3. **Use refs, not selectors** - More reliable, deterministic
4. **Re-snapshot after navigation** - Page state changes
5. **Use sessions for parallel work** - Each session is isolated

202
vendor/ruvector/.claude/skills/custom-workers/SKILL.md vendored Normal file
View File

@@ -0,0 +1,202 @@
---
name: "Custom Workers"
description: "Create and run custom background analysis workers with composable phases. Use when you need automated code analysis, security scanning, pattern learning, or API documentation generation."
hooks:
pre: |
echo "🔧 Custom Workers activated"
.claude/agentic-flow-fast.sh workers stats 2>/dev/null || true
post: |
echo "✅ Custom Workers complete"
.claude/agentic-flow-fast.sh workers results --json 2>/dev/null | head -20 || true
---
# Custom Workers
Build composable background analysis workers with 24 phase executors and 6 presets.
## Quick Start
```bash
# List available presets
npx ruvector workers presets
# List available phase executors
npx ruvector workers phases
# Create a custom worker from preset
npx ruvector workers create my-scanner --preset security-scan
# Run the worker
npx ruvector workers run my-scanner --path ./src
```
## Available Presets
| Preset | Description | Phases |
|--------|-------------|--------|
| `quick-scan` | Fast file discovery and stats | file-discovery → summarization |
| `deep-analysis` | Comprehensive code analysis | file-discovery → static-analysis → complexity-analysis → import-analysis → pattern-extraction → graph-build → vectorization → summarization |
| `security-scan` | Security-focused analysis | file-discovery → security-analysis → secret-detection → dependency-discovery → report-generation |
| `learning` | Pattern learning and memory | file-discovery → pattern-extraction → embedding-generation → pattern-storage → sona-training |
| `api-docs` | API endpoint documentation | file-discovery → api-discovery → type-analysis → report-generation |
| `test-analysis` | Test coverage analysis | file-discovery → static-analysis → pattern-extraction → summarization |
## Phase Executors (24 total)
### Discovery Phases
- `file-discovery` - Find files matching patterns
- `pattern-discovery` - Discover code patterns
- `dependency-discovery` - Map dependencies
- `api-discovery` - Find API endpoints
### Analysis Phases
- `static-analysis` - AST-based code analysis
- `complexity-analysis` - Cyclomatic complexity
- `security-analysis` - Security vulnerability scan
- `performance-analysis` - Performance bottlenecks
- `import-analysis` - Import/export mapping
- `type-analysis` - TypeScript type extraction
### Pattern Phases
- `pattern-extraction` - Extract code patterns
- `todo-extraction` - Find TODOs/FIXMEs
- `secret-detection` - Detect hardcoded secrets
- `code-smell-detection` - Identify code smells
### Build Phases
- `graph-build` - Build code graph
- `call-graph` - Function call graph
- `dependency-graph` - Dependency graph
### Learning Phases
- `vectorization` - Convert to vectors
- `embedding-generation` - ONNX embeddings (384d)
- `pattern-storage` - Store in VectorDB
- `sona-training` - SONA reinforcement learning
### Output Phases
- `summarization` - Generate summary
- `report-generation` - Create report
- `indexing` - Index for search
## YAML Configuration
Create `workers.yaml` in your project:
```yaml
version: '1.0'
workers:
- name: auth-scanner
triggers: [auth-scan, scan-auth]
phases:
- type: file-discovery
config:
patterns: ["**/auth/**", "**/login/**"]
- type: security-analysis
- type: secret-detection
- type: report-generation
capabilities:
onnxEmbeddings: true
vectorDb: true
- name: api-documenter
triggers: [api-docs, document-api]
phases:
- type: file-discovery
config:
patterns: ["**/routes/**", "**/api/**"]
- type: api-discovery
- type: type-analysis
- type: report-generation
```
Load configuration:
```bash
npx ruvector workers load-config --file workers.yaml
```
## CLI Commands
```bash
# Core commands
npx ruvector workers presets # List presets
npx ruvector workers phases # List phases
npx ruvector workers create <name> --preset <preset>
npx ruvector workers run <name> --path <path>
# Configuration
npx ruvector workers init-config # Generate workers.yaml
npx ruvector workers load-config # Load from workers.yaml
npx ruvector workers custom # List registered workers
# Monitoring
npx ruvector workers status # Worker status
npx ruvector workers results # Analysis results
npx ruvector workers stats # Statistics
```
## MCP Tools
Available via ruvector MCP server:
| Tool | Description |
|------|-------------|
| `workers_presets` | List available presets |
| `workers_phases` | List phase executors |
| `workers_create` | Create custom worker |
| `workers_run` | Run worker on path |
| `workers_custom` | List custom workers |
| `workers_init_config` | Generate config |
| `workers_load_config` | Load config |
## Capabilities
Workers can use these capabilities:
- **ONNX Embeddings**: Real transformer embeddings (all-MiniLM-L6-v2, 384d, SIMD)
- **VectorDB**: Store and search embeddings with HNSW indexing
- **SONA Learning**: Self-Organizing Neural Architecture for pattern learning
- **ReasoningBank**: Trajectory tracking and meta-learning
## Integration with Hooks
Workers auto-dispatch on UserPromptSubmit via trigger keywords:
- Type "audit this code" → triggers audit worker
- Type "security scan" → triggers security worker
- Type "learn patterns" → triggers learning worker
## Example: Security Scanner
```bash
# Create from security-scan preset
npx ruvector workers create security-checker --preset security-scan --triggers "security,vuln,cve"
# Run on source
npx ruvector workers run security-checker --path ./src
# View results
npx ruvector workers results
```
## Example: Custom Learning Worker
```yaml
# workers.yaml
workers:
- name: code-learner
triggers: [learn, pattern-learn]
phases:
- type: file-discovery
config:
patterns: ["**/*.ts", "**/*.js"]
exclude: ["node_modules/**"]
- type: static-analysis
- type: pattern-extraction
- type: embedding-generation
- type: pattern-storage
- type: sona-training
capabilities:
onnxEmbeddings: true
vectorDb: true
sonaLearning: true
```

756
vendor/ruvector/.claude/skills/flow-nexus-neural/SKILL.md vendored Normal file
View File

@@ -0,0 +1,756 @@
---
name: flow-nexus-neural
description: Train and deploy neural networks in distributed E2B sandboxes with Flow Nexus
version: 1.0.0
category: ai-ml
tags:
- neural-networks
- distributed-training
- machine-learning
- deep-learning
- flow-nexus
- e2b-sandboxes
requires_auth: true
mcp_server: flow-nexus
hooks:
pre: |
echo "🧠 Flow Nexus Neural activated"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js pre-edit "$FILE" 2>/dev/null || true
fi
post: |
echo "✅ Flow Nexus Neural complete"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js post-edit "$FILE" "true" 2>/dev/null || true
fi
---
# Flow Nexus Neural Networks
Deploy, train, and manage neural networks in distributed E2B sandbox environments. Train custom models with multiple architectures (feedforward, LSTM, GAN, transformer) or use pre-built templates from the marketplace.
## Self-Learning Intelligence
Integrates with RuVector's Q-learning and vector memory for improved performance.
CLI: `node .claude/intelligence/cli.js stats`
## Prerequisites
```bash
# Add Flow Nexus MCP server
claude mcp add flow-nexus npx flow-nexus@latest mcp start
# Register and login
npx flow-nexus@latest register
npx flow-nexus@latest login
```
## Core Capabilities
### 1. Single-Node Neural Training
Train neural networks with custom architectures and configurations.
**Available Architectures:**
- `feedforward` - Standard fully-connected networks
- `lstm` - Long Short-Term Memory for sequences
- `gan` - Generative Adversarial Networks
- `autoencoder` - Dimensionality reduction
- `transformer` - Attention-based models
**Training Tiers:**
- `nano` - Minimal resources (fast, limited)
- `mini` - Small models
- `small` - Standard models
- `medium` - Complex models
- `large` - Large-scale training
#### Example: Train Custom Classifier
```javascript
mcp__flow-nexus__neural_train({
config: {
architecture: {
type: "feedforward",
layers: [
{ type: "dense", units: 256, activation: "relu" },
{ type: "dropout", rate: 0.3 },
{ type: "dense", units: 128, activation: "relu" },
{ type: "dropout", rate: 0.2 },
{ type: "dense", units: 64, activation: "relu" },
{ type: "dense", units: 10, activation: "softmax" }
]
},
training: {
epochs: 100,
batch_size: 32,
learning_rate: 0.001,
optimizer: "adam"
},
divergent: {
enabled: true,
pattern: "lateral", // quantum, chaotic, associative, evolutionary
factor: 0.5
}
},
tier: "small",
user_id: "your_user_id"
})
```
#### Example: LSTM for Time Series
```javascript
mcp__flow-nexus__neural_train({
config: {
architecture: {
type: "lstm",
layers: [
{ type: "lstm", units: 128, return_sequences: true },
{ type: "dropout", rate: 0.2 },
{ type: "lstm", units: 64 },
{ type: "dense", units: 1, activation: "linear" }
]
},
training: {
epochs: 150,
batch_size: 64,
learning_rate: 0.01,
optimizer: "adam"
}
},
tier: "medium"
})
```
#### Example: Transformer Architecture
```javascript
mcp__flow-nexus__neural_train({
config: {
architecture: {
type: "transformer",
layers: [
{ type: "embedding", vocab_size: 10000, embedding_dim: 512 },
{ type: "transformer_encoder", num_heads: 8, ff_dim: 2048 },
{ type: "global_average_pooling" },
{ type: "dense", units: 128, activation: "relu" },
{ type: "dense", units: 2, activation: "softmax" }
]
},
training: {
epochs: 50,
batch_size: 16,
learning_rate: 0.0001,
optimizer: "adam"
}
},
tier: "large"
})
```
### 2. Model Inference
Run predictions on trained models.
```javascript
mcp__flow-nexus__neural_predict({
model_id: "model_abc123",
input: [
[0.5, 0.3, 0.2, 0.1],
[0.8, 0.1, 0.05, 0.05],
[0.2, 0.6, 0.15, 0.05]
],
user_id: "your_user_id"
})
```
**Response:**
```json
{
"predictions": [
[0.12, 0.85, 0.03],
[0.89, 0.08, 0.03],
[0.05, 0.92, 0.03]
],
"inference_time_ms": 45,
"model_version": "1.0.0"
}
```
### 3. Template Marketplace
Browse and deploy pre-trained models from the marketplace.
#### List Available Templates
```javascript
mcp__flow-nexus__neural_list_templates({
category: "classification", // timeseries, regression, nlp, vision, anomaly, generative
tier: "free", // or "paid"
search: "sentiment",
limit: 20
})
```
**Response:**
```json
{
"templates": [
{
"id": "sentiment-analysis-v2",
"name": "Sentiment Analysis Classifier",
"description": "Pre-trained BERT model for sentiment analysis",
"category": "nlp",
"accuracy": 0.94,
"downloads": 1523,
"tier": "free"
},
{
"id": "image-classifier-resnet",
"name": "ResNet Image Classifier",
"description": "ResNet-50 for image classification",
"category": "vision",
"accuracy": 0.96,
"downloads": 2341,
"tier": "paid"
}
]
}
```
#### Deploy Template
```javascript
mcp__flow-nexus__neural_deploy_template({
template_id: "sentiment-analysis-v2",
custom_config: {
training: {
epochs: 50,
learning_rate: 0.0001
}
},
user_id: "your_user_id"
})
```
### 4. Distributed Training Clusters
Train large models across multiple E2B sandboxes with distributed computing.
#### Initialize Cluster
```javascript
mcp__flow-nexus__neural_cluster_init({
name: "large-model-cluster",
architecture: "transformer", // transformer, cnn, rnn, gnn, hybrid
topology: "mesh", // mesh, ring, star, hierarchical
consensus: "proof-of-learning", // byzantine, raft, gossip
daaEnabled: true, // Decentralized Autonomous Agents
wasmOptimization: true
})
```
**Response:**
```json
{
"cluster_id": "cluster_xyz789",
"name": "large-model-cluster",
"status": "initializing",
"topology": "mesh",
"max_nodes": 100,
"created_at": "2025-10-19T10:30:00Z"
}
```
#### Deploy Worker Nodes
```javascript
// Deploy parameter server
mcp__flow-nexus__neural_node_deploy({
cluster_id: "cluster_xyz789",
node_type: "parameter_server",
model: "large",
template: "nodejs",
capabilities: ["parameter_management", "gradient_aggregation"],
autonomy: 0.8
})
// Deploy worker nodes
mcp__flow-nexus__neural_node_deploy({
cluster_id: "cluster_xyz789",
node_type: "worker",
model: "xl",
role: "worker",
capabilities: ["training", "inference"],
layers: [
{ type: "transformer_encoder", num_heads: 16 },
{ type: "feed_forward", units: 4096 }
],
autonomy: 0.9
})
// Deploy aggregator
mcp__flow-nexus__neural_node_deploy({
cluster_id: "cluster_xyz789",
node_type: "aggregator",
model: "large",
capabilities: ["gradient_aggregation", "model_synchronization"]
})
```
#### Connect Cluster Topology
```javascript
mcp__flow-nexus__neural_cluster_connect({
cluster_id: "cluster_xyz789",
topology: "mesh" // Override default if needed
})
```
#### Start Distributed Training
```javascript
mcp__flow-nexus__neural_train_distributed({
cluster_id: "cluster_xyz789",
dataset: "imagenet", // or custom dataset identifier
epochs: 100,
batch_size: 128,
learning_rate: 0.001,
optimizer: "adam", // sgd, rmsprop, adagrad
federated: true // Enable federated learning
})
```
**Federated Learning Example:**
```javascript
mcp__flow-nexus__neural_train_distributed({
cluster_id: "cluster_xyz789",
dataset: "medical_images_distributed",
epochs: 200,
batch_size: 64,
learning_rate: 0.0001,
optimizer: "adam",
federated: true, // Data stays on local nodes
aggregation_rounds: 50,
min_nodes_per_round: 5
})
```
#### Monitor Cluster Status
```javascript
mcp__flow-nexus__neural_cluster_status({
cluster_id: "cluster_xyz789"
})
```
**Response:**
```json
{
"cluster_id": "cluster_xyz789",
"status": "training",
"nodes": [
{
"node_id": "node_001",
"type": "parameter_server",
"status": "active",
"cpu_usage": 0.75,
"memory_usage": 0.82
},
{
"node_id": "node_002",
"type": "worker",
"status": "active",
"training_progress": 0.45
}
],
"training_metrics": {
"current_epoch": 45,
"total_epochs": 100,
"loss": 0.234,
"accuracy": 0.891
}
}
```
#### Run Distributed Inference
```javascript
mcp__flow-nexus__neural_predict_distributed({
cluster_id: "cluster_xyz789",
input_data: JSON.stringify([
[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6]
]),
aggregation: "ensemble" // mean, majority, weighted, ensemble
})
```
#### Terminate Cluster
```javascript
mcp__flow-nexus__neural_cluster_terminate({
cluster_id: "cluster_xyz789"
})
```
### 5. Model Management
#### List Your Models
```javascript
mcp__flow-nexus__neural_list_models({
user_id: "your_user_id",
include_public: true
})
```
**Response:**
```json
{
"models": [
{
"model_id": "model_abc123",
"name": "Custom Classifier v1",
"architecture": "feedforward",
"accuracy": 0.92,
"created_at": "2025-10-15T14:20:00Z",
"status": "trained"
},
{
"model_id": "model_def456",
"name": "LSTM Forecaster",
"architecture": "lstm",
"mse": 0.0045,
"created_at": "2025-10-18T09:15:00Z",
"status": "training"
}
]
}
```
#### Check Training Status
```javascript
mcp__flow-nexus__neural_training_status({
job_id: "job_training_xyz"
})
```
**Response:**
```json
{
"job_id": "job_training_xyz",
"status": "training",
"progress": 0.67,
"current_epoch": 67,
"total_epochs": 100,
"current_loss": 0.234,
"estimated_completion": "2025-10-19T12:45:00Z"
}
```
#### Performance Benchmarking
```javascript
mcp__flow-nexus__neural_performance_benchmark({
model_id: "model_abc123",
benchmark_type: "comprehensive" // inference, throughput, memory, comprehensive
})
```
**Response:**
```json
{
"model_id": "model_abc123",
"benchmarks": {
"inference_latency_ms": 12.5,
"throughput_qps": 8000,
"memory_usage_mb": 245,
"gpu_utilization": 0.78,
"accuracy": 0.92,
"f1_score": 0.89
},
"timestamp": "2025-10-19T11:00:00Z"
}
```
#### Create Validation Workflow
```javascript
mcp__flow-nexus__neural_validation_workflow({
model_id: "model_abc123",
user_id: "your_user_id",
validation_type: "comprehensive" // performance, accuracy, robustness, comprehensive
})
```
### 6. Publishing and Marketplace
#### Publish Model as Template
```javascript
mcp__flow-nexus__neural_publish_template({
model_id: "model_abc123",
name: "High-Accuracy Sentiment Classifier",
description: "Fine-tuned BERT model for sentiment analysis with 94% accuracy",
category: "nlp",
price: 0, // 0 for free, or credits amount
user_id: "your_user_id"
})
```
#### Rate a Template
```javascript
mcp__flow-nexus__neural_rate_template({
template_id: "sentiment-analysis-v2",
rating: 5,
review: "Excellent model! Achieved 95% accuracy on my dataset.",
user_id: "your_user_id"
})
```
## Common Use Cases
### Image Classification with CNN
```javascript
// Initialize cluster for large-scale image training
const cluster = await mcp__flow-nexus__neural_cluster_init({
name: "image-classification-cluster",
architecture: "cnn",
topology: "hierarchical",
wasmOptimization: true
})
// Deploy worker nodes
await mcp__flow-nexus__neural_node_deploy({
cluster_id: cluster.cluster_id,
node_type: "worker",
model: "large",
capabilities: ["training", "data_augmentation"]
})
// Start training
await mcp__flow-nexus__neural_train_distributed({
cluster_id: cluster.cluster_id,
dataset: "custom_images",
epochs: 100,
batch_size: 64,
learning_rate: 0.001,
optimizer: "adam"
})
```
### NLP Sentiment Analysis
```javascript
// Use pre-built template
const deployment = await mcp__flow-nexus__neural_deploy_template({
template_id: "sentiment-analysis-v2",
custom_config: {
training: {
epochs: 30,
batch_size: 16
}
}
})
// Run inference
const result = await mcp__flow-nexus__neural_predict({
model_id: deployment.model_id,
input: ["This product is amazing!", "Terrible experience."]
})
```
### Time Series Forecasting
```javascript
// Train LSTM model
const training = await mcp__flow-nexus__neural_train({
config: {
architecture: {
type: "lstm",
layers: [
{ type: "lstm", units: 128, return_sequences: true },
{ type: "dropout", rate: 0.2 },
{ type: "lstm", units: 64 },
{ type: "dense", units: 1 }
]
},
training: {
epochs: 150,
batch_size: 64,
learning_rate: 0.01,
optimizer: "adam"
}
},
tier: "medium"
})
// Monitor progress
const status = await mcp__flow-nexus__neural_training_status({
job_id: training.job_id
})
```
### Federated Learning for Privacy
```javascript
// Initialize federated cluster
const cluster = await mcp__flow-nexus__neural_cluster_init({
name: "federated-medical-cluster",
architecture: "transformer",
topology: "mesh",
consensus: "proof-of-learning",
daaEnabled: true
})
// Deploy nodes across different locations
for (let i = 0; i < 5; i++) {
await mcp__flow-nexus__neural_node_deploy({
cluster_id: cluster.cluster_id,
node_type: "worker",
model: "large",
autonomy: 0.9
})
}
// Train with federated learning (data never leaves nodes)
await mcp__flow-nexus__neural_train_distributed({
cluster_id: cluster.cluster_id,
dataset: "medical_records_distributed",
epochs: 200,
federated: true,
aggregation_rounds: 100
})
```
## Architecture Patterns
### Feedforward Networks
Best for: Classification, regression, simple pattern recognition
```javascript
{
type: "feedforward",
layers: [
{ type: "dense", units: 256, activation: "relu" },
{ type: "dropout", rate: 0.3 },
{ type: "dense", units: 128, activation: "relu" },
{ type: "dense", units: 10, activation: "softmax" }
]
}
```
### LSTM Networks
Best for: Time series, sequences, forecasting
```javascript
{
type: "lstm",
layers: [
{ type: "lstm", units: 128, return_sequences: true },
{ type: "lstm", units: 64 },
{ type: "dense", units: 1 }
]
}
```
### Transformers
Best for: NLP, attention mechanisms, large-scale text
```javascript
{
type: "transformer",
layers: [
{ type: "embedding", vocab_size: 10000, embedding_dim: 512 },
{ type: "transformer_encoder", num_heads: 8, ff_dim: 2048 },
{ type: "global_average_pooling" },
{ type: "dense", units: 2, activation: "softmax" }
]
}
```
### GANs
Best for: Generative tasks, image synthesis
```javascript
{
type: "gan",
generator_layers: [...],
discriminator_layers: [...]
}
```
### Autoencoders
Best for: Dimensionality reduction, anomaly detection
```javascript
{
type: "autoencoder",
encoder_layers: [
{ type: "dense", units: 128, activation: "relu" },
{ type: "dense", units: 64, activation: "relu" }
],
decoder_layers: [
{ type: "dense", units: 128, activation: "relu" },
{ type: "dense", units: input_dim, activation: "sigmoid" }
]
}
```
## Best Practices
1. **Start Small**: Begin with `nano` or `mini` tiers for experimentation
2. **Use Templates**: Leverage marketplace templates for common tasks
3. **Monitor Training**: Check status regularly to catch issues early
4. **Benchmark Models**: Always benchmark before production deployment
5. **Distributed Training**: Use clusters for large models (>1B parameters)
6. **Federated Learning**: Use for privacy-sensitive data
7. **Version Models**: Publish successful models as templates for reuse
8. **Validate Thoroughly**: Use validation workflows before deployment
## Troubleshooting
### Training Stalled
```javascript
// Check cluster status
const status = await mcp__flow-nexus__neural_cluster_status({
cluster_id: "cluster_id"
})
// Terminate and restart if needed
await mcp__flow-nexus__neural_cluster_terminate({
cluster_id: "cluster_id"
})
```
### Low Accuracy
- Increase epochs
- Adjust learning rate
- Add regularization (dropout)
- Try different optimizer
- Use data augmentation
### Out of Memory
- Reduce batch size
- Use smaller model tier
- Enable gradient accumulation
- Use distributed training
## Related Skills
- `flow-nexus-sandbox` - E2B sandbox management
- `flow-nexus-swarm` - AI swarm orchestration
- `flow-nexus-workflow` - Workflow automation
## Resources
- Flow Nexus Docs: https://flow-nexus.ruv.io/docs
- Neural Network Guide: https://flow-nexus.ruv.io/docs/neural
- Template Marketplace: https://flow-nexus.ruv.io/templates
- API Reference: https://flow-nexus.ruv.io/api
---
**Note**: Distributed training requires authentication. Register at https://flow-nexus.ruv.io or use `npx flow-nexus@latest register`.

1175
vendor/ruvector/.claude/skills/flow-nexus-platform/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

628
vendor/ruvector/.claude/skills/flow-nexus-swarm/SKILL.md vendored Normal file
View File

@@ -0,0 +1,628 @@
---
name: flow-nexus-swarm
description: Cloud-based AI swarm deployment and event-driven workflow automation with Flow Nexus platform
category: orchestration
tags: [swarm, workflow, cloud, agents, automation, message-queue]
version: 1.0.0
requires:
- flow-nexus MCP server
- Active Flow Nexus account (register at flow-nexus.ruv.io)
hooks:
pre: |
echo "🧠 Flow Nexus Swarm activated"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js pre-edit "$FILE" 2>/dev/null || true
fi
post: |
echo "✅ Flow Nexus Swarm complete"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js post-edit "$FILE" "true" 2>/dev/null || true
fi
---
# Flow Nexus Swarm & Workflow Orchestration
Deploy and manage cloud-based AI agent swarms with event-driven workflow automation, message queue processing, and intelligent agent coordination.
## Self-Learning Intelligence
Integrates with RuVector's Q-learning and vector memory for improved performance.
CLI: `node .claude/intelligence/cli.js stats`
## 📋 Table of Contents
1. [Overview](#overview)
2. [Swarm Management](#swarm-management)
3. [Workflow Automation](#workflow-automation)
4. [Agent Orchestration](#agent-orchestration)
5. [Templates & Patterns](#templates--patterns)
6. [Advanced Features](#advanced-features)
7. [Best Practices](#best-practices)
## Overview
Flow Nexus provides cloud-based orchestration for AI agent swarms with:
- **Multi-topology Support**: Hierarchical, mesh, ring, and star architectures
- **Event-driven Workflows**: Message queue processing with async execution
- **Template Library**: Pre-built swarm configurations for common use cases
- **Intelligent Agent Assignment**: Vector similarity matching for optimal agent selection
- **Real-time Monitoring**: Comprehensive metrics and audit trails
- **Scalable Infrastructure**: Cloud-based execution with auto-scaling
## Swarm Management
### Initialize Swarm
Create a new swarm with specified topology and configuration:
```javascript
mcp__flow-nexus__swarm_init({
topology: "hierarchical", // Options: mesh, ring, star, hierarchical
maxAgents: 8,
strategy: "balanced" // Options: balanced, specialized, adaptive
})
```
**Topology Guide:**
- **Hierarchical**: Tree structure with coordinator nodes (best for complex projects)
- **Mesh**: Peer-to-peer collaboration (best for research and analysis)
- **Ring**: Circular coordination (best for sequential workflows)
- **Star**: Centralized hub (best for simple delegation)
**Strategy Guide:**
- **Balanced**: Equal distribution of workload across agents
- **Specialized**: Agents focus on specific expertise areas
- **Adaptive**: Dynamic adjustment based on task complexity
### Spawn Agents
Add specialized agents to the swarm:
```javascript
mcp__flow-nexus__agent_spawn({
type: "researcher", // Options: researcher, coder, analyst, optimizer, coordinator
name: "Lead Researcher",
capabilities: ["web_search", "analysis", "summarization"]
})
```
**Agent Types:**
- **Researcher**: Information gathering, web search, analysis
- **Coder**: Code generation, refactoring, implementation
- **Analyst**: Data analysis, pattern recognition, insights
- **Optimizer**: Performance tuning, resource optimization
- **Coordinator**: Task delegation, progress tracking, integration
### Orchestrate Tasks
Distribute tasks across the swarm:
```javascript
mcp__flow-nexus__task_orchestrate({
task: "Build a REST API with authentication and database integration",
strategy: "parallel", // Options: parallel, sequential, adaptive
maxAgents: 5,
priority: "high" // Options: low, medium, high, critical
})
```
**Execution Strategies:**
- **Parallel**: Maximum concurrency for independent subtasks
- **Sequential**: Step-by-step execution with dependencies
- **Adaptive**: AI-powered strategy selection based on task analysis
### Monitor & Scale Swarms
```javascript
// Get detailed swarm status
mcp__flow-nexus__swarm_status({
swarm_id: "optional-id" // Uses active swarm if not provided
})
// List all active swarms
mcp__flow-nexus__swarm_list({
status: "active" // Options: active, destroyed, all
})
// Scale swarm up or down
mcp__flow-nexus__swarm_scale({
target_agents: 10,
swarm_id: "optional-id"
})
// Gracefully destroy swarm
mcp__flow-nexus__swarm_destroy({
swarm_id: "optional-id"
})
```
## Workflow Automation
### Create Workflow
Define event-driven workflows with message queue processing:
```javascript
mcp__flow-nexus__workflow_create({
name: "CI/CD Pipeline",
description: "Automated testing, building, and deployment",
steps: [
{
id: "test",
action: "run_tests",
agent: "tester",
parallel: true
},
{
id: "build",
action: "build_app",
agent: "builder",
depends_on: ["test"]
},
{
id: "deploy",
action: "deploy_prod",
agent: "deployer",
depends_on: ["build"]
}
],
triggers: ["push_to_main", "manual_trigger"],
metadata: {
priority: 10,
retry_policy: "exponential_backoff"
}
})
```
**Workflow Features:**
- **Dependency Management**: Define step dependencies with `depends_on`
- **Parallel Execution**: Set `parallel: true` for concurrent steps
- **Event Triggers**: GitHub events, schedules, manual triggers
- **Retry Policies**: Automatic retry on transient failures
- **Priority Queuing**: High-priority workflows execute first
### Execute Workflow
Run workflows synchronously or asynchronously:
```javascript
mcp__flow-nexus__workflow_execute({
workflow_id: "workflow_id",
input_data: {
branch: "main",
commit: "abc123",
environment: "production"
},
async: true // Queue-based execution for long-running workflows
})
```
**Execution Modes:**
- **Sync (async: false)**: Immediate execution, wait for completion
- **Async (async: true)**: Message queue processing, non-blocking
### Monitor Workflows
```javascript
// Get workflow status and metrics
mcp__flow-nexus__workflow_status({
workflow_id: "id",
execution_id: "specific-run-id", // Optional
include_metrics: true
})
// List workflows with filters
mcp__flow-nexus__workflow_list({
status: "running", // Options: running, completed, failed, pending
limit: 10,
offset: 0
})
// Get complete audit trail
mcp__flow-nexus__workflow_audit_trail({
workflow_id: "id",
limit: 50,
start_time: "2025-01-01T00:00:00Z"
})
```
### Agent Assignment
Intelligently assign agents to workflow tasks:
```javascript
mcp__flow-nexus__workflow_agent_assign({
task_id: "task_id",
agent_type: "coder", // Preferred agent type
use_vector_similarity: true // AI-powered capability matching
})
```
**Vector Similarity Matching:**
- Analyzes task requirements and agent capabilities
- Finds optimal agent based on past performance
- Considers workload and availability
### Queue Management
Monitor and manage message queues:
```javascript
mcp__flow-nexus__workflow_queue_status({
queue_name: "optional-specific-queue",
include_messages: true // Show pending messages
})
```
## Agent Orchestration
### Full-Stack Development Pattern
```javascript
// 1. Initialize swarm with hierarchical topology
mcp__flow-nexus__swarm_init({
topology: "hierarchical",
maxAgents: 8,
strategy: "specialized"
})
// 2. Spawn specialized agents
mcp__flow-nexus__agent_spawn({ type: "coordinator", name: "Project Manager" })
mcp__flow-nexus__agent_spawn({ type: "coder", name: "Backend Developer" })
mcp__flow-nexus__agent_spawn({ type: "coder", name: "Frontend Developer" })
mcp__flow-nexus__agent_spawn({ type: "coder", name: "Database Architect" })
mcp__flow-nexus__agent_spawn({ type: "analyst", name: "QA Engineer" })
// 3. Create development workflow
mcp__flow-nexus__workflow_create({
name: "Full-Stack Development",
steps: [
{ id: "requirements", action: "analyze_requirements", agent: "coordinator" },
{ id: "db_design", action: "design_schema", agent: "Database Architect" },
{ id: "backend", action: "build_api", agent: "Backend Developer", depends_on: ["db_design"] },
{ id: "frontend", action: "build_ui", agent: "Frontend Developer", depends_on: ["requirements"] },
{ id: "integration", action: "integrate", agent: "Backend Developer", depends_on: ["backend", "frontend"] },
{ id: "testing", action: "qa_testing", agent: "QA Engineer", depends_on: ["integration"] }
]
})
// 4. Execute workflow
mcp__flow-nexus__workflow_execute({
workflow_id: "workflow_id",
input_data: {
project: "E-commerce Platform",
tech_stack: ["Node.js", "React", "PostgreSQL"]
}
})
```
### Research & Analysis Pattern
```javascript
// 1. Initialize mesh topology for collaborative research
mcp__flow-nexus__swarm_init({
topology: "mesh",
maxAgents: 5,
strategy: "balanced"
})
// 2. Spawn research agents
mcp__flow-nexus__agent_spawn({ type: "researcher", name: "Primary Researcher" })
mcp__flow-nexus__agent_spawn({ type: "researcher", name: "Secondary Researcher" })
mcp__flow-nexus__agent_spawn({ type: "analyst", name: "Data Analyst" })
mcp__flow-nexus__agent_spawn({ type: "analyst", name: "Insights Analyst" })
// 3. Orchestrate research task
mcp__flow-nexus__task_orchestrate({
task: "Research machine learning trends for 2025 and analyze market opportunities",
strategy: "parallel",
maxAgents: 4,
priority: "high"
})
```
### CI/CD Pipeline Pattern
```javascript
mcp__flow-nexus__workflow_create({
name: "Deployment Pipeline",
description: "Automated testing, building, and multi-environment deployment",
steps: [
{ id: "lint", action: "lint_code", agent: "code_quality", parallel: true },
{ id: "unit_test", action: "unit_tests", agent: "test_runner", parallel: true },
{ id: "integration_test", action: "integration_tests", agent: "test_runner", parallel: true },
{ id: "build", action: "build_artifacts", agent: "builder", depends_on: ["lint", "unit_test", "integration_test"] },
{ id: "security_scan", action: "security_scan", agent: "security", depends_on: ["build"] },
{ id: "deploy_staging", action: "deploy", agent: "deployer", depends_on: ["security_scan"] },
{ id: "smoke_test", action: "smoke_tests", agent: "test_runner", depends_on: ["deploy_staging"] },
{ id: "deploy_prod", action: "deploy", agent: "deployer", depends_on: ["smoke_test"] }
],
triggers: ["github_push", "github_pr_merged"],
metadata: {
priority: 10,
auto_rollback: true
}
})
```
### Data Processing Pipeline Pattern
```javascript
mcp__flow-nexus__workflow_create({
name: "ETL Pipeline",
description: "Extract, Transform, Load data processing",
steps: [
{ id: "extract", action: "extract_data", agent: "data_extractor" },
{ id: "validate_raw", action: "validate_data", agent: "validator", depends_on: ["extract"] },
{ id: "transform", action: "transform_data", agent: "transformer", depends_on: ["validate_raw"] },
{ id: "enrich", action: "enrich_data", agent: "enricher", depends_on: ["transform"] },
{ id: "load", action: "load_data", agent: "loader", depends_on: ["enrich"] },
{ id: "validate_final", action: "validate_data", agent: "validator", depends_on: ["load"] }
],
triggers: ["schedule:0 2 * * *"], // Daily at 2 AM
metadata: {
retry_policy: "exponential_backoff",
max_retries: 3
}
})
```
## Templates & Patterns
### Use Pre-built Templates
```javascript
// Create swarm from template
mcp__flow-nexus__swarm_create_from_template({
template_name: "full-stack-dev",
overrides: {
maxAgents: 6,
strategy: "specialized"
}
})
// List available templates
mcp__flow-nexus__swarm_templates_list({
category: "quickstart", // Options: quickstart, specialized, enterprise, custom, all
includeStore: true
})
```
**Available Template Categories:**
**Quickstart Templates:**
- `full-stack-dev`: Complete web development swarm
- `research-team`: Research and analysis swarm
- `code-review`: Automated code review swarm
- `data-pipeline`: ETL and data processing
**Specialized Templates:**
- `ml-development`: Machine learning project swarm
- `mobile-dev`: Mobile app development
- `devops-automation`: Infrastructure and deployment
- `security-audit`: Security analysis and testing
**Enterprise Templates:**
- `enterprise-migration`: Large-scale system migration
- `multi-repo-sync`: Multi-repository coordination
- `compliance-review`: Regulatory compliance workflows
- `incident-response`: Automated incident management
### Custom Template Creation
Save successful swarm configurations as reusable templates for future projects.
## Advanced Features
### Real-time Monitoring
```javascript
// Subscribe to execution streams
mcp__flow-nexus__execution_stream_subscribe({
stream_type: "claude-flow-swarm",
deployment_id: "deployment_id"
})
// Get execution status
mcp__flow-nexus__execution_stream_status({
stream_id: "stream_id"
})
// List files created during execution
mcp__flow-nexus__execution_files_list({
stream_id: "stream_id",
created_by: "claude-flow"
})
```
### Swarm Metrics & Analytics
```javascript
// Get swarm performance metrics
mcp__flow-nexus__swarm_status({
swarm_id: "id"
})
// Analyze workflow efficiency
mcp__flow-nexus__workflow_status({
workflow_id: "id",
include_metrics: true
})
```
### Multi-Swarm Coordination
Coordinate multiple swarms for complex, multi-phase projects:
```javascript
// Phase 1: Research swarm
const researchSwarm = await mcp__flow-nexus__swarm_init({
topology: "mesh",
maxAgents: 4
})
// Phase 2: Development swarm
const devSwarm = await mcp__flow-nexus__swarm_init({
topology: "hierarchical",
maxAgents: 8
})
// Phase 3: Testing swarm
const testSwarm = await mcp__flow-nexus__swarm_init({
topology: "star",
maxAgents: 5
})
```
## Best Practices
### 1. Choose the Right Topology
```javascript
// Simple projects: Star
mcp__flow-nexus__swarm_init({ topology: "star", maxAgents: 3 })
// Collaborative work: Mesh
mcp__flow-nexus__swarm_init({ topology: "mesh", maxAgents: 5 })
// Complex projects: Hierarchical
mcp__flow-nexus__swarm_init({ topology: "hierarchical", maxAgents: 10 })
// Sequential workflows: Ring
mcp__flow-nexus__swarm_init({ topology: "ring", maxAgents: 4 })
```
### 2. Optimize Agent Assignment
```javascript
// Use vector similarity for optimal matching
mcp__flow-nexus__workflow_agent_assign({
task_id: "complex-task",
use_vector_similarity: true
})
```
### 3. Implement Proper Error Handling
```javascript
mcp__flow-nexus__workflow_create({
name: "Resilient Workflow",
steps: [...],
metadata: {
retry_policy: "exponential_backoff",
max_retries: 3,
timeout: 300000, // 5 minutes
on_failure: "notify_and_rollback"
}
})
```
### 4. Monitor and Scale
```javascript
// Regular monitoring
const status = await mcp__flow-nexus__swarm_status()
// Scale based on workload
if (status.workload > 0.8) {
await mcp__flow-nexus__swarm_scale({ target_agents: status.agents + 2 })
}
```
### 5. Use Async Execution for Long-Running Workflows
```javascript
// Long-running workflows should use message queues
mcp__flow-nexus__workflow_execute({
workflow_id: "data-pipeline",
async: true // Non-blocking execution
})
// Monitor progress
mcp__flow-nexus__workflow_queue_status({ include_messages: true })
```
### 6. Clean Up Resources
```javascript
// Destroy swarm when complete
mcp__flow-nexus__swarm_destroy({ swarm_id: "id" })
```
### 7. Leverage Templates
```javascript
// Use proven templates instead of building from scratch
mcp__flow-nexus__swarm_create_from_template({
template_name: "code-review",
overrides: { maxAgents: 4 }
})
```
## Integration with Claude Flow
Flow Nexus swarms integrate seamlessly with Claude Flow hooks:
```bash
# Pre-task coordination setup
npx claude-flow@alpha hooks pre-task --description "Initialize swarm"
# Post-task metrics export
npx claude-flow@alpha hooks post-task --task-id "swarm-execution"
```
## Common Use Cases
### 1. Multi-Repo Development
- Coordinate development across multiple repositories
- Synchronized testing and deployment
- Cross-repo dependency management
### 2. Research Projects
- Distributed information gathering
- Parallel analysis of different data sources
- Collaborative synthesis and reporting
### 3. DevOps Automation
- Infrastructure as Code deployment
- Multi-environment testing
- Automated rollback and recovery
### 4. Code Quality Workflows
- Automated code review
- Security scanning
- Performance benchmarking
### 5. Data Processing
- Large-scale ETL pipelines
- Real-time data transformation
- Data validation and quality checks
## Authentication & Setup
```bash
# Install Flow Nexus
npm install -g flow-nexus@latest
# Register account
npx flow-nexus@latest register
# Login
npx flow-nexus@latest login
# Add MCP server to Claude Code
claude mcp add flow-nexus npx flow-nexus@latest mcp start
```
## Support & Resources
- **Platform**: https://flow-nexus.ruv.io
- **Documentation**: https://github.com/ruvnet/flow-nexus
- **Issues**: https://github.com/ruvnet/flow-nexus/issues
---
**Remember**: Flow Nexus provides cloud-based orchestration infrastructure. For local execution and coordination, use the core `claude-flow` MCP server alongside Flow Nexus for maximum flexibility.

1140
vendor/ruvector/.claude/skills/github-code-review/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

874
vendor/ruvector/.claude/skills/github-multi-repo/SKILL.md vendored Normal file
View File

@@ -0,0 +1,874 @@
---
name: github-multi-repo
version: 1.0.0
description: Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration
category: github-integration
tags: [multi-repo, synchronization, architecture, coordination, github]
author: Claude Flow Team
requires:
- ruv-swarm@^1.0.11
- gh-cli@^2.0.0
capabilities:
- cross-repository coordination
- package synchronization
- architecture optimization
- template management
- distributed workflows
---
# GitHub Multi-Repository Coordination Skill
## Overview
Advanced multi-repository coordination system that combines swarm intelligence, package synchronization, and repository architecture optimization. This skill enables organization-wide automation, cross-project collaboration, and scalable repository management.
## Core Capabilities
### 🔄 Multi-Repository Swarm Coordination
Cross-repository AI swarm orchestration for distributed development workflows.
### 📦 Package Synchronization
Intelligent dependency resolution and version alignment across multiple packages.
### 🏗️ Repository Architecture
Structure optimization and template management for scalable projects.
### 🔗 Integration Management
Cross-package integration testing and deployment coordination.
## Quick Start
### Initialize Multi-Repo Coordination
```bash
# Basic swarm initialization
npx claude-flow skill run github-multi-repo init \
--repos "org/frontend,org/backend,org/shared" \
--topology hierarchical
# Advanced initialization with synchronization
npx claude-flow skill run github-multi-repo init \
--repos "org/frontend,org/backend,org/shared" \
--topology mesh \
--shared-memory \
--sync-strategy eventual
```
### Synchronize Packages
```bash
# Synchronize package versions and dependencies
npx claude-flow skill run github-multi-repo sync \
--packages "claude-code-flow,ruv-swarm" \
--align-versions \
--update-docs
```
### Optimize Architecture
```bash
# Analyze and optimize repository structure
npx claude-flow skill run github-multi-repo optimize \
--analyze-structure \
--suggest-improvements \
--create-templates
```
## Features
### 1. Cross-Repository Swarm Orchestration
#### Repository Discovery
```javascript
// Auto-discover related repositories with gh CLI
const REPOS = Bash(`gh repo list my-organization --limit 100 \
--json name,description,languages,topics \
--jq '.[] | select(.languages | keys | contains(["TypeScript"]))'`)
// Analyze repository dependencies
const DEPS = Bash(`gh repo list my-organization --json name | \
jq -r '.[].name' | while read -r repo; do
gh api repos/my-organization/$repo/contents/package.json \
--jq '.content' 2>/dev/null | base64 -d | jq '{name, dependencies}'
done | jq -s '.'`)
// Initialize swarm with discovered repositories
mcp__claude-flow__swarm_init({
topology: "hierarchical",
maxAgents: 8,
metadata: { repos: REPOS, dependencies: DEPS }
})
```
#### Synchronized Operations
```javascript
// Execute synchronized changes across repositories
[Parallel Multi-Repo Operations]:
// Spawn coordination agents
Task("Repository Coordinator", "Coordinate changes across all repositories", "coordinator")
Task("Dependency Analyzer", "Analyze cross-repo dependencies", "analyst")
Task("Integration Tester", "Validate cross-repo changes", "tester")
// Get matching repositories
Bash(`gh repo list org --limit 100 --json name \
--jq '.[] | select(.name | test("-service$")) | .name' > /tmp/repos.txt`)
// Execute task across repositories
Bash(`cat /tmp/repos.txt | while read -r repo; do
gh repo clone org/$repo /tmp/$repo -- --depth=1
cd /tmp/$repo
# Apply changes
npm update
npm test
# Create PR if successful
if [ $? -eq 0 ]; then
git checkout -b update-dependencies-$(date +%Y%m%d)
git add -A
git commit -m "chore: Update dependencies"
git push origin HEAD
gh pr create --title "Update dependencies" --body "Automated update" --label "dependencies"
fi
done`)
// Track all operations
TodoWrite { todos: [
{ id: "discover", content: "Discover all service repositories", status: "completed" },
{ id: "update", content: "Update dependencies", status: "completed" },
{ id: "test", content: "Run integration tests", status: "in_progress" },
{ id: "pr", content: "Create pull requests", status: "pending" }
]}
```
### 2. Package Synchronization
#### Version Alignment
```javascript
// Synchronize package dependencies and versions
[Complete Package Sync]:
// Initialize sync swarm
mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 5 })
// Spawn sync agents
Task("Sync Coordinator", "Coordinate version alignment", "coordinator")
Task("Dependency Analyzer", "Analyze dependencies", "analyst")
Task("Integration Tester", "Validate synchronization", "tester")
// Read package states
Read("/workspaces/ruv-FANN/claude-code-flow/claude-code-flow/package.json")
Read("/workspaces/ruv-FANN/ruv-swarm/npm/package.json")
// Align versions using gh CLI
Bash(`gh api repos/:owner/:repo/git/refs \
-f ref='refs/heads/sync/package-alignment' \
-f sha=$(gh api repos/:owner/:repo/git/refs/heads/main --jq '.object.sha')`)
// Update package.json files
Bash(`gh api repos/:owner/:repo/contents/package.json \
--method PUT \
-f message="feat: Align Node.js version requirements" \
-f branch="sync/package-alignment" \
-f content="$(cat aligned-package.json | base64)"`)
// Store sync state
mcp__claude-flow__memory_usage({
action: "store",
key: "sync/packages/status",
value: {
timestamp: Date.now(),
packages_synced: ["claude-code-flow", "ruv-swarm"],
status: "synchronized"
}
})
```
#### Documentation Synchronization
```javascript
// Synchronize CLAUDE.md files across packages
[Documentation Sync]:
// Get source documentation
Bash(`gh api repos/:owner/:repo/contents/ruv-swarm/docs/CLAUDE.md \
--jq '.content' | base64 -d > /tmp/claude-source.md`)
// Update target documentation
Bash(`gh api repos/:owner/:repo/contents/claude-code-flow/CLAUDE.md \
--method PUT \
-f message="docs: Synchronize CLAUDE.md" \
-f branch="sync/documentation" \
-f content="$(cat /tmp/claude-source.md | base64)"`)
// Track sync status
mcp__claude-flow__memory_usage({
action: "store",
key: "sync/documentation/status",
value: { status: "synchronized", files: ["CLAUDE.md"] }
})
```
#### Cross-Package Integration
```javascript
// Coordinate feature implementation across packages
[Cross-Package Feature]:
// Push changes to all packages
mcp__github__push_files({
branch: "feature/github-integration",
files: [
{
path: "claude-code-flow/.claude/commands/github/github-modes.md",
content: "[GitHub modes documentation]"
},
{
path: "ruv-swarm/src/github-coordinator/hooks.js",
content: "[GitHub coordination hooks]"
}
],
message: "feat: Add GitHub workflow integration"
})
// Create coordinated PR
Bash(`gh pr create \
--title "Feature: GitHub Workflow Integration" \
--body "## 🚀 GitHub Integration
### Features
- ✅ Multi-repo coordination
- ✅ Package synchronization
- ✅ Architecture optimization
### Testing
- [x] Package dependency verification
- [x] Integration tests
- [x] Cross-package compatibility"`)
```
### 3. Repository Architecture
#### Structure Analysis
```javascript
// Analyze and optimize repository structure
[Architecture Analysis]:
// Initialize architecture swarm
mcp__claude-flow__swarm_init({ topology: "hierarchical", maxAgents: 6 })
// Spawn architecture agents
Task("Senior Architect", "Analyze repository structure", "architect")
Task("Structure Analyst", "Identify optimization opportunities", "analyst")
Task("Performance Optimizer", "Optimize structure for scalability", "optimizer")
Task("Best Practices Researcher", "Research architecture patterns", "researcher")
// Analyze current structures
LS("/workspaces/ruv-FANN/claude-code-flow/claude-code-flow")
LS("/workspaces/ruv-FANN/ruv-swarm/npm")
// Search for best practices
Bash(`gh search repos "language:javascript template architecture" \
--limit 10 \
--json fullName,description,stargazersCount \
--sort stars \
--order desc`)
// Store analysis results
mcp__claude-flow__memory_usage({
action: "store",
key: "architecture/analysis/results",
value: {
repositories_analyzed: ["claude-code-flow", "ruv-swarm"],
optimization_areas: ["structure", "workflows", "templates"],
recommendations: ["standardize_structure", "improve_workflows"]
}
})
```
#### Template Creation
```javascript
// Create standardized repository template
[Template Creation]:
// Create template repository
mcp__github__create_repository({
name: "claude-project-template",
description: "Standardized template for Claude Code projects",
private: false,
autoInit: true
})
// Push template structure
mcp__github__push_files({
repo: "claude-project-template",
files: [
{
path: ".claude/commands/github/github-modes.md",
content: "[GitHub modes template]"
},
{
path: ".claude/config.json",
content: JSON.stringify({
version: "1.0",
mcp_servers: {
"ruv-swarm": {
command: "npx",
args: ["ruv-swarm", "mcp", "start"]
}
}
})
},
{
path: "CLAUDE.md",
content: "[Standardized CLAUDE.md]"
},
{
path: "package.json",
content: JSON.stringify({
name: "claude-project-template",
engines: { node: ">=20.0.0" },
dependencies: { "ruv-swarm": "^1.0.11" }
})
}
],
message: "feat: Create standardized template"
})
```
#### Cross-Repository Standardization
```javascript
// Synchronize structure across repositories
[Structure Standardization]:
const repositories = ["claude-code-flow", "ruv-swarm", "claude-extensions"]
// Update common files across all repositories
repositories.forEach(repo => {
mcp__github__create_or_update_file({
repo: "ruv-FANN",
path: `${repo}/.github/workflows/integration.yml`,
content: `name: Integration Tests
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with: { node-version: '20' }
- run: npm install && npm test`,
message: "ci: Standardize integration workflow",
branch: "structure/standardization"
})
})
```
### 4. Orchestration Workflows
#### Dependency Management
```javascript
// Update dependencies across all repositories
[Organization-Wide Dependency Update]:
// Create tracking issue
TRACKING_ISSUE=$(Bash(`gh issue create \
--title "Dependency Update: typescript@5.0.0" \
--body "Tracking TypeScript update across all repositories" \
--label "dependencies,tracking" \
--json number -q .number`))
// Find all TypeScript repositories
TS_REPOS=$(Bash(`gh repo list org --limit 100 --json name | \
jq -r '.[].name' | while read -r repo; do
if gh api repos/org/$repo/contents/package.json 2>/dev/null | \
jq -r '.content' | base64 -d | grep -q '"typescript"'; then
echo "$repo"
fi
done`))
// Update each repository
Bash(`echo "$TS_REPOS" | while read -r repo; do
gh repo clone org/$repo /tmp/$repo -- --depth=1
cd /tmp/$repo
npm install --save-dev typescript@5.0.0
if npm test; then
git checkout -b update-typescript-5
git add package.json package-lock.json
git commit -m "chore: Update TypeScript to 5.0.0
Part of #$TRACKING_ISSUE"
git push origin HEAD
gh pr create \
--title "Update TypeScript to 5.0.0" \
--body "Updates TypeScript\n\nTracking: #$TRACKING_ISSUE" \
--label "dependencies"
else
gh issue comment $TRACKING_ISSUE \
--body "❌ Failed to update $repo - tests failing"
fi
done`)
```
#### Refactoring Operations
```javascript
// Coordinate large-scale refactoring
[Cross-Repo Refactoring]:
// Initialize refactoring swarm
mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 8 })
// Spawn specialized agents
Task("Refactoring Coordinator", "Coordinate refactoring across repos", "coordinator")
Task("Impact Analyzer", "Analyze refactoring impact", "analyst")
Task("Code Transformer", "Apply refactoring changes", "coder")
Task("Migration Guide Creator", "Create migration documentation", "documenter")
Task("Integration Tester", "Validate refactored code", "tester")
// Execute refactoring
mcp__claude-flow__task_orchestrate({
task: "Rename OldAPI to NewAPI across all repositories",
strategy: "sequential",
priority: "high"
})
```
#### Security Updates
```javascript
// Coordinate security patches
[Security Patch Deployment]:
// Scan all repositories
Bash(`gh repo list org --limit 100 --json name | jq -r '.[].name' | \
while read -r repo; do
gh repo clone org/$repo /tmp/$repo -- --depth=1
cd /tmp/$repo
npm audit --json > /tmp/audit-$repo.json
done`)
// Apply patches
Bash(`for repo in /tmp/audit-*.json; do
if [ $(jq '.vulnerabilities | length' $repo) -gt 0 ]; then
cd /tmp/$(basename $repo .json | sed 's/audit-//')
npm audit fix
if npm test; then
git checkout -b security/patch-$(date +%Y%m%d)
git add -A
git commit -m "security: Apply security patches"
git push origin HEAD
gh pr create --title "Security patches" --label "security"
fi
fi
done`)
```
## Configuration
### Multi-Repo Config File
```yaml
# .swarm/multi-repo.yml
version: 1
organization: my-org
repositories:
- name: frontend
url: github.com/my-org/frontend
role: ui
agents: [coder, designer, tester]
- name: backend
url: github.com/my-org/backend
role: api
agents: [architect, coder, tester]
- name: shared
url: github.com/my-org/shared
role: library
agents: [analyst, coder]
coordination:
topology: hierarchical
communication: webhook
memory: redis://shared-memory
dependencies:
- from: frontend
to: [backend, shared]
- from: backend
to: [shared]
```
### Repository Roles
```javascript
{
"roles": {
"ui": {
"responsibilities": ["user-interface", "ux", "accessibility"],
"default-agents": ["designer", "coder", "tester"]
},
"api": {
"responsibilities": ["endpoints", "business-logic", "data"],
"default-agents": ["architect", "coder", "security"]
},
"library": {
"responsibilities": ["shared-code", "utilities", "types"],
"default-agents": ["analyst", "coder", "documenter"]
}
}
}
```
## Communication Strategies
### 1. Webhook-Based Coordination
```javascript
const { MultiRepoSwarm } = require('ruv-swarm');
const swarm = new MultiRepoSwarm({
webhook: {
url: 'https://swarm-coordinator.example.com',
secret: process.env.WEBHOOK_SECRET
}
});
swarm.on('repo:update', async (event) => {
await swarm.propagate(event, {
to: event.dependencies,
strategy: 'eventual-consistency'
});
});
```
### 2. Event Streaming
```yaml
# Kafka configuration for real-time coordination
kafka:
brokers: ['kafka1:9092', 'kafka2:9092']
topics:
swarm-events:
partitions: 10
replication: 3
swarm-memory:
partitions: 5
replication: 3
```
## Synchronization Patterns
### 1. Eventually Consistent
```javascript
{
"sync": {
"strategy": "eventual",
"max-lag": "5m",
"retry": {
"attempts": 3,
"backoff": "exponential"
}
}
}
```
### 2. Strong Consistency
```javascript
{
"sync": {
"strategy": "strong",
"consensus": "raft",
"quorum": 0.51,
"timeout": "30s"
}
}
```
### 3. Hybrid Approach
```javascript
{
"sync": {
"default": "eventual",
"overrides": {
"security-updates": "strong",
"dependency-updates": "strong",
"documentation": "eventual"
}
}
}
```
## Use Cases
### 1. Microservices Coordination
```bash
npx claude-flow skill run github-multi-repo microservices \
--services "auth,users,orders,payments" \
--ensure-compatibility \
--sync-contracts \
--integration-tests
```
### 2. Library Updates
```bash
npx claude-flow skill run github-multi-repo lib-update \
--library "org/shared-lib" \
--version "2.0.0" \
--find-consumers \
--update-imports \
--run-tests
```
### 3. Organization-Wide Changes
```bash
npx claude-flow skill run github-multi-repo org-policy \
--policy "add-security-headers" \
--repos "org/*" \
--validate-compliance \
--create-reports
```
## Architecture Patterns
### Monorepo Structure
```
ruv-FANN/
├── packages/
│ ├── claude-code-flow/
│ │ ├── src/
│ │ ├── .claude/
│ │ └── package.json
│ ├── ruv-swarm/
│ │ ├── src/
│ │ ├── wasm/
│ │ └── package.json
│ └── shared/
│ ├── types/
│ ├── utils/
│ └── config/
├── tools/
│ ├── build/
│ ├── test/
│ └── deploy/
├── docs/
│ ├── architecture/
│ ├── integration/
│ └── examples/
└── .github/
├── workflows/
├── templates/
└── actions/
```
### Command Structure
```
.claude/
├── commands/
│ ├── github/
│ │ ├── github-modes.md
│ │ ├── pr-manager.md
│ │ ├── issue-tracker.md
│ │ └── sync-coordinator.md
│ ├── sparc/
│ │ ├── sparc-modes.md
│ │ ├── coder.md
│ │ └── tester.md
│ └── swarm/
│ ├── coordination.md
│ └── orchestration.md
├── templates/
│ ├── issue.md
│ ├── pr.md
│ └── project.md
└── config.json
```
## Monitoring & Visualization
### Multi-Repo Dashboard
```bash
npx claude-flow skill run github-multi-repo dashboard \
--port 3000 \
--metrics "agent-activity,task-progress,memory-usage" \
--real-time
```
### Dependency Graph
```bash
npx claude-flow skill run github-multi-repo dep-graph \
--format mermaid \
--include-agents \
--show-data-flow
```
### Health Monitoring
```bash
npx claude-flow skill run github-multi-repo health-check \
--repos "org/*" \
--check "connectivity,memory,agents" \
--alert-on-issues
```
## Best Practices
### 1. Repository Organization
- Clear repository roles and boundaries
- Consistent naming conventions
- Documented dependencies
- Shared configuration standards
### 2. Communication
- Use appropriate sync strategies
- Implement circuit breakers
- Monitor latency and failures
- Clear error propagation
### 3. Security
- Secure cross-repo authentication
- Encrypted communication channels
- Audit trail for all operations
- Principle of least privilege
### 4. Version Management
- Semantic versioning alignment
- Dependency compatibility validation
- Automated version bump coordination
### 5. Testing Integration
- Cross-package test validation
- Integration test automation
- Performance regression detection
## Performance Optimization
### Caching Strategy
```bash
npx claude-flow skill run github-multi-repo cache-strategy \
--analyze-patterns \
--suggest-cache-layers \
--implement-invalidation
```
### Parallel Execution
```bash
npx claude-flow skill run github-multi-repo parallel-optimize \
--analyze-dependencies \
--identify-parallelizable \
--execute-optimal
```
### Resource Pooling
```bash
npx claude-flow skill run github-multi-repo resource-pool \
--share-agents \
--distribute-load \
--monitor-usage
```
## Troubleshooting
### Connectivity Issues
```bash
npx claude-flow skill run github-multi-repo diagnose-connectivity \
--test-all-repos \
--check-permissions \
--verify-webhooks
```
### Memory Synchronization
```bash
npx claude-flow skill run github-multi-repo debug-memory \
--check-consistency \
--identify-conflicts \
--repair-state
```
### Performance Bottlenecks
```bash
npx claude-flow skill run github-multi-repo perf-analysis \
--profile-operations \
--identify-bottlenecks \
--suggest-optimizations
```
## Advanced Features
### 1. Distributed Task Queue
```bash
npx claude-flow skill run github-multi-repo queue \
--backend redis \
--workers 10 \
--priority-routing \
--dead-letter-queue
```
### 2. Cross-Repo Testing
```bash
npx claude-flow skill run github-multi-repo test \
--setup-test-env \
--link-services \
--run-e2e \
--tear-down
```
### 3. Monorepo Migration
```bash
npx claude-flow skill run github-multi-repo to-monorepo \
--analyze-repos \
--suggest-structure \
--preserve-history \
--create-migration-prs
```
## Examples
### Full-Stack Application Update
```bash
npx claude-flow skill run github-multi-repo fullstack-update \
--frontend "org/web-app" \
--backend "org/api-server" \
--database "org/db-migrations" \
--coordinate-deployment
```
### Cross-Team Collaboration
```bash
npx claude-flow skill run github-multi-repo cross-team \
--teams "frontend,backend,devops" \
--task "implement-feature-x" \
--assign-by-expertise \
--track-progress
```
## Metrics and Reporting
### Sync Quality Metrics
- Package version alignment percentage
- Documentation consistency score
- Integration test success rate
- Synchronization completion time
### Architecture Health Metrics
- Repository structure consistency score
- Documentation coverage percentage
- Cross-repository integration success rate
- Template adoption and usage statistics
### Automated Reporting
- Weekly sync status reports
- Dependency drift detection
- Documentation divergence alerts
- Integration health monitoring
## Integration Points
### Related Skills
- `github-workflow` - GitHub workflow automation
- `github-pr` - Pull request management
- `sparc-architect` - Architecture design
- `sparc-optimizer` - Performance optimization
### Related Commands
- `/github sync-coordinator` - Cross-repo synchronization
- `/github release-manager` - Coordinated releases
- `/github repo-architect` - Repository optimization
- `/sparc architect` - Detailed architecture design
## Support and Resources
- Documentation: https://github.com/ruvnet/claude-flow
- Issues: https://github.com/ruvnet/claude-flow/issues
- Examples: `.claude/examples/github-multi-repo/`
---
**Version:** 1.0.0
**Last Updated:** 2025-10-19
**Maintainer:** Claude Flow Team

1277
vendor/ruvector/.claude/skills/github-project-management/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1081
vendor/ruvector/.claude/skills/github-release-management/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1065
vendor/ruvector/.claude/skills/github-workflow-automation/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

729
vendor/ruvector/.claude/skills/hive-mind-advanced/SKILL.md vendored Normal file
View File

@@ -0,0 +1,729 @@
---
name: hive-mind-advanced
description: Advanced Hive Mind collective intelligence system for queen-led multi-agent coordination with consensus mechanisms and persistent memory
version: 1.0.0
category: coordination
tags: [hive-mind, swarm, queen-worker, consensus, collective-intelligence, multi-agent, coordination]
author: Claude Flow Team
hooks:
pre: |
echo "🧠 Hive Mind Advanced activated"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js pre-edit "$FILE" 2>/dev/null || true
fi
post: |
echo "✅ Hive Mind Advanced complete"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js post-edit "$FILE" "true" 2>/dev/null || true
fi
---
# Hive Mind Advanced Skill
Master the advanced Hive Mind collective intelligence system for sophisticated multi-agent coordination using queen-led architecture, Byzantine consensus, and collective memory.
## 🧠 Self-Learning Intelligence
Integrates with RuVector's Q-learning and vector memory for improved performance.
CLI: `node .claude/intelligence/cli.js stats`
## Overview
The Hive Mind system represents the pinnacle of multi-agent coordination in Claude Flow, implementing a queen-led hierarchical architecture where a strategic queen coordinator directs specialized worker agents through collective decision-making and shared memory.
## Core Concepts
### Architecture Patterns
**Queen-Led Coordination**
- Strategic queen agents orchestrate high-level objectives
- Tactical queens manage mid-level execution
- Adaptive queens dynamically adjust strategies based on performance
**Worker Specialization**
- Researcher agents: Analysis and investigation
- Coder agents: Implementation and development
- Analyst agents: Data processing and metrics
- Tester agents: Quality assurance and validation
- Architect agents: System design and planning
- Reviewer agents: Code review and improvement
- Optimizer agents: Performance enhancement
- Documenter agents: Documentation generation
**Collective Memory System**
- Shared knowledge base across all agents
- LRU cache with memory pressure handling
- SQLite persistence with WAL mode
- Memory consolidation and association
- Access pattern tracking and optimization
### Consensus Mechanisms
**Majority Consensus**
Simple voting where the option with most votes wins.
**Weighted Consensus**
Queen vote counts as 3x weight, providing strategic guidance.
**Byzantine Fault Tolerance**
Requires 2/3 majority for decision approval, ensuring robust consensus even with faulty agents.
## Getting Started
### 1. Initialize Hive Mind
```bash
# Basic initialization
npx claude-flow hive-mind init
# Force reinitialize
npx claude-flow hive-mind init --force
# Custom configuration
npx claude-flow hive-mind init --config hive-config.json
```
### 2. Spawn a Swarm
```bash
# Basic spawn with objective
npx claude-flow hive-mind spawn "Build microservices architecture"
# Strategic queen type
npx claude-flow hive-mind spawn "Research AI patterns" --queen-type strategic
# Tactical queen with max workers
npx claude-flow hive-mind spawn "Implement API" --queen-type tactical --max-workers 12
# Adaptive queen with consensus
npx claude-flow hive-mind spawn "Optimize system" --queen-type adaptive --consensus byzantine
# Generate Claude Code commands
npx claude-flow hive-mind spawn "Build full-stack app" --claude
```
### 3. Monitor Status
```bash
# Check hive mind status
npx claude-flow hive-mind status
# Get detailed metrics
npx claude-flow hive-mind metrics
# Monitor collective memory
npx claude-flow hive-mind memory
```
## Advanced Workflows
### Session Management
**Create and Manage Sessions**
```bash
# List active sessions
npx claude-flow hive-mind sessions
# Pause a session
npx claude-flow hive-mind pause <session-id>
# Resume a paused session
npx claude-flow hive-mind resume <session-id>
# Stop a running session
npx claude-flow hive-mind stop <session-id>
```
**Session Features**
- Automatic checkpoint creation
- Progress tracking with completion percentages
- Parent-child process management
- Session logs with event tracking
- Export/import capabilities
### Consensus Building
The Hive Mind builds consensus through structured voting:
```javascript
// Programmatic consensus building
const decision = await hiveMind.buildConsensus(
'Architecture pattern selection',
['microservices', 'monolith', 'serverless']
);
// Result includes:
// - decision: Winning option
// - confidence: Vote percentage
// - votes: Individual agent votes
```
**Consensus Algorithms**
1. **Majority** - Simple democratic voting
2. **Weighted** - Queen has 3x voting power
3. **Byzantine** - 2/3 supermajority required
### Collective Memory
**Storing Knowledge**
```javascript
// Store in collective memory
await memory.store('api-patterns', {
rest: { pros: [...], cons: [...] },
graphql: { pros: [...], cons: [...] }
}, 'knowledge', { confidence: 0.95 });
```
**Memory Types**
- `knowledge`: Permanent insights (no TTL)
- `context`: Session context (1 hour TTL)
- `task`: Task-specific data (30 min TTL)
- `result`: Execution results (permanent, compressed)
- `error`: Error logs (24 hour TTL)
- `metric`: Performance metrics (1 hour TTL)
- `consensus`: Decision records (permanent)
- `system`: System configuration (permanent)
**Searching and Retrieval**
```javascript
// Search memory by pattern
const results = await memory.search('api*', {
type: 'knowledge',
minConfidence: 0.8,
limit: 50
});
// Get related memories
const related = await memory.getRelated('api-patterns', 10);
// Build associations
await memory.associate('rest-api', 'authentication', 0.9);
```
### Task Distribution
**Automatic Worker Assignment**
The system intelligently assigns tasks based on:
- Keyword matching with agent specialization
- Historical performance metrics
- Worker availability and load
- Task complexity analysis
```javascript
// Create task (auto-assigned)
const task = await hiveMind.createTask(
'Implement user authentication',
priority: 8,
{ estimatedDuration: 30000 }
);
```
**Auto-Scaling**
```javascript
// Configure auto-scaling
const config = {
autoScale: true,
maxWorkers: 12,
scaleUpThreshold: 2, // Pending tasks per idle worker
scaleDownThreshold: 2 // Idle workers above pending tasks
};
```
## Integration Patterns
### With Claude Code
Generate Claude Code spawn commands directly:
```bash
npx claude-flow hive-mind spawn "Build REST API" --claude
```
Output:
```javascript
Task("Queen Coordinator", "Orchestrate REST API development...", "coordinator")
Task("Backend Developer", "Implement Express routes...", "backend-dev")
Task("Database Architect", "Design PostgreSQL schema...", "code-analyzer")
Task("Test Engineer", "Create Jest test suite...", "tester")
```
### With SPARC Methodology
```bash
# Use hive mind for SPARC workflow
npx claude-flow sparc tdd "User authentication" --hive-mind
# Spawns:
# - Specification agent
# - Architecture agent
# - Coder agents
# - Tester agents
# - Reviewer agents
```
### With GitHub Integration
```bash
# Repository analysis with hive mind
npx claude-flow hive-mind spawn "Analyze repo quality" --objective "owner/repo"
# PR review coordination
npx claude-flow hive-mind spawn "Review PR #123" --queen-type tactical
```
## Performance Optimization
### Memory Optimization
The collective memory system includes advanced optimizations:
**LRU Cache**
- Configurable cache size (default: 1000 entries)
- Memory pressure handling (default: 50MB)
- Automatic eviction of least-used entries
**Database Optimization**
- WAL (Write-Ahead Logging) mode
- 64MB cache size
- 256MB memory mapping
- Prepared statements for common queries
- Automatic ANALYZE and OPTIMIZE
**Object Pooling**
- Query result pooling
- Memory entry pooling
- Reduced garbage collection pressure
### Performance Metrics
```javascript
// Get performance insights
const insights = hiveMind.getPerformanceInsights();
// Includes:
// - asyncQueue utilization
// - Batch processing stats
// - Success rates
// - Average processing times
// - Memory efficiency
```
### Task Execution
**Parallel Processing**
- Batch agent spawning (5 agents per batch)
- Concurrent task orchestration
- Async operation optimization
- Non-blocking task assignment
**Benchmarks**
- 10-20x faster batch spawning
- 2.8-4.4x speed improvement overall
- 32.3% token reduction
- 84.8% SWE-Bench solve rate
## Configuration
### Hive Mind Config
```javascript
{
"objective": "Build microservices",
"name": "my-hive",
"queenType": "strategic", // strategic | tactical | adaptive
"maxWorkers": 8,
"consensusAlgorithm": "byzantine", // majority | weighted | byzantine
"autoScale": true,
"memorySize": 100, // MB
"taskTimeout": 60, // minutes
"encryption": false
}
```
### Memory Config
```javascript
{
"maxSize": 100, // MB
"compressionThreshold": 1024, // bytes
"gcInterval": 300000, // 5 minutes
"cacheSize": 1000,
"cacheMemoryMB": 50,
"enablePooling": true,
"enableAsyncOperations": true
}
```
## Hooks Integration
Hive Mind integrates with Claude Flow hooks for automation:
**Pre-Task Hooks**
- Auto-assign agents by file type
- Validate objective complexity
- Optimize topology selection
- Cache search patterns
**Post-Task Hooks**
- Auto-format deliverables
- Train neural patterns
- Update collective memory
- Analyze performance bottlenecks
**Session Hooks**
- Generate session summaries
- Persist checkpoint data
- Track comprehensive metrics
- Restore execution context
## Best Practices
### 1. Choose the Right Queen Type
**Strategic Queens** - For research, planning, and analysis
```bash
npx claude-flow hive-mind spawn "Research ML frameworks" --queen-type strategic
```
**Tactical Queens** - For implementation and execution
```bash
npx claude-flow hive-mind spawn "Build authentication" --queen-type tactical
```
**Adaptive Queens** - For optimization and dynamic tasks
```bash
npx claude-flow hive-mind spawn "Optimize performance" --queen-type adaptive
```
### 2. Leverage Consensus
Use consensus for critical decisions:
- Architecture pattern selection
- Technology stack choices
- Implementation approach
- Code review approval
- Release readiness
### 3. Utilize Collective Memory
**Store Learnings**
```javascript
// After successful pattern implementation
await memory.store('auth-pattern', {
approach: 'JWT with refresh tokens',
pros: ['Stateless', 'Scalable'],
cons: ['Token size', 'Revocation complexity'],
implementation: {...}
}, 'knowledge', { confidence: 0.95 });
```
**Build Associations**
```javascript
// Link related concepts
await memory.associate('jwt-auth', 'refresh-tokens', 0.9);
await memory.associate('jwt-auth', 'oauth2', 0.7);
```
### 4. Monitor Performance
```bash
# Regular status checks
npx claude-flow hive-mind status
# Track metrics
npx claude-flow hive-mind metrics
# Analyze memory usage
npx claude-flow hive-mind memory
```
### 5. Session Management
**Checkpoint Frequently**
```javascript
// Create checkpoints at key milestones
await sessionManager.saveCheckpoint(
sessionId,
'api-routes-complete',
{ completedRoutes: [...], remaining: [...] }
);
```
**Resume Sessions**
```bash
# Resume from any previous state
npx claude-flow hive-mind resume <session-id>
```
## Troubleshooting
### Memory Issues
**High Memory Usage**
```bash
# Run garbage collection
npx claude-flow hive-mind memory --gc
# Optimize database
npx claude-flow hive-mind memory --optimize
# Export and clear
npx claude-flow hive-mind memory --export --clear
```
**Low Cache Hit Rate**
```javascript
// Increase cache size in config
{
"cacheSize": 2000,
"cacheMemoryMB": 100
}
```
### Performance Issues
**Slow Task Assignment**
```javascript
// Enable worker type caching
// The system caches best worker matches for 5 minutes
// Automatic - no configuration needed
```
**High Queue Utilization**
```javascript
// Increase async queue concurrency
{
"asyncQueueConcurrency": 20 // Default: min(maxWorkers * 2, 20)
}
```
### Consensus Failures
**No Consensus Reached (Byzantine)**
```bash
# Switch to weighted consensus for more decisive results
npx claude-flow hive-mind spawn "..." --consensus weighted
# Or use simple majority
npx claude-flow hive-mind spawn "..." --consensus majority
```
## Advanced Topics
### Custom Worker Types
Define specialized workers in `.claude/agents/`:
```yaml
name: security-auditor
type: specialist
capabilities:
- vulnerability-scanning
- security-review
- penetration-testing
- compliance-checking
priority: high
```
### Neural Pattern Training
The system trains on successful patterns:
```javascript
// Automatic pattern learning
// Happens after successful task completion
// Stores in collective memory
// Improves future task matching
```
### Multi-Hive Coordination
Run multiple hive minds simultaneously:
```bash
# Frontend hive
npx claude-flow hive-mind spawn "Build UI" --name frontend-hive
# Backend hive
npx claude-flow hive-mind spawn "Build API" --name backend-hive
# They share collective memory for coordination
```
### Export/Import Sessions
```bash
# Export session for backup
npx claude-flow hive-mind export <session-id> --output backup.json
# Import session
npx claude-flow hive-mind import backup.json
```
## API Reference
### HiveMindCore
```javascript
const hiveMind = new HiveMindCore({
objective: 'Build system',
queenType: 'strategic',
maxWorkers: 8,
consensusAlgorithm: 'byzantine'
});
await hiveMind.initialize();
await hiveMind.spawnQueen(queenData);
await hiveMind.spawnWorkers(['coder', 'tester']);
await hiveMind.createTask('Implement feature', 7);
const decision = await hiveMind.buildConsensus('topic', options);
const status = hiveMind.getStatus();
await hiveMind.shutdown();
```
### CollectiveMemory
```javascript
const memory = new CollectiveMemory({
swarmId: 'hive-123',
maxSize: 100,
cacheSize: 1000
});
await memory.store(key, value, type, metadata);
const data = await memory.retrieve(key);
const results = await memory.search(pattern, options);
const related = await memory.getRelated(key, limit);
await memory.associate(key1, key2, strength);
const stats = memory.getStatistics();
const analytics = memory.getAnalytics();
const health = await memory.healthCheck();
```
### HiveMindSessionManager
```javascript
const sessionManager = new HiveMindSessionManager();
const sessionId = await sessionManager.createSession(
swarmId, swarmName, objective, metadata
);
await sessionManager.saveCheckpoint(sessionId, name, data);
const sessions = await sessionManager.getActiveSessions();
const session = await sessionManager.getSession(sessionId);
await sessionManager.pauseSession(sessionId);
await sessionManager.resumeSession(sessionId);
await sessionManager.stopSession(sessionId);
await sessionManager.completeSession(sessionId);
```
## Examples
### Full-Stack Development
```bash
# Initialize hive mind
npx claude-flow hive-mind init
# Spawn full-stack hive
npx claude-flow hive-mind spawn "Build e-commerce platform" \
--queen-type strategic \
--max-workers 10 \
--consensus weighted \
--claude
# Output generates Claude Code commands:
# - Queen coordinator
# - Frontend developers (React)
# - Backend developers (Node.js)
# - Database architects
# - DevOps engineers
# - Security auditors
# - Test engineers
# - Documentation specialists
```
### Research and Analysis
```bash
# Spawn research hive
npx claude-flow hive-mind spawn "Research GraphQL vs REST" \
--queen-type adaptive \
--consensus byzantine
# Researchers gather data
# Analysts process findings
# Queen builds consensus on recommendation
# Results stored in collective memory
```
### Code Review
```bash
# Review coordination
npx claude-flow hive-mind spawn "Review PR #456" \
--queen-type tactical \
--max-workers 6
# Spawns:
# - Code analyzers
# - Security reviewers
# - Performance reviewers
# - Test coverage analyzers
# - Documentation reviewers
# - Consensus on approval/changes
```
## Skill Progression
### Beginner
1. Initialize hive mind
2. Spawn basic swarms
3. Monitor status
4. Use majority consensus
### Intermediate
1. Configure queen types
2. Implement session management
3. Use weighted consensus
4. Access collective memory
5. Enable auto-scaling
### Advanced
1. Byzantine fault tolerance
2. Memory optimization
3. Custom worker types
4. Multi-hive coordination
5. Neural pattern training
6. Session export/import
7. Performance tuning
## Related Skills
- `swarm-orchestration`: Basic swarm coordination
- `consensus-mechanisms`: Distributed decision making
- `memory-systems`: Advanced memory management
- `sparc-methodology`: Structured development workflow
- `github-integration`: Repository coordination
## References
- [Hive Mind Documentation](https://github.com/ruvnet/claude-flow/docs/hive-mind)
- [Collective Intelligence Patterns](https://github.com/ruvnet/claude-flow/docs/patterns)
- [Byzantine Consensus](https://github.com/ruvnet/claude-flow/docs/consensus)
- [Memory Optimization](https://github.com/ruvnet/claude-flow/docs/memory)
---
**Skill Version**: 1.0.0
**Last Updated**: 2025-10-19
**Maintained By**: Claude Flow Team
**License**: MIT

1201
vendor/ruvector/.claude/skills/hooks-automation/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1202
vendor/ruvector/.claude/skills/pair-programming/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

580
vendor/ruvector/.claude/skills/performance-analysis/SKILL.md vendored Normal file
View File

@@ -0,0 +1,580 @@
---
name: performance-analysis
version: 1.0.0
description: Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms
category: monitoring
tags: [performance, bottleneck, optimization, profiling, metrics, analysis]
author: Claude Flow Team
hooks:
pre: |
echo "🧠 Performance Analysis activated"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js pre-edit "$FILE" 2>/dev/null || true
fi
post: |
echo "✅ Performance Analysis complete"
if [ -d "/workspaces/ruvector/.claude/intelligence" ]; then
cd /workspaces/ruvector/.claude/intelligence
INTELLIGENCE_MODE=treatment node cli.js post-edit "$FILE" "true" 2>/dev/null || true
fi
---
# Performance Analysis Skill
Comprehensive performance analysis suite for identifying bottlenecks, profiling swarm operations, generating detailed reports, and providing actionable optimization recommendations.
## 🧠 Self-Learning Intelligence
Integrates with RuVector's Q-learning and vector memory for improved performance.
CLI: `node .claude/intelligence/cli.js stats`
## Overview
This skill consolidates all performance analysis capabilities:
- **Bottleneck Detection**: Identify performance bottlenecks across communication, processing, memory, and network
- **Performance Profiling**: Real-time monitoring and historical analysis of swarm operations
- **Report Generation**: Create comprehensive performance reports in multiple formats
- **Optimization Recommendations**: AI-powered suggestions for improving performance
## Quick Start
### Basic Bottleneck Detection
```bash
npx claude-flow bottleneck detect
```
### Generate Performance Report
```bash
npx claude-flow analysis performance-report --format html --include-metrics
```
### Analyze and Auto-Fix
```bash
npx claude-flow bottleneck detect --fix --threshold 15
```
## Core Capabilities
### 1. Bottleneck Detection
#### Command Syntax
```bash
npx claude-flow bottleneck detect [options]
```
#### Options
- `--swarm-id, -s <id>` - Analyze specific swarm (default: current)
- `--time-range, -t <range>` - Analysis period: 1h, 24h, 7d, all (default: 1h)
- `--threshold <percent>` - Bottleneck threshold percentage (default: 20)
- `--export, -e <file>` - Export analysis to file
- `--fix` - Apply automatic optimizations
#### Usage Examples
```bash
# Basic detection for current swarm
npx claude-flow bottleneck detect
# Analyze specific swarm over 24 hours
npx claude-flow bottleneck detect --swarm-id swarm-123 -t 24h
# Export detailed analysis
npx claude-flow bottleneck detect -t 24h -e bottlenecks.json
# Auto-fix detected issues
npx claude-flow bottleneck detect --fix --threshold 15
# Low threshold for sensitive detection
npx claude-flow bottleneck detect --threshold 10 --export critical-issues.json
```
#### Metrics Analyzed
**Communication Bottlenecks:**
- Message queue delays
- Agent response times
- Coordination overhead
- Memory access patterns
- Inter-agent communication latency
**Processing Bottlenecks:**
- Task completion times
- Agent utilization rates
- Parallel execution efficiency
- Resource contention
- CPU/memory usage patterns
**Memory Bottlenecks:**
- Cache hit rates
- Memory access patterns
- Storage I/O performance
- Neural pattern loading times
- Memory allocation efficiency
**Network Bottlenecks:**
- API call latency
- MCP communication delays
- External service timeouts
- Concurrent request limits
- Network throughput issues
#### Output Format
```
🔍 Bottleneck Analysis Report
━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 Summary
├── Time Range: Last 1 hour
├── Agents Analyzed: 6
├── Tasks Processed: 42
└── Critical Issues: 2
🚨 Critical Bottlenecks
1. Agent Communication (35% impact)
└── coordinator → coder-1 messages delayed by 2.3s avg
2. Memory Access (28% impact)
└── Neural pattern loading taking 1.8s per access
⚠️ Warning Bottlenecks
1. Task Queue (18% impact)
└── 5 tasks waiting > 10s for assignment
💡 Recommendations
1. Switch to hierarchical topology (est. 40% improvement)
2. Enable memory caching (est. 25% improvement)
3. Increase agent concurrency to 8 (est. 20% improvement)
✅ Quick Fixes Available
Run with --fix to apply:
- Enable smart caching
- Optimize message routing
- Adjust agent priorities
```
### 2. Performance Profiling
#### Real-time Detection
Automatic analysis during task execution:
- Execution time vs. complexity
- Agent utilization rates
- Resource constraints
- Operation patterns
#### Common Bottleneck Patterns
**Time Bottlenecks:**
- Tasks taking > 5 minutes
- Sequential operations that could parallelize
- Redundant file operations
- Inefficient algorithm implementations
**Coordination Bottlenecks:**
- Single agent for complex tasks
- Unbalanced agent workloads
- Poor topology selection
- Excessive synchronization points
**Resource Bottlenecks:**
- High operation count (> 100)
- Memory constraints
- I/O limitations
- Thread pool saturation
#### MCP Integration
```javascript
// Check for bottlenecks in Claude Code
mcp__claude-flow__bottleneck_detect({
timeRange: "1h",
threshold: 20,
autoFix: false
})
// Get detailed task results with bottleneck analysis
mcp__claude-flow__task_results({
taskId: "task-123",
format: "detailed"
})
```
**Result Format:**
```json
{
"bottlenecks": [
{
"type": "coordination",
"severity": "high",
"description": "Single agent used for complex task",
"recommendation": "Spawn specialized agents for parallel work",
"impact": "35%",
"affectedComponents": ["coordinator", "coder-1"]
}
],
"improvements": [
{
"area": "execution_time",
"suggestion": "Use parallel task execution",
"expectedImprovement": "30-50% time reduction",
"implementationSteps": [
"Split task into smaller units",
"Spawn 3-4 specialized agents",
"Use mesh topology for coordination"
]
}
],
"metrics": {
"avgExecutionTime": "142s",
"agentUtilization": "67%",
"cacheHitRate": "82%",
"parallelizationFactor": 1.2
}
}
```
### 3. Report Generation
#### Command Syntax
```bash
npx claude-flow analysis performance-report [options]
```
#### Options
- `--format <type>` - Report format: json, html, markdown (default: markdown)
- `--include-metrics` - Include detailed metrics and charts
- `--compare <id>` - Compare with previous swarm
- `--time-range <range>` - Analysis period: 1h, 24h, 7d, 30d, all
- `--output <file>` - Output file path
- `--sections <list>` - Comma-separated sections to include
#### Report Sections
1. **Executive Summary**
- Overall performance score
- Key metrics overview
- Critical findings
2. **Swarm Overview**
- Topology configuration
- Agent distribution
- Task statistics
3. **Performance Metrics**
- Execution times
- Throughput analysis
- Resource utilization
- Latency breakdown
4. **Bottleneck Analysis**
- Identified bottlenecks
- Impact assessment
- Optimization priorities
5. **Comparative Analysis** (when --compare used)
- Performance trends
- Improvement metrics
- Regression detection
6. **Recommendations**
- Prioritized action items
- Expected improvements
- Implementation guidance
#### Usage Examples
```bash
# Generate HTML report with all metrics
npx claude-flow analysis performance-report --format html --include-metrics
# Compare current swarm with previous
npx claude-flow analysis performance-report --compare swarm-123 --format markdown
# Custom output with specific sections
npx claude-flow analysis performance-report \
--sections summary,metrics,recommendations \
--output reports/perf-analysis.html \
--format html
# Weekly performance report
npx claude-flow analysis performance-report \
--time-range 7d \
--include-metrics \
--format markdown \
--output docs/weekly-performance.md
# JSON format for CI/CD integration
npx claude-flow analysis performance-report \
--format json \
--output build/performance.json
```
#### Sample Markdown Report
```markdown
# Performance Analysis Report
## Executive Summary
- **Overall Score**: 87/100
- **Analysis Period**: Last 24 hours
- **Swarms Analyzed**: 3
- **Critical Issues**: 1
## Key Metrics
| Metric | Value | Trend | Target |
|--------|-------|-------|--------|
| Avg Task Time | 42s | ↓ 12% | 35s |
| Agent Utilization | 78% | ↑ 5% | 85% |
| Cache Hit Rate | 91% | → | 90% |
| Parallel Efficiency | 2.3x | ↑ 0.4x | 2.5x |
## Bottleneck Analysis
### Critical
1. **Agent Communication Delay** (Impact: 35%)
- Coordinator → Coder messages delayed by 2.3s avg
- **Fix**: Switch to hierarchical topology
### Warnings
1. **Memory Access Pattern** (Impact: 18%)
- Neural pattern loading: 1.8s per access
- **Fix**: Enable memory caching
## Recommendations
1. **High Priority**: Switch to hierarchical topology (40% improvement)
2. **Medium Priority**: Enable memory caching (25% improvement)
3. **Low Priority**: Increase agent concurrency to 8 (20% improvement)
```
### 4. Optimization Recommendations
#### Automatic Fixes
When using `--fix`, the following optimizations may be applied:
**1. Topology Optimization**
- Switch to more efficient topology (mesh → hierarchical)
- Adjust communication patterns
- Reduce coordination overhead
- Optimize message routing
**2. Caching Enhancement**
- Enable memory caching
- Optimize cache strategies
- Preload common patterns
- Implement cache warming
**3. Concurrency Tuning**
- Adjust agent counts
- Optimize parallel execution
- Balance workload distribution
- Implement load balancing
**4. Priority Adjustment**
- Reorder task queues
- Prioritize critical paths
- Reduce wait times
- Implement fair scheduling
**5. Resource Optimization**
- Optimize memory usage
- Reduce I/O operations
- Batch API calls
- Implement connection pooling
#### Performance Impact
Typical improvements after bottleneck resolution:
- **Communication**: 30-50% faster message delivery
- **Processing**: 20-40% reduced task completion time
- **Memory**: 40-60% fewer cache misses
- **Network**: 25-45% reduced API latency
- **Overall**: 25-45% total performance improvement
## Advanced Usage
### Continuous Monitoring
```bash
# Monitor performance in real-time
npx claude-flow swarm monitor --interval 5
# Generate hourly reports
while true; do
npx claude-flow analysis performance-report \
--format json \
--output logs/perf-$(date +%Y%m%d-%H%M).json
sleep 3600
done
```
### CI/CD Integration
```yaml
# .github/workflows/performance.yml
name: Performance Analysis
on: [push, pull_request]
jobs:
analyze:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run Performance Analysis
run: |
npx claude-flow analysis performance-report \
--format json \
--output performance.json
- name: Check Performance Thresholds
run: |
npx claude-flow bottleneck detect \
--threshold 15 \
--export bottlenecks.json
- name: Upload Reports
uses: actions/upload-artifact@v2
with:
name: performance-reports
path: |
performance.json
bottlenecks.json
```
### Custom Analysis Scripts
```javascript
// scripts/analyze-performance.js
const { exec } = require('child_process');
const fs = require('fs');
async function analyzePerformance() {
// Run bottleneck detection
const bottlenecks = await runCommand(
'npx claude-flow bottleneck detect --format json'
);
// Generate performance report
const report = await runCommand(
'npx claude-flow analysis performance-report --format json'
);
// Analyze results
const analysis = {
bottlenecks: JSON.parse(bottlenecks),
performance: JSON.parse(report),
timestamp: new Date().toISOString()
};
// Save combined analysis
fs.writeFileSync(
'analysis/combined-report.json',
JSON.stringify(analysis, null, 2)
);
// Generate alerts if needed
if (analysis.bottlenecks.critical.length > 0) {
console.error('CRITICAL: Performance bottlenecks detected!');
process.exit(1);
}
}
function runCommand(cmd) {
return new Promise((resolve, reject) => {
exec(cmd, (error, stdout, stderr) => {
if (error) reject(error);
else resolve(stdout);
});
});
}
analyzePerformance().catch(console.error);
```
## Best Practices
### 1. Regular Analysis
- Run bottleneck detection after major changes
- Generate weekly performance reports
- Monitor trends over time
- Set up automated alerts
### 2. Threshold Tuning
- Start with default threshold (20%)
- Lower for production systems (10-15%)
- Higher for development (25-30%)
- Adjust based on requirements
### 3. Fix Strategy
- Always review before applying --fix
- Test fixes in development first
- Apply fixes incrementally
- Monitor impact after changes
### 4. Report Integration
- Include in documentation
- Share with team regularly
- Track improvements over time
- Use for capacity planning
### 5. Continuous Optimization
- Learn from each analysis
- Build performance budgets
- Establish baselines
- Set improvement goals
## Troubleshooting
### Common Issues
**High Memory Usage**
```bash
# Analyze memory bottlenecks
npx claude-flow bottleneck detect --threshold 10
# Check cache performance
npx claude-flow cache manage --action stats
# Review memory metrics
npx claude-flow memory usage
```
**Slow Task Execution**
```bash
# Identify slow tasks
npx claude-flow task status --detailed
# Analyze coordination overhead
npx claude-flow bottleneck detect --time-range 1h
# Check agent utilization
npx claude-flow agent metrics
```
**Poor Cache Performance**
```bash
# Analyze cache hit rates
npx claude-flow analysis performance-report --sections metrics
# Review cache strategy
npx claude-flow cache manage --action analyze
# Enable cache warming
npx claude-flow bottleneck detect --fix
```
## Integration with Other Skills
- **swarm-orchestration**: Use performance data to optimize topology
- **memory-management**: Improve cache strategies based on analysis
- **task-coordination**: Adjust scheduling based on bottlenecks
- **neural-training**: Train patterns from performance data
## Related Commands
- `npx claude-flow swarm monitor` - Real-time monitoring
- `npx claude-flow token usage` - Token optimization analysis
- `npx claude-flow cache manage` - Cache optimization
- `npx claude-flow agent metrics` - Agent performance metrics
- `npx claude-flow task status` - Task execution analysis
## See Also
- [Bottleneck Detection Guide](/workspaces/claude-code-flow/.claude/commands/analysis/bottleneck-detect.md)
- [Performance Report Guide](/workspaces/claude-code-flow/.claude/commands/analysis/performance-report.md)
- [Performance Bottlenecks Overview](/workspaces/claude-code-flow/.claude/commands/analysis/performance-bottlenecks.md)
- [Swarm Monitoring Documentation](../swarm-orchestration/SKILL.md)
- [Memory Management Documentation](../memory-management/SKILL.md)
---
**Version**: 1.0.0
**Last Updated**: 2025-10-19
**Maintainer**: Claude Flow Team

446
vendor/ruvector/.claude/skills/reasoningbank-agentdb/SKILL.md vendored Normal file
View File

@@ -0,0 +1,446 @@
---
name: "ReasoningBank with AgentDB"
description: "Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database. Includes trajectory tracking, verdict judgment, memory distillation, and pattern recognition. Use when building self-learning agents, optimizing decision-making, or implementing experience replay systems."
---
# ReasoningBank with AgentDB
## What This Skill Does
Provides ReasoningBank adaptive learning patterns using AgentDB's high-performance backend (150x-12,500x faster). Enables agents to learn from experiences, judge outcomes, distill memories, and improve decision-making over time with 100% backward compatibility.
**Performance**: 150x faster pattern retrieval, 500x faster batch operations, <1ms memory access.
## Prerequisites
- Node.js 18+
- AgentDB v1.0.7+ (via agentic-flow)
- Understanding of reinforcement learning concepts (optional)
---
## Quick Start with CLI
### Initialize ReasoningBank Database
```bash
# Initialize AgentDB for ReasoningBank
npx agentdb@latest init ./.agentdb/reasoningbank.db --dimension 1536
# Start MCP server for Claude Code integration
npx agentdb@latest mcp
claude mcp add agentdb npx agentdb@latest mcp
```
### Migrate from Legacy ReasoningBank
```bash
# Automatic migration with validation
npx agentdb@latest migrate --source .swarm/memory.db
# Verify migration
npx agentdb@latest stats ./.agentdb/reasoningbank.db
```
---
## Quick Start with API
```typescript
import { createAgentDBAdapter, computeEmbedding } from 'agentic-flow/reasoningbank';
// Initialize ReasoningBank with AgentDB
const rb = await createAgentDBAdapter({
dbPath: '.agentdb/reasoningbank.db',
enableLearning: true, // Enable learning plugins
enableReasoning: true, // Enable reasoning agents
cacheSize: 1000, // 1000 pattern cache
});
// Store successful experience
const query = "How to optimize database queries?";
const embedding = await computeEmbedding(query);
await rb.insertPattern({
id: '',
type: 'experience',
domain: 'database-optimization',
pattern_data: JSON.stringify({
embedding,
pattern: {
query,
approach: 'indexing + query optimization',
outcome: 'success',
metrics: { latency_reduction: 0.85 }
}
}),
confidence: 0.95,
usage_count: 1,
success_count: 1,
created_at: Date.now(),
last_used: Date.now(),
});
// Retrieve similar experiences with reasoning
const result = await rb.retrieveWithReasoning(embedding, {
domain: 'database-optimization',
k: 5,
useMMR: true, // Diverse results
synthesizeContext: true, // Rich context synthesis
});
console.log('Memories:', result.memories);
console.log('Context:', result.context);
console.log('Patterns:', result.patterns);
```
---
## Core ReasoningBank Concepts
### 1. Trajectory Tracking
Track agent execution paths and outcomes:
```typescript
// Record trajectory (sequence of actions)
const trajectory = {
task: 'optimize-api-endpoint',
steps: [
{ action: 'analyze-bottleneck', result: 'found N+1 query' },
{ action: 'add-eager-loading', result: 'reduced queries' },
{ action: 'add-caching', result: 'improved latency' }
],
outcome: 'success',
metrics: { latency_before: 2500, latency_after: 150 }
};
const embedding = await computeEmbedding(JSON.stringify(trajectory));
await rb.insertPattern({
id: '',
type: 'trajectory',
domain: 'api-optimization',
pattern_data: JSON.stringify({ embedding, pattern: trajectory }),
confidence: 0.9,
usage_count: 1,
success_count: 1,
created_at: Date.now(),
last_used: Date.now(),
});
```
### 2. Verdict Judgment
Judge whether a trajectory was successful:
```typescript
// Retrieve similar past trajectories
const similar = await rb.retrieveWithReasoning(queryEmbedding, {
domain: 'api-optimization',
k: 10,
});
// Judge based on similarity to successful patterns
const verdict = similar.memories.filter(m =>
m.pattern.outcome === 'success' &&
m.similarity > 0.8
).length > 5 ? 'likely_success' : 'needs_review';
console.log('Verdict:', verdict);
console.log('Confidence:', similar.memories[0]?.similarity || 0);
```
### 3. Memory Distillation
Consolidate similar experiences into patterns:
```typescript
// Get all experiences in domain
const experiences = await rb.retrieveWithReasoning(embedding, {
domain: 'api-optimization',
k: 100,
optimizeMemory: true, // Automatic consolidation
});
// Distill into high-level pattern
const distilledPattern = {
domain: 'api-optimization',
pattern: 'For N+1 queries: add eager loading, then cache',
success_rate: 0.92,
sample_size: experiences.memories.length,
confidence: 0.95
};
await rb.insertPattern({
id: '',
type: 'distilled-pattern',
domain: 'api-optimization',
pattern_data: JSON.stringify({
embedding: await computeEmbedding(JSON.stringify(distilledPattern)),
pattern: distilledPattern
}),
confidence: 0.95,
usage_count: 0,
success_count: 0,
created_at: Date.now(),
last_used: Date.now(),
});
```
---
## Integration with Reasoning Agents
AgentDB provides 4 reasoning modules that enhance ReasoningBank:
### 1. PatternMatcher
Find similar successful patterns:
```typescript
const result = await rb.retrieveWithReasoning(queryEmbedding, {
domain: 'problem-solving',
k: 10,
useMMR: true, // Maximal Marginal Relevance for diversity
});
// PatternMatcher returns diverse, relevant memories
result.memories.forEach(mem => {
console.log(`Pattern: ${mem.pattern.approach}`);
console.log(`Similarity: ${mem.similarity}`);
console.log(`Success Rate: ${mem.success_count / mem.usage_count}`);
});
```
### 2. ContextSynthesizer
Generate rich context from multiple memories:
```typescript
const result = await rb.retrieveWithReasoning(queryEmbedding, {
domain: 'code-optimization',
synthesizeContext: true, // Enable context synthesis
k: 5,
});
// ContextSynthesizer creates coherent narrative
console.log('Synthesized Context:', result.context);
// "Based on 5 similar optimizations, the most effective approach
// involves profiling, identifying bottlenecks, and applying targeted
// improvements. Success rate: 87%"
```
### 3. MemoryOptimizer
Automatically consolidate and prune:
```typescript
const result = await rb.retrieveWithReasoning(queryEmbedding, {
domain: 'testing',
optimizeMemory: true, // Enable automatic optimization
});
// MemoryOptimizer consolidates similar patterns and prunes low-quality
console.log('Optimizations:', result.optimizations);
// { consolidated: 15, pruned: 3, improved_quality: 0.12 }
```
### 4. ExperienceCurator
Filter by quality and relevance:
```typescript
const result = await rb.retrieveWithReasoning(queryEmbedding, {
domain: 'debugging',
k: 20,
minConfidence: 0.8, // Only high-confidence experiences
});
// ExperienceCurator returns only quality experiences
result.memories.forEach(mem => {
console.log(`Confidence: ${mem.confidence}`);
console.log(`Success Rate: ${mem.success_count / mem.usage_count}`);
});
```
---
## Legacy API Compatibility
AgentDB maintains 100% backward compatibility with legacy ReasoningBank:
```typescript
import {
retrieveMemories,
judgeTrajectory,
distillMemories
} from 'agentic-flow/reasoningbank';
// Legacy API works unchanged (uses AgentDB backend automatically)
const memories = await retrieveMemories(query, {
domain: 'code-generation',
agent: 'coder'
});
const verdict = await judgeTrajectory(trajectory, query);
const newMemories = await distillMemories(
trajectory,
verdict,
query,
{ domain: 'code-generation' }
);
```
---
## Performance Characteristics
- **Pattern Search**: 150x faster (100µs vs 15ms)
- **Memory Retrieval**: <1ms (with cache)
- **Batch Insert**: 500x faster (2ms vs 1s for 100 patterns)
- **Trajectory Judgment**: <5ms (including retrieval + analysis)
- **Memory Distillation**: <50ms (consolidate 100 patterns)
---
## Advanced Patterns
### Hierarchical Memory
Organize memories by abstraction level:
```typescript
// Low-level: Specific implementation
await rb.insertPattern({
type: 'concrete',
domain: 'debugging/null-pointer',
pattern_data: JSON.stringify({
embedding,
pattern: { bug: 'NPE in UserService.getUser()', fix: 'Add null check' }
}),
confidence: 0.9,
// ...
});
// Mid-level: Pattern across similar cases
await rb.insertPattern({
type: 'pattern',
domain: 'debugging',
pattern_data: JSON.stringify({
embedding,
pattern: { category: 'null-pointer', approach: 'defensive-checks' }
}),
confidence: 0.85,
// ...
});
// High-level: General principle
await rb.insertPattern({
type: 'principle',
domain: 'software-engineering',
pattern_data: JSON.stringify({
embedding,
pattern: { principle: 'fail-fast with clear errors' }
}),
confidence: 0.95,
// ...
});
```
### Multi-Domain Learning
Transfer learning across domains:
```typescript
// Learn from backend optimization
const backendExperience = await rb.retrieveWithReasoning(embedding, {
domain: 'backend-optimization',
k: 10,
});
// Apply to frontend optimization
const transferredKnowledge = backendExperience.memories.map(mem => ({
...mem,
domain: 'frontend-optimization',
adapted: true,
}));
```
---
## CLI Operations
### Database Management
```bash
# Export trajectories and patterns
npx agentdb@latest export ./.agentdb/reasoningbank.db ./backup.json
# Import experiences
npx agentdb@latest import ./experiences.json
# Get statistics
npx agentdb@latest stats ./.agentdb/reasoningbank.db
# Shows: total patterns, domains, confidence distribution
```
### Migration
```bash
# Migrate from legacy ReasoningBank
npx agentdb@latest migrate --source .swarm/memory.db --target .agentdb/reasoningbank.db
# Validate migration
npx agentdb@latest stats .agentdb/reasoningbank.db
```
---
## Troubleshooting
### Issue: Migration fails
```bash
# Check source database exists
ls -la .swarm/memory.db
# Run with verbose logging
DEBUG=agentdb:* npx agentdb@latest migrate --source .swarm/memory.db
```
### Issue: Low confidence scores
```typescript
// Enable context synthesis for better quality
const result = await rb.retrieveWithReasoning(embedding, {
synthesizeContext: true,
useMMR: true,
k: 10,
});
```
### Issue: Memory growing too large
```typescript
// Enable automatic optimization
const result = await rb.retrieveWithReasoning(embedding, {
optimizeMemory: true, // Consolidates similar patterns
});
// Or manually optimize
await rb.optimize();
```
---
## Learn More
- **AgentDB Integration**: node_modules/agentic-flow/docs/AGENTDB_INTEGRATION.md
- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
- **MCP Integration**: `npx agentdb@latest mcp`
- **Website**: https://agentdb.ruv.io
---
**Category**: Machine Learning / Reinforcement Learning
**Difficulty**: Intermediate
**Estimated Time**: 20-30 minutes

201
vendor/ruvector/.claude/skills/reasoningbank-intelligence/SKILL.md vendored Normal file
View File

@@ -0,0 +1,201 @@
---
name: "ReasoningBank Intelligence"
description: "Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement. Use when building self-learning agents, optimizing workflows, or implementing meta-cognitive systems."
---
# ReasoningBank Intelligence
## What This Skill Does
Implements ReasoningBank's adaptive learning system for AI agents to learn from experience, recognize patterns, and optimize strategies over time. Enables meta-cognitive capabilities and continuous improvement.
## Prerequisites
- agentic-flow v1.5.11+
- AgentDB v1.0.4+ (for persistence)
- Node.js 18+
## Quick Start
```typescript
import { ReasoningBank } from 'agentic-flow/reasoningbank';
// Initialize ReasoningBank
const rb = new ReasoningBank({
persist: true,
learningRate: 0.1,
adapter: 'agentdb' // Use AgentDB for storage
});
// Record task outcome
await rb.recordExperience({
task: 'code_review',
approach: 'static_analysis_first',
outcome: {
success: true,
metrics: {
bugs_found: 5,
time_taken: 120,
false_positives: 1
}
},
context: {
language: 'typescript',
complexity: 'medium'
}
});
// Get optimal strategy
const strategy = await rb.recommendStrategy('code_review', {
language: 'typescript',
complexity: 'high'
});
```
## Core Features
### 1. Pattern Recognition
```typescript
// Learn patterns from data
await rb.learnPattern({
pattern: 'api_errors_increase_after_deploy',
triggers: ['deployment', 'traffic_spike'],
actions: ['rollback', 'scale_up'],
confidence: 0.85
});
// Match patterns
const matches = await rb.matchPatterns(currentSituation);
```
### 2. Strategy Optimization
```typescript
// Compare strategies
const comparison = await rb.compareStrategies('bug_fixing', [
'tdd_approach',
'debug_first',
'reproduce_then_fix'
]);
// Get best strategy
const best = comparison.strategies[0];
console.log(`Best: ${best.name} (score: ${best.score})`);
```
### 3. Continuous Learning
```typescript
// Enable auto-learning from all tasks
await rb.enableAutoLearning({
threshold: 0.7, // Only learn from high-confidence outcomes
updateFrequency: 100 // Update models every 100 experiences
});
```
## Advanced Usage
### Meta-Learning
```typescript
// Learn about learning
await rb.metaLearn({
observation: 'parallel_execution_faster_for_independent_tasks',
confidence: 0.95,
applicability: {
task_types: ['batch_processing', 'data_transformation'],
conditions: ['tasks_independent', 'io_bound']
}
});
```
### Transfer Learning
```typescript
// Apply knowledge from one domain to another
await rb.transferKnowledge({
from: 'code_review_javascript',
to: 'code_review_typescript',
similarity: 0.8
});
```
### Adaptive Agents
```typescript
// Create self-improving agent
class AdaptiveAgent {
async execute(task: Task) {
// Get optimal strategy
const strategy = await rb.recommendStrategy(task.type, task.context);
// Execute with strategy
const result = await this.executeWithStrategy(task, strategy);
// Learn from outcome
await rb.recordExperience({
task: task.type,
approach: strategy.name,
outcome: result,
context: task.context
});
return result;
}
}
```
## Integration with AgentDB
```typescript
// Persist ReasoningBank data
await rb.configure({
storage: {
type: 'agentdb',
options: {
database: './reasoning-bank.db',
enableVectorSearch: true
}
}
});
// Query learned patterns
const patterns = await rb.query({
category: 'optimization',
minConfidence: 0.8,
timeRange: { last: '30d' }
});
```
## Performance Metrics
```typescript
// Track learning effectiveness
const metrics = await rb.getMetrics();
console.log(`
Total Experiences: ${metrics.totalExperiences}
Patterns Learned: ${metrics.patternsLearned}
Strategy Success Rate: ${metrics.strategySuccessRate}
Improvement Over Time: ${metrics.improvement}
`);
```
## Best Practices
1. **Record consistently**: Log all task outcomes, not just successes
2. **Provide context**: Rich context improves pattern matching
3. **Set thresholds**: Filter low-confidence learnings
4. **Review periodically**: Audit learned patterns for quality
5. **Use vector search**: Enable semantic pattern matching
## Troubleshooting
### Issue: Poor recommendations
**Solution**: Ensure sufficient training data (100+ experiences per task type)
### Issue: Slow pattern matching
**Solution**: Enable vector indexing in AgentDB
### Issue: Memory growing large
**Solution**: Set TTL for old experiences or enable pruning
## Learn More
- ReasoningBank Guide: agentic-flow/src/reasoningbank/README.md
- AgentDB Integration: packages/agentdb/docs/reasoningbank.md
- Pattern Learning: docs/reasoning/patterns.md

910
vendor/ruvector/.claude/skills/skill-builder/SKILL.md vendored Normal file
View File

@@ -0,0 +1,910 @@
---
name: "Skill Builder"
description: "Create new Claude Code Skills with proper YAML frontmatter, progressive disclosure structure, and complete directory organization. Use when you need to build custom skills for specific workflows, generate skill templates, or understand the Claude Skills specification."
---
# Skill Builder
## What This Skill Does
Creates production-ready Claude Code Skills with proper YAML frontmatter, progressive disclosure architecture, and complete file/folder structure. This skill guides you through building skills that Claude can autonomously discover and use across all surfaces (Claude.ai, Claude Code, SDK, API).
## Prerequisites
- Claude Code 2.0+ or Claude.ai with Skills support
- Basic understanding of Markdown and YAML
- Text editor or IDE
## Quick Start
### Creating Your First Skill
```bash
# 1. Create skill directory (MUST be at top level, NOT in subdirectories!)
mkdir -p ~/.claude/skills/my-first-skill
# 2. Create SKILL.md with proper format
cat > ~/.claude/skills/my-first-skill/SKILL.md << 'EOF'
---
name: "My First Skill"
description: "Brief description of what this skill does and when Claude should use it. Maximum 1024 characters."
---
# My First Skill
## What This Skill Does
[Your instructions here]
## Quick Start
[Basic usage]
EOF
# 3. Verify skill is detected
# Restart Claude Code or refresh Claude.ai
```
---
## Complete Specification
### 📋 YAML Frontmatter (REQUIRED)
Every SKILL.md **must** start with YAML frontmatter containing exactly two required fields:
```yaml
---
name: "Skill Name" # REQUIRED: Max 64 chars
description: "What this skill does # REQUIRED: Max 1024 chars
and when Claude should use it." # Include BOTH what & when
---
```
#### Field Requirements
**`name`** (REQUIRED):
- **Type**: String
- **Max Length**: 64 characters
- **Format**: Human-friendly display name
- **Usage**: Shown in skill lists, UI, and loaded into Claude's system prompt
- **Best Practice**: Use Title Case, be concise and descriptive
- **Examples**:
- ✅ "API Documentation Generator"
- ✅ "React Component Builder"
- ✅ "Database Schema Designer"
- ❌ "skill-1" (not descriptive)
- ❌ "This is a very long skill name that exceeds sixty-four characters" (too long)
**`description`** (REQUIRED):
- **Type**: String
- **Max Length**: 1024 characters
- **Format**: Plain text or minimal markdown
- **Content**: MUST include:
1. **What** the skill does (functionality)
2. **When** Claude should invoke it (trigger conditions)
- **Usage**: Loaded into Claude's system prompt for autonomous matching
- **Best Practice**: Front-load key trigger words, be specific about use cases
- **Examples**:
- ✅ "Generate OpenAPI 3.0 documentation from Express.js routes. Use when creating API docs, documenting endpoints, or building API specifications."
- ✅ "Create React functional components with TypeScript, hooks, and tests. Use when scaffolding new components or converting class components."
- ❌ "A comprehensive guide to API documentation" (no "when" clause)
- ❌ "Documentation tool" (too vague)
#### YAML Formatting Rules
```yaml
---
# ✅ CORRECT: Simple string
name: "API Builder"
description: "Creates REST APIs with Express and TypeScript."
# ✅ CORRECT: Multi-line description
name: "Full-Stack Generator"
description: "Generates full-stack applications with React frontend and Node.js backend. Use when starting new projects or scaffolding applications."
# ✅ CORRECT: Special characters quoted
name: "JSON:API Builder"
description: "Creates JSON:API compliant endpoints: pagination, filtering, relationships."
# ❌ WRONG: Missing quotes with special chars
name: API:Builder # YAML parse error!
# ❌ WRONG: Extra fields (ignored but discouraged)
name: "My Skill"
description: "My description"
version: "1.0.0" # NOT part of spec
author: "Me" # NOT part of spec
tags: ["dev", "api"] # NOT part of spec
---
```
**Critical**: Only `name` and `description` are used by Claude. Additional fields are ignored.
---
### 📂 Directory Structure
#### Minimal Skill (Required)
```
~/.claude/skills/ # Personal skills location
└── my-skill/ # Skill directory (MUST be at top level!)
└── SKILL.md # REQUIRED: Main skill file
```
**IMPORTANT**: Skills MUST be directly under `~/.claude/skills/[skill-name]/`.
Claude Code does NOT support nested subdirectories or namespaces!
#### Full-Featured Skill (Recommended)
```
~/.claude/skills/
└── my-skill/ # Top-level skill directory
├── SKILL.md # REQUIRED: Main skill file
├── README.md # Optional: Human-readable docs
├── scripts/ # Optional: Executable scripts
│ ├── setup.sh
│ ├── validate.js
│ └── deploy.py
├── resources/ # Optional: Supporting files
│ ├── templates/
│ │ ├── api-template.js
│ │ └── component.tsx
│ ├── examples/
│ │ └── sample-output.json
│ └── schemas/
│ └── config-schema.json
└── docs/ # Optional: Additional documentation
├── ADVANCED.md
├── TROUBLESHOOTING.md
└── API_REFERENCE.md
```
#### Skills Locations
**Personal Skills** (available across all projects):
```
~/.claude/skills/
└── [your-skills]/
```
- **Path**: `~/.claude/skills/` or `$HOME/.claude/skills/`
- **Scope**: Available in all projects for this user
- **Version Control**: NOT committed to git (outside repo)
- **Use Case**: Personal productivity tools, custom workflows
**Project Skills** (team-shared, version controlled):
```
<project-root>/.claude/skills/
└── [team-skills]/
```
- **Path**: `.claude/skills/` in project root
- **Scope**: Available only in this project
- **Version Control**: SHOULD be committed to git
- **Use Case**: Team workflows, project-specific tools, shared knowledge
---
### 🎯 Progressive Disclosure Architecture
Claude Code uses a **3-level progressive disclosure system** to scale to 100+ skills without context penalty:
#### Level 1: Metadata (Name + Description)
**Loaded**: At Claude Code startup, always
**Size**: ~200 chars per skill
**Purpose**: Enable autonomous skill matching
**Context**: Loaded into system prompt for ALL skills
```yaml
---
name: "API Builder" # 11 chars
description: "Creates REST APIs..." # ~50 chars
---
# Total: ~61 chars per skill
# 100 skills = ~6KB context (minimal!)
```
#### Level 2: SKILL.md Body
**Loaded**: When skill is triggered/matched
**Size**: ~1-10KB typically
**Purpose**: Main instructions and procedures
**Context**: Only loaded for ACTIVE skills
```markdown
# API Builder
## What This Skill Does
[Main instructions - loaded only when skill is active]
## Quick Start
[Basic procedures]
## Step-by-Step Guide
[Detailed instructions]
```
#### Level 3+: Referenced Files
**Loaded**: On-demand as Claude navigates
**Size**: Variable (KB to MB)
**Purpose**: Deep reference, examples, schemas
**Context**: Loaded only when Claude accesses specific files
```markdown
# In SKILL.md
See [Advanced Configuration](docs/ADVANCED.md) for complex scenarios.
See [API Reference](docs/API_REFERENCE.md) for complete documentation.
Use template: `resources/templates/api-template.js`
# Claude will load these files ONLY if needed
```
**Benefit**: Install 100+ skills with ~6KB context. Only active skill content (1-10KB) enters context.
---
### 📝 SKILL.md Content Structure
#### Recommended 4-Level Structure
```markdown
---
name: "Your Skill Name"
description: "What it does and when to use it"
---
# Your Skill Name
## Level 1: Overview (Always Read First)
Brief 2-3 sentence description of the skill.
## Prerequisites
- Requirement 1
- Requirement 2
## What This Skill Does
1. Primary function
2. Secondary function
3. Key benefit
---
## Level 2: Quick Start (For Fast Onboarding)
### Basic Usage
```bash
# Simplest use case
command --option value
```
### Common Scenarios
1. **Scenario 1**: How to...
2. **Scenario 2**: How to...
---
## Level 3: Detailed Instructions (For Deep Work)
### Step-by-Step Guide
#### Step 1: Initial Setup
```bash
# Commands
```
Expected output:
```
Success message
```
#### Step 2: Configuration
- Configuration option 1
- Configuration option 2
#### Step 3: Execution
- Run the main command
- Verify results
### Advanced Options
#### Option 1: Custom Configuration
```bash
# Advanced usage
```
#### Option 2: Integration
```bash
# Integration steps
```
---
## Level 4: Reference (Rarely Needed)
### Troubleshooting
#### Issue: Common Problem
**Symptoms**: What you see
**Cause**: Why it happens
**Solution**: How to fix
```bash
# Fix command
```
#### Issue: Another Problem
**Solution**: Steps to resolve
### Complete API Reference
See [API_REFERENCE.md](docs/API_REFERENCE.md)
### Examples
See [examples/](resources/examples/)
### Related Skills
- [Related Skill 1](#)
- [Related Skill 2](#)
### Resources
- [External Link 1](https://example.com)
- [Documentation](https://docs.example.com)
```
---
### 🎨 Content Best Practices
#### Writing Effective Descriptions
**Front-Load Keywords**:
```yaml
# ✅ GOOD: Keywords first
description: "Generate TypeScript interfaces from JSON schema. Use when converting schemas, creating types, or building API clients."
# ❌ BAD: Keywords buried
description: "This skill helps developers who need to work with JSON schemas by providing a way to generate TypeScript interfaces."
```
**Include Trigger Conditions**:
```yaml
# ✅ GOOD: Clear "when" clause
description: "Debug React performance issues using Chrome DevTools. Use when components re-render unnecessarily, investigating slow updates, or optimizing bundle size."
# ❌ BAD: No trigger conditions
description: "Helps with React performance debugging."
```
**Be Specific**:
```yaml
# ✅ GOOD: Specific technologies
description: "Create Express.js REST endpoints with Joi validation, Swagger docs, and Jest tests. Use when building new APIs or adding endpoints."
# ❌ BAD: Too generic
description: "Build API endpoints with proper validation and testing."
```
#### Progressive Disclosure Writing
**Keep Level 1 Brief** (Overview):
```markdown
## What This Skill Does
Creates production-ready React components with TypeScript, hooks, and tests in 3 steps.
```
**Level 2 for Common Paths** (Quick Start):
```markdown
## Quick Start
```bash
# Most common use case (80% of users)
generate-component MyComponent
```
```
**Level 3 for Details** (Step-by-Step):
```markdown
## Step-by-Step Guide
### Creating a Basic Component
1. Run generator
2. Choose template
3. Customize options
[Detailed explanations]
```
**Level 4 for Edge Cases** (Reference):
```markdown
## Advanced Configuration
For complex scenarios like HOCs, render props, or custom hooks, see [ADVANCED.md](docs/ADVANCED.md).
```
---
### 🛠️ Adding Scripts and Resources
#### Scripts Directory
**Purpose**: Executable scripts that Claude can run
**Location**: `scripts/` in skill directory
**Usage**: Referenced from SKILL.md
Example:
```bash
# In skill directory
scripts/
├── setup.sh # Initialization script
├── validate.js # Validation logic
├── generate.py # Code generation
└── deploy.sh # Deployment script
```
Reference from SKILL.md:
```markdown
## Setup
Run the setup script:
```bash
./scripts/setup.sh
```
## Validation
Validate your configuration:
```bash
node scripts/validate.js config.json
```
```
#### Resources Directory
**Purpose**: Templates, examples, schemas, static files
**Location**: `resources/` in skill directory
**Usage**: Referenced or copied by scripts
Example:
```bash
resources/
├── templates/
│ ├── component.tsx.template
│ ├── test.spec.ts.template
│ └── story.stories.tsx.template
├── examples/
│ ├── basic-example/
│ ├── advanced-example/
│ └── integration-example/
└── schemas/
├── config.schema.json
└── output.schema.json
```
Reference from SKILL.md:
```markdown
## Templates
Use the component template:
```bash
cp resources/templates/component.tsx.template src/components/MyComponent.tsx
```
## Examples
See working examples in `resources/examples/`:
- `basic-example/` - Simple component
- `advanced-example/` - With hooks and context
```
---
### 🔗 File References and Navigation
Claude can navigate to referenced files automatically. Use these patterns:
#### Markdown Links
```markdown
See [Advanced Configuration](docs/ADVANCED.md) for complex scenarios.
See [Troubleshooting Guide](docs/TROUBLESHOOTING.md) if you encounter errors.
```
#### Relative File Paths
```markdown
Use the template located at `resources/templates/api-template.js`
See examples in `resources/examples/basic-usage/`
```
#### Inline File Content
```markdown
## Example Configuration
See `resources/examples/config.json`:
```json
{
"option": "value"
}
```
```
**Best Practice**: Keep SKILL.md lean (~2-5KB). Move lengthy content to separate files and reference them. Claude will load only what's needed.
---
### ✅ Validation Checklist
Before publishing a skill, verify:
**YAML Frontmatter**:
- [ ] Starts with `---`
- [ ] Contains `name` field (max 64 chars)
- [ ] Contains `description` field (max 1024 chars)
- [ ] Description includes "what" and "when"
- [ ] Ends with `---`
- [ ] No YAML syntax errors
**File Structure**:
- [ ] SKILL.md exists in skill directory
- [ ] Directory is DIRECTLY in `~/.claude/skills/[skill-name]/` or `.claude/skills/[skill-name]/`
- [ ] Uses clear, descriptive directory name
- [ ] **NO nested subdirectories** (Claude Code requires top-level structure)
**Content Quality**:
- [ ] Level 1 (Overview) is brief and clear
- [ ] Level 2 (Quick Start) shows common use case
- [ ] Level 3 (Details) provides step-by-step guide
- [ ] Level 4 (Reference) links to advanced content
- [ ] Examples are concrete and runnable
- [ ] Troubleshooting section addresses common issues
**Progressive Disclosure**:
- [ ] Core instructions in SKILL.md (~2-5KB)
- [ ] Advanced content in separate docs/
- [ ] Large resources in resources/ directory
- [ ] Clear navigation between levels
**Testing**:
- [ ] Skill appears in Claude's skill list
- [ ] Description triggers on relevant queries
- [ ] Instructions are clear and actionable
- [ ] Scripts execute successfully (if included)
- [ ] Examples work as documented
---
## Skill Builder Templates
### Template 1: Basic Skill (Minimal)
```markdown
---
name: "My Basic Skill"
description: "One sentence what. One sentence when to use."
---
# My Basic Skill
## What This Skill Does
[2-3 sentences describing functionality]
## Quick Start
```bash
# Single command to get started
```
## Step-by-Step Guide
### Step 1: Setup
[Instructions]
### Step 2: Usage
[Instructions]
### Step 3: Verify
[Instructions]
## Troubleshooting
- **Issue**: Problem description
- **Solution**: Fix description
```
### Template 2: Intermediate Skill (With Scripts)
```markdown
---
name: "My Intermediate Skill"
description: "Detailed what with key features. When to use with specific triggers: scaffolding, generating, building."
---
# My Intermediate Skill
## Prerequisites
- Requirement 1
- Requirement 2
## What This Skill Does
1. Primary function
2. Secondary function
3. Integration capability
## Quick Start
```bash
./scripts/setup.sh
./scripts/generate.sh my-project
```
## Configuration
Edit `config.json`:
```json
{
"option1": "value1",
"option2": "value2"
}
```
## Step-by-Step Guide
### Basic Usage
[Steps for 80% use case]
### Advanced Usage
[Steps for complex scenarios]
## Available Scripts
- `scripts/setup.sh` - Initial setup
- `scripts/generate.sh` - Code generation
- `scripts/validate.sh` - Validation
## Resources
- Templates: `resources/templates/`
- Examples: `resources/examples/`
## Troubleshooting
[Common issues and solutions]
```
### Template 3: Advanced Skill (Full-Featured)
```markdown
---
name: "My Advanced Skill"
description: "Comprehensive what with all features and integrations. Use when [trigger 1], [trigger 2], or [trigger 3]. Supports [technology stack]."
---
# My Advanced Skill
## Overview
[Brief 2-3 sentence description]
## Prerequisites
- Technology 1 (version X+)
- Technology 2 (version Y+)
- API keys or credentials
## What This Skill Does
1. **Core Feature**: Description
2. **Integration**: Description
3. **Automation**: Description
---
## Quick Start (60 seconds)
### Installation
```bash
./scripts/install.sh
```
### First Use
```bash
./scripts/quickstart.sh
```
Expected output:
```
✓ Setup complete
✓ Configuration validated
→ Ready to use
```
---
## Configuration
### Basic Configuration
Edit `config.json`:
```json
{
"mode": "production",
"features": ["feature1", "feature2"]
}
```
### Advanced Configuration
See [Configuration Guide](docs/CONFIGURATION.md)
---
## Step-by-Step Guide
### 1. Initial Setup
[Detailed steps]
### 2. Core Workflow
[Main procedures]
### 3. Integration
[Integration steps]
---
## Advanced Features
### Feature 1: Custom Templates
```bash
./scripts/generate.sh --template custom
```
### Feature 2: Batch Processing
```bash
./scripts/batch.sh --input data.json
```
### Feature 3: CI/CD Integration
See [CI/CD Guide](docs/CICD.md)
---
## Scripts Reference
| Script | Purpose | Usage |
|--------|---------|-------|
| `install.sh` | Install dependencies | `./scripts/install.sh` |
| `generate.sh` | Generate code | `./scripts/generate.sh [name]` |
| `validate.sh` | Validate output | `./scripts/validate.sh` |
| `deploy.sh` | Deploy to environment | `./scripts/deploy.sh [env]` |
---
## Resources
### Templates
- `resources/templates/basic.template` - Basic template
- `resources/templates/advanced.template` - Advanced template
### Examples
- `resources/examples/basic/` - Simple example
- `resources/examples/advanced/` - Complex example
- `resources/examples/integration/` - Integration example
### Schemas
- `resources/schemas/config.schema.json` - Configuration schema
- `resources/schemas/output.schema.json` - Output validation
---
## Troubleshooting
### Issue: Installation Failed
**Symptoms**: Error during `install.sh`
**Cause**: Missing dependencies
**Solution**:
```bash
# Install prerequisites
npm install -g required-package
./scripts/install.sh --force
```
### Issue: Validation Errors
**Symptoms**: Validation script fails
**Solution**: See [Troubleshooting Guide](docs/TROUBLESHOOTING.md)
---
## API Reference
Complete API documentation: [API_REFERENCE.md](docs/API_REFERENCE.md)
## Related Skills
- [Related Skill 1](../related-skill-1/)
- [Related Skill 2](../related-skill-2/)
## Resources
- [Official Documentation](https://example.com/docs)
- [GitHub Repository](https://github.com/example/repo)
- [Community Forum](https://forum.example.com)
---
**Created**: 2025-10-19
**Category**: Advanced
**Difficulty**: Intermediate
**Estimated Time**: 15-30 minutes
```
---
## Examples from the Wild
### Example 1: Simple Documentation Skill
```markdown
---
name: "README Generator"
description: "Generate comprehensive README.md files for GitHub repositories. Use when starting new projects, documenting code, or improving existing READMEs."
---
# README Generator
## What This Skill Does
Creates well-structured README.md files with badges, installation, usage, and contribution sections.
## Quick Start
```bash
# Answer a few questions
./scripts/generate-readme.sh
# README.md created with:
# - Project title and description
# - Installation instructions
# - Usage examples
# - Contribution guidelines
```
## Customization
Edit sections in `resources/templates/sections/` before generating.
```
### Example 2: Code Generation Skill
```markdown
---
name: "React Component Generator"
description: "Generate React functional components with TypeScript, hooks, tests, and Storybook stories. Use when creating new components, scaffolding UI, or following component architecture patterns."
---
# React Component Generator
## Prerequisites
- Node.js 18+
- React 18+
- TypeScript 5+
## Quick Start
```bash
./scripts/generate-component.sh MyComponent
# Creates:
# - src/components/MyComponent/MyComponent.tsx
# - src/components/MyComponent/MyComponent.test.tsx
# - src/components/MyComponent/MyComponent.stories.tsx
# - src/components/MyComponent/index.ts
```
## Step-by-Step Guide
### 1. Run Generator
```bash
./scripts/generate-component.sh ComponentName
```
### 2. Choose Template
- Basic: Simple functional component
- With State: useState hooks
- With Context: useContext integration
- With API: Data fetching component
### 3. Customize
Edit generated files in `src/components/ComponentName/`
## Templates
See `resources/templates/` for available component templates.
```
---
## Learn More
### Official Resources
- [Anthropic Agent Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills)
- [GitHub Skills Repository](https://github.com/anthropics/skills)
- [Claude Code Documentation](https://docs.claude.com/en/docs/claude-code)
### Community
- [Skills Marketplace](https://github.com/anthropics/skills) - Browse community skills
- [Anthropic Discord](https://discord.gg/anthropic) - Get help from community
### Advanced Topics
- Multi-file skills with complex navigation
- Skills that spawn other skills
- Integration with MCP tools
- Dynamic skill generation
---
**Created**: 2025-10-19
**Version**: 1.0.0
**Maintained By**: agentic-flow team
**License**: MIT

1115
vendor/ruvector/.claude/skills/sparc-methodology/SKILL.md vendored Normal file
View File

File diff suppressed because it is too large Load Diff

563
vendor/ruvector/.claude/skills/stream-chain/SKILL.md vendored Normal file
View File

@@ -0,0 +1,563 @@
---
name: stream-chain
description: Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows
version: 1.0.0
category: workflow
tags: [streaming, pipeline, chaining, multi-agent, workflow]
---
# Stream-Chain Skill
Execute sophisticated multi-step workflows where each agent's output flows into the next, enabling complex data transformations and sequential processing pipelines.
## Overview
Stream-Chain provides two powerful modes for orchestrating multi-agent workflows:
1. **Custom Chains** (`run`): Execute custom prompt sequences with full control
2. **Predefined Pipelines** (`pipeline`): Use battle-tested workflows for common tasks
Each step in a chain receives the complete output from the previous step, enabling sophisticated multi-agent coordination through streaming data flow.
---
## Quick Start
### Run a Custom Chain
```bash
claude-flow stream-chain run \
"Analyze codebase structure" \
"Identify improvement areas" \
"Generate action plan"
```
### Execute a Pipeline
```bash
claude-flow stream-chain pipeline analysis
```
---
## Custom Chains (`run`)
Execute custom stream chains with your own prompts for maximum flexibility.
### Syntax
```bash
claude-flow stream-chain run <prompt1> <prompt2> [...] [options]
```
**Requirements:**
- Minimum 2 prompts required
- Each prompt becomes a step in the chain
- Output flows sequentially through all steps
### Options
| Option | Description | Default |
|--------|-------------|---------|
| `--verbose` | Show detailed execution information | `false` |
| `--timeout <seconds>` | Timeout per step | `30` |
| `--debug` | Enable debug mode with full logging | `false` |
### How Context Flows
Each step receives the previous output as context:
```
Step 1: "Write a sorting function"
Output: [function implementation]
Step 2 receives:
"Previous step output:
[function implementation]
Next task: Add comprehensive tests"
Step 3 receives:
"Previous steps output:
[function + tests]
Next task: Optimize performance"
```
### Examples
#### Basic Development Chain
```bash
claude-flow stream-chain run \
"Write a user authentication function" \
"Add input validation and error handling" \
"Create unit tests with edge cases"
```
#### Security Audit Workflow
```bash
claude-flow stream-chain run \
"Analyze authentication system for vulnerabilities" \
"Identify and categorize security issues by severity" \
"Propose fixes with implementation priority" \
"Generate security test cases" \
--timeout 45 \
--verbose
```
#### Code Refactoring Chain
```bash
claude-flow stream-chain run \
"Identify code smells in src/ directory" \
"Create refactoring plan with specific changes" \
"Apply refactoring to top 3 priority items" \
"Verify refactored code maintains behavior" \
--debug
```
#### Data Processing Pipeline
```bash
claude-flow stream-chain run \
"Extract data from API responses" \
"Transform data into normalized format" \
"Validate data against schema" \
"Generate data quality report"
```
---
## Predefined Pipelines (`pipeline`)
Execute battle-tested workflows optimized for common development tasks.
### Syntax
```bash
claude-flow stream-chain pipeline <type> [options]
```
### Available Pipelines
#### 1. Analysis Pipeline
Comprehensive codebase analysis and improvement identification.
```bash
claude-flow stream-chain pipeline analysis
```
**Workflow Steps:**
1. **Structure Analysis**: Map directory structure and identify components
2. **Issue Detection**: Find potential improvements and problems
3. **Recommendations**: Generate actionable improvement report
**Use Cases:**
- New codebase onboarding
- Technical debt assessment
- Architecture review
- Code quality audits
#### 2. Refactor Pipeline
Systematic code refactoring with prioritization.
```bash
claude-flow stream-chain pipeline refactor
```
**Workflow Steps:**
1. **Candidate Identification**: Find code needing refactoring
2. **Prioritization**: Create ranked refactoring plan
3. **Implementation**: Provide refactored code for top priorities
**Use Cases:**
- Technical debt reduction
- Code quality improvement
- Legacy code modernization
- Design pattern implementation
#### 3. Test Pipeline
Comprehensive test generation with coverage analysis.
```bash
claude-flow stream-chain pipeline test
```
**Workflow Steps:**
1. **Coverage Analysis**: Identify areas lacking tests
2. **Test Design**: Create test cases for critical functions
3. **Implementation**: Generate unit tests with assertions
**Use Cases:**
- Increasing test coverage
- TDD workflow support
- Regression test creation
- Quality assurance
#### 4. Optimize Pipeline
Performance optimization with profiling and implementation.
```bash
claude-flow stream-chain pipeline optimize
```
**Workflow Steps:**
1. **Profiling**: Identify performance bottlenecks
2. **Strategy**: Analyze and suggest optimization approaches
3. **Implementation**: Provide optimized code
**Use Cases:**
- Performance improvement
- Resource optimization
- Scalability enhancement
- Latency reduction
### Pipeline Options
| Option | Description | Default |
|--------|-------------|---------|
| `--verbose` | Show detailed execution | `false` |
| `--timeout <seconds>` | Timeout per step | `30` |
| `--debug` | Enable debug mode | `false` |
### Pipeline Examples
#### Quick Analysis
```bash
claude-flow stream-chain pipeline analysis
```
#### Extended Refactoring
```bash
claude-flow stream-chain pipeline refactor --timeout 60 --verbose
```
#### Debug Test Generation
```bash
claude-flow stream-chain pipeline test --debug
```
#### Comprehensive Optimization
```bash
claude-flow stream-chain pipeline optimize --timeout 90 --verbose
```
### Pipeline Output
Each pipeline execution provides:
- **Progress**: Step-by-step execution status
- **Results**: Success/failure per step
- **Timing**: Total and per-step execution time
- **Summary**: Consolidated results and recommendations
---
## Custom Pipeline Definitions
Define reusable pipelines in `.claude-flow/config.json`:
### Configuration Format
```json
{
"streamChain": {
"pipelines": {
"security": {
"name": "Security Audit Pipeline",
"description": "Comprehensive security analysis",
"prompts": [
"Scan codebase for security vulnerabilities",
"Categorize issues by severity (critical/high/medium/low)",
"Generate fixes with priority and implementation steps",
"Create security test suite"
],
"timeout": 45
},
"documentation": {
"name": "Documentation Generation Pipeline",
"prompts": [
"Analyze code structure and identify undocumented areas",
"Generate API documentation with examples",
"Create usage guides and tutorials",
"Build architecture diagrams and flow charts"
]
}
}
}
}
```
### Execute Custom Pipeline
```bash
claude-flow stream-chain pipeline security
claude-flow stream-chain pipeline documentation
```
---
## Advanced Use Cases
### Multi-Agent Coordination
Chain different agent types for complex workflows:
```bash
claude-flow stream-chain run \
"Research best practices for API design" \
"Design REST API with discovered patterns" \
"Implement API endpoints with validation" \
"Generate OpenAPI specification" \
"Create integration tests" \
"Write deployment documentation"
```
### Data Transformation Pipeline
Process and transform data through multiple stages:
```bash
claude-flow stream-chain run \
"Extract user data from CSV files" \
"Normalize and validate data format" \
"Enrich data with external API calls" \
"Generate analytics report" \
"Create visualization code"
```
### Code Migration Workflow
Systematic code migration with validation:
```bash
claude-flow stream-chain run \
"Analyze legacy codebase dependencies" \
"Create migration plan with risk assessment" \
"Generate modernized code for high-priority modules" \
"Create migration tests" \
"Document migration steps and rollback procedures"
```
### Quality Assurance Chain
Comprehensive code quality workflow:
```bash
claude-flow stream-chain pipeline analysis
claude-flow stream-chain pipeline refactor
claude-flow stream-chain pipeline test
claude-flow stream-chain pipeline optimize
```
---
## Best Practices
### 1. Clear and Specific Prompts
**Good:**
```bash
"Analyze authentication.js for SQL injection vulnerabilities"
```
**Avoid:**
```bash
"Check security"
```
### 2. Logical Progression
Order prompts to build on previous outputs:
```bash
1. "Identify the problem"
2. "Analyze root causes"
3. "Design solution"
4. "Implement solution"
5. "Verify implementation"
```
### 3. Appropriate Timeouts
- Simple tasks: 30 seconds (default)
- Analysis tasks: 45-60 seconds
- Implementation tasks: 60-90 seconds
- Complex workflows: 90-120 seconds
### 4. Verification Steps
Include validation in your chains:
```bash
claude-flow stream-chain run \
"Implement feature X" \
"Write tests for feature X" \
"Verify tests pass and cover edge cases"
```
### 5. Iterative Refinement
Use chains for iterative improvement:
```bash
claude-flow stream-chain run \
"Generate initial implementation" \
"Review and identify issues" \
"Refine based on issues found" \
"Final quality check"
```
---
## Integration with Claude Flow
### Combine with Swarm Coordination
```bash
# Initialize swarm for coordination
claude-flow swarm init --topology mesh
# Execute stream chain with swarm agents
claude-flow stream-chain run \
"Agent 1: Research task" \
"Agent 2: Implement solution" \
"Agent 3: Test implementation" \
"Agent 4: Review and refine"
```
### Memory Integration
Stream chains automatically store context in memory for cross-session persistence:
```bash
# Execute chain with memory
claude-flow stream-chain run \
"Analyze requirements" \
"Design architecture" \
--verbose
# Results stored in .claude-flow/memory/stream-chain/
```
### Neural Pattern Training
Successful chains train neural patterns for improved performance:
```bash
# Enable neural training
claude-flow stream-chain pipeline optimize --debug
# Patterns learned and stored for future optimizations
```
---
## Troubleshooting
### Chain Timeout
If steps timeout, increase timeout value:
```bash
claude-flow stream-chain run "complex task" --timeout 120
```
### Context Loss
If context not flowing properly, use `--debug`:
```bash
claude-flow stream-chain run "step 1" "step 2" --debug
```
### Pipeline Not Found
Verify pipeline name and custom definitions:
```bash
# Check available pipelines
cat .claude-flow/config.json | grep -A 10 "streamChain"
```
---
## Performance Characteristics
- **Throughput**: 2-5 steps per minute (varies by complexity)
- **Context Size**: Up to 100K tokens per step
- **Memory Usage**: ~50MB per active chain
- **Concurrency**: Supports parallel chain execution
---
## Related Skills
- **SPARC Methodology**: Systematic development workflow
- **Swarm Coordination**: Multi-agent orchestration
- **Memory Management**: Persistent context storage
- **Neural Patterns**: Adaptive learning
---
## Examples Repository
### Complete Development Workflow
```bash
# Full feature development chain
claude-flow stream-chain run \
"Analyze requirements for user profile feature" \
"Design database schema and API endpoints" \
"Implement backend with validation" \
"Create frontend components" \
"Write comprehensive tests" \
"Generate API documentation" \
--timeout 60 \
--verbose
```
### Code Review Pipeline
```bash
# Automated code review workflow
claude-flow stream-chain run \
"Analyze recent git changes" \
"Identify code quality issues" \
"Check for security vulnerabilities" \
"Verify test coverage" \
"Generate code review report with recommendations"
```
### Migration Assistant
```bash
# Framework migration helper
claude-flow stream-chain run \
"Analyze current Vue 2 codebase" \
"Identify Vue 3 breaking changes" \
"Create migration checklist" \
"Generate migration scripts" \
"Provide updated code examples"
```
---
## Conclusion
Stream-Chain enables sophisticated multi-step workflows by:
- **Sequential Processing**: Each step builds on previous results
- **Context Preservation**: Full output history flows through chain
- **Flexible Orchestration**: Custom chains or predefined pipelines
- **Agent Coordination**: Natural multi-agent collaboration pattern
- **Data Transformation**: Complex processing through simple steps
Use `run` for custom workflows and `pipeline` for battle-tested solutions.

973
vendor/ruvector/.claude/skills/swarm-advanced/SKILL.md vendored Normal file
View File

@@ -0,0 +1,973 @@
---
name: swarm-advanced
description: Advanced swarm orchestration patterns for research, development, testing, and complex distributed workflows
version: 2.0.0
category: orchestration
tags: [swarm, distributed, parallel, research, testing, development, coordination]
author: Claude Flow Team
---
# Advanced Swarm Orchestration
Master advanced swarm patterns for distributed research, development, and testing workflows. This skill covers comprehensive orchestration strategies using both MCP tools and CLI commands.
## Quick Start
### Prerequisites
```bash
# Ensure Claude Flow is installed
npm install -g claude-flow@alpha
# Add MCP server (if using MCP tools)
claude mcp add claude-flow npx claude-flow@alpha mcp start
```
### Basic Pattern
```javascript
// 1. Initialize swarm topology
mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 6 })
// 2. Spawn specialized agents
mcp__claude-flow__agent_spawn({ type: "researcher", name: "Agent 1" })
// 3. Orchestrate tasks
mcp__claude-flow__task_orchestrate({ task: "...", strategy: "parallel" })
```
## Core Concepts
### Swarm Topologies
**Mesh Topology** - Peer-to-peer communication, best for research and analysis
- All agents communicate directly
- High flexibility and resilience
- Use for: Research, analysis, brainstorming
**Hierarchical Topology** - Coordinator with subordinates, best for development
- Clear command structure
- Sequential workflow support
- Use for: Development, structured workflows
**Star Topology** - Central coordinator, best for testing
- Centralized control and monitoring
- Parallel execution with coordination
- Use for: Testing, validation, quality assurance
**Ring Topology** - Sequential processing chain
- Step-by-step processing
- Pipeline workflows
- Use for: Multi-stage processing, data pipelines
### Agent Strategies
**Adaptive** - Dynamic adjustment based on task complexity
**Balanced** - Equal distribution of work across agents
**Specialized** - Task-specific agent assignment
**Parallel** - Maximum concurrent execution
## Pattern 1: Research Swarm
### Purpose
Deep research through parallel information gathering, analysis, and synthesis.
### Architecture
```javascript
// Initialize research swarm
mcp__claude-flow__swarm_init({
"topology": "mesh",
"maxAgents": 6,
"strategy": "adaptive"
})
// Spawn research team
const researchAgents = [
{
type: "researcher",
name: "Web Researcher",
capabilities: ["web-search", "content-extraction", "source-validation"]
},
{
type: "researcher",
name: "Academic Researcher",
capabilities: ["paper-analysis", "citation-tracking", "literature-review"]
},
{
type: "analyst",
name: "Data Analyst",
capabilities: ["data-processing", "statistical-analysis", "visualization"]
},
{
type: "analyst",
name: "Pattern Analyzer",
capabilities: ["trend-detection", "correlation-analysis", "outlier-detection"]
},
{
type: "documenter",
name: "Report Writer",
capabilities: ["synthesis", "technical-writing", "formatting"]
}
]
// Spawn all agents
researchAgents.forEach(agent => {
mcp__claude-flow__agent_spawn({
type: agent.type,
name: agent.name,
capabilities: agent.capabilities
})
})
```
### Research Workflow
#### Phase 1: Information Gathering
```javascript
// Parallel information collection
mcp__claude-flow__parallel_execute({
"tasks": [
{
"id": "web-search",
"command": "search recent publications and articles"
},
{
"id": "academic-search",
"command": "search academic databases and papers"
},
{
"id": "data-collection",
"command": "gather relevant datasets and statistics"
},
{
"id": "expert-search",
"command": "identify domain experts and thought leaders"
}
]
})
// Store research findings in memory
mcp__claude-flow__memory_usage({
"action": "store",
"key": "research-findings-" + Date.now(),
"value": JSON.stringify(findings),
"namespace": "research",
"ttl": 604800 // 7 days
})
```
#### Phase 2: Analysis and Validation
```javascript
// Pattern recognition in findings
mcp__claude-flow__pattern_recognize({
"data": researchData,
"patterns": ["trend", "correlation", "outlier", "emerging-pattern"]
})
// Cognitive analysis
mcp__claude-flow__cognitive_analyze({
"behavior": "research-synthesis"
})
// Quality assessment
mcp__claude-flow__quality_assess({
"target": "research-sources",
"criteria": ["credibility", "relevance", "recency", "authority"]
})
// Cross-reference validation
mcp__claude-flow__neural_patterns({
"action": "analyze",
"operation": "fact-checking",
"metadata": { "sources": sourcesArray }
})
```
#### Phase 3: Knowledge Management
```javascript
// Search existing knowledge base
mcp__claude-flow__memory_search({
"pattern": "topic X",
"namespace": "research",
"limit": 20
})
// Create knowledge graph connections
mcp__claude-flow__neural_patterns({
"action": "learn",
"operation": "knowledge-graph",
"metadata": {
"topic": "X",
"connections": relatedTopics,
"depth": 3
}
})
// Store connections for future use
mcp__claude-flow__memory_usage({
"action": "store",
"key": "knowledge-graph-X",
"value": JSON.stringify(knowledgeGraph),
"namespace": "research/graphs",
"ttl": 2592000 // 30 days
})
```
#### Phase 4: Report Generation
```javascript
// Orchestrate report generation
mcp__claude-flow__task_orchestrate({
"task": "generate comprehensive research report",
"strategy": "sequential",
"priority": "high",
"dependencies": ["gather", "analyze", "validate", "synthesize"]
})
// Monitor research progress
mcp__claude-flow__swarm_status({
"swarmId": "research-swarm"
})
// Generate final report
mcp__claude-flow__workflow_execute({
"workflowId": "research-report-generation",
"params": {
"findings": findings,
"format": "comprehensive",
"sections": ["executive-summary", "methodology", "findings", "analysis", "conclusions", "references"]
}
})
```
### CLI Fallback
```bash
# Quick research swarm
npx claude-flow swarm "research AI trends in 2025" \
--strategy research \
--mode distributed \
--max-agents 6 \
--parallel \
--output research-report.md
```
## Pattern 2: Development Swarm
### Purpose
Full-stack development through coordinated specialist agents.
### Architecture
```javascript
// Initialize development swarm with hierarchy
mcp__claude-flow__swarm_init({
"topology": "hierarchical",
"maxAgents": 8,
"strategy": "balanced"
})
// Spawn development team
const devTeam = [
{ type: "architect", name: "System Architect", role: "coordinator" },
{ type: "coder", name: "Backend Developer", capabilities: ["node", "api", "database"] },
{ type: "coder", name: "Frontend Developer", capabilities: ["react", "ui", "ux"] },
{ type: "coder", name: "Database Engineer", capabilities: ["sql", "nosql", "optimization"] },
{ type: "tester", name: "QA Engineer", capabilities: ["unit", "integration", "e2e"] },
{ type: "reviewer", name: "Code Reviewer", capabilities: ["security", "performance", "best-practices"] },
{ type: "documenter", name: "Technical Writer", capabilities: ["api-docs", "guides", "tutorials"] },
{ type: "monitor", name: "DevOps Engineer", capabilities: ["ci-cd", "deployment", "monitoring"] }
]
// Spawn all team members
devTeam.forEach(member => {
mcp__claude-flow__agent_spawn({
type: member.type,
name: member.name,
capabilities: member.capabilities,
swarmId: "dev-swarm"
})
})
```
### Development Workflow
#### Phase 1: Architecture and Design
```javascript
// System architecture design
mcp__claude-flow__task_orchestrate({
"task": "design system architecture for REST API",
"strategy": "sequential",
"priority": "critical",
"assignTo": "System Architect"
})
// Store architecture decisions
mcp__claude-flow__memory_usage({
"action": "store",
"key": "architecture-decisions",
"value": JSON.stringify(architectureDoc),
"namespace": "development/design"
})
```
#### Phase 2: Parallel Implementation
```javascript
// Parallel development tasks
mcp__claude-flow__parallel_execute({
"tasks": [
{
"id": "backend-api",
"command": "implement REST API endpoints",
"assignTo": "Backend Developer"
},
{
"id": "frontend-ui",
"command": "build user interface components",
"assignTo": "Frontend Developer"
},
{
"id": "database-schema",
"command": "design and implement database schema",
"assignTo": "Database Engineer"
},
{
"id": "api-documentation",
"command": "create API documentation",
"assignTo": "Technical Writer"
}
]
})
// Monitor development progress
mcp__claude-flow__swarm_monitor({
"swarmId": "dev-swarm",
"interval": 5000
})
```
#### Phase 3: Testing and Validation
```javascript
// Comprehensive testing
mcp__claude-flow__batch_process({
"items": [
{ type: "unit", target: "all-modules" },
{ type: "integration", target: "api-endpoints" },
{ type: "e2e", target: "user-flows" },
{ type: "performance", target: "critical-paths" }
],
"operation": "execute-tests"
})
// Quality assessment
mcp__claude-flow__quality_assess({
"target": "codebase",
"criteria": ["coverage", "complexity", "maintainability", "security"]
})
```
#### Phase 4: Review and Deployment
```javascript
// Code review workflow
mcp__claude-flow__workflow_execute({
"workflowId": "code-review-process",
"params": {
"reviewers": ["Code Reviewer"],
"criteria": ["security", "performance", "best-practices"]
}
})
// CI/CD pipeline
mcp__claude-flow__pipeline_create({
"config": {
"stages": ["build", "test", "security-scan", "deploy"],
"environment": "production"
}
})
```
### CLI Fallback
```bash
# Quick development swarm
npx claude-flow swarm "build REST API with authentication" \
--strategy development \
--mode hierarchical \
--monitor \
--output sqlite
```
## Pattern 3: Testing Swarm
### Purpose
Comprehensive quality assurance through distributed testing.
### Architecture
```javascript
// Initialize testing swarm with star topology
mcp__claude-flow__swarm_init({
"topology": "star",
"maxAgents": 7,
"strategy": "parallel"
})
// Spawn testing team
const testingTeam = [
{
type: "tester",
name: "Unit Test Coordinator",
capabilities: ["unit-testing", "mocking", "coverage", "tdd"]
},
{
type: "tester",
name: "Integration Tester",
capabilities: ["integration", "api-testing", "contract-testing"]
},
{
type: "tester",
name: "E2E Tester",
capabilities: ["e2e", "ui-testing", "user-flows", "selenium"]
},
{
type: "tester",
name: "Performance Tester",
capabilities: ["load-testing", "stress-testing", "benchmarking"]
},
{
type: "monitor",
name: "Security Tester",
capabilities: ["security-testing", "penetration-testing", "vulnerability-scanning"]
},
{
type: "analyst",
name: "Test Analyst",
capabilities: ["coverage-analysis", "test-optimization", "reporting"]
},
{
type: "documenter",
name: "Test Documenter",
capabilities: ["test-documentation", "test-plans", "reports"]
}
]
// Spawn all testers
testingTeam.forEach(tester => {
mcp__claude-flow__agent_spawn({
type: tester.type,
name: tester.name,
capabilities: tester.capabilities,
swarmId: "testing-swarm"
})
})
```
### Testing Workflow
#### Phase 1: Test Planning
```javascript
// Analyze test coverage requirements
mcp__claude-flow__quality_assess({
"target": "test-coverage",
"criteria": [
"line-coverage",
"branch-coverage",
"function-coverage",
"edge-cases"
]
})
// Identify test scenarios
mcp__claude-flow__pattern_recognize({
"data": testScenarios,
"patterns": [
"edge-case",
"boundary-condition",
"error-path",
"happy-path"
]
})
// Store test plan
mcp__claude-flow__memory_usage({
"action": "store",
"key": "test-plan-" + Date.now(),
"value": JSON.stringify(testPlan),
"namespace": "testing/plans"
})
```
#### Phase 2: Parallel Test Execution
```javascript
// Execute all test suites in parallel
mcp__claude-flow__parallel_execute({
"tasks": [
{
"id": "unit-tests",
"command": "npm run test:unit",
"assignTo": "Unit Test Coordinator"
},
{
"id": "integration-tests",
"command": "npm run test:integration",
"assignTo": "Integration Tester"
},
{
"id": "e2e-tests",
"command": "npm run test:e2e",
"assignTo": "E2E Tester"
},
{
"id": "performance-tests",
"command": "npm run test:performance",
"assignTo": "Performance Tester"
},
{
"id": "security-tests",
"command": "npm run test:security",
"assignTo": "Security Tester"
}
]
})
// Batch process test suites
mcp__claude-flow__batch_process({
"items": testSuites,
"operation": "execute-test-suite"
})
```
#### Phase 3: Performance and Security
```javascript
// Run performance benchmarks
mcp__claude-flow__benchmark_run({
"suite": "comprehensive-performance"
})
// Bottleneck analysis
mcp__claude-flow__bottleneck_analyze({
"component": "application",
"metrics": ["response-time", "throughput", "memory", "cpu"]
})
// Security scanning
mcp__claude-flow__security_scan({
"target": "application",
"depth": "comprehensive"
})
// Vulnerability analysis
mcp__claude-flow__error_analysis({
"logs": securityScanLogs
})
```
#### Phase 4: Monitoring and Reporting
```javascript
// Real-time test monitoring
mcp__claude-flow__swarm_monitor({
"swarmId": "testing-swarm",
"interval": 2000
})
// Generate comprehensive test report
mcp__claude-flow__performance_report({
"format": "detailed",
"timeframe": "current-run"
})
// Get test results
mcp__claude-flow__task_results({
"taskId": "test-execution-001"
})
// Trend analysis
mcp__claude-flow__trend_analysis({
"metric": "test-coverage",
"period": "30d"
})
```
### CLI Fallback
```bash
# Quick testing swarm
npx claude-flow swarm "test application comprehensively" \
--strategy testing \
--mode star \
--parallel \
--timeout 600
```
## Pattern 4: Analysis Swarm
### Purpose
Deep code and system analysis through specialized analyzers.
### Architecture
```javascript
// Initialize analysis swarm
mcp__claude-flow__swarm_init({
"topology": "mesh",
"maxAgents": 5,
"strategy": "adaptive"
})
// Spawn analysis specialists
const analysisTeam = [
{
type: "analyst",
name: "Code Analyzer",
capabilities: ["static-analysis", "complexity-analysis", "dead-code-detection"]
},
{
type: "analyst",
name: "Security Analyzer",
capabilities: ["security-scan", "vulnerability-detection", "dependency-audit"]
},
{
type: "analyst",
name: "Performance Analyzer",
capabilities: ["profiling", "bottleneck-detection", "optimization"]
},
{
type: "analyst",
name: "Architecture Analyzer",
capabilities: ["dependency-analysis", "coupling-detection", "modularity-assessment"]
},
{
type: "documenter",
name: "Analysis Reporter",
capabilities: ["reporting", "visualization", "recommendations"]
}
]
// Spawn all analysts
analysisTeam.forEach(analyst => {
mcp__claude-flow__agent_spawn({
type: analyst.type,
name: analyst.name,
capabilities: analyst.capabilities
})
})
```
### Analysis Workflow
```javascript
// Parallel analysis execution
mcp__claude-flow__parallel_execute({
"tasks": [
{ "id": "analyze-code", "command": "analyze codebase structure and quality" },
{ "id": "analyze-security", "command": "scan for security vulnerabilities" },
{ "id": "analyze-performance", "command": "identify performance bottlenecks" },
{ "id": "analyze-architecture", "command": "assess architectural patterns" }
]
})
// Generate comprehensive analysis report
mcp__claude-flow__performance_report({
"format": "detailed",
"timeframe": "current"
})
// Cost analysis
mcp__claude-flow__cost_analysis({
"timeframe": "30d"
})
```
## Advanced Techniques
### Error Handling and Fault Tolerance
```javascript
// Setup fault tolerance for all agents
mcp__claude-flow__daa_fault_tolerance({
"agentId": "all",
"strategy": "auto-recovery"
})
// Error handling pattern
try {
await mcp__claude-flow__task_orchestrate({
"task": "complex operation",
"strategy": "parallel",
"priority": "high"
})
} catch (error) {
// Check swarm health
const status = await mcp__claude-flow__swarm_status({})
// Analyze error patterns
await mcp__claude-flow__error_analysis({
"logs": [error.message]
})
// Auto-recovery attempt
if (status.healthy) {
await mcp__claude-flow__task_orchestrate({
"task": "retry failed operation",
"strategy": "sequential"
})
}
}
```
### Memory and State Management
```javascript
// Cross-session persistence
mcp__claude-flow__memory_persist({
"sessionId": "swarm-session-001"
})
// Namespace management for different swarms
mcp__claude-flow__memory_namespace({
"namespace": "research-swarm",
"action": "create"
})
// Create state snapshot
mcp__claude-flow__state_snapshot({
"name": "development-checkpoint-1"
})
// Restore from snapshot if needed
mcp__claude-flow__context_restore({
"snapshotId": "development-checkpoint-1"
})
// Backup memory stores
mcp__claude-flow__memory_backup({
"path": "/workspaces/claude-code-flow/backups/swarm-memory.json"
})
```
### Neural Pattern Learning
```javascript
// Train neural patterns from successful workflows
mcp__claude-flow__neural_train({
"pattern_type": "coordination",
"training_data": JSON.stringify(successfulWorkflows),
"epochs": 50
})
// Adaptive learning from experience
mcp__claude-flow__learning_adapt({
"experience": {
"workflow": "research-to-report",
"success": true,
"duration": 3600,
"quality": 0.95
}
})
// Pattern recognition for optimization
mcp__claude-flow__pattern_recognize({
"data": workflowMetrics,
"patterns": ["bottleneck", "optimization-opportunity", "efficiency-gain"]
})
```
### Workflow Automation
```javascript
// Create reusable workflow
mcp__claude-flow__workflow_create({
"name": "full-stack-development",
"steps": [
{ "phase": "design", "agents": ["architect"] },
{ "phase": "implement", "agents": ["backend-dev", "frontend-dev"], "parallel": true },
{ "phase": "test", "agents": ["tester", "security-tester"], "parallel": true },
{ "phase": "review", "agents": ["reviewer"] },
{ "phase": "deploy", "agents": ["devops"] }
],
"triggers": ["on-commit", "scheduled-daily"]
})
// Setup automation rules
mcp__claude-flow__automation_setup({
"rules": [
{
"trigger": "file-changed",
"pattern": "*.js",
"action": "run-tests"
},
{
"trigger": "PR-created",
"action": "code-review-swarm"
}
]
})
// Event-driven triggers
mcp__claude-flow__trigger_setup({
"events": ["code-commit", "PR-merge", "deployment"],
"actions": ["test", "analyze", "document"]
})
```
### Performance Optimization
```javascript
// Topology optimization
mcp__claude-flow__topology_optimize({
"swarmId": "current-swarm"
})
// Load balancing
mcp__claude-flow__load_balance({
"swarmId": "development-swarm",
"tasks": taskQueue
})
// Agent coordination sync
mcp__claude-flow__coordination_sync({
"swarmId": "development-swarm"
})
// Auto-scaling
mcp__claude-flow__swarm_scale({
"swarmId": "development-swarm",
"targetSize": 12
})
```
### Monitoring and Metrics
```javascript
// Real-time swarm monitoring
mcp__claude-flow__swarm_monitor({
"swarmId": "active-swarm",
"interval": 3000
})
// Collect comprehensive metrics
mcp__claude-flow__metrics_collect({
"components": ["agents", "tasks", "memory", "performance"]
})
// Health monitoring
mcp__claude-flow__health_check({
"components": ["swarm", "agents", "neural", "memory"]
})
// Usage statistics
mcp__claude-flow__usage_stats({
"component": "swarm-orchestration"
})
// Trend analysis
mcp__claude-flow__trend_analysis({
"metric": "agent-performance",
"period": "7d"
})
```
## Best Practices
### 1. Choosing the Right Topology
- **Mesh**: Research, brainstorming, collaborative analysis
- **Hierarchical**: Structured development, sequential workflows
- **Star**: Testing, validation, centralized coordination
- **Ring**: Pipeline processing, staged workflows
### 2. Agent Specialization
- Assign specific capabilities to each agent
- Avoid overlapping responsibilities
- Use coordination agents for complex workflows
- Leverage memory for agent communication
### 3. Parallel Execution
- Identify independent tasks for parallelization
- Use sequential execution for dependent tasks
- Monitor resource usage during parallel execution
- Implement proper error handling
### 4. Memory Management
- Use namespaces to organize memory
- Set appropriate TTL values
- Create regular backups
- Implement state snapshots for checkpoints
### 5. Monitoring and Optimization
- Monitor swarm health regularly
- Collect and analyze metrics
- Optimize topology based on performance
- Use neural patterns to learn from success
### 6. Error Recovery
- Implement fault tolerance strategies
- Use auto-recovery mechanisms
- Analyze error patterns
- Create fallback workflows
## Real-World Examples
### Example 1: AI Research Project
```javascript
// Research AI trends, analyze findings, generate report
mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 6 })
// Spawn: 2 researchers, 2 analysts, 1 synthesizer, 1 documenter
// Parallel gather → Analyze patterns → Synthesize → Report
```
### Example 2: Full-Stack Application
```javascript
// Build complete web application with testing
mcp__claude-flow__swarm_init({ topology: "hierarchical", maxAgents: 8 })
// Spawn: 1 architect, 2 devs, 1 db engineer, 2 testers, 1 reviewer, 1 devops
// Design → Parallel implement → Test → Review → Deploy
```
### Example 3: Security Audit
```javascript
// Comprehensive security analysis
mcp__claude-flow__swarm_init({ topology: "star", maxAgents: 5 })
// Spawn: 1 coordinator, 1 code analyzer, 1 security scanner, 1 penetration tester, 1 reporter
// Parallel scan → Vulnerability analysis → Penetration test → Report
```
### Example 4: Performance Optimization
```javascript
// Identify and fix performance bottlenecks
mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 4 })
// Spawn: 1 profiler, 1 bottleneck analyzer, 1 optimizer, 1 tester
// Profile → Identify bottlenecks → Optimize → Validate
```
## Troubleshooting
### Common Issues
**Issue**: Swarm agents not coordinating properly
**Solution**: Check topology selection, verify memory usage, enable monitoring
**Issue**: Parallel execution failing
**Solution**: Verify task dependencies, check resource limits, implement error handling
**Issue**: Memory persistence not working
**Solution**: Verify namespaces, check TTL settings, ensure backup configuration
**Issue**: Performance degradation
**Solution**: Optimize topology, reduce agent count, analyze bottlenecks
## Related Skills
- `sparc-methodology` - Systematic development workflow
- `github-integration` - Repository management and automation
- `neural-patterns` - AI-powered coordination optimization
- `memory-management` - Cross-session state persistence
## References
- [Claude Flow Documentation](https://github.com/ruvnet/claude-flow)
- [Swarm Orchestration Guide](https://github.com/ruvnet/claude-flow/wiki/swarm)
- [MCP Tools Reference](https://github.com/ruvnet/claude-flow/wiki/mcp)
- [Performance Optimization](https://github.com/ruvnet/claude-flow/wiki/performance)
---
**Version**: 2.0.0
**Last Updated**: 2025-10-19
**Skill Level**: Advanced
**Estimated Learning Time**: 2-3 hours

179
vendor/ruvector/.claude/skills/swarm-orchestration/SKILL.md vendored Normal file
View File

@@ -0,0 +1,179 @@
---
name: "Swarm Orchestration"
description: "Orchestrate multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination. Use when scaling beyond single agents, implementing complex workflows, or building distributed AI systems."
---
# Swarm Orchestration
## What This Skill Does
Orchestrates multi-agent swarms using agentic-flow's advanced coordination system. Supports mesh, hierarchical, and adaptive topologies with automatic task distribution, load balancing, and fault tolerance.
## Prerequisites
- agentic-flow v1.5.11+
- Node.js 18+
- Understanding of distributed systems (helpful)
## Quick Start
```bash
# Initialize swarm
npx agentic-flow hooks swarm-init --topology mesh --max-agents 5
# Spawn agents
npx agentic-flow hooks agent-spawn --type coder
npx agentic-flow hooks agent-spawn --type tester
npx agentic-flow hooks agent-spawn --type reviewer
# Orchestrate task
npx agentic-flow hooks task-orchestrate \
--task "Build REST API with tests" \
--mode parallel
```
## Topology Patterns
### 1. Mesh (Peer-to-Peer)
```typescript
// Equal peers, distributed decision-making
await swarm.init({
topology: 'mesh',
agents: ['coder', 'tester', 'reviewer'],
communication: 'broadcast'
});
```
### 2. Hierarchical (Queen-Worker)
```typescript
// Centralized coordination, specialized workers
await swarm.init({
topology: 'hierarchical',
queen: 'architect',
workers: ['backend-dev', 'frontend-dev', 'db-designer']
});
```
### 3. Adaptive (Dynamic)
```typescript
// Automatically switches topology based on task
await swarm.init({
topology: 'adaptive',
optimization: 'task-complexity'
});
```
## Task Orchestration
### Parallel Execution
```typescript
// Execute tasks concurrently
const results = await swarm.execute({
tasks: [
{ agent: 'coder', task: 'Implement API endpoints' },
{ agent: 'frontend', task: 'Build UI components' },
{ agent: 'tester', task: 'Write test suite' }
],
mode: 'parallel',
timeout: 300000 // 5 minutes
});
```
### Pipeline Execution
```typescript
// Sequential pipeline with dependencies
await swarm.pipeline([
{ stage: 'design', agent: 'architect' },
{ stage: 'implement', agent: 'coder', after: 'design' },
{ stage: 'test', agent: 'tester', after: 'implement' },
{ stage: 'review', agent: 'reviewer', after: 'test' }
]);
```
### Adaptive Execution
```typescript
// Let swarm decide execution strategy
await swarm.autoOrchestrate({
goal: 'Build production-ready API',
constraints: {
maxTime: 3600,
maxAgents: 8,
quality: 'high'
}
});
```
## Memory Coordination
```typescript
// Share state across swarm
await swarm.memory.store('api-schema', {
endpoints: [...],
models: [...]
});
// Agents read shared memory
const schema = await swarm.memory.retrieve('api-schema');
```
## Advanced Features
### Load Balancing
```typescript
// Automatic work distribution
await swarm.enableLoadBalancing({
strategy: 'dynamic',
metrics: ['cpu', 'memory', 'task-queue']
});
```
### Fault Tolerance
```typescript
// Handle agent failures
await swarm.setResiliency({
retry: { maxAttempts: 3, backoff: 'exponential' },
fallback: 'reassign-task'
});
```
### Performance Monitoring
```typescript
// Track swarm metrics
const metrics = await swarm.getMetrics();
// { throughput, latency, success_rate, agent_utilization }
```
## Integration with Hooks
```bash
# Pre-task coordination
npx agentic-flow hooks pre-task --description "Build API"
# Post-task synchronization
npx agentic-flow hooks post-task --task-id "task-123"
# Session restore
npx agentic-flow hooks session-restore --session-id "swarm-001"
```
## Best Practices
1. **Start small**: Begin with 2-3 agents, scale up
2. **Use memory**: Share context through swarm memory
3. **Monitor metrics**: Track performance and bottlenecks
4. **Enable hooks**: Automatic coordination and sync
5. **Set timeouts**: Prevent hung tasks
## Troubleshooting
### Issue: Agents not coordinating
**Solution**: Verify memory access and enable hooks
### Issue: Poor performance
**Solution**: Check topology (use adaptive) and enable load balancing
## Learn More
- Swarm Guide: docs/swarm/orchestration.md
- Topology Patterns: docs/swarm/topologies.md
- Hooks Integration: docs/hooks/coordination.md

872
vendor/ruvector/.claude/skills/v3-cli-modernization/SKILL.md vendored Normal file
View File

@@ -0,0 +1,872 @@
---
name: "V3 CLI Modernization"
description: "CLI modernization and hooks system enhancement for claude-flow v3. Implements interactive prompts, command decomposition, enhanced hooks integration, and intelligent workflow automation."
---
# V3 CLI Modernization
## What This Skill Does
Modernizes claude-flow v3 CLI with interactive prompts, intelligent command decomposition, enhanced hooks integration, performance optimization, and comprehensive workflow automation capabilities.
## Quick Start
```bash
# Initialize CLI modernization analysis
Task("CLI architecture", "Analyze current CLI structure and identify optimization opportunities", "cli-hooks-developer")
# Modernization implementation (parallel)
Task("Command decomposition", "Break down large CLI files into focused modules", "cli-hooks-developer")
Task("Interactive prompts", "Implement intelligent interactive CLI experience", "cli-hooks-developer")
Task("Hooks enhancement", "Deep integrate hooks with CLI lifecycle", "cli-hooks-developer")
```
## CLI Architecture Modernization
### Current State Analysis
```
Current CLI Issues:
├── index.ts: 108KB monolithic file
├── enterprise.ts: 68KB feature module
├── Limited interactivity: Basic command parsing
├── Hooks integration: Basic pre/post execution
└── No intelligent workflows: Manual command chaining
Target Architecture:
├── Modular Commands: <500 lines per command
├── Interactive Prompts: Smart context-aware UX
├── Enhanced Hooks: Deep lifecycle integration
├── Workflow Automation: Intelligent command orchestration
└── Performance: <200ms command response time
```
### Modular Command Architecture
```typescript
// src/cli/core/command-registry.ts
interface CommandModule {
name: string;
description: string;
category: CommandCategory;
handler: CommandHandler;
middleware: MiddlewareStack;
permissions: Permission[];
examples: CommandExample[];
}
export class ModularCommandRegistry {
private commands = new Map<string, CommandModule>();
private categories = new Map<CommandCategory, CommandModule[]>();
private aliases = new Map<string, string>();
registerCommand(command: CommandModule): void {
this.commands.set(command.name, command);
// Register in category index
if (!this.categories.has(command.category)) {
this.categories.set(command.category, []);
}
this.categories.get(command.category)!.push(command);
}
async executeCommand(name: string, args: string[]): Promise<CommandResult> {
const command = this.resolveCommand(name);
if (!command) {
throw new CommandNotFoundError(name, this.getSuggestions(name));
}
// Execute middleware stack
const context = await this.buildExecutionContext(command, args);
const result = await command.middleware.execute(context);
return result;
}
private resolveCommand(name: string): CommandModule | undefined {
// Try exact match first
if (this.commands.has(name)) {
return this.commands.get(name);
}
// Try alias
const aliasTarget = this.aliases.get(name);
if (aliasTarget) {
return this.commands.get(aliasTarget);
}
// Try fuzzy match
return this.findFuzzyMatch(name);
}
}
```
## Command Decomposition Strategy
### Swarm Commands Module
```typescript
// src/cli/commands/swarm/swarm.command.ts
@Command({
name: 'swarm',
description: 'Swarm coordination and management',
category: 'orchestration'
})
export class SwarmCommand {
constructor(
private swarmCoordinator: UnifiedSwarmCoordinator,
private promptService: InteractivePromptService
) {}
@SubCommand('init')
@Option('--topology', 'Swarm topology (mesh|hierarchical|adaptive)', 'hierarchical')
@Option('--agents', 'Number of agents to spawn', 5)
@Option('--interactive', 'Interactive agent configuration', false)
async init(
@Arg('projectName') projectName: string,
options: SwarmInitOptions
): Promise<CommandResult> {
if (options.interactive) {
return this.interactiveSwarmInit(projectName);
}
return this.quickSwarmInit(projectName, options);
}
private async interactiveSwarmInit(projectName: string): Promise<CommandResult> {
console.log(`🚀 Initializing Swarm for ${projectName}`);
// Interactive topology selection
const topology = await this.promptService.select({
message: 'Select swarm topology:',
choices: [
{ name: 'Hierarchical (Queen-led coordination)', value: 'hierarchical' },
{ name: 'Mesh (Peer-to-peer collaboration)', value: 'mesh' },
{ name: 'Adaptive (Dynamic topology switching)', value: 'adaptive' }
]
});
// Agent configuration
const agents = await this.promptAgentConfiguration();
// Initialize with configuration
const swarm = await this.swarmCoordinator.initialize({
name: projectName,
topology,
agents,
hooks: {
onAgentSpawn: this.handleAgentSpawn.bind(this),
onTaskComplete: this.handleTaskComplete.bind(this),
onSwarmComplete: this.handleSwarmComplete.bind(this)
}
});
return CommandResult.success({
message: `✅ Swarm ${projectName} initialized with ${agents.length} agents`,
data: { swarmId: swarm.id, topology, agentCount: agents.length }
});
}
@SubCommand('status')
async status(): Promise<CommandResult> {
const swarms = await this.swarmCoordinator.listActiveSwarms();
if (swarms.length === 0) {
return CommandResult.info('No active swarms found');
}
// Interactive swarm selection if multiple
const selectedSwarm = swarms.length === 1
? swarms[0]
: await this.promptService.select({
message: 'Select swarm to inspect:',
choices: swarms.map(s => ({
name: `${s.name} (${s.agents.length} agents, ${s.topology})`,
value: s
}))
});
return this.displaySwarmStatus(selectedSwarm);
}
}
```
### Learning Commands Module
```typescript
// src/cli/commands/learning/learning.command.ts
@Command({
name: 'learning',
description: 'Learning system management and optimization',
category: 'intelligence'
})
export class LearningCommand {
constructor(
private learningService: IntegratedLearningService,
private promptService: InteractivePromptService
) {}
@SubCommand('start')
@Option('--algorithm', 'RL algorithm to use', 'auto')
@Option('--tier', 'Learning tier (basic|standard|advanced)', 'standard')
async start(options: LearningStartOptions): Promise<CommandResult> {
// Auto-detect optimal algorithm if not specified
if (options.algorithm === 'auto') {
const taskContext = await this.analyzeCurrentContext();
options.algorithm = this.learningService.selectOptimalAlgorithm(taskContext);
console.log(`🧠 Auto-selected ${options.algorithm} algorithm based on context`);
}
const session = await this.learningService.startSession({
algorithm: options.algorithm,
tier: options.tier,
userId: await this.getCurrentUser()
});
return CommandResult.success({
message: `🚀 Learning session started with ${options.algorithm}`,
data: { sessionId: session.id, algorithm: options.algorithm, tier: options.tier }
});
}
@SubCommand('feedback')
@Arg('reward', 'Reward value (0-1)', 'number')
async feedback(
@Arg('reward') reward: number,
@Option('--context', 'Additional context for learning')
context?: string
): Promise<CommandResult> {
const activeSession = await this.learningService.getActiveSession();
if (!activeSession) {
return CommandResult.error('No active learning session found. Start one with `learning start`');
}
await this.learningService.submitFeedback({
sessionId: activeSession.id,
reward,
context,
timestamp: new Date()
});
return CommandResult.success({
message: `📊 Feedback recorded (reward: ${reward})`,
data: { reward, sessionId: activeSession.id }
});
}
@SubCommand('metrics')
async metrics(): Promise<CommandResult> {
const metrics = await this.learningService.getMetrics();
// Interactive metrics display
await this.displayInteractiveMetrics(metrics);
return CommandResult.success('Metrics displayed');
}
}
```
## Interactive Prompt System
### Advanced Prompt Service
```typescript
// src/cli/services/interactive-prompt.service.ts
interface PromptOptions {
message: string;
type: 'select' | 'multiselect' | 'input' | 'confirm' | 'progress';
choices?: PromptChoice[];
default?: any;
validate?: (input: any) => boolean | string;
transform?: (input: any) => any;
}
export class InteractivePromptService {
private inquirer: any; // Dynamic import for tree-shaking
async select<T>(options: SelectPromptOptions<T>): Promise<T> {
const { default: inquirer } = await import('inquirer');
const result = await inquirer.prompt([{
type: 'list',
name: 'selection',
message: options.message,
choices: options.choices,
default: options.default
}]);
return result.selection;
}
async multiSelect<T>(options: MultiSelectPromptOptions<T>): Promise<T[]> {
const { default: inquirer } = await import('inquirer');
const result = await inquirer.prompt([{
type: 'checkbox',
name: 'selections',
message: options.message,
choices: options.choices,
validate: (input: T[]) => {
if (options.minSelections && input.length < options.minSelections) {
return `Please select at least ${options.minSelections} options`;
}
if (options.maxSelections && input.length > options.maxSelections) {
return `Please select at most ${options.maxSelections} options`;
}
return true;
}
}]);
return result.selections;
}
async input(options: InputPromptOptions): Promise<string> {
const { default: inquirer } = await import('inquirer');
const result = await inquirer.prompt([{
type: 'input',
name: 'input',
message: options.message,
default: options.default,
validate: options.validate,
transformer: options.transform
}]);
return result.input;
}
async progressTask<T>(
task: ProgressTask<T>,
options: ProgressOptions
): Promise<T> {
const { default: cliProgress } = await import('cli-progress');
const progressBar = new cliProgress.SingleBar({
format: `${options.title} |{bar}| {percentage}% | {status}`,
barCompleteChar: '█',
barIncompleteChar: '░',
hideCursor: true
});
progressBar.start(100, 0, { status: 'Starting...' });
try {
const result = await task({
updateProgress: (percent: number, status?: string) => {
progressBar.update(percent, { status: status || 'Processing...' });
}
});
progressBar.update(100, { status: 'Complete!' });
progressBar.stop();
return result;
} catch (error) {
progressBar.stop();
throw error;
}
}
async confirmWithDetails(
message: string,
details: ConfirmationDetails
): Promise<boolean> {
console.log('\n' + chalk.bold(message));
console.log(chalk.gray('Details:'));
for (const [key, value] of Object.entries(details)) {
console.log(chalk.gray(` ${key}: ${value}`));
}
return this.confirm('\nProceed?');
}
}
```
## Enhanced Hooks Integration
### Deep CLI Hooks Integration
```typescript
// src/cli/hooks/cli-hooks-manager.ts
interface CLIHookEvent {
type: 'command_start' | 'command_end' | 'command_error' | 'agent_spawn' | 'task_complete';
command: string;
args: string[];
context: ExecutionContext;
timestamp: Date;
}
export class CLIHooksManager {
private hooks: Map<string, HookHandler[]> = new Map();
private learningIntegration: LearningHooksIntegration;
constructor() {
this.learningIntegration = new LearningHooksIntegration();
this.setupDefaultHooks();
}
private setupDefaultHooks(): void {
// Learning integration hooks
this.registerHook('command_start', async (event: CLIHookEvent) => {
await this.learningIntegration.recordCommandStart(event);
});
this.registerHook('command_end', async (event: CLIHookEvent) => {
await this.learningIntegration.recordCommandSuccess(event);
});
this.registerHook('command_error', async (event: CLIHookEvent) => {
await this.learningIntegration.recordCommandError(event);
});
// Intelligent suggestions
this.registerHook('command_start', async (event: CLIHookEvent) => {
const suggestions = await this.generateIntelligentSuggestions(event);
if (suggestions.length > 0) {
this.displaySuggestions(suggestions);
}
});
// Performance monitoring
this.registerHook('command_end', async (event: CLIHookEvent) => {
await this.recordPerformanceMetrics(event);
});
}
async executeHooks(type: string, event: CLIHookEvent): Promise<void> {
const handlers = this.hooks.get(type) || [];
await Promise.all(handlers.map(handler =>
this.executeHookSafely(handler, event)
));
}
private async generateIntelligentSuggestions(event: CLIHookEvent): Promise<Suggestion[]> {
const context = await this.learningIntegration.getExecutionContext(event);
const patterns = await this.learningIntegration.findSimilarPatterns(context);
return patterns.map(pattern => ({
type: 'optimization',
message: `Based on similar executions, consider: ${pattern.suggestion}`,
confidence: pattern.confidence
}));
}
}
```
### Learning Integration
```typescript
// src/cli/hooks/learning-hooks-integration.ts
export class LearningHooksIntegration {
constructor(
private agenticFlowHooks: AgenticFlowHooksClient,
private agentDBLearning: AgentDBLearningClient
) {}
async recordCommandStart(event: CLIHookEvent): Promise<void> {
// Start trajectory tracking
await this.agenticFlowHooks.trajectoryStart({
sessionId: event.context.sessionId,
command: event.command,
args: event.args,
context: event.context
});
// Record experience in AgentDB
await this.agentDBLearning.recordExperience({
type: 'command_execution',
state: this.encodeCommandState(event),
action: event.command,
timestamp: event.timestamp
});
}
async recordCommandSuccess(event: CLIHookEvent): Promise<void> {
const executionTime = Date.now() - event.timestamp.getTime();
const reward = this.calculateReward(event, executionTime, true);
// Complete trajectory
await this.agenticFlowHooks.trajectoryEnd({
sessionId: event.context.sessionId,
success: true,
reward,
verdict: 'positive'
});
// Submit feedback to learning system
await this.agentDBLearning.submitFeedback({
sessionId: event.context.learningSessionId,
reward,
success: true,
latencyMs: executionTime
});
// Store successful pattern
if (reward > 0.8) {
await this.agenticFlowHooks.storePattern({
pattern: event.command,
solution: event.context.result,
confidence: reward
});
}
}
async recordCommandError(event: CLIHookEvent): Promise<void> {
const executionTime = Date.now() - event.timestamp.getTime();
const reward = this.calculateReward(event, executionTime, false);
// Complete trajectory with error
await this.agenticFlowHooks.trajectoryEnd({
sessionId: event.context.sessionId,
success: false,
reward,
verdict: 'negative',
error: event.context.error
});
// Learn from failure
await this.agentDBLearning.submitFeedback({
sessionId: event.context.learningSessionId,
reward,
success: false,
latencyMs: executionTime,
error: event.context.error
});
}
private calculateReward(event: CLIHookEvent, executionTime: number, success: boolean): number {
if (!success) return 0;
// Base reward for success
let reward = 0.5;
// Performance bonus (faster execution)
const expectedTime = this.getExpectedExecutionTime(event.command);
if (executionTime < expectedTime) {
reward += 0.3 * (1 - executionTime / expectedTime);
}
// Complexity bonus
const complexity = this.calculateCommandComplexity(event);
reward += complexity * 0.2;
return Math.min(reward, 1.0);
}
}
```
## Intelligent Workflow Automation
### Workflow Orchestrator
```typescript
// src/cli/workflows/workflow-orchestrator.ts
interface WorkflowStep {
id: string;
command: string;
args: string[];
dependsOn: string[];
condition?: WorkflowCondition;
retryPolicy?: RetryPolicy;
}
export class WorkflowOrchestrator {
constructor(
private commandRegistry: ModularCommandRegistry,
private promptService: InteractivePromptService
) {}
async executeWorkflow(workflow: Workflow): Promise<WorkflowResult> {
const context = new WorkflowExecutionContext(workflow);
// Display workflow overview
await this.displayWorkflowOverview(workflow);
const confirmed = await this.promptService.confirm(
'Execute this workflow?'
);
if (!confirmed) {
return WorkflowResult.cancelled();
}
// Execute steps
return this.promptService.progressTask(
async ({ updateProgress }) => {
const steps = this.sortStepsByDependencies(workflow.steps);
for (let i = 0; i < steps.length; i++) {
const step = steps[i];
updateProgress((i / steps.length) * 100, `Executing ${step.command}`);
await this.executeStep(step, context);
}
return WorkflowResult.success(context.getResults());
},
{ title: `Workflow: ${workflow.name}` }
);
}
async generateWorkflowFromIntent(intent: string): Promise<Workflow> {
// Use learning system to generate workflow
const patterns = await this.findWorkflowPatterns(intent);
if (patterns.length === 0) {
throw new Error('Could not generate workflow for intent');
}
// Select best pattern or let user choose
const selectedPattern = patterns.length === 1
? patterns[0]
: await this.promptService.select({
message: 'Select workflow template:',
choices: patterns.map(p => ({
name: `${p.name} (${p.confidence}% match)`,
value: p
}))
});
return this.customizeWorkflow(selectedPattern, intent);
}
private async executeStep(step: WorkflowStep, context: WorkflowExecutionContext): Promise<void> {
// Check conditions
if (step.condition && !this.evaluateCondition(step.condition, context)) {
context.skipStep(step.id, 'Condition not met');
return;
}
// Check dependencies
const missingDeps = step.dependsOn.filter(dep => !context.isStepCompleted(dep));
if (missingDeps.length > 0) {
throw new WorkflowError(`Step ${step.id} has unmet dependencies: ${missingDeps.join(', ')}`);
}
// Execute with retry policy
const retryPolicy = step.retryPolicy || { maxAttempts: 1 };
let lastError: Error | null = null;
for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
try {
const result = await this.commandRegistry.executeCommand(step.command, step.args);
context.completeStep(step.id, result);
return;
} catch (error) {
lastError = error as Error;
if (attempt < retryPolicy.maxAttempts) {
await this.delay(retryPolicy.backoffMs || 1000);
}
}
}
throw new WorkflowError(`Step ${step.id} failed after ${retryPolicy.maxAttempts} attempts: ${lastError?.message}`);
}
}
```
## Performance Optimization
### Command Performance Monitoring
```typescript
// src/cli/performance/command-performance.ts
export class CommandPerformanceMonitor {
private metrics = new Map<string, CommandMetrics>();
async measureCommand<T>(
commandName: string,
executor: () => Promise<T>
): Promise<T> {
const start = performance.now();
const memBefore = process.memoryUsage();
try {
const result = await executor();
const end = performance.now();
const memAfter = process.memoryUsage();
this.recordMetrics(commandName, {
executionTime: end - start,
memoryDelta: memAfter.heapUsed - memBefore.heapUsed,
success: true
});
return result;
} catch (error) {
const end = performance.now();
this.recordMetrics(commandName, {
executionTime: end - start,
memoryDelta: 0,
success: false,
error: error as Error
});
throw error;
}
}
private recordMetrics(command: string, measurement: PerformanceMeasurement): void {
if (!this.metrics.has(command)) {
this.metrics.set(command, new CommandMetrics(command));
}
const metrics = this.metrics.get(command)!;
metrics.addMeasurement(measurement);
// Alert if performance degrades
if (metrics.getP95ExecutionTime() > 5000) { // 5 seconds
console.warn(`⚠️ Command '${command}' is performing slowly (P95: ${metrics.getP95ExecutionTime()}ms)`);
}
}
getCommandReport(command: string): PerformanceReport {
const metrics = this.metrics.get(command);
if (!metrics) {
throw new Error(`No metrics found for command: ${command}`);
}
return {
command,
totalExecutions: metrics.getTotalExecutions(),
successRate: metrics.getSuccessRate(),
avgExecutionTime: metrics.getAverageExecutionTime(),
p95ExecutionTime: metrics.getP95ExecutionTime(),
avgMemoryUsage: metrics.getAverageMemoryUsage(),
recommendations: this.generateRecommendations(metrics)
};
}
}
```
## Smart Auto-completion
### Intelligent Command Completion
```typescript
// src/cli/completion/intelligent-completion.ts
export class IntelligentCompletion {
constructor(
private learningService: LearningService,
private commandRegistry: ModularCommandRegistry
) {}
async generateCompletions(
partial: string,
context: CompletionContext
): Promise<Completion[]> {
const completions: Completion[] = [];
// 1. Exact command matches
const exactMatches = this.commandRegistry.findCommandsByPrefix(partial);
completions.push(...exactMatches.map(cmd => ({
value: cmd.name,
description: cmd.description,
type: 'command',
confidence: 1.0
})));
// 2. Learning-based suggestions
const learnedSuggestions = await this.learningService.suggestCommands(
partial,
context
);
completions.push(...learnedSuggestions);
// 3. Context-aware suggestions
const contextualSuggestions = await this.generateContextualSuggestions(
partial,
context
);
completions.push(...contextualSuggestions);
// Sort by confidence and relevance
return completions
.sort((a, b) => b.confidence - a.confidence)
.slice(0, 10); // Top 10 suggestions
}
private async generateContextualSuggestions(
partial: string,
context: CompletionContext
): Promise<Completion[]> {
const suggestions: Completion[] = [];
// If in git repository, suggest git-related commands
if (context.isGitRepository) {
if (partial.startsWith('git')) {
suggestions.push({
value: 'git commit',
description: 'Create git commit with generated message',
type: 'workflow',
confidence: 0.8
});
}
}
// If package.json exists, suggest npm commands
if (context.hasPackageJson) {
if (partial.startsWith('npm') || partial.startsWith('swarm')) {
suggestions.push({
value: 'swarm init',
description: 'Initialize swarm for this project',
type: 'workflow',
confidence: 0.9
});
}
}
return suggestions;
}
}
```
## Success Metrics
### CLI Performance Targets
- [ ] **Command Response**: <200ms average command execution time
- [ ] **File Decomposition**: index.ts (108KB) → <10KB per command module
- [ ] **Interactive UX**: Smart prompts with context awareness
- [ ] **Hook Integration**: Deep lifecycle integration with learning
- [ ] **Workflow Automation**: Intelligent multi-step command orchestration
- [ ] **Auto-completion**: >90% accuracy for command suggestions
### User Experience Improvements
```typescript
const cliImprovements = {
before: {
commandResponse: '~500ms',
interactivity: 'Basic command parsing',
workflows: 'Manual command chaining',
suggestions: 'Static help text'
},
after: {
commandResponse: '<200ms with caching',
interactivity: 'Smart context-aware prompts',
workflows: 'Automated multi-step execution',
suggestions: 'Learning-based intelligent completion'
}
};
```
## Related V3 Skills
- `v3-core-implementation` - Core domain integration
- `v3-memory-unification` - Memory-backed command caching
- `v3-swarm-coordination` - CLI swarm management integration
- `v3-performance-optimization` - CLI performance monitoring
## Usage Examples
### Complete CLI Modernization
```bash
# Full CLI modernization implementation
Task("CLI modernization implementation",
"Implement modular commands, interactive prompts, and intelligent workflows",
"cli-hooks-developer")
```
### Interactive Command Enhancement
```bash
# Enhanced interactive commands
claude-flow swarm init --interactive
claude-flow learning start --guided
claude-flow workflow create --from-intent "setup new project"
```

797
vendor/ruvector/.claude/skills/v3-core-implementation/SKILL.md vendored Normal file
View File

@@ -0,0 +1,797 @@
---
name: "V3 Core Implementation"
description: "Core module implementation for claude-flow v3. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with comprehensive testing."
---
# V3 Core Implementation
## What This Skill Does
Implements the core TypeScript modules for claude-flow v3 following Domain-Driven Design principles, clean architecture patterns, and modern TypeScript best practices with comprehensive test coverage.
## Quick Start
```bash
# Initialize core implementation
Task("Core foundation", "Set up DDD domain structure and base classes", "core-implementer")
# Domain implementation (parallel)
Task("Task domain", "Implement task management domain with entities and services", "core-implementer")
Task("Session domain", "Implement session management domain", "core-implementer")
Task("Health domain", "Implement health monitoring domain", "core-implementer")
```
## Core Implementation Architecture
### Domain Structure
```
src/
├── core/
│ ├── kernel/ # Microkernel pattern
│ │ ├── claude-flow-kernel.ts
│ │ ├── domain-registry.ts
│ │ └── plugin-loader.ts
│ │
│ ├── domains/ # DDD Bounded Contexts
│ │ ├── task-management/
│ │ │ ├── entities/
│ │ │ ├── value-objects/
│ │ │ ├── services/
│ │ │ ├── repositories/
│ │ │ └── events/
│ │ │
│ │ ├── session-management/
│ │ ├── health-monitoring/
│ │ ├── lifecycle-management/
│ │ └── event-coordination/
│ │
│ ├── shared/ # Shared kernel
│ │ ├── domain/
│ │ │ ├── entity.ts
│ │ │ ├── value-object.ts
│ │ │ ├── domain-event.ts
│ │ │ └── aggregate-root.ts
│ │ │
│ │ ├── infrastructure/
│ │ │ ├── event-bus.ts
│ │ │ ├── dependency-container.ts
│ │ │ └── logger.ts
│ │ │
│ │ └── types/
│ │ ├── common.ts
│ │ ├── errors.ts
│ │ └── interfaces.ts
│ │
│ └── application/ # Application services
│ ├── use-cases/
│ ├── commands/
│ ├── queries/
│ └── handlers/
```
## Base Domain Classes
### Entity Base Class
```typescript
// src/core/shared/domain/entity.ts
export abstract class Entity<T> {
protected readonly _id: T;
private _domainEvents: DomainEvent[] = [];
constructor(id: T) {
this._id = id;
}
get id(): T {
return this._id;
}
public equals(object?: Entity<T>): boolean {
if (object == null || object == undefined) {
return false;
}
if (this === object) {
return true;
}
if (!(object instanceof Entity)) {
return false;
}
return this._id === object._id;
}
protected addDomainEvent(domainEvent: DomainEvent): void {
this._domainEvents.push(domainEvent);
}
public getUncommittedEvents(): DomainEvent[] {
return this._domainEvents;
}
public markEventsAsCommitted(): void {
this._domainEvents = [];
}
}
```
### Value Object Base Class
```typescript
// src/core/shared/domain/value-object.ts
export abstract class ValueObject<T> {
protected readonly props: T;
constructor(props: T) {
this.props = Object.freeze(props);
}
public equals(object?: ValueObject<T>): boolean {
if (object == null || object == undefined) {
return false;
}
if (this === object) {
return true;
}
return JSON.stringify(this.props) === JSON.stringify(object.props);
}
get value(): T {
return this.props;
}
}
```
### Aggregate Root
```typescript
// src/core/shared/domain/aggregate-root.ts
export abstract class AggregateRoot<T> extends Entity<T> {
private _version: number = 0;
get version(): number {
return this._version;
}
protected incrementVersion(): void {
this._version++;
}
public applyEvent(event: DomainEvent): void {
this.addDomainEvent(event);
this.incrementVersion();
}
}
```
## Task Management Domain Implementation
### Task Entity
```typescript
// src/core/domains/task-management/entities/task.entity.ts
import { AggregateRoot } from '../../../shared/domain/aggregate-root';
import { TaskId } from '../value-objects/task-id.vo';
import { TaskStatus } from '../value-objects/task-status.vo';
import { Priority } from '../value-objects/priority.vo';
import { TaskAssignedEvent } from '../events/task-assigned.event';
interface TaskProps {
id: TaskId;
description: string;
priority: Priority;
status: TaskStatus;
assignedAgentId?: string;
createdAt: Date;
updatedAt: Date;
}
export class Task extends AggregateRoot<TaskId> {
private props: TaskProps;
private constructor(props: TaskProps) {
super(props.id);
this.props = props;
}
static create(description: string, priority: Priority): Task {
const task = new Task({
id: TaskId.create(),
description,
priority,
status: TaskStatus.pending(),
createdAt: new Date(),
updatedAt: new Date()
});
return task;
}
static reconstitute(props: TaskProps): Task {
return new Task(props);
}
public assignTo(agentId: string): void {
if (this.props.status.equals(TaskStatus.completed())) {
throw new Error('Cannot assign completed task');
}
this.props.assignedAgentId = agentId;
this.props.status = TaskStatus.assigned();
this.props.updatedAt = new Date();
this.applyEvent(new TaskAssignedEvent(
this.id.value,
agentId,
this.props.priority
));
}
public complete(result: TaskResult): void {
if (!this.props.assignedAgentId) {
throw new Error('Cannot complete unassigned task');
}
this.props.status = TaskStatus.completed();
this.props.updatedAt = new Date();
this.applyEvent(new TaskCompletedEvent(
this.id.value,
result,
this.calculateDuration()
));
}
// Getters
get description(): string { return this.props.description; }
get priority(): Priority { return this.props.priority; }
get status(): TaskStatus { return this.props.status; }
get assignedAgentId(): string | undefined { return this.props.assignedAgentId; }
get createdAt(): Date { return this.props.createdAt; }
get updatedAt(): Date { return this.props.updatedAt; }
private calculateDuration(): number {
return this.props.updatedAt.getTime() - this.props.createdAt.getTime();
}
}
```
### Task Value Objects
```typescript
// src/core/domains/task-management/value-objects/task-id.vo.ts
export class TaskId extends ValueObject<string> {
private constructor(value: string) {
super({ value });
}
static create(): TaskId {
return new TaskId(crypto.randomUUID());
}
static fromString(id: string): TaskId {
if (!id || id.length === 0) {
throw new Error('TaskId cannot be empty');
}
return new TaskId(id);
}
get value(): string {
return this.props.value;
}
}
// src/core/domains/task-management/value-objects/task-status.vo.ts
type TaskStatusType = 'pending' | 'assigned' | 'in_progress' | 'completed' | 'failed';
export class TaskStatus extends ValueObject<TaskStatusType> {
private constructor(status: TaskStatusType) {
super({ value: status });
}
static pending(): TaskStatus { return new TaskStatus('pending'); }
static assigned(): TaskStatus { return new TaskStatus('assigned'); }
static inProgress(): TaskStatus { return new TaskStatus('in_progress'); }
static completed(): TaskStatus { return new TaskStatus('completed'); }
static failed(): TaskStatus { return new TaskStatus('failed'); }
get value(): TaskStatusType {
return this.props.value;
}
public isPending(): boolean { return this.value === 'pending'; }
public isAssigned(): boolean { return this.value === 'assigned'; }
public isInProgress(): boolean { return this.value === 'in_progress'; }
public isCompleted(): boolean { return this.value === 'completed'; }
public isFailed(): boolean { return this.value === 'failed'; }
}
// src/core/domains/task-management/value-objects/priority.vo.ts
type PriorityLevel = 'low' | 'medium' | 'high' | 'critical';
export class Priority extends ValueObject<PriorityLevel> {
private constructor(level: PriorityLevel) {
super({ value: level });
}
static low(): Priority { return new Priority('low'); }
static medium(): Priority { return new Priority('medium'); }
static high(): Priority { return new Priority('high'); }
static critical(): Priority { return new Priority('critical'); }
get value(): PriorityLevel {
return this.props.value;
}
public getNumericValue(): number {
const priorities = { low: 1, medium: 2, high: 3, critical: 4 };
return priorities[this.value];
}
}
```
## Domain Services
### Task Scheduling Service
```typescript
// src/core/domains/task-management/services/task-scheduling.service.ts
import { Injectable } from '../../../shared/infrastructure/dependency-container';
import { Task } from '../entities/task.entity';
import { Priority } from '../value-objects/priority.vo';
@Injectable()
export class TaskSchedulingService {
public prioritizeTasks(tasks: Task[]): Task[] {
return tasks.sort((a, b) =>
b.priority.getNumericValue() - a.priority.getNumericValue()
);
}
public canSchedule(task: Task, agentCapacity: number): boolean {
if (agentCapacity <= 0) return false;
// Critical tasks always schedulable
if (task.priority.equals(Priority.critical())) return true;
// Other logic based on capacity
return true;
}
public calculateEstimatedDuration(task: Task): number {
// Simple heuristic - would use ML in real implementation
const baseTime = 300000; // 5 minutes
const priorityMultiplier = {
low: 0.5,
medium: 1.0,
high: 1.5,
critical: 2.0
};
return baseTime * priorityMultiplier[task.priority.value];
}
}
```
## Repository Interfaces & Implementations
### Task Repository Interface
```typescript
// src/core/domains/task-management/repositories/task.repository.ts
export interface ITaskRepository {
save(task: Task): Promise<void>;
findById(id: TaskId): Promise<Task | null>;
findByAgentId(agentId: string): Promise<Task[]>;
findByStatus(status: TaskStatus): Promise<Task[]>;
findPendingTasks(): Promise<Task[]>;
delete(id: TaskId): Promise<void>;
}
```
### SQLite Implementation
```typescript
// src/core/domains/task-management/repositories/sqlite-task.repository.ts
@Injectable()
export class SqliteTaskRepository implements ITaskRepository {
constructor(
@Inject('Database') private db: Database,
@Inject('Logger') private logger: ILogger
) {}
async save(task: Task): Promise<void> {
const sql = `
INSERT OR REPLACE INTO tasks (
id, description, priority, status, assigned_agent_id, created_at, updated_at
) VALUES (?, ?, ?, ?, ?, ?, ?)
`;
await this.db.run(sql, [
task.id.value,
task.description,
task.priority.value,
task.status.value,
task.assignedAgentId,
task.createdAt.toISOString(),
task.updatedAt.toISOString()
]);
this.logger.debug(`Task saved: ${task.id.value}`);
}
async findById(id: TaskId): Promise<Task | null> {
const sql = 'SELECT * FROM tasks WHERE id = ?';
const row = await this.db.get(sql, [id.value]);
return row ? this.mapRowToTask(row) : null;
}
async findPendingTasks(): Promise<Task[]> {
const sql = 'SELECT * FROM tasks WHERE status = ? ORDER BY priority DESC, created_at ASC';
const rows = await this.db.all(sql, ['pending']);
return rows.map(row => this.mapRowToTask(row));
}
private mapRowToTask(row: any): Task {
return Task.reconstitute({
id: TaskId.fromString(row.id),
description: row.description,
priority: Priority.fromString(row.priority),
status: TaskStatus.fromString(row.status),
assignedAgentId: row.assigned_agent_id,
createdAt: new Date(row.created_at),
updatedAt: new Date(row.updated_at)
});
}
}
```
## Application Layer
### Use Case Implementation
```typescript
// src/core/application/use-cases/assign-task.use-case.ts
@Injectable()
export class AssignTaskUseCase {
constructor(
@Inject('TaskRepository') private taskRepository: ITaskRepository,
@Inject('AgentRepository') private agentRepository: IAgentRepository,
@Inject('DomainEventBus') private eventBus: DomainEventBus,
@Inject('Logger') private logger: ILogger
) {}
async execute(command: AssignTaskCommand): Promise<AssignTaskResult> {
try {
// 1. Validate command
await this.validateCommand(command);
// 2. Load aggregates
const task = await this.taskRepository.findById(command.taskId);
if (!task) {
throw new TaskNotFoundError(command.taskId);
}
const agent = await this.agentRepository.findById(command.agentId);
if (!agent) {
throw new AgentNotFoundError(command.agentId);
}
// 3. Business logic
if (!agent.canAcceptTask(task)) {
throw new AgentCannotAcceptTaskError(command.agentId, command.taskId);
}
task.assignTo(command.agentId);
agent.acceptTask(task.id);
// 4. Persist changes
await Promise.all([
this.taskRepository.save(task),
this.agentRepository.save(agent)
]);
// 5. Publish domain events
const events = [
...task.getUncommittedEvents(),
...agent.getUncommittedEvents()
];
for (const event of events) {
await this.eventBus.publish(event);
}
task.markEventsAsCommitted();
agent.markEventsAsCommitted();
// 6. Return result
this.logger.info(`Task ${command.taskId.value} assigned to agent ${command.agentId}`);
return AssignTaskResult.success({
taskId: task.id,
agentId: command.agentId,
assignedAt: new Date()
});
} catch (error) {
this.logger.error(`Failed to assign task ${command.taskId.value}:`, error);
return AssignTaskResult.failure(error);
}
}
private async validateCommand(command: AssignTaskCommand): Promise<void> {
if (!command.taskId) {
throw new ValidationError('Task ID is required');
}
if (!command.agentId) {
throw new ValidationError('Agent ID is required');
}
}
}
```
## Dependency Injection Setup
### Container Configuration
```typescript
// src/core/shared/infrastructure/dependency-container.ts
import { Container } from 'inversify';
import { TYPES } from './types';
export class DependencyContainer {
private container: Container;
constructor() {
this.container = new Container();
this.setupBindings();
}
private setupBindings(): void {
// Repositories
this.container.bind<ITaskRepository>(TYPES.TaskRepository)
.to(SqliteTaskRepository)
.inSingletonScope();
this.container.bind<IAgentRepository>(TYPES.AgentRepository)
.to(SqliteAgentRepository)
.inSingletonScope();
// Services
this.container.bind<TaskSchedulingService>(TYPES.TaskSchedulingService)
.to(TaskSchedulingService)
.inSingletonScope();
// Use Cases
this.container.bind<AssignTaskUseCase>(TYPES.AssignTaskUseCase)
.to(AssignTaskUseCase)
.inSingletonScope();
// Infrastructure
this.container.bind<ILogger>(TYPES.Logger)
.to(ConsoleLogger)
.inSingletonScope();
this.container.bind<DomainEventBus>(TYPES.DomainEventBus)
.to(InMemoryDomainEventBus)
.inSingletonScope();
}
get<T>(serviceIdentifier: symbol): T {
return this.container.get<T>(serviceIdentifier);
}
bind<T>(serviceIdentifier: symbol): BindingToSyntax<T> {
return this.container.bind<T>(serviceIdentifier);
}
}
```
## Modern TypeScript Configuration
### Strict TypeScript Setup
```json
// tsconfig.json
{
"compilerOptions": {
"target": "ES2022",
"lib": ["ES2022"],
"module": "NodeNext",
"moduleResolution": "NodeNext",
"declaration": true,
"outDir": "./dist",
"strict": true,
"exactOptionalPropertyTypes": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedIndexedAccess": true,
"noImplicitOverride": true,
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"esModuleInterop": true,
"allowSyntheticDefaultImports": true,
"baseUrl": ".",
"paths": {
"@/*": ["src/*"],
"@core/*": ["src/core/*"],
"@shared/*": ["src/core/shared/*"],
"@domains/*": ["src/core/domains/*"]
}
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
}
```
## Testing Implementation
### Domain Unit Tests
```typescript
// src/core/domains/task-management/__tests__/entities/task.entity.test.ts
describe('Task Entity', () => {
let task: Task;
beforeEach(() => {
task = Task.create('Test task', Priority.medium());
});
describe('creation', () => {
it('should create task with pending status', () => {
expect(task.status.isPending()).toBe(true);
expect(task.description).toBe('Test task');
expect(task.priority.equals(Priority.medium())).toBe(true);
});
it('should generate unique ID', () => {
const task1 = Task.create('Task 1', Priority.low());
const task2 = Task.create('Task 2', Priority.low());
expect(task1.id.equals(task2.id)).toBe(false);
});
});
describe('assignment', () => {
it('should assign to agent and change status', () => {
const agentId = 'agent-123';
task.assignTo(agentId);
expect(task.assignedAgentId).toBe(agentId);
expect(task.status.isAssigned()).toBe(true);
});
it('should emit TaskAssignedEvent when assigned', () => {
const agentId = 'agent-123';
task.assignTo(agentId);
const events = task.getUncommittedEvents();
expect(events).toHaveLength(1);
expect(events[0]).toBeInstanceOf(TaskAssignedEvent);
});
it('should not allow assignment of completed task', () => {
task.assignTo('agent-123');
task.complete(TaskResult.success('done'));
expect(() => task.assignTo('agent-456'))
.toThrow('Cannot assign completed task');
});
});
});
```
### Integration Tests
```typescript
// src/core/domains/task-management/__tests__/integration/task-repository.integration.test.ts
describe('TaskRepository Integration', () => {
let repository: SqliteTaskRepository;
let db: Database;
beforeEach(async () => {
db = new Database(':memory:');
await setupTasksTable(db);
repository = new SqliteTaskRepository(db, new ConsoleLogger());
});
afterEach(async () => {
await db.close();
});
it('should save and retrieve task', async () => {
const task = Task.create('Test task', Priority.high());
await repository.save(task);
const retrieved = await repository.findById(task.id);
expect(retrieved).toBeDefined();
expect(retrieved!.id.equals(task.id)).toBe(true);
expect(retrieved!.description).toBe('Test task');
expect(retrieved!.priority.equals(Priority.high())).toBe(true);
});
it('should find pending tasks ordered by priority', async () => {
const lowTask = Task.create('Low priority', Priority.low());
const highTask = Task.create('High priority', Priority.high());
await repository.save(lowTask);
await repository.save(highTask);
const pending = await repository.findPendingTasks();
expect(pending).toHaveLength(2);
expect(pending[0].id.equals(highTask.id)).toBe(true); // High priority first
expect(pending[1].id.equals(lowTask.id)).toBe(true);
});
});
```
## Performance Optimizations
### Entity Caching
```typescript
// src/core/shared/infrastructure/entity-cache.ts
@Injectable()
export class EntityCache<T extends Entity<any>> {
private cache = new Map<string, { entity: T; timestamp: number }>();
private readonly ttl: number = 300000; // 5 minutes
set(id: string, entity: T): void {
this.cache.set(id, { entity, timestamp: Date.now() });
}
get(id: string): T | null {
const cached = this.cache.get(id);
if (!cached) return null;
// Check TTL
if (Date.now() - cached.timestamp > this.ttl) {
this.cache.delete(id);
return null;
}
return cached.entity;
}
invalidate(id: string): void {
this.cache.delete(id);
}
clear(): void {
this.cache.clear();
}
}
```
## Success Metrics
- [ ] **Domain Isolation**: 100% clean dependency boundaries
- [ ] **Test Coverage**: >90% unit test coverage for domain logic
- [ ] **Type Safety**: Strict TypeScript compilation with zero any types
- [ ] **Performance**: <50ms average use case execution time
- [ ] **Memory Efficiency**: <100MB heap usage for core domains
- [ ] **Plugin Architecture**: Modular domain loading capability
## Related V3 Skills
- `v3-ddd-architecture` - DDD architectural design
- `v3-mcp-optimization` - MCP server integration
- `v3-memory-unification` - AgentDB repository integration
- `v3-swarm-coordination` - Swarm domain implementation
## Usage Examples
### Complete Core Implementation
```bash
# Full core module implementation
Task("Core implementation",
"Implement all core domains with DDD patterns and comprehensive testing",
"core-implementer")
```
### Domain-Specific Implementation
```bash
# Single domain implementation
Task("Task domain implementation",
"Implement task management domain with entities, services, and repositories",
"core-implementer")
```

442
vendor/ruvector/.claude/skills/v3-ddd-architecture/SKILL.md vendored Normal file
View File

@@ -0,0 +1,442 @@
---
name: "V3 DDD Architecture"
description: "Domain-Driven Design architecture for claude-flow v3. Implements modular, bounded context architecture with clean separation of concerns and microkernel pattern."
---
# V3 DDD Architecture
## What This Skill Does
Designs and implements Domain-Driven Design (DDD) architecture for claude-flow v3, decomposing god objects into bounded contexts, implementing clean architecture patterns, and enabling modular, testable code structure.
## Quick Start
```bash
# Initialize DDD architecture analysis
Task("Architecture analysis", "Analyze current architecture and design DDD boundaries", "core-architect")
# Domain modeling (parallel)
Task("Domain decomposition", "Break down orchestrator god object into domains", "core-architect")
Task("Context mapping", "Map bounded contexts and relationships", "core-architect")
Task("Interface design", "Design clean domain interfaces", "core-architect")
```
## DDD Implementation Strategy
### Current Architecture Analysis
```
├── PROBLEMATIC: core/orchestrator.ts (1,440 lines - GOD OBJECT)
│ ├── Task management responsibilities
│ ├── Session management responsibilities
│ ├── Health monitoring responsibilities
│ ├── Lifecycle management responsibilities
│ └── Event coordination responsibilities
│
└── TARGET: Modular DDD Architecture
├── core/domains/
│ ├── task-management/
│ ├── session-management/
│ ├── health-monitoring/
│ ├── lifecycle-management/
│ └── event-coordination/
└── core/shared/
├── interfaces/
├── value-objects/
└── domain-events/
```
### Domain Boundaries
#### 1. Task Management Domain
```typescript
// core/domains/task-management/
interface TaskManagementDomain {
// Entities
Task: TaskEntity;
TaskQueue: TaskQueueEntity;
// Value Objects
TaskId: TaskIdVO;
TaskStatus: TaskStatusVO;
Priority: PriorityVO;
// Services
TaskScheduler: TaskSchedulingService;
TaskValidator: TaskValidationService;
// Repository
TaskRepository: ITaskRepository;
}
```
#### 2. Session Management Domain
```typescript
// core/domains/session-management/
interface SessionManagementDomain {
// Entities
Session: SessionEntity;
SessionState: SessionStateEntity;
// Value Objects
SessionId: SessionIdVO;
SessionStatus: SessionStatusVO;
// Services
SessionLifecycle: SessionLifecycleService;
SessionPersistence: SessionPersistenceService;
// Repository
SessionRepository: ISessionRepository;
}
```
#### 3. Health Monitoring Domain
```typescript
// core/domains/health-monitoring/
interface HealthMonitoringDomain {
// Entities
HealthCheck: HealthCheckEntity;
Metric: MetricEntity;
// Value Objects
HealthStatus: HealthStatusVO;
Threshold: ThresholdVO;
// Services
HealthCollector: HealthCollectionService;
AlertManager: AlertManagementService;
// Repository
MetricsRepository: IMetricsRepository;
}
```
## Microkernel Architecture Pattern
### Core Kernel
```typescript
// core/kernel/claude-flow-kernel.ts
export class ClaudeFlowKernel {
private domains: Map<string, Domain> = new Map();
private eventBus: DomainEventBus;
private dependencyContainer: Container;
async initialize(): Promise<void> {
// Load core domains
await this.loadDomain('task-management', new TaskManagementDomain());
await this.loadDomain('session-management', new SessionManagementDomain());
await this.loadDomain('health-monitoring', new HealthMonitoringDomain());
// Wire up domain events
this.setupDomainEventHandlers();
}
async loadDomain(name: string, domain: Domain): Promise<void> {
await domain.initialize(this.dependencyContainer);
this.domains.set(name, domain);
}
getDomain<T extends Domain>(name: string): T {
const domain = this.domains.get(name);
if (!domain) {
throw new DomainNotLoadedError(name);
}
return domain as T;
}
}
```
### Plugin Architecture
```typescript
// core/plugins/
interface DomainPlugin {
name: string;
version: string;
dependencies: string[];
initialize(kernel: ClaudeFlowKernel): Promise<void>;
shutdown(): Promise<void>;
}
// Example: Swarm Coordination Plugin
export class SwarmCoordinationPlugin implements DomainPlugin {
name = 'swarm-coordination';
version = '3.0.0';
dependencies = ['task-management', 'session-management'];
async initialize(kernel: ClaudeFlowKernel): Promise<void> {
const taskDomain = kernel.getDomain<TaskManagementDomain>('task-management');
const sessionDomain = kernel.getDomain<SessionManagementDomain>('session-management');
// Register swarm coordination services
this.swarmCoordinator = new UnifiedSwarmCoordinator(taskDomain, sessionDomain);
kernel.registerService('swarm-coordinator', this.swarmCoordinator);
}
}
```
## Domain Events & Integration
### Event-Driven Communication
```typescript
// core/shared/domain-events/
abstract class DomainEvent {
public readonly eventId: string;
public readonly aggregateId: string;
public readonly occurredOn: Date;
public readonly eventVersion: number;
constructor(aggregateId: string) {
this.eventId = crypto.randomUUID();
this.aggregateId = aggregateId;
this.occurredOn = new Date();
this.eventVersion = 1;
}
}
// Task domain events
export class TaskAssignedEvent extends DomainEvent {
constructor(
taskId: string,
public readonly agentId: string,
public readonly priority: Priority
) {
super(taskId);
}
}
export class TaskCompletedEvent extends DomainEvent {
constructor(
taskId: string,
public readonly result: TaskResult,
public readonly duration: number
) {
super(taskId);
}
}
// Event handlers
@EventHandler(TaskCompletedEvent)
export class TaskCompletedHandler {
constructor(
private metricsRepository: IMetricsRepository,
private sessionService: SessionLifecycleService
) {}
async handle(event: TaskCompletedEvent): Promise<void> {
// Update metrics
await this.metricsRepository.recordTaskCompletion(
event.aggregateId,
event.duration
);
// Update session state
await this.sessionService.markTaskCompleted(
event.aggregateId,
event.result
);
}
}
```
## Clean Architecture Layers
```typescript
// Architecture layers
┌─────────────────────────────────────────┐
│ Presentation │ ← CLI, API, UI
├─────────────────────────────────────────┤
│ Application │ ← Use Cases, Commands
├─────────────────────────────────────────┤
│ Domain │ ← Entities, Services, Events
├─────────────────────────────────────────┤
│ Infrastructure │ ← DB, MCP, External APIs
└─────────────────────────────────────────┘
// Dependency direction: Outside → Inside
// Domain layer has NO external dependencies
```
### Application Layer (Use Cases)
```typescript
// core/application/use-cases/
export class AssignTaskUseCase {
constructor(
private taskRepository: ITaskRepository,
private agentRepository: IAgentRepository,
private eventBus: DomainEventBus
) {}
async execute(command: AssignTaskCommand): Promise<TaskResult> {
// 1. Validate command
await this.validateCommand(command);
// 2. Load aggregates
const task = await this.taskRepository.findById(command.taskId);
const agent = await this.agentRepository.findById(command.agentId);
// 3. Business logic (in domain)
task.assignTo(agent);
// 4. Persist changes
await this.taskRepository.save(task);
// 5. Publish domain events
task.getUncommittedEvents().forEach(event =>
this.eventBus.publish(event)
);
// 6. Return result
return TaskResult.success(task);
}
}
```
## Module Configuration
### Bounded Context Modules
```typescript
// core/domains/task-management/module.ts
export const taskManagementModule = {
name: 'task-management',
entities: [
TaskEntity,
TaskQueueEntity
],
valueObjects: [
TaskIdVO,
TaskStatusVO,
PriorityVO
],
services: [
TaskSchedulingService,
TaskValidationService
],
repositories: [
{ provide: ITaskRepository, useClass: SqliteTaskRepository }
],
eventHandlers: [
TaskAssignedHandler,
TaskCompletedHandler
]
};
```
## Migration Strategy
### Phase 1: Extract Domain Services
```typescript
// Extract services from orchestrator.ts
const extractionPlan = {
week1: [
'TaskManager → task-management domain',
'SessionManager → session-management domain'
],
week2: [
'HealthMonitor → health-monitoring domain',
'LifecycleManager → lifecycle-management domain'
],
week3: [
'EventCoordinator → event-coordination domain',
'Wire up domain events'
]
};
```
### Phase 2: Implement Clean Interfaces
```typescript
// Clean separation with dependency injection
export class TaskController {
constructor(
@Inject('AssignTaskUseCase') private assignTask: AssignTaskUseCase,
@Inject('CompleteTaskUseCase') private completeTask: CompleteTaskUseCase
) {}
async assign(request: AssignTaskRequest): Promise<TaskResponse> {
const command = AssignTaskCommand.fromRequest(request);
const result = await this.assignTask.execute(command);
return TaskResponse.fromResult(result);
}
}
```
### Phase 3: Plugin System
```typescript
// Enable plugin-based extensions
const pluginSystem = {
core: ['task-management', 'session-management', 'health-monitoring'],
optional: ['swarm-coordination', 'learning-integration', 'performance-monitoring']
};
```
## Testing Strategy
### Domain Testing (London School TDD)
```typescript
// Pure domain logic testing
describe('Task Entity', () => {
let task: TaskEntity;
let mockAgent: jest.Mocked<AgentEntity>;
beforeEach(() => {
task = new TaskEntity(TaskId.create(), 'Test task');
mockAgent = createMock<AgentEntity>();
});
it('should assign to agent when valid', () => {
mockAgent.canAcceptTask.mockReturnValue(true);
task.assignTo(mockAgent);
expect(task.assignedAgent).toBe(mockAgent);
expect(task.status.value).toBe('assigned');
});
it('should emit TaskAssignedEvent when assigned', () => {
mockAgent.canAcceptTask.mockReturnValue(true);
task.assignTo(mockAgent);
const events = task.getUncommittedEvents();
expect(events).toHaveLength(1);
expect(events[0]).toBeInstanceOf(TaskAssignedEvent);
});
});
```
## Success Metrics
- [ ] **God Object Elimination**: orchestrator.ts (1,440 lines) → 5 focused domains (<300 lines each)
- [ ] **Bounded Context Isolation**: 100% domain independence
- [ ] **Plugin Architecture**: Core + optional modules loading
- [ ] **Clean Architecture**: Dependency inversion maintained
- [ ] **Event-Driven Communication**: Loose coupling between domains
- [ ] **Test Coverage**: >90% domain logic coverage
## Related V3 Skills
- `v3-core-implementation` - Implementation of DDD domains
- `v3-memory-unification` - AgentDB integration within bounded contexts
- `v3-swarm-coordination` - Swarm coordination as domain plugin
- `v3-performance-optimization` - Performance optimization across domains
## Usage Examples
### Complete Domain Extraction
```bash
# Full DDD architecture implementation
Task("DDD architecture implementation",
"Extract orchestrator into DDD domains with clean architecture",
"core-architect")
```
### Plugin Development
```bash
# Create domain plugin
npm run create:plugin -- --name swarm-coordination --template domain
```

241
vendor/ruvector/.claude/skills/v3-integration-deep/SKILL.md vendored Normal file
View File

@@ -0,0 +1,241 @@
---
name: "V3 Deep Integration"
description: "Deep agentic-flow@alpha integration implementing ADR-001. Eliminates 10,000+ duplicate lines by building claude-flow as specialized extension rather than parallel implementation."
---
# V3 Deep Integration
## What This Skill Does
Transforms claude-flow from parallel implementation to specialized extension of agentic-flow@alpha, eliminating massive code duplication while achieving performance improvements and feature parity.
## Quick Start
```bash
# Initialize deep integration
Task("Integration architecture", "Design agentic-flow@alpha adapter layer", "v3-integration-architect")
# Feature integration (parallel)
Task("SONA integration", "Integrate 5 SONA learning modes", "v3-integration-architect")
Task("Flash Attention", "Implement 2.49x-7.47x speedup", "v3-integration-architect")
Task("AgentDB coordination", "Setup 150x-12,500x search", "v3-integration-architect")
```
## Code Deduplication Strategy
### Current Overlap → Integration
```
┌─────────────────────────────────────────┐
│ claude-flow agentic-flow │
├─────────────────────────────────────────┤
│ SwarmCoordinator → Swarm System │ 80% overlap (eliminate)
│ AgentManager → Agent Lifecycle │ 70% overlap (eliminate)
│ TaskScheduler → Task Execution │ 60% overlap (eliminate)
│ SessionManager → Session Mgmt │ 50% overlap (eliminate)
└─────────────────────────────────────────┘
TARGET: <5,000 lines (vs 15,000+ currently)
```
## agentic-flow@alpha Feature Integration
### SONA Learning Modes
```typescript
class SONAIntegration {
async initializeMode(mode: SONAMode): Promise<void> {
switch(mode) {
case 'real-time': // ~0.05ms adaptation
case 'balanced': // general purpose
case 'research': // deep exploration
case 'edge': // resource-constrained
case 'batch': // high-throughput
}
await this.agenticFlow.sona.setMode(mode);
}
}
```
### Flash Attention Integration
```typescript
class FlashAttentionIntegration {
async optimizeAttention(): Promise<AttentionResult> {
return this.agenticFlow.attention.flashAttention({
speedupTarget: '2.49x-7.47x',
memoryReduction: '50-75%',
mechanisms: ['multi-head', 'linear', 'local', 'global']
});
}
}
```
### AgentDB Coordination
```typescript
class AgentDBIntegration {
async setupCrossAgentMemory(): Promise<void> {
await this.agentdb.enableCrossAgentSharing({
indexType: 'HNSW',
speedupTarget: '150x-12500x',
dimensions: 1536
});
}
}
```
### MCP Tools Integration
```typescript
class MCPToolsIntegration {
async integrateBuiltinTools(): Promise<void> {
// Leverage 213 pre-built tools
const tools = await this.agenticFlow.mcp.getAvailableTools();
await this.registerClaudeFlowSpecificTools(tools);
// Use 19 hook types
const hookTypes = await this.agenticFlow.hooks.getTypes();
await this.configureClaudeFlowHooks(hookTypes);
}
}
```
## Migration Implementation
### Phase 1: Adapter Layer
```typescript
import { Agent as AgenticFlowAgent } from 'agentic-flow@alpha';
export class ClaudeFlowAgent extends AgenticFlowAgent {
async handleClaudeFlowTask(task: ClaudeTask): Promise<TaskResult> {
return this.executeWithSONA(task);
}
// Backward compatibility
async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
return this.adaptToNewAPI(oldAPI);
}
}
```
### Phase 2: System Migration
```typescript
class SystemMigration {
async migrateSwarmCoordination(): Promise<void> {
// Replace SwarmCoordinator (800+ lines) with agentic-flow Swarm
const swarmConfig = await this.extractSwarmConfig();
await this.agenticFlow.swarm.initialize(swarmConfig);
}
async migrateAgentManagement(): Promise<void> {
// Replace AgentManager (1,736+ lines) with agentic-flow lifecycle
const agents = await this.extractActiveAgents();
for (const agent of agents) {
await this.agenticFlow.agent.create(agent);
}
}
async migrateTaskExecution(): Promise<void> {
// Replace TaskScheduler with agentic-flow task graph
const tasks = await this.extractTasks();
await this.agenticFlow.task.executeGraph(this.buildTaskGraph(tasks));
}
}
```
### Phase 3: Cleanup
```typescript
class CodeCleanup {
async removeDeprecatedCode(): Promise<void> {
// Remove massive duplicate implementations
await this.removeFile('src/core/SwarmCoordinator.ts'); // 800+ lines
await this.removeFile('src/agents/AgentManager.ts'); // 1,736+ lines
await this.removeFile('src/task/TaskScheduler.ts'); // 500+ lines
// Total reduction: 10,000+ → <5,000 lines
}
}
```
## RL Algorithm Integration
```typescript
class RLIntegration {
algorithms = [
'PPO', 'DQN', 'A2C', 'MCTS', 'Q-Learning',
'SARSA', 'Actor-Critic', 'Decision-Transformer'
];
async optimizeAgentBehavior(): Promise<void> {
for (const algorithm of this.algorithms) {
await this.agenticFlow.rl.train(algorithm, {
episodes: 1000,
rewardFunction: this.claudeFlowRewardFunction
});
}
}
}
```
## Performance Integration
### Flash Attention Targets
```typescript
const attentionBenchmark = {
baseline: 'current attention mechanism',
target: '2.49x-7.47x improvement',
memoryReduction: '50-75%',
implementation: 'agentic-flow@alpha Flash Attention'
};
```
### AgentDB Search Performance
```typescript
const searchBenchmark = {
baseline: 'linear search in current systems',
target: '150x-12,500x via HNSW indexing',
implementation: 'agentic-flow@alpha AgentDB'
};
```
## Backward Compatibility
### Gradual Migration
```typescript
class BackwardCompatibility {
// Phase 1: Dual operation
async enableDualOperation(): Promise<void> {
this.oldSystem.continue();
this.newSystem.initialize();
this.syncState(this.oldSystem, this.newSystem);
}
// Phase 2: Feature-by-feature migration
async migrateGradually(): Promise<void> {
const features = this.getAllFeatures();
for (const feature of features) {
await this.migrateFeature(feature);
await this.validateFeatureParity(feature);
}
}
// Phase 3: Complete transition
async completeTransition(): Promise<void> {
await this.validateFullParity();
await this.deprecateOldSystem();
}
}
```
## Success Metrics
- **Code Reduction**: <5,000 lines orchestration (vs 15,000+)
- **Performance**: 2.49x-7.47x Flash Attention speedup
- **Search**: 150x-12,500x AgentDB improvement
- **Memory**: 50-75% usage reduction
- **Feature Parity**: 100% v2 functionality maintained
- **SONA**: <0.05ms adaptation time
- **Integration**: All 213 MCP tools + 19 hook types available
## Related V3 Skills
- `v3-memory-unification` - Memory system integration
- `v3-performance-optimization` - Performance target validation
- `v3-swarm-coordination` - Swarm system migration
- `v3-security-overhaul` - Secure integration patterns

777
vendor/ruvector/.claude/skills/v3-mcp-optimization/SKILL.md vendored Normal file
View File

@@ -0,0 +1,777 @@
---
name: "V3 MCP Optimization"
description: "MCP server optimization and transport layer enhancement for claude-flow v3. Implements connection pooling, load balancing, tool registry optimization, and performance monitoring for sub-100ms response times."
---
# V3 MCP Optimization
## What This Skill Does
Optimizes claude-flow v3 MCP (Model Context Protocol) server implementation with advanced transport layer optimizations, connection pooling, load balancing, and comprehensive performance monitoring to achieve sub-100ms response times.
## Quick Start
```bash
# Initialize MCP optimization analysis
Task("MCP architecture", "Analyze current MCP server performance and bottlenecks", "mcp-specialist")
# Optimization implementation (parallel)
Task("Connection pooling", "Implement MCP connection pooling and reuse", "mcp-specialist")
Task("Load balancing", "Add dynamic load balancing for MCP tools", "mcp-specialist")
Task("Transport optimization", "Optimize transport layer performance", "mcp-specialist")
```
## MCP Performance Architecture
### Current State Analysis
```
Current MCP Issues:
├── Cold Start Latency: ~1.8s MCP server init
├── Connection Overhead: New connection per request
├── Tool Registry: Linear search O(n) for 213+ tools
├── Transport Layer: No connection reuse
└── Memory Usage: No cleanup of idle connections
Target Performance:
├── Startup Time: <400ms (4.5x improvement)
├── Tool Lookup: <5ms (O(1) hash table)
├── Connection Reuse: 90%+ connection pool hits
├── Response Time: <100ms p95
└── Memory Efficiency: 50% reduction
```
### MCP Server Architecture
```typescript
// src/core/mcp/mcp-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
interface OptimizedMCPConfig {
// Connection pooling
maxConnections: number;
idleTimeoutMs: number;
connectionReuseEnabled: boolean;
// Tool registry
toolCacheEnabled: boolean;
toolIndexType: 'hash' | 'trie';
// Performance
requestTimeoutMs: number;
batchingEnabled: boolean;
compressionEnabled: boolean;
// Monitoring
metricsEnabled: boolean;
healthCheckIntervalMs: number;
}
export class OptimizedMCPServer {
private server: Server;
private connectionPool: ConnectionPool;
private toolRegistry: FastToolRegistry;
private loadBalancer: MCPLoadBalancer;
private metrics: MCPMetrics;
constructor(config: OptimizedMCPConfig) {
this.server = new Server({
name: 'claude-flow-v3',
version: '3.0.0'
}, {
capabilities: {
tools: { listChanged: true },
resources: { subscribe: true, listChanged: true },
prompts: { listChanged: true }
}
});
this.connectionPool = new ConnectionPool(config);
this.toolRegistry = new FastToolRegistry(config.toolIndexType);
this.loadBalancer = new MCPLoadBalancer();
this.metrics = new MCPMetrics(config.metricsEnabled);
}
async start(): Promise<void> {
// Pre-warm connection pool
await this.connectionPool.preWarm();
// Pre-build tool index
await this.toolRegistry.buildIndex();
// Setup request handlers with optimizations
this.setupOptimizedHandlers();
// Start health monitoring
this.startHealthMonitoring();
// Start server
const transport = new StdioServerTransport();
await this.server.connect(transport);
this.metrics.recordStartup();
}
}
```
## Connection Pool Implementation
### Advanced Connection Pooling
```typescript
// src/core/mcp/connection-pool.ts
interface PooledConnection {
id: string;
connection: MCPConnection;
lastUsed: number;
usageCount: number;
isHealthy: boolean;
}
export class ConnectionPool {
private pool: Map<string, PooledConnection> = new Map();
private readonly config: ConnectionPoolConfig;
private healthChecker: HealthChecker;
constructor(config: ConnectionPoolConfig) {
this.config = {
maxConnections: 50,
minConnections: 5,
idleTimeoutMs: 300000, // 5 minutes
maxUsageCount: 1000,
healthCheckIntervalMs: 30000,
...config
};
this.healthChecker = new HealthChecker(this.config.healthCheckIntervalMs);
}
async getConnection(endpoint: string): Promise<MCPConnection> {
const start = performance.now();
// Try to get from pool first
const pooled = this.findAvailableConnection(endpoint);
if (pooled) {
pooled.lastUsed = Date.now();
pooled.usageCount++;
this.recordMetric('pool_hit', performance.now() - start);
return pooled.connection;
}
// Check pool capacity
if (this.pool.size >= this.config.maxConnections) {
await this.evictLeastUsedConnection();
}
// Create new connection
const connection = await this.createConnection(endpoint);
const pooledConn: PooledConnection = {
id: this.generateConnectionId(),
connection,
lastUsed: Date.now(),
usageCount: 1,
isHealthy: true
};
this.pool.set(pooledConn.id, pooledConn);
this.recordMetric('pool_miss', performance.now() - start);
return connection;
}
async releaseConnection(connection: MCPConnection): Promise<void> {
// Mark connection as available for reuse
const pooled = this.findConnectionById(connection.id);
if (pooled) {
// Check if connection should be retired
if (pooled.usageCount >= this.config.maxUsageCount) {
await this.removeConnection(pooled.id);
}
}
}
async preWarm(): Promise<void> {
const connections: Promise<MCPConnection>[] = [];
for (let i = 0; i < this.config.minConnections; i++) {
connections.push(this.createConnection('default'));
}
await Promise.all(connections);
}
private async evictLeastUsedConnection(): Promise<void> {
let oldestConn: PooledConnection | null = null;
let oldestTime = Date.now();
for (const conn of this.pool.values()) {
if (conn.lastUsed < oldestTime) {
oldestTime = conn.lastUsed;
oldestConn = conn;
}
}
if (oldestConn) {
await this.removeConnection(oldestConn.id);
}
}
private findAvailableConnection(endpoint: string): PooledConnection | null {
for (const conn of this.pool.values()) {
if (conn.isHealthy &&
conn.connection.endpoint === endpoint &&
Date.now() - conn.lastUsed < this.config.idleTimeoutMs) {
return conn;
}
}
return null;
}
}
```
## Fast Tool Registry
### O(1) Tool Lookup Implementation
```typescript
// src/core/mcp/fast-tool-registry.ts
interface ToolIndexEntry {
name: string;
handler: ToolHandler;
metadata: ToolMetadata;
usageCount: number;
avgLatencyMs: number;
}
export class FastToolRegistry {
private toolIndex: Map<string, ToolIndexEntry> = new Map();
private categoryIndex: Map<string, string[]> = new Map();
private fuzzyMatcher: FuzzyMatcher;
private cache: LRUCache<string, ToolIndexEntry>;
constructor(indexType: 'hash' | 'trie' = 'hash') {
this.fuzzyMatcher = new FuzzyMatcher();
this.cache = new LRUCache<string, ToolIndexEntry>(1000); // Cache 1000 most used tools
}
async buildIndex(): Promise<void> {
const start = performance.now();
// Load all available tools
const tools = await this.loadAllTools();
// Build hash index for O(1) lookup
for (const tool of tools) {
const entry: ToolIndexEntry = {
name: tool.name,
handler: tool.handler,
metadata: tool.metadata,
usageCount: 0,
avgLatencyMs: 0
};
this.toolIndex.set(tool.name, entry);
// Build category index
const category = tool.metadata.category || 'general';
if (!this.categoryIndex.has(category)) {
this.categoryIndex.set(category, []);
}
this.categoryIndex.get(category)!.push(tool.name);
}
// Build fuzzy search index
await this.fuzzyMatcher.buildIndex(tools.map(t => t.name));
console.log(`Tool index built in ${(performance.now() - start).toFixed(2)}ms for ${tools.length} tools`);
}
findTool(name: string): ToolIndexEntry | null {
// Try cache first
const cached = this.cache.get(name);
if (cached) return cached;
// Try exact match
const exact = this.toolIndex.get(name);
if (exact) {
this.cache.set(name, exact);
return exact;
}
// Try fuzzy match
const fuzzyMatches = this.fuzzyMatcher.search(name, 1);
if (fuzzyMatches.length > 0) {
const match = this.toolIndex.get(fuzzyMatches[0]);
if (match) {
this.cache.set(name, match);
return match;
}
}
return null;
}
findToolsByCategory(category: string): ToolIndexEntry[] {
const toolNames = this.categoryIndex.get(category) || [];
return toolNames
.map(name => this.toolIndex.get(name))
.filter(entry => entry !== undefined) as ToolIndexEntry[];
}
getMostUsedTools(limit: number = 10): ToolIndexEntry[] {
return Array.from(this.toolIndex.values())
.sort((a, b) => b.usageCount - a.usageCount)
.slice(0, limit);
}
recordToolUsage(toolName: string, latencyMs: number): void {
const entry = this.toolIndex.get(toolName);
if (entry) {
entry.usageCount++;
// Moving average for latency
entry.avgLatencyMs = (entry.avgLatencyMs + latencyMs) / 2;
}
}
}
```
## Load Balancing & Request Distribution
### Intelligent Load Balancer
```typescript
// src/core/mcp/load-balancer.ts
interface ServerInstance {
id: string;
endpoint: string;
load: number;
responseTime: number;
isHealthy: boolean;
maxConnections: number;
currentConnections: number;
}
export class MCPLoadBalancer {
private servers: Map<string, ServerInstance> = new Map();
private routingStrategy: RoutingStrategy = 'least-connections';
addServer(server: ServerInstance): void {
this.servers.set(server.id, server);
}
selectServer(toolCategory?: string): ServerInstance | null {
const healthyServers = Array.from(this.servers.values())
.filter(server => server.isHealthy);
if (healthyServers.length === 0) return null;
switch (this.routingStrategy) {
case 'round-robin':
return this.roundRobinSelection(healthyServers);
case 'least-connections':
return this.leastConnectionsSelection(healthyServers);
case 'response-time':
return this.responseTimeSelection(healthyServers);
case 'weighted':
return this.weightedSelection(healthyServers, toolCategory);
default:
return healthyServers[0];
}
}
private leastConnectionsSelection(servers: ServerInstance[]): ServerInstance {
return servers.reduce((least, current) =>
current.currentConnections < least.currentConnections ? current : least
);
}
private responseTimeSelection(servers: ServerInstance[]): ServerInstance {
return servers.reduce((fastest, current) =>
current.responseTime < fastest.responseTime ? current : fastest
);
}
private weightedSelection(servers: ServerInstance[], category?: string): ServerInstance {
// Prefer servers with lower load and better response time
const scored = servers.map(server => ({
server,
score: this.calculateServerScore(server, category)
}));
scored.sort((a, b) => b.score - a.score);
return scored[0].server;
}
private calculateServerScore(server: ServerInstance, category?: string): number {
const loadFactor = 1 - (server.currentConnections / server.maxConnections);
const responseFactor = 1 / (server.responseTime + 1);
const categoryBonus = this.getCategoryBonus(server, category);
return loadFactor * 0.4 + responseFactor * 0.4 + categoryBonus * 0.2;
}
updateServerMetrics(serverId: string, metrics: Partial<ServerInstance>): void {
const server = this.servers.get(serverId);
if (server) {
Object.assign(server, metrics);
}
}
}
```
## Transport Layer Optimization
### High-Performance Transport
```typescript
// src/core/mcp/optimized-transport.ts
export class OptimizedTransport {
private compression: boolean = true;
private batching: boolean = true;
private batchBuffer: MCPMessage[] = [];
private batchTimeout: NodeJS.Timeout | null = null;
constructor(private config: TransportConfig) {}
async send(message: MCPMessage): Promise<void> {
if (this.batching && this.canBatch(message)) {
this.addToBatch(message);
return;
}
await this.sendImmediate(message);
}
private async sendImmediate(message: MCPMessage): Promise<void> {
const start = performance.now();
// Compress if enabled
const payload = this.compression
? await this.compress(message)
: message;
// Send through transport
await this.transport.send(payload);
// Record metrics
this.recordLatency(performance.now() - start);
}
private addToBatch(message: MCPMessage): void {
this.batchBuffer.push(message);
// Start batch timeout if not already running
if (!this.batchTimeout) {
this.batchTimeout = setTimeout(
() => this.flushBatch(),
this.config.batchTimeoutMs || 10
);
}
// Flush if batch is full
if (this.batchBuffer.length >= this.config.maxBatchSize) {
this.flushBatch();
}
}
private async flushBatch(): Promise<void> {
if (this.batchBuffer.length === 0) return;
const batch = this.batchBuffer.splice(0);
this.batchTimeout = null;
// Send as single batched message
await this.sendImmediate({
type: 'batch',
messages: batch
});
}
private canBatch(message: MCPMessage): boolean {
// Don't batch urgent messages or responses
return message.type !== 'response' &&
message.priority !== 'high' &&
message.type !== 'error';
}
private async compress(data: any): Promise<Buffer> {
// Use fast compression for smaller messages
return gzipSync(JSON.stringify(data));
}
}
```
## Performance Monitoring
### Real-time MCP Metrics
```typescript
// src/core/mcp/metrics.ts
interface MCPMetrics {
requestCount: number;
errorCount: number;
avgResponseTime: number;
p95ResponseTime: number;
connectionPoolHits: number;
connectionPoolMisses: number;
toolLookupTime: number;
startupTime: number;
}
export class MCPMetricsCollector {
private metrics: MCPMetrics;
private responseTimeBuffer: number[] = [];
private readonly bufferSize = 1000;
constructor() {
this.metrics = this.createInitialMetrics();
}
recordRequest(latencyMs: number): void {
this.metrics.requestCount++;
this.updateResponseTimes(latencyMs);
}
recordError(): void {
this.metrics.errorCount++;
}
recordConnectionPoolHit(): void {
this.metrics.connectionPoolHits++;
}
recordConnectionPoolMiss(): void {
this.metrics.connectionPoolMisses++;
}
recordToolLookup(latencyMs: number): void {
this.metrics.toolLookupTime = this.updateMovingAverage(
this.metrics.toolLookupTime,
latencyMs
);
}
recordStartup(latencyMs: number): void {
this.metrics.startupTime = latencyMs;
}
getMetrics(): MCPMetrics {
return { ...this.metrics };
}
getHealthStatus(): HealthStatus {
const errorRate = this.metrics.errorCount / this.metrics.requestCount;
const poolHitRate = this.metrics.connectionPoolHits /
(this.metrics.connectionPoolHits + this.metrics.connectionPoolMisses);
return {
status: this.determineHealthStatus(errorRate, poolHitRate),
errorRate,
poolHitRate,
avgResponseTime: this.metrics.avgResponseTime,
p95ResponseTime: this.metrics.p95ResponseTime
};
}
private updateResponseTimes(latency: number): void {
this.responseTimeBuffer.push(latency);
if (this.responseTimeBuffer.length > this.bufferSize) {
this.responseTimeBuffer.shift();
}
this.metrics.avgResponseTime = this.calculateAverage(this.responseTimeBuffer);
this.metrics.p95ResponseTime = this.calculatePercentile(this.responseTimeBuffer, 95);
}
private calculatePercentile(arr: number[], percentile: number): number {
const sorted = arr.slice().sort((a, b) => a - b);
const index = Math.ceil((percentile / 100) * sorted.length) - 1;
return sorted[index] || 0;
}
private determineHealthStatus(errorRate: number, poolHitRate: number): 'healthy' | 'warning' | 'critical' {
if (errorRate > 0.1 || poolHitRate < 0.5) return 'critical';
if (errorRate > 0.05 || poolHitRate < 0.7) return 'warning';
return 'healthy';
}
}
```
## Tool Registry Optimization
### Pre-compiled Tool Index
```typescript
// src/core/mcp/tool-precompiler.ts
export class ToolPrecompiler {
async precompileTools(): Promise<CompiledToolRegistry> {
const tools = await this.loadAllTools();
// Create optimized lookup structures
const nameIndex = new Map<string, Tool>();
const categoryIndex = new Map<string, Tool[]>();
const fuzzyIndex = new Map<string, string[]>();
for (const tool of tools) {
// Exact name index
nameIndex.set(tool.name, tool);
// Category index
const category = tool.metadata.category || 'general';
if (!categoryIndex.has(category)) {
categoryIndex.set(category, []);
}
categoryIndex.get(category)!.push(tool);
// Pre-compute fuzzy variations
const variations = this.generateFuzzyVariations(tool.name);
for (const variation of variations) {
if (!fuzzyIndex.has(variation)) {
fuzzyIndex.set(variation, []);
}
fuzzyIndex.get(variation)!.push(tool.name);
}
}
return {
nameIndex,
categoryIndex,
fuzzyIndex,
totalTools: tools.length,
compiledAt: new Date()
};
}
private generateFuzzyVariations(name: string): string[] {
const variations: string[] = [];
// Common typos and abbreviations
variations.push(name.toLowerCase());
variations.push(name.replace(/[-_]/g, ''));
variations.push(name.replace(/[aeiou]/gi, '')); // Consonants only
// Add more fuzzy matching logic as needed
return variations;
}
}
```
## Advanced Caching Strategy
### Multi-Level Caching
```typescript
// src/core/mcp/multi-level-cache.ts
export class MultiLevelCache {
private l1Cache: Map<string, any> = new Map(); // In-memory, fastest
private l2Cache: LRUCache<string, any>; // LRU cache, larger capacity
private l3Cache: DiskCache; // Persistent disk cache
constructor(config: CacheConfig) {
this.l2Cache = new LRUCache<string, any>({
max: config.l2MaxEntries || 10000,
ttl: config.l2TTL || 300000 // 5 minutes
});
this.l3Cache = new DiskCache(config.l3Path || './.cache/mcp');
}
async get(key: string): Promise<any | null> {
// Try L1 cache first (fastest)
if (this.l1Cache.has(key)) {
return this.l1Cache.get(key);
}
// Try L2 cache
const l2Value = this.l2Cache.get(key);
if (l2Value) {
// Promote to L1
this.l1Cache.set(key, l2Value);
return l2Value;
}
// Try L3 cache (disk)
const l3Value = await this.l3Cache.get(key);
if (l3Value) {
// Promote to L2 and L1
this.l2Cache.set(key, l3Value);
this.l1Cache.set(key, l3Value);
return l3Value;
}
return null;
}
async set(key: string, value: any, options?: CacheOptions): Promise<void> {
// Set in all levels
this.l1Cache.set(key, value);
this.l2Cache.set(key, value);
if (options?.persistent) {
await this.l3Cache.set(key, value);
}
// Manage L1 cache size
if (this.l1Cache.size > 1000) {
const firstKey = this.l1Cache.keys().next().value;
this.l1Cache.delete(firstKey);
}
}
}
```
## Success Metrics
### Performance Targets
- [ ] **Startup Time**: <400ms MCP server initialization (4.5x improvement)
- [ ] **Response Time**: <100ms p95 for tool execution
- [ ] **Tool Lookup**: <5ms average lookup time
- [ ] **Connection Pool**: >90% hit rate
- [ ] **Memory Usage**: 50% reduction in idle memory
- [ ] **Error Rate**: <1% failed requests
- [ ] **Throughput**: >1000 requests/second
### Monitoring Dashboards
```typescript
const mcpDashboard = {
metrics: [
'Request latency (p50, p95, p99)',
'Error rate by tool category',
'Connection pool utilization',
'Tool lookup performance',
'Memory usage trends',
'Cache hit rates (L1, L2, L3)'
],
alerts: [
'Response time >200ms for 5 minutes',
'Error rate >5% for 1 minute',
'Pool hit rate <70% for 10 minutes',
'Memory usage >500MB for 5 minutes'
]
};
```
## Related V3 Skills
- `v3-core-implementation` - Core domain integration with MCP
- `v3-performance-optimization` - Overall performance optimization
- `v3-swarm-coordination` - MCP integration with swarm coordination
- `v3-memory-unification` - Memory sharing via MCP tools
## Usage Examples
### Complete MCP Optimization
```bash
# Full MCP server optimization
Task("MCP optimization implementation",
"Implement all MCP performance optimizations with monitoring",
"mcp-specialist")
```
### Specific Optimization
```bash
# Connection pool optimization
Task("MCP connection pooling",
"Implement advanced connection pooling with health monitoring",
"mcp-specialist")
```

174
vendor/ruvector/.claude/skills/v3-memory-unification/SKILL.md vendored Normal file
View File

@@ -0,0 +1,174 @@
---
name: "V3 Memory Unification"
description: "Unify 6+ memory systems into AgentDB with HNSW indexing for 150x-12,500x search improvements. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend)."
---
# V3 Memory Unification
## What This Skill Does
Consolidates disparate memory systems into unified AgentDB backend with HNSW vector search, achieving 150x-12,500x search performance improvements while maintaining backward compatibility.
## Quick Start
```bash
# Initialize memory unification
Task("Memory architecture", "Design AgentDB unification strategy", "v3-memory-specialist")
# AgentDB integration
Task("AgentDB setup", "Configure HNSW indexing and vector search", "v3-memory-specialist")
# Data migration
Task("Memory migration", "Migrate SQLite/Markdown to AgentDB", "v3-memory-specialist")
```
## Systems to Unify
### Legacy Systems → AgentDB
```
┌─────────────────────────────────────────┐
│ • MemoryManager (basic operations) │
│ • DistributedMemorySystem (clustering) │
│ • SwarmMemory (agent-specific) │
│ • AdvancedMemoryManager (features) │
│ • SQLiteBackend (structured) │
│ • MarkdownBackend (file-based) │
│ • HybridBackend (combination) │
└─────────────────────────────────────────┘
↓
┌─────────────────────────────────────────┐
│ 🚀 AgentDB with HNSW │
│ • 150x-12,500x faster search │
│ • Unified query interface │
│ • Cross-agent memory sharing │
│ • SONA learning integration │
└─────────────────────────────────────────┘
```
## Implementation Architecture
### Unified Memory Service
```typescript
class UnifiedMemoryService implements IMemoryBackend {
constructor(
private agentdb: AgentDBAdapter,
private indexer: HNSWIndexer,
private migrator: DataMigrator
) {}
async store(entry: MemoryEntry): Promise<void> {
await this.agentdb.store(entry);
await this.indexer.index(entry);
}
async query(query: MemoryQuery): Promise<MemoryEntry[]> {
if (query.semantic) {
return this.indexer.search(query); // 150x-12,500x faster
}
return this.agentdb.query(query);
}
}
```
### HNSW Vector Search
```typescript
class HNSWIndexer {
constructor(dimensions: number = 1536) {
this.index = new HNSWIndex({
dimensions,
efConstruction: 200,
M: 16,
speedupTarget: '150x-12500x'
});
}
async search(query: MemoryQuery): Promise<MemoryEntry[]> {
const embedding = await this.embedContent(query.content);
const results = this.index.search(embedding, query.limit || 10);
return this.retrieveEntries(results);
}
}
```
## Migration Strategy
### Phase 1: Foundation
```typescript
// AgentDB adapter setup
const agentdb = new AgentDBAdapter({
dimensions: 1536,
indexType: 'HNSW',
speedupTarget: '150x-12500x'
});
```
### Phase 2: Data Migration
```typescript
// SQLite → AgentDB
const migrateFromSQLite = async () => {
const entries = await sqlite.getAll();
for (const entry of entries) {
const embedding = await generateEmbedding(entry.content);
await agentdb.store({ ...entry, embedding });
}
};
// Markdown → AgentDB
const migrateFromMarkdown = async () => {
const files = await glob('**/*.md');
for (const file of files) {
const content = await fs.readFile(file, 'utf-8');
await agentdb.store({
id: generateId(),
content,
embedding: await generateEmbedding(content),
metadata: { originalFile: file }
});
}
};
```
## SONA Integration
### Learning Pattern Storage
```typescript
class SONAMemoryIntegration {
async storePattern(pattern: LearningPattern): Promise<void> {
await this.memory.store({
id: pattern.id,
content: pattern.data,
metadata: {
sonaMode: pattern.mode,
reward: pattern.reward,
adaptationTime: pattern.adaptationTime
},
embedding: await this.generateEmbedding(pattern.data)
});
}
async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {
return this.memory.query({
type: 'semantic',
content: query,
filters: { type: 'learning_pattern' }
});
}
}
```
## Performance Targets
- **Search Speed**: 150x-12,500x improvement via HNSW
- **Memory Usage**: 50-75% reduction through optimization
- **Query Latency**: <100ms for 1M+ entries
- **Cross-Agent Sharing**: Real-time memory synchronization
- **SONA Integration**: <0.05ms adaptation time
## Success Metrics
- [ ] All 7 legacy memory systems migrated to AgentDB
- [ ] 150x-12,500x search performance validated
- [ ] 50-75% memory usage reduction achieved
- [ ] Backward compatibility maintained
- [ ] SONA learning patterns integrated
- [ ] Cross-agent memory sharing operational

390
vendor/ruvector/.claude/skills/v3-performance-optimization/SKILL.md vendored Normal file
View File

@@ -0,0 +1,390 @@
---
name: "V3 Performance Optimization"
description: "Achieve aggressive v3 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite."
---
# V3 Performance Optimization
## What This Skill Does
Validates and optimizes claude-flow v3 to achieve industry-leading performance through Flash Attention, AgentDB HNSW indexing, and comprehensive system optimization with continuous benchmarking.
## Quick Start
```bash
# Initialize performance optimization
Task("Performance baseline", "Establish v2 performance benchmarks", "v3-performance-engineer")
# Target validation (parallel)
Task("Flash Attention", "Validate 2.49x-7.47x speedup target", "v3-performance-engineer")
Task("Search optimization", "Validate 150x-12,500x search improvement", "v3-performance-engineer")
Task("Memory optimization", "Achieve 50-75% memory reduction", "v3-performance-engineer")
```
## Performance Target Matrix
### Flash Attention Revolution
```
┌─────────────────────────────────────────┐
│ FLASH ATTENTION │
├─────────────────────────────────────────┤
│ Baseline: Standard attention │
│ Target: 2.49x - 7.47x speedup │
│ Memory: 50-75% reduction │
│ Latency: Sub-millisecond processing │
└─────────────────────────────────────────┘
```
### Search Performance Revolution
```
┌─────────────────────────────────────────┐
│ SEARCH OPTIMIZATION │
├─────────────────────────────────────────┤
│ Current: O(n) linear search │
│ Target: 150x - 12,500x improvement │
│ Method: HNSW indexing │
│ Latency: <100ms for 1M+ entries │
└─────────────────────────────────────────┘
```
## Comprehensive Benchmark Suite
### Startup Performance
```typescript
class StartupBenchmarks {
async benchmarkColdStart(): Promise<BenchmarkResult> {
const startTime = performance.now();
await this.initializeCLI();
await this.initializeMCPServer();
await this.spawnTestAgent();
const totalTime = performance.now() - startTime;
return {
total: totalTime,
target: 500, // ms
achieved: totalTime < 500
};
}
}
```
### Memory Operation Benchmarks
```typescript
class MemoryBenchmarks {
async benchmarkVectorSearch(): Promise<SearchBenchmark> {
const queries = this.generateTestQueries(10000);
// Baseline: Current linear search
const baselineTime = await this.timeOperation(() =>
this.currentMemory.searchAll(queries)
);
// Target: HNSW search
const hnswTime = await this.timeOperation(() =>
this.agentDBMemory.hnswSearchAll(queries)
);
const improvement = baselineTime / hnswTime;
return {
baseline: baselineTime,
hnsw: hnswTime,
improvement,
targetRange: [150, 12500],
achieved: improvement >= 150
};
}
async benchmarkMemoryUsage(): Promise<MemoryBenchmark> {
const baseline = process.memoryUsage().heapUsed;
await this.loadTestDataset();
const withData = process.memoryUsage().heapUsed;
await this.enableOptimization();
const optimized = process.memoryUsage().heapUsed;
const reduction = (withData - optimized) / withData;
return {
baseline,
withData,
optimized,
reductionPercent: reduction * 100,
targetReduction: [50, 75],
achieved: reduction >= 0.5
};
}
}
```
### Swarm Coordination Benchmarks
```typescript
class SwarmBenchmarks {
async benchmark15AgentCoordination(): Promise<SwarmBenchmark> {
const agents = await this.spawn15Agents();
// Coordination latency
const coordinationTime = await this.timeOperation(() =>
this.coordinateSwarmTask(agents)
);
// Task decomposition
const decompositionTime = await this.timeOperation(() =>
this.decomposeComplexTask()
);
// Consensus achievement
const consensusTime = await this.timeOperation(() =>
this.achieveSwarmConsensus(agents)
);
return {
coordination: coordinationTime,
decomposition: decompositionTime,
consensus: consensusTime,
agentCount: 15,
efficiency: this.calculateEfficiency(agents)
};
}
}
```
### Flash Attention Benchmarks
```typescript
class AttentionBenchmarks {
async benchmarkFlashAttention(): Promise<AttentionBenchmark> {
const sequences = this.generateSequences([512, 1024, 2048, 4096]);
const results = [];
for (const sequence of sequences) {
// Baseline attention
const baselineResult = await this.benchmarkStandardAttention(sequence);
// Flash attention
const flashResult = await this.benchmarkFlashAttention(sequence);
results.push({
sequenceLength: sequence.length,
speedup: baselineResult.time / flashResult.time,
memoryReduction: (baselineResult.memory - flashResult.memory) / baselineResult.memory,
targetSpeedup: [2.49, 7.47],
achieved: this.checkTarget(flashResult, [2.49, 7.47])
});
}
return {
results,
averageSpeedup: this.calculateAverage(results, 'speedup'),
averageMemoryReduction: this.calculateAverage(results, 'memoryReduction')
};
}
}
```
### SONA Learning Benchmarks
```typescript
class SONABenchmarks {
async benchmarkAdaptationTime(): Promise<SONABenchmark> {
const scenarios = [
'pattern_recognition',
'task_optimization',
'error_correction',
'performance_tuning'
];
const results = [];
for (const scenario of scenarios) {
const startTime = performance.hrtime.bigint();
await this.sona.adapt(scenario);
const endTime = performance.hrtime.bigint();
const adaptationTimeMs = Number(endTime - startTime) / 1000000;
results.push({
scenario,
adaptationTime: adaptationTimeMs,
target: 0.05, // ms
achieved: adaptationTimeMs <= 0.05
});
}
return {
scenarios: results,
averageTime: results.reduce((sum, r) => sum + r.adaptationTime, 0) / results.length,
successRate: results.filter(r => r.achieved).length / results.length
};
}
}
```
## Performance Monitoring Dashboard
### Real-time Metrics
```typescript
class PerformanceMonitor {
async collectMetrics(): Promise<PerformanceSnapshot> {
return {
timestamp: Date.now(),
flashAttention: await this.measureFlashAttention(),
searchPerformance: await this.measureSearchSpeed(),
memoryUsage: await this.measureMemoryEfficiency(),
startupTime: await this.measureStartupLatency(),
sonaAdaptation: await this.measureSONASpeed(),
swarmCoordination: await this.measureSwarmEfficiency()
};
}
async generateReport(): Promise<PerformanceReport> {
const snapshot = await this.collectMetrics();
return {
summary: this.generateSummary(snapshot),
achievements: this.checkTargetAchievements(snapshot),
trends: this.analyzeTrends(),
recommendations: this.generateOptimizations(),
regressions: await this.detectRegressions()
};
}
}
```
### Continuous Regression Detection
```typescript
class PerformanceRegression {
async detectRegressions(): Promise<RegressionReport> {
const current = await this.runFullBenchmark();
const baseline = await this.getBaseline();
const regressions = [];
for (const [metric, currentValue] of Object.entries(current)) {
const baselineValue = baseline[metric];
const change = (currentValue - baselineValue) / baselineValue;
if (change < -0.05) { // 5% regression threshold
regressions.push({
metric,
baseline: baselineValue,
current: currentValue,
regressionPercent: change * 100,
severity: this.classifyRegression(change)
});
}
}
return {
hasRegressions: regressions.length > 0,
regressions,
recommendations: this.generateRegressionFixes(regressions)
};
}
}
```
## Optimization Strategies
### Memory Optimization
```typescript
class MemoryOptimization {
async optimizeMemoryUsage(): Promise<OptimizationResult> {
// Implement memory pooling
await this.setupMemoryPools();
// Enable garbage collection tuning
await this.optimizeGarbageCollection();
// Implement object reuse patterns
await this.setupObjectPools();
// Enable memory compression
await this.enableMemoryCompression();
return this.validateMemoryReduction();
}
}
```
### CPU Optimization
```typescript
class CPUOptimization {
async optimizeCPUUsage(): Promise<OptimizationResult> {
// Implement worker thread pools
await this.setupWorkerThreads();
// Enable CPU-specific optimizations
await this.enableSIMDInstructions();
// Implement task batching
await this.optimizeTaskBatching();
return this.validateCPUImprovement();
}
}
```
## Target Validation Framework
### Performance Gates
```typescript
class PerformanceGates {
async validateAllTargets(): Promise<ValidationReport> {
const results = await Promise.all([
this.validateFlashAttention(), // 2.49x-7.47x
this.validateSearchPerformance(), // 150x-12,500x
this.validateMemoryReduction(), // 50-75%
this.validateStartupTime(), // <500ms
this.validateSONAAdaptation() // <0.05ms
]);
return {
allTargetsAchieved: results.every(r => r.achieved),
results,
overallScore: this.calculateOverallScore(results),
recommendations: this.generateRecommendations(results)
};
}
}
```
## Success Metrics
### Primary Targets
- [ ] **Flash Attention**: 2.49x-7.47x speedup validated
- [ ] **Search Performance**: 150x-12,500x improvement confirmed
- [ ] **Memory Reduction**: 50-75% usage optimization achieved
- [ ] **Startup Time**: <500ms cold start consistently
- [ ] **SONA Adaptation**: <0.05ms learning response time
- [ ] **15-Agent Coordination**: Efficient parallel execution
### Continuous Monitoring
- [ ] **Performance Dashboard**: Real-time metrics collection
- [ ] **Regression Testing**: Automated performance validation
- [ ] **Trend Analysis**: Performance evolution tracking
- [ ] **Alert System**: Immediate regression notification
## Related V3 Skills
- `v3-integration-deep` - Performance integration with agentic-flow
- `v3-memory-unification` - Memory performance optimization
- `v3-swarm-coordination` - Swarm performance coordination
- `v3-security-overhaul` - Secure performance patterns
## Usage Examples
### Complete Performance Validation
```bash
# Full performance suite
npm run benchmark:v3
# Specific target validation
npm run benchmark:flash-attention
npm run benchmark:agentdb-search
npm run benchmark:memory-optimization
# Continuous monitoring
npm run monitor:performance
```

82
vendor/ruvector/.claude/skills/v3-security-overhaul/SKILL.md vendored Normal file
View File

@@ -0,0 +1,82 @@
---
name: "V3 Security Overhaul"
description: "Complete security architecture overhaul for claude-flow v3. Addresses critical CVEs (CVE-1, CVE-2, CVE-3) and implements secure-by-default patterns. Use for security-first v3 implementation."
---
# V3 Security Overhaul
## What This Skill Does
Orchestrates comprehensive security overhaul for claude-flow v3, addressing critical vulnerabilities and establishing security-first development practices using specialized v3 security agents.
## Quick Start
```bash
# Initialize V3 security domain (parallel)
Task("Security architecture", "Design v3 threat model and security boundaries", "v3-security-architect")
Task("CVE remediation", "Fix CVE-1, CVE-2, CVE-3 critical vulnerabilities", "security-auditor")
Task("Security testing", "Implement TDD London School security framework", "test-architect")
```
## Critical Security Fixes
### CVE-1: Vulnerable Dependencies
```bash
npm update @anthropic-ai/claude-code@^2.0.31
npm audit --audit-level high
```
### CVE-2: Weak Password Hashing
```typescript
// ❌ Old: SHA-256 with hardcoded salt
const hash = crypto.createHash('sha256').update(password + salt).digest('hex');
// ✅ New: bcrypt with 12 rounds
import bcrypt from 'bcrypt';
const hash = await bcrypt.hash(password, 12);
```
### CVE-3: Hardcoded Credentials
```typescript
// ✅ Generate secure random credentials
const apiKey = crypto.randomBytes(32).toString('hex');
```
## Security Patterns
### Input Validation (Zod)
```typescript
import { z } from 'zod';
const TaskSchema = z.object({
taskId: z.string().uuid(),
content: z.string().max(10000),
agentType: z.enum(['security', 'core', 'integration'])
});
```
### Path Sanitization
```typescript
function securePath(userPath: string, allowedPrefix: string): string {
const resolved = path.resolve(allowedPrefix, userPath);
if (!resolved.startsWith(path.resolve(allowedPrefix))) {
throw new SecurityError('Path traversal detected');
}
return resolved;
}
```
### Safe Command Execution
```typescript
import { execFile } from 'child_process';
// ✅ Safe: No shell interpretation
const { stdout } = await execFile('git', [userInput], { shell: false });
```
## Success Metrics
- **Security Score**: 90/100 (npm audit + custom scans)
- **CVE Resolution**: 100% of critical vulnerabilities fixed
- **Test Coverage**: >95% security-critical code
- **Implementation**: All secure patterns documented and tested

340
vendor/ruvector/.claude/skills/v3-swarm-coordination/SKILL.md vendored Normal file
View File

@@ -0,0 +1,340 @@
---
name: "V3 Swarm Coordination"
description: "15-agent hierarchical mesh coordination for v3 implementation. Orchestrates parallel execution across security, core, and integration domains following 10 ADRs with 14-week timeline."
---
# V3 Swarm Coordination
## What This Skill Does
Orchestrates the complete 15-agent hierarchical mesh swarm for claude-flow v3 implementation, coordinating parallel execution across domains while maintaining dependencies and timeline adherence.
## Quick Start
```bash
# Initialize 15-agent v3 swarm
Task("Swarm initialization", "Initialize hierarchical mesh for v3 implementation", "v3-queen-coordinator")
# Security domain (Phase 1 - Critical priority)
Task("Security architecture", "Design v3 threat model and security boundaries", "v3-security-architect")
Task("CVE remediation", "Fix CVE-1, CVE-2, CVE-3 vulnerabilities", "security-auditor")
Task("Security testing", "Implement TDD security framework", "test-architect")
# Core domain (Phase 2 - Parallel execution)
Task("Memory unification", "Implement AgentDB 150x improvement", "v3-memory-specialist")
Task("Integration architecture", "Deep agentic-flow@alpha integration", "v3-integration-architect")
Task("Performance validation", "Validate 2.49x-7.47x targets", "v3-performance-engineer")
```
## 15-Agent Swarm Architecture
### Hierarchical Mesh Topology
```
👑 QUEEN COORDINATOR
(Agent #1)
│
┌────────────────────┼────────────────────┐
│ │ │
🛡️ SECURITY 🧠 CORE 🔗 INTEGRATION
(Agents #2-4) (Agents #5-9) (Agents #10-12)
│ │ │
└────────────────────┼────────────────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
🧪 QUALITY ⚡ PERFORMANCE 🚀 DEPLOYMENT
(Agent #13) (Agent #14) (Agent #15)
```
### Agent Roster
| ID | Agent | Domain | Phase | Responsibility |
|----|-------|--------|-------|----------------|
| 1 | Queen Coordinator | Orchestration | All | GitHub issues, dependencies, timeline |
| 2 | Security Architect | Security | Foundation | Threat modeling, CVE planning |
| 3 | Security Implementer | Security | Foundation | CVE fixes, secure patterns |
| 4 | Security Tester | Security | Foundation | TDD security testing |
| 5 | Core Architect | Core | Systems | DDD architecture, coordination |
| 6 | Core Implementer | Core | Systems | Core module implementation |
| 7 | Memory Specialist | Core | Systems | AgentDB unification |
| 8 | Swarm Specialist | Core | Systems | Unified coordination engine |
| 9 | MCP Specialist | Core | Systems | MCP server optimization |
| 10 | Integration Architect | Integration | Integration | agentic-flow@alpha deep integration |
| 11 | CLI/Hooks Developer | Integration | Integration | CLI modernization |
| 12 | Neural/Learning Dev | Integration | Integration | SONA integration |
| 13 | TDD Test Engineer | Quality | All | London School TDD |
| 14 | Performance Engineer | Performance | Optimization | Benchmarking validation |
| 15 | Release Engineer | Deployment | Release | CI/CD and v3.0.0 release |
## Implementation Phases
### Phase 1: Foundation (Week 1-2)
**Active Agents**: #1, #2-4, #5-6
```typescript
const phase1 = async () => {
// Parallel security and architecture foundation
await Promise.all([
// Security domain (critical priority)
Task("Security architecture", "Complete threat model and security boundaries", "v3-security-architect"),
Task("CVE-1 fix", "Update vulnerable dependencies", "security-implementer"),
Task("CVE-2 fix", "Replace weak password hashing", "security-implementer"),
Task("CVE-3 fix", "Remove hardcoded credentials", "security-implementer"),
Task("Security testing", "TDD London School security framework", "test-architect"),
// Core architecture foundation
Task("DDD architecture", "Design domain boundaries and structure", "core-architect"),
Task("Type modernization", "Update type system for v3", "core-implementer")
]);
};
```
### Phase 2: Core Systems (Week 3-6)
**Active Agents**: #1, #5-9, #13
```typescript
const phase2 = async () => {
// Parallel core system implementation
await Promise.all([
Task("Memory unification", "Implement AgentDB with 150x-12,500x improvement", "v3-memory-specialist"),
Task("Swarm coordination", "Merge 4 coordination systems into unified engine", "swarm-specialist"),
Task("MCP optimization", "Optimize MCP server performance", "mcp-specialist"),
Task("Core implementation", "Implement DDD modular architecture", "core-implementer"),
Task("TDD core tests", "Comprehensive test coverage for core systems", "test-architect")
]);
};
```
### Phase 3: Integration (Week 7-10)
**Active Agents**: #1, #10-12, #13-14
```typescript
const phase3 = async () => {
// Parallel integration and optimization
await Promise.all([
Task("agentic-flow integration", "Eliminate 10,000+ duplicate lines", "v3-integration-architect"),
Task("CLI modernization", "Enhance CLI with hooks system", "cli-hooks-developer"),
Task("SONA integration", "Implement <0.05ms learning adaptation", "neural-learning-developer"),
Task("Performance benchmarking", "Validate 2.49x-7.47x targets", "v3-performance-engineer"),
Task("Integration testing", "End-to-end system validation", "test-architect")
]);
};
```
### Phase 4: Release (Week 11-14)
**Active Agents**: All 15
```typescript
const phase4 = async () => {
// Full swarm final optimization
await Promise.all([
Task("Performance optimization", "Final optimization pass", "v3-performance-engineer"),
Task("Release preparation", "CI/CD pipeline and v3.0.0 release", "release-engineer"),
Task("Final testing", "Complete test coverage validation", "test-architect"),
// All agents: Final polish and optimization
...agents.map(agent =>
Task("Final polish", `Agent ${agent.id} final optimization`, agent.name)
)
]);
};
```
## Coordination Patterns
### Dependency Management
```typescript
class DependencyCoordination {
private dependencies = new Map([
// Security first (no dependencies)
[2, []], [3, [2]], [4, [2, 3]],
// Core depends on security foundation
[5, [2]], [6, [5]], [7, [5]], [8, [5, 7]], [9, [5]],
// Integration depends on core systems
[10, [5, 7, 8]], [11, [5, 10]], [12, [7, 10]],
// Quality and performance cross-cutting
[13, [2, 5]], [14, [5, 7, 8, 10]], [15, [13, 14]]
]);
async coordinateExecution(): Promise<void> {
const completed = new Set<number>();
while (completed.size < 15) {
const ready = this.getReadyAgents(completed);
if (ready.length === 0) {
throw new Error('Deadlock detected in dependency chain');
}
// Execute ready agents in parallel
await Promise.all(ready.map(agentId => this.executeAgent(agentId)));
ready.forEach(id => completed.add(id));
}
}
}
```
### GitHub Integration
```typescript
class GitHubCoordination {
async initializeV3Milestone(): Promise<void> {
await gh.createMilestone({
title: 'Claude-Flow v3.0.0 Implementation',
description: '15-agent swarm implementation of 10 ADRs',
dueDate: this.calculate14WeekDeadline()
});
}
async createEpicIssues(): Promise<void> {
const epics = [
{ title: 'Security Overhaul (CVE-1,2,3)', agents: [2, 3, 4] },
{ title: 'Memory Unification (AgentDB)', agents: [7] },
{ title: 'agentic-flow Integration', agents: [10] },
{ title: 'Performance Optimization', agents: [14] },
{ title: 'DDD Architecture', agents: [5, 6] }
];
for (const epic of epics) {
await gh.createIssue({
title: epic.title,
labels: ['epic', 'v3', ...epic.agents.map(id => `agent-${id}`)],
assignees: epic.agents.map(id => this.getAgentGithubUser(id))
});
}
}
async trackProgress(): Promise<void> {
// Hourly progress updates from each agent
setInterval(async () => {
for (const agent of this.agents) {
await this.postAgentProgress(agent);
}
}, 3600000); // 1 hour
}
}
```
### Communication Bus
```typescript
class SwarmCommunication {
private bus = new QuicSwarmBus({
maxAgents: 15,
messageTimeout: 30000,
retryAttempts: 3
});
async broadcastToSecurityDomain(message: SwarmMessage): Promise<void> {
await this.bus.broadcast(message, {
targetAgents: [2, 3, 4],
priority: 'critical'
});
}
async coordinateCoreSystems(message: SwarmMessage): Promise<void> {
await this.bus.broadcast(message, {
targetAgents: [5, 6, 7, 8, 9],
priority: 'high'
});
}
async notifyIntegrationTeam(message: SwarmMessage): Promise<void> {
await this.bus.broadcast(message, {
targetAgents: [10, 11, 12],
priority: 'medium'
});
}
}
```
## Performance Coordination
### Parallel Efficiency Monitoring
```typescript
class EfficiencyMonitor {
async measureParallelEfficiency(): Promise<EfficiencyReport> {
const agentUtilization = await this.measureAgentUtilization();
const coordinationOverhead = await this.measureCoordinationCost();
return {
totalEfficiency: agentUtilization.average,
target: 0.85, // >85% utilization
achieved: agentUtilization.average > 0.85,
bottlenecks: this.identifyBottlenecks(agentUtilization),
recommendations: this.generateOptimizations()
};
}
}
```
### Load Balancing
```typescript
class SwarmLoadBalancer {
async balanceWorkload(): Promise<void> {
const workloads = await this.analyzeAgentWorkloads();
for (const [agentId, load] of workloads.entries()) {
if (load > this.getCapacityThreshold(agentId)) {
await this.redistributeWork(agentId);
}
}
}
async redistributeWork(overloadedAgent: number): Promise<void> {
const availableAgents = this.getAvailableAgents();
const tasks = await this.getAgentTasks(overloadedAgent);
// Redistribute tasks to available agents
for (const task of tasks) {
const bestAgent = this.selectOptimalAgent(task, availableAgents);
await this.reassignTask(task, bestAgent);
}
}
}
```
## Success Metrics
### Swarm Coordination
- [ ] **Parallel Efficiency**: >85% agent utilization time
- [ ] **Dependency Resolution**: Zero deadlocks or blocking issues
- [ ] **Communication Latency**: <100ms inter-agent messaging
- [ ] **Timeline Adherence**: 14-week delivery maintained
- [ ] **GitHub Integration**: <4h automated issue response
### Implementation Targets
- [ ] **ADR Coverage**: All 10 ADRs implemented successfully
- [ ] **Performance**: 2.49x-7.47x Flash Attention achieved
- [ ] **Search**: 150x-12,500x AgentDB improvement validated
- [ ] **Code Reduction**: <5,000 lines (vs 15,000+)
- [ ] **Security**: 90/100 security score achieved
## Related V3 Skills
- `v3-security-overhaul` - Security domain coordination
- `v3-memory-unification` - Memory system coordination
- `v3-integration-deep` - Integration domain coordination
- `v3-performance-optimization` - Performance domain coordination
## Usage Examples
### Initialize Complete V3 Swarm
```bash
# Queen Coordinator initializes full swarm
Task("V3 swarm initialization",
"Initialize 15-agent hierarchical mesh for complete v3 implementation",
"v3-queen-coordinator")
```
### Phase-based Execution
```bash
# Phase 1: Security-first foundation
npm run v3:phase1:security
# Phase 2: Core systems parallel
npm run v3:phase2:core-systems
# Phase 3: Integration and optimization
npm run v3:phase3:integration
# Phase 4: Release preparation
npm run v3:phase4:release
```

649
vendor/ruvector/.claude/skills/verification-quality/SKILL.md vendored Normal file
View File

@@ -0,0 +1,649 @@
---
name: "Verification & Quality Assurance"
description: "Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs and codebase reliability."
version: "2.0.0"
category: "quality-assurance"
tags: ["verification", "truth-scoring", "quality", "rollback", "metrics", "ci-cd"]
---
# Verification & Quality Assurance Skill
## What This Skill Does
This skill provides a comprehensive verification and quality assurance system that ensures code quality and correctness through:
- **Truth Scoring**: Real-time reliability metrics (0.0-1.0 scale) for code, agents, and tasks
- **Verification Checks**: Automated code correctness, security, and best practices validation
- **Automatic Rollback**: Instant reversion of changes that fail verification (default threshold: 0.95)
- **Quality Metrics**: Statistical analysis with trends, confidence intervals, and improvement tracking
- **CI/CD Integration**: Export capabilities for continuous integration pipelines
- **Real-time Monitoring**: Live dashboards and watch modes for ongoing verification
## Prerequisites
- Claude Flow installed (`npx claude-flow@alpha`)
- Git repository (for rollback features)
- Node.js 18+ (for dashboard features)
## Quick Start
```bash
# View current truth scores
npx claude-flow@alpha truth
# Run verification check
npx claude-flow@alpha verify check
# Verify specific file with custom threshold
npx claude-flow@alpha verify check --file src/app.js --threshold 0.98
# Rollback last failed verification
npx claude-flow@alpha verify rollback --last-good
```
---
## Complete Guide
### Truth Scoring System
#### View Truth Metrics
Display comprehensive quality and reliability metrics for your codebase and agent tasks.
**Basic Usage:**
```bash
# View current truth scores (default: table format)
npx claude-flow@alpha truth
# View scores for specific time period
npx claude-flow@alpha truth --period 7d
# View scores for specific agent
npx claude-flow@alpha truth --agent coder --period 24h
# Find files/tasks below threshold
npx claude-flow@alpha truth --threshold 0.8
```
**Output Formats:**
```bash
# Table format (default)
npx claude-flow@alpha truth --format table
# JSON for programmatic access
npx claude-flow@alpha truth --format json
# CSV for spreadsheet analysis
npx claude-flow@alpha truth --format csv
# HTML report with visualizations
npx claude-flow@alpha truth --format html --export report.html
```
**Real-time Monitoring:**
```bash
# Watch mode with live updates
npx claude-flow@alpha truth --watch
# Export metrics automatically
npx claude-flow@alpha truth --export .claude-flow/metrics/truth-$(date +%Y%m%d).json
```
#### Truth Score Dashboard
Example dashboard output:
```
📊 Truth Metrics Dashboard
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Overall Truth Score: 0.947 ✅
Trend: ↗️ +2.3% (7d)
Top Performers:
verification-agent 0.982 ⭐
code-analyzer 0.971 ⭐
test-generator 0.958 ✅
Needs Attention:
refactor-agent 0.821 ⚠️
docs-generator 0.794 ⚠️
Recent Tasks:
task-456 0.991 ✅ "Implement auth"
task-455 0.967 ✅ "Add tests"
task-454 0.743 ❌ "Refactor API"
```
#### Metrics Explained
**Truth Scores (0.0-1.0):**
- `1.0-0.95`: Excellent ⭐ (production-ready)
- `0.94-0.85`: Good ✅ (acceptable quality)
- `0.84-0.75`: Warning ⚠️ (needs attention)
- `<0.75`: Critical ❌ (requires immediate action)
**Trend Indicators:**
- ↗️ Improving (positive trend)
- → Stable (consistent performance)
- ↘️ Declining (quality regression detected)
**Statistics:**
- **Mean Score**: Average truth score across all measurements
- **Median Score**: Middle value (less affected by outliers)
- **Standard Deviation**: Consistency of scores (lower = more consistent)
- **Confidence Interval**: Statistical reliability of measurements
### Verification Checks
#### Run Verification
Execute comprehensive verification checks on code, tasks, or agent outputs.
**File Verification:**
```bash
# Verify single file
npx claude-flow@alpha verify check --file src/app.js
# Verify directory recursively
npx claude-flow@alpha verify check --directory src/
# Verify with auto-fix enabled
npx claude-flow@alpha verify check --file src/utils.js --auto-fix
# Verify current working directory
npx claude-flow@alpha verify check
```
**Task Verification:**
```bash
# Verify specific task output
npx claude-flow@alpha verify check --task task-123
# Verify with custom threshold
npx claude-flow@alpha verify check --task task-456 --threshold 0.99
# Verbose output for debugging
npx claude-flow@alpha verify check --task task-789 --verbose
```
**Batch Verification:**
```bash
# Verify multiple files in parallel
npx claude-flow@alpha verify batch --files "*.js" --parallel
# Verify with pattern matching
npx claude-flow@alpha verify batch --pattern "src/**/*.ts"
# Integration test suite
npx claude-flow@alpha verify integration --test-suite full
```
#### Verification Criteria
The verification system evaluates:
1. **Code Correctness**
- Syntax validation
- Type checking (TypeScript)
- Logic flow analysis
- Error handling completeness
2. **Best Practices**
- Code style adherence
- SOLID principles
- Design patterns usage
- Modularity and reusability
3. **Security**
- Vulnerability scanning
- Secret detection
- Input validation
- Authentication/authorization checks
4. **Performance**
- Algorithmic complexity
- Memory usage patterns
- Database query optimization
- Bundle size impact
5. **Documentation**
- JSDoc/TypeDoc completeness
- README accuracy
- API documentation
- Code comments quality
#### JSON Output for CI/CD
```bash
# Get structured JSON output
npx claude-flow@alpha verify check --json > verification.json
# Example JSON structure:
{
"overallScore": 0.947,
"passed": true,
"threshold": 0.95,
"checks": [
{
"name": "code-correctness",
"score": 0.98,
"passed": true
},
{
"name": "security",
"score": 0.91,
"passed": false,
"issues": [...]
}
]
}
```
### Automatic Rollback
#### Rollback Failed Changes
Automatically revert changes that fail verification checks.
**Basic Rollback:**
```bash
# Rollback to last known good state
npx claude-flow@alpha verify rollback --last-good
# Rollback to specific commit
npx claude-flow@alpha verify rollback --to-commit abc123
# Interactive rollback with preview
npx claude-flow@alpha verify rollback --interactive
```
**Smart Rollback:**
```bash
# Rollback only failed files (preserve good changes)
npx claude-flow@alpha verify rollback --selective
# Rollback with automatic backup
npx claude-flow@alpha verify rollback --backup-first
# Dry-run mode (preview without executing)
npx claude-flow@alpha verify rollback --dry-run
```
**Rollback Performance:**
- Git-based rollback: <1 second
- Selective file rollback: <500ms
- Backup creation: Automatic before rollback
### Verification Reports
#### Generate Reports
Create detailed verification reports with metrics and visualizations.
**Report Formats:**
```bash
# JSON report
npx claude-flow@alpha verify report --format json
# HTML report with charts
npx claude-flow@alpha verify report --export metrics.html --format html
# CSV for data analysis
npx claude-flow@alpha verify report --format csv --export metrics.csv
# Markdown summary
npx claude-flow@alpha verify report --format markdown
```
**Time-based Reports:**
```bash
# Last 24 hours
npx claude-flow@alpha verify report --period 24h
# Last 7 days
npx claude-flow@alpha verify report --period 7d
# Last 30 days with trends
npx claude-flow@alpha verify report --period 30d --include-trends
# Custom date range
npx claude-flow@alpha verify report --from 2025-01-01 --to 2025-01-31
```
**Report Content:**
- Overall truth scores
- Per-agent performance metrics
- Task completion quality
- Verification pass/fail rates
- Rollback frequency
- Quality improvement trends
- Statistical confidence intervals
### Interactive Dashboard
#### Launch Dashboard
Run interactive web-based verification dashboard with real-time updates.
```bash
# Launch dashboard on default port (3000)
npx claude-flow@alpha verify dashboard
# Custom port
npx claude-flow@alpha verify dashboard --port 8080
# Export dashboard data
npx claude-flow@alpha verify dashboard --export
# Dashboard with auto-refresh
npx claude-flow@alpha verify dashboard --refresh 5s
```
**Dashboard Features:**
- Real-time truth score updates (WebSocket)
- Interactive charts and graphs
- Agent performance comparison
- Task history timeline
- Rollback history viewer
- Export to PDF/HTML
- Filter by time period/agent/score
### Configuration
#### Default Configuration
Set verification preferences in `.claude-flow/config.json`:
```json
{
"verification": {
"threshold": 0.95,
"autoRollback": true,
"gitIntegration": true,
"hooks": {
"preCommit": true,
"preTask": true,
"postEdit": true
},
"checks": {
"codeCorrectness": true,
"security": true,
"performance": true,
"documentation": true,
"bestPractices": true
}
},
"truth": {
"defaultFormat": "table",
"defaultPeriod": "24h",
"warningThreshold": 0.85,
"criticalThreshold": 0.75,
"autoExport": {
"enabled": true,
"path": ".claude-flow/metrics/truth-daily.json"
}
}
}
```
#### Threshold Configuration
**Adjust verification strictness:**
```bash
# Strict mode (99% accuracy required)
npx claude-flow@alpha verify check --threshold 0.99
# Lenient mode (90% acceptable)
npx claude-flow@alpha verify check --threshold 0.90
# Set default threshold
npx claude-flow@alpha config set verification.threshold 0.98
```
**Per-environment thresholds:**
```json
{
"verification": {
"thresholds": {
"production": 0.99,
"staging": 0.95,
"development": 0.90
}
}
}
```
### Integration Examples
#### CI/CD Integration
**GitHub Actions:**
```yaml
name: Quality Verification
on: [push, pull_request]
jobs:
verify:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Install Dependencies
run: npm install
- name: Run Verification
run: |
npx claude-flow@alpha verify check --json > verification.json
- name: Check Truth Score
run: |
score=$(jq '.overallScore' verification.json)
if (( $(echo "$score < 0.95" | bc -l) )); then
echo "Truth score too low: $score"
exit 1
fi
- name: Upload Report
uses: actions/upload-artifact@v3
with:
name: verification-report
path: verification.json
```
**GitLab CI:**
```yaml
verify:
stage: test
script:
- npx claude-flow@alpha verify check --threshold 0.95 --json > verification.json
- |
score=$(jq '.overallScore' verification.json)
if [ $(echo "$score < 0.95" | bc) -eq 1 ]; then
echo "Verification failed with score: $score"
exit 1
fi
artifacts:
paths:
- verification.json
reports:
junit: verification.json
```
#### Swarm Integration
Run verification automatically during swarm operations:
```bash
# Swarm with verification enabled
npx claude-flow@alpha swarm --verify --threshold 0.98
# Hive Mind with auto-rollback
npx claude-flow@alpha hive-mind --verify --rollback-on-fail
# Training pipeline with verification
npx claude-flow@alpha train --verify --threshold 0.99
```
#### Pair Programming Integration
Enable real-time verification during collaborative development:
```bash
# Pair with verification
npx claude-flow@alpha pair --verify --real-time
# Pair with custom threshold
npx claude-flow@alpha pair --verify --threshold 0.97 --auto-fix
```
### Advanced Workflows
#### Continuous Verification
Monitor codebase continuously during development:
```bash
# Watch directory for changes
npx claude-flow@alpha verify watch --directory src/
# Watch with auto-fix
npx claude-flow@alpha verify watch --directory src/ --auto-fix
# Watch with notifications
npx claude-flow@alpha verify watch --notify --threshold 0.95
```
#### Monitoring Integration
Send metrics to external monitoring systems:
```bash
# Export to Prometheus
npx claude-flow@alpha truth --format json | \
curl -X POST https://pushgateway.example.com/metrics/job/claude-flow \
-d @-
# Send to DataDog
npx claude-flow@alpha verify report --format json | \
curl -X POST "https://api.datadoghq.com/api/v1/series?api_key=${DD_API_KEY}" \
-H "Content-Type: application/json" \
-d @-
# Custom webhook
npx claude-flow@alpha truth --format json | \
curl -X POST https://metrics.example.com/api/truth \
-H "Content-Type: application/json" \
-d @-
```
#### Pre-commit Hooks
Automatically verify before commits:
```bash
# Install pre-commit hook
npx claude-flow@alpha verify install-hook --pre-commit
# .git/hooks/pre-commit example:
#!/bin/bash
npx claude-flow@alpha verify check --threshold 0.95 --json > /tmp/verify.json
score=$(jq '.overallScore' /tmp/verify.json)
if (( $(echo "$score < 0.95" | bc -l) )); then
echo "❌ Verification failed with score: $score"
echo "Run 'npx claude-flow@alpha verify check --verbose' for details"
exit 1
fi
echo "✅ Verification passed with score: $score"
```
### Performance Metrics
**Verification Speed:**
- Single file check: <100ms
- Directory scan: <500ms (per 100 files)
- Full codebase analysis: <5s (typical project)
- Truth score calculation: <50ms
**Rollback Speed:**
- Git-based rollback: <1s
- Selective file rollback: <500ms
- Backup creation: <2s
**Dashboard Performance:**
- Initial load: <1s
- Real-time updates: <100ms latency (WebSocket)
- Chart rendering: 60 FPS
### Troubleshooting
#### Common Issues
**Low Truth Scores:**
```bash
# Get detailed breakdown
npx claude-flow@alpha truth --verbose --threshold 0.0
# Check specific criteria
npx claude-flow@alpha verify check --verbose
# View agent-specific issues
npx claude-flow@alpha truth --agent <agent-name> --format json
```
**Rollback Failures:**
```bash
# Check git status
git status
# View rollback history
npx claude-flow@alpha verify rollback --history
# Manual rollback
git reset --hard HEAD~1
```
**Verification Timeouts:**
```bash
# Increase timeout
npx claude-flow@alpha verify check --timeout 60s
# Verify in batches
npx claude-flow@alpha verify batch --batch-size 10
```
### Exit Codes
Verification commands return standard exit codes:
- `0`: Verification passed (score ≥ threshold)
- `1`: Verification failed (score < threshold)
- `2`: Error during verification (invalid input, system error)
### Related Commands
- `npx claude-flow@alpha pair` - Collaborative development with verification
- `npx claude-flow@alpha train` - Training with verification feedback
- `npx claude-flow@alpha swarm` - Multi-agent coordination with quality checks
- `npx claude-flow@alpha report` - Generate comprehensive project reports
### Best Practices
1. **Set Appropriate Thresholds**: Use 0.99 for critical code, 0.95 for standard, 0.90 for experimental
2. **Enable Auto-rollback**: Prevent bad code from persisting
3. **Monitor Trends**: Track improvement over time, not just current scores
4. **Integrate with CI/CD**: Make verification part of your pipeline
5. **Use Watch Mode**: Get immediate feedback during development
6. **Export Metrics**: Track quality metrics in your monitoring system
7. **Review Rollbacks**: Understand why changes were rejected
8. **Train Agents**: Use verification feedback to improve agent performance
### Additional Resources
- Truth Scoring Algorithm: See `/docs/truth-scoring.md`
- Verification Criteria: See `/docs/verification-criteria.md`
- Integration Examples: See `/examples/verification/`
- API Reference: See `/docs/api/verification.md`