claude-flow 2.7.0-alpha.10 → 2.7.0-alpha.12

package/docs/reasoningbank/EXAMPLES.md

@@ -0,0 +1,611 @@
+# ReasoningBank Examples & Code Snippets
+
+## Quick Reference
+
+This document provides ready-to-use examples and code snippets for common ReasoningBank operations.
+
+## Table of Contents
+
+- [CLI Examples](#cli-examples)
+- [JavaScript/TypeScript Examples](#javascripttypescript-examples)
+- [Use Case Examples](#use-case-examples)
+- [Integration Patterns](#integration-patterns)
+
+---
+
+## CLI Examples
+
+### Basic Operations
+
+```bash
+# Store a simple pattern
+npx claude-flow@alpha memory store api_key \
+  "JWT tokens with HMAC SHA256 signing" \
+  --namespace backend --reasoningbank
+
+# Query with semantic search
+npx claude-flow@alpha memory query "authentication" \
+  --namespace backend --reasoningbank
+
+# List all patterns in namespace
+npx claude-flow@alpha memory list --namespace backend --reasoningbank
+
+# Delete a pattern
+npx claude-flow@alpha memory delete api_key \
+  --namespace backend --reasoningbank
+
+# Check system status
+npx claude-flow@alpha memory status --reasoningbank
+```
+
+### Advanced Queries
+
+```bash
+# Query with confidence threshold
+npx claude-flow@alpha memory query "security" \
+  --min-confidence 0.7 --reasoningbank
+
+# Query with similarity threshold
+npx claude-flow@alpha memory query "performance" \
+  --min-similarity 0.8 --reasoningbank
+
+# Cross-namespace search
+npx claude-flow@alpha memory query "API design" --reasoningbank
+
+# Query with limit
+npx claude-flow@alpha memory query "optimization" \
+  --limit 5 --reasoningbank
+```
+
+### Cognitive Patterns
+
+```bash
+# Store with cognitive pattern
+npx claude-flow@alpha memory store debug_strategy \
+  "Use binary search to isolate bugs" \
+  --cognitive-pattern convergent \
+  --reasoningbank
+
+# Query by cognitive pattern
+npx claude-flow@alpha memory query "problem solving" \
+  --cognitive-pattern divergent --reasoningbank
+```
+
+---
+
+## JavaScript/TypeScript Examples
+
+### Basic Integration
+
+```javascript
+import { spawn } from 'child_process';
+import path from 'path';
+
+class ReasoningBankClient {
+  constructor() {
+    this.messageId = 0;
+    this.pendingRequests = new Map();
+  }
+
+  async initialize() {
+    // Spawn agentic-flow process
+    const agenticFlowPath = path.join(
+      process.cwd(),
+      'node_modules/agentic-flow/dist/index.js'
+    );
+
+    this.process = spawn('node', [agenticFlowPath]);
+
+    // Handle responses
+    this.process.stdout.on('data', data => {
+      try {
+        const response = JSON.parse(data.toString());
+        const handler = this.pendingRequests.get(response.id);
+
+        if (handler) {
+          if (response.error) {
+            handler.reject(new Error(response.error.message));
+          } else {
+            handler.resolve(response.result);
+          }
+          this.pendingRequests.delete(response.id);
+        }
+      } catch (err) {
+        console.error('Failed to parse response:', err);
+      }
+    });
+
+    this.process.stderr.on('data', data => {
+      console.error('agentic-flow error:', data.toString());
+    });
+  }
+
+  async sendRequest(method, params) {
+    const id = ++this.messageId;
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error('Request timeout'));
+      }, 30000); // 30 second timeout
+
+      this.pendingRequests.set(id, {
+        resolve: result => {
+          clearTimeout(timeout);
+          resolve(result);
+        },
+        reject: error => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+
+      const request = JSON.stringify({
+        jsonrpc: '2.0',
+        method,
+        params,
+        id
+      });
+
+      this.process.stdin.write(request + '\n');
+    });
+  }
+
+  async storePattern(title, content, options = {}) {
+    return this.sendRequest('storePattern', {
+      title,
+      content,
+      namespace: options.namespace || 'default',
+      components: options.components || {}
+    });
+  }
+
+  async query(query, options = {}) {
+    return this.sendRequest('searchPatterns', {
+      query,
+      namespace: options.namespace || 'default',
+      limit: options.limit || 10,
+      minConfidence: options.minConfidence,
+      minSimilarity: options.minSimilarity
+    });
+  }
+
+  async getPattern(id) {
+    return this.sendRequest('getPattern', { id });
+  }
+
+  async deletePattern(id) {
+    return this.sendRequest('deletePattern', { id });
+  }
+
+  async getStatistics(namespace) {
+    return this.sendRequest('getStatistics', { namespace });
+  }
+
+  shutdown() {
+    if (this.process) {
+      this.process.kill();
+    }
+  }
+}
+
+// Usage
+const client = new ReasoningBankClient();
+await client.initialize();
+
+// Store a pattern
+await client.storePattern('jwt_auth', 'JWT with refresh tokens', {
+  namespace: 'backend',
+  components: { reliability: 0.8 }
+});
+
+// Query patterns
+const results = await client.query('authentication', {
+  namespace: 'backend',
+  limit: 5
+});
+
+console.log('Found patterns:', results);
+
+// Cleanup
+client.shutdown();
+```
+
+### Self-Learning Agent
+
+```javascript
+class SelfLearningAgent {
+  constructor(namespace) {
+    this.namespace = namespace;
+    this.client = new ReasoningBankClient();
+  }
+
+  async initialize() {
+    await this.client.initialize();
+  }
+
+  async learn(task, outcome, notes) {
+    // Store the task as a pattern
+    await this.client.storePattern(
+      `task_${Date.now()}`,
+      `${task} - ${notes}`,
+      {
+        namespace: this.namespace,
+        components: {
+          reliability: outcome === 'success' ? 0.7 : 0.3,
+          task_type: this.classifyTask(task),
+          outcome,
+          timestamp: Date.now()
+        }
+      }
+    );
+  }
+
+  async recall(query, options = {}) {
+    // Query relevant past experiences
+    const results = await this.client.query(query, {
+      namespace: this.namespace,
+      minConfidence: options.minConfidence || 0.5,
+      limit: options.limit || 5
+    });
+
+    // Sort by reliability
+    return results.sort((a, b) =>
+      (b.components?.reliability || 0) - (a.components?.reliability || 0)
+    );
+  }
+
+  async solve(task) {
+    // 1. Recall similar past tasks
+    const similarTasks = await this.recall(task, { minConfidence: 0.6 });
+
+    if (similarTasks.length === 0) {
+      console.log('No prior experience found. Exploring...');
+      return this.exploreNewSolution(task);
+    }
+
+    // 2. Apply highest confidence approach
+    const bestApproach = similarTasks[0];
+    console.log(`Applying approach: ${bestApproach.title}`);
+    console.log(`Confidence: ${(bestApproach.components.reliability * 100).toFixed(0)}%`);
+
+    // 3. Execute approach
+    const result = await this.executeApproach(bestApproach, task);
+
+    // 4. Learn from outcome
+    await this.learn(task, result.success ? 'success' : 'failure', result.notes);
+
+    return result;
+  }
+
+  async exploreNewSolution(task) {
+    // Implement exploration logic
+    return {
+      success: false,
+      notes: 'Exploration in progress'
+    };
+  }
+
+  async executeApproach(approach, task) {
+    // Implement execution logic
+    return {
+      success: true,
+      notes: `Successfully applied ${approach.title}`
+    };
+  }
+
+  classifyTask(task) {
+    // Simple classification based on keywords
+    const keywords = task.toLowerCase();
+
+    if (keywords.includes('auth') || keywords.includes('login')) {
+      return 'authentication';
+    } else if (keywords.includes('database') || keywords.includes('query')) {
+      return 'database';
+    } else if (keywords.includes('api')) {
+      return 'api';
+    } else {
+      return 'general';
+    }
+  }
+
+  shutdown() {
+    this.client.shutdown();
+  }
+}
+
+// Usage
+const agent = new SelfLearningAgent('development');
+await agent.initialize();
+
+// Agent learns from experience
+await agent.solve('Implement user authentication');
+await agent.solve('Build REST API endpoints');
+await agent.solve('Add JWT token validation');
+
+// Agent gets smarter over time!
+const approaches = await agent.recall('authentication');
+console.log('Learned approaches:', approaches);
+
+agent.shutdown();
+```
+
+---
+
+## Use Case Examples
+
+### 1. Team Knowledge Base
+
+```bash
+# Team members store architectural decisions
+npx claude-flow@alpha memory store arch_001 \
+  "Microservices with event-driven architecture using Kafka" \
+  --namespace team_decisions --reasoningbank
+
+npx claude-flow@alpha memory store arch_002 \
+  "Use PostgreSQL for transactional data, Redis for caching" \
+  --namespace team_decisions --reasoningbank
+
+npx claude-flow@alpha memory store arch_003 \
+  "API Gateway pattern with Kong for rate limiting and auth" \
+  --namespace team_decisions --reasoningbank
+
+# New team member queries decisions
+npx claude-flow@alpha memory query "message queue" \
+  --namespace team_decisions --reasoningbank
+# Returns: arch_001 (Kafka decision)
+
+npx claude-flow@alpha memory query "database choice" \
+  --namespace team_decisions --reasoningbank
+# Returns: arch_002 (PostgreSQL/Redis)
+```
+
+### 2. Bug Solution Database
+
+```bash
+# Store bug solutions as you fix them
+npx claude-flow@alpha memory store bug_cors_error \
+  "CORS error on API calls: Add Access-Control-Allow-Origin header in Express middleware" \
+  --namespace debugging --reasoningbank
+
+npx claude-flow@alpha memory store bug_react_rerender \
+  "Infinite re-renders in useEffect: Use useRef for values that don't need re-renders" \
+  --namespace debugging --reasoningbank
+
+npx claude-flow@alpha memory store bug_memory_leak \
+  "Memory leak in React: Clean up subscriptions in useEffect return function" \
+  --namespace debugging --reasoningbank
+
+# Later, when you encounter similar bugs
+npx claude-flow@alpha memory query "React infinite loop" \
+  --namespace debugging --reasoningbank
+# Instantly finds the solution!
+```
+
+### 3. API Best Practices Library
+
+```bash
+# Build a library of API patterns
+npx claude-flow@alpha memory store api_versioning \
+  "Use /api/v1/, /api/v2/ URL versioning for backward compatibility" \
+  --namespace api_patterns --reasoningbank
+
+npx claude-flow@alpha memory store api_pagination \
+  "Cursor-based pagination: /api/items?limit=20&cursor=abc123" \
+  --namespace api_patterns --reasoningbank
+
+npx claude-flow@alpha memory store api_error_format \
+  'Consistent error format: {"error": true, "message": "...", "code": 400}' \
+  --namespace api_patterns --reasoningbank
+
+npx claude-flow@alpha memory store api_rate_limiting \
+  "100 requests/minute per IP using sliding window algorithm" \
+  --namespace api_patterns --reasoningbank
+
+# Query when designing new API
+npx claude-flow@alpha memory query "API response format" \
+  --namespace api_patterns --reasoningbank
+```
+
+---
+
+## Integration Patterns
+
+### Pattern 1: Pre-Task Retrieval
+
+```javascript
+// Before starting a task, retrieve relevant patterns
+async function executeTask(task) {
+  // 1. Query ReasoningBank
+  const relevantPatterns = await reasoningBank.query(task.description, {
+    namespace: task.domain,
+    limit: 3
+  });
+
+  // 2. Display patterns to user/agent
+  console.log('Relevant past experiences:');
+  relevantPatterns.forEach((pattern, i) => {
+    console.log(`${i + 1}. ${pattern.title} (${(pattern.score * 100).toFixed(0)}% match)`);
+    console.log(`   ${pattern.content}`);
+  });
+
+  // 3. Ask user/agent to select or proceed with new approach
+  const selected = await promptUser('Use which pattern? (0 for new)');
+
+  if (selected > 0) {
+    return applyPattern(relevantPatterns[selected - 1], task);
+  } else {
+    return exploreNewApproach(task);
+  }
+}
+```
+
+### Pattern 2: Post-Task Learning
+
+```javascript
+// After completing a task, store the outcome
+async function completeTask(task, outcome) {
+  // 1. Store pattern with outcome
+  await reasoningBank.storePattern(
+    `${task.type}_${Date.now()}`,
+    task.solution,
+    {
+      namespace: task.domain,
+      components: {
+        reliability: outcome.success ? 0.7 : 0.3,
+        duration_ms: outcome.duration,
+        outcome: outcome.success ? 'success' : 'failure',
+        error: outcome.error
+      }
+    }
+  );
+
+  // 2. If similar pattern exists, update its confidence
+  if (outcome.basedOnPattern) {
+    const existingPattern = await reasoningBank.getPattern(outcome.basedOnPattern);
+
+    if (outcome.success) {
+      existingPattern.components.reliability += 0.1;
+    } else {
+      existingPattern.components.reliability -= 0.15;
+    }
+
+    await reasoningBank.updatePattern(existingPattern.id, existingPattern);
+  }
+}
+```
+
+### Pattern 3: Continuous Learning Loop
+
+```javascript
+// Implement SAFLA (Self-Aware Feedback Loop Algorithm)
+class SAFLAAgent {
+  async executeSAFLACycle(task) {
+    // 1. OBSERVE: Retrieve relevant patterns
+    const patterns = await this.reasoningBank.query(task, {
+      namespace: this.namespace,
+      minConfidence: 0.4
+    });
+
+    // 2. ANALYZE: Evaluate pattern relevance and confidence
+    const analysis = this.analyzePatterns(patterns);
+
+    // 3. LEARN: Select best approach
+    const selectedPattern = analysis.bestPattern;
+
+    // 4. ADAPT: Execute with selected pattern
+    const result = await this.execute(selectedPattern, task);
+
+    // 5. FEEDBACK: Update confidence and store outcome
+    await this.updateConfidence(selectedPattern.id, result.success);
+    await this.storeOutcome(task, result);
+
+    // Return to step 1 for next task
+    return result;
+  }
+
+  analyzePatterns(patterns) {
+    return {
+      bestPattern: patterns[0],
+      alternatives: patterns.slice(1),
+      confidence: patterns[0]?.components.reliability || 0.5
+    };
+  }
+
+  async updateConfidence(patternId, success) {
+    const pattern = await this.reasoningBank.getPattern(patternId);
+
+    if (success) {
+      pattern.components.reliability = Math.min(
+        1.0,
+        pattern.components.reliability + 0.15
+      );
+    } else {
+      pattern.components.reliability = Math.max(
+        0.0,
+        pattern.components.reliability - 0.1
+      );
+    }
+
+    await this.reasoningBank.updatePattern(patternId, pattern);
+  }
+}
+```
+
+---
+
+## Shell Scripts
+
+### Bulk Import
+
+```bash
+#!/bin/bash
+# bulk-import.sh - Import patterns from CSV file
+
+# CSV format: title,content,namespace
+while IFS=',' read -r title content namespace; do
+  npx claude-flow@alpha memory store "$title" "$content" \
+    --namespace "$namespace" --reasoningbank
+done < patterns.csv
+
+echo "Import complete!"
+```
+
+### Backup & Restore
+
+```bash
+#!/bin/bash
+# backup-memory.sh - Backup ReasoningBank database
+
+BACKUP_DIR="backups/$(date +%Y%m%d_%H%M%S)"
+mkdir -p "$BACKUP_DIR"
+
+# Copy database
+cp .swarm/memory.db "$BACKUP_DIR/"
+
+# Export as JSON (if feature available)
+npx claude-flow@alpha memory export --all > "$BACKUP_DIR/patterns.json"
+
+echo "Backup saved to $BACKUP_DIR"
+```
+
+### Generate Report
+
+```bash
+#!/bin/bash
+# report.sh - Generate usage report
+
+echo "ReasoningBank Usage Report"
+echo "=========================="
+echo ""
+
+npx claude-flow@alpha memory status --detailed --reasoningbank | \
+  grep -E "(Total Patterns|Most Used|Average Confidence)"
+
+echo ""
+echo "Namespaces:"
+npx claude-flow@alpha memory list --reasoningbank | \
+  grep -E "^├──|^└──"
+```
+
+---
+
+## Summary
+
+This document provided:
+
+- ✅ CLI command examples
+- ✅ JavaScript/TypeScript integration code
+- ✅ Real-world use cases
+- ✅ Integration patterns (pre-task, post-task, SAFLA)
+- ✅ Shell scripts for automation
+
+For more examples, see:
+- **[Basic Tutorial](./tutorial-basic.md)** - Step-by-step learning
+- **[Advanced Tutorial](./tutorial-advanced.md)** - Advanced patterns
+- **[Architecture](./architecture.md)** - Implementation details
+
+---
+
+**Last Updated**: 2025-10-14
+**Version**: v2.7.0-alpha.10