@claude-flow/cli 3.7.0-alpha.1 → 3.7.0-alpha.10

package/.claude/skills/reasoningbank-intelligence/SKILL.md

@@ -1,201 +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 v3.0.0-alpha.1+
-- AgentDB v3.0.0-alpha.10+ (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
+---
+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 v3.0.0-alpha.1+
+- AgentDB v3.0.0-alpha.10+ (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