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

package/.claude/settings.reasoningbank-example.json

@@ -0,0 +1,124 @@
+{
+  "comment": "ReasoningBank-Enhanced Claude Code Settings - Copy sections to .claude/settings.json",
+  "env": {
+    "CLAUDE_FLOW_AUTO_COMMIT": "false",
+    "CLAUDE_FLOW_AUTO_PUSH": "false",
+    "CLAUDE_FLOW_HOOKS_ENABLED": "true",
+    "CLAUDE_FLOW_TELEMETRY_ENABLED": "true",
+    "CLAUDE_FLOW_REMOTE_EXECUTION": "true",
+    "CLAUDE_FLOW_CHECKPOINTS_ENABLED": "true",
+    "REASONINGBANK_ENABLED": "true"
+  },
+  "permissions": {
+    "allow": [
+      "Bash(npx claude-flow:*)",
+      "Bash(npm run lint)",
+      "Bash(npm run test:*)",
+      "Bash(npm test:*)",
+      "Bash(git status)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git push)",
+      "Bash(git config:*)",
+      "Bash(git tag:*)",
+      "Bash(git branch:*)",
+      "Bash(git checkout:*)",
+      "Bash(git stash:*)",
+      "Bash(jq:*)",
+      "Bash(node:*)",
+      "Bash(which:*)",
+      "Bash(pwd)",
+      "Bash(ls:*)"
+    ],
+    "deny": [
+      "Bash(rm -rf /)"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Query ReasoningBank before bash commands (adds <10ms)",
+            "command": "cat | jq -r '.tool_input.command // empty' | tr '\\n' '\\0' | xargs -0 -I {} bash -c 'CMD=\"{}\"; PATTERNS=$(npx claude-flow@alpha memory query \"$CMD\" --reasoningbank --limit 2 --format json 2>/dev/null || echo \"{}\"); if echo \"$PATTERNS\" | jq -e \".results | length > 0\" > /dev/null 2>&1; then COUNT=$(echo \"$PATTERNS\" | jq \".results | length\"); echo \"📚 Found $COUNT ReasoningBank pattern(s)\" >&2; fi; npx claude-flow@alpha hooks pre-command --command \"$CMD\" --validate-safety true'"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Load code patterns before editing",
+            "command": "cat | jq -r '.tool_input.file_path // .tool_input.path // empty' | tr '\\n' '\\0' | xargs -0 -I {} bash -c 'FILE=\"{}\"; if [ -n \"$FILE\" ]; then EXT=\"${FILE##*.}\"; PATTERNS=$(npx claude-flow@alpha memory query \"$EXT code patterns\" --namespace code --reasoningbank --limit 2 2>/dev/null || echo \"\"); if [ -n \"$PATTERNS\" ]; then echo \"📚 Loaded $EXT patterns from ReasoningBank\" >&2; fi; fi; npx claude-flow@alpha hooks pre-edit --file \"$FILE\" --auto-assign-agents true'"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Store successful bash patterns in ReasoningBank",
+            "command": "cat | jq -r '.tool_input.command // empty' | tr '\\n' '\\0' | xargs -0 -I {} bash -c 'CMD=\"{}\"; EXIT_CODE=$(jq -r \".result.exit_code // \\\"1\\\"\" 2>/dev/null); if [ \"$EXIT_CODE\" = \"0\" ]; then KEY=\"cmd_$(echo -n \"$CMD\" | md5sum 2>/dev/null | cut -d\" \" -f1 || echo $(date +%s))\"; DESC=\"Successful: $CMD\"; npx claude-flow@alpha memory store \"$KEY\" \"$DESC\" --namespace commands --reasoningbank --confidence 0.6 2>/dev/null; fi; npx claude-flow@alpha hooks post-command --command \"$CMD\" --track-metrics true'"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Store code patterns after successful edits",
+            "command": "cat | jq -r '.tool_input.file_path // .tool_input.path // empty' | tr '\\n' '\\0' | xargs -0 -I {} bash -c 'FILE=\"{}\"; if [ -f \"$FILE\" ]; then EXT=\"${FILE##*.}\"; TIMESTAMP=$(date +%s); KEY=\"edit_${EXT}_${TIMESTAMP}\"; DESC=\"Edited $EXT file: $(basename \"$FILE\")\"; npx claude-flow@alpha memory store \"$KEY\" \"$DESC\" --namespace code --reasoningbank --confidence 0.5 2>/dev/null; echo \"💾 Stored pattern in ReasoningBank\" >&2; fi; npx claude-flow@alpha hooks post-edit --file \"$FILE\" --format true'"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "manual",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Show session patterns before manual compact",
+            "command": "/bin/bash -c 'SESSION_COUNT=$(npx claude-flow@alpha memory stats --reasoningbank 2>/dev/null | grep -oP \"Total.*: \\K[0-9]+\" || echo \"0\"); echo \"🔄 PreCompact Guidance:\"; echo \"📋 IMPORTANT: Review CLAUDE.md for 54 agents and concurrent patterns\"; echo \"🧠 ReasoningBank: $SESSION_COUNT total patterns stored\"; echo \"✅ Ready for compact operation\"'"
+          }
+        ]
+      },
+      {
+        "matcher": "auto",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Auto-compact with ReasoningBank context",
+            "command": "/bin/bash -c 'TOP_PATTERNS=$(npx claude-flow@alpha memory list --reasoningbank --limit 3 2>/dev/null | grep -oP \"\\d+ patterns\" || echo \"patterns available\"); echo \"🔄 Auto-Compact (Context Full):\"; echo \"📚 ReasoningBank: $TOP_PATTERNS\"; echo \"⚡ GOLDEN RULE: Batch all operations in single messages\"; echo \"✅ Auto-compact proceeding with memory context\"'"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Consolidate ReasoningBank and generate session summary",
+            "command": "bash -c 'echo \"🧠 Consolidating ReasoningBank memory...\"; BEFORE=$(npx claude-flow@alpha memory stats --reasoningbank 2>/dev/null | grep -oP \"Total.*: \\K[0-9]+\" || echo \"0\"); npx claude-flow@alpha memory consolidate --reasoningbank --threshold 0.9 --prune-low-confidence 0.2 2>/dev/null && echo \"✅ Consolidated ReasoningBank (before: $BEFORE patterns)\" || echo \"⚠️ Consolidation skipped\"; npx claude-flow@alpha hooks session-end --generate-summary true --persist-state true --export-metrics true; echo \"✅ Session ended - ReasoningBank updated\"'"
+          }
+        ]
+      }
+    ]
+  },
+  "includeCoAuthoredBy": true,
+  "enabledMcpjsonServers": ["claude-flow", "ruv-swarm"],
+  "statusLine": {
+    "type": "command",
+    "command": ".claude/statusline-command.sh"
+  }
+}

package/.claude/settings.reasoningbank-minimal.json

@@ -0,0 +1,40 @@
+{
+  "comment": "MINIMAL ReasoningBank Integration - Lightweight version for testing",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Quick pattern query before editing (2-6ms overhead)",
+            "command": "cat | jq -r '.tool_input.file_path // .tool_input.path // empty' | xargs -I {} bash -c 'npx claude-flow@alpha memory query \"{}\" --reasoningbank --limit 2 2>&1 | grep -q \"Found\" && echo \"📚 ReasoningBank: Found patterns\" >&2 || true'"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Store successful edits (1-2ms overhead)",
+            "command": "cat | jq -r '.tool_input.file_path // .tool_input.path // empty' | xargs -I {} bash -c 'FILE=\"{}\"; [ -f \"$FILE\" ] && npx claude-flow@alpha memory store \"edit_$(basename $FILE)_$(date +%s)\" \"Edited: $FILE\" --namespace code --reasoningbank --confidence 0.5 2>/dev/null && echo \"💾 Pattern stored\" >&2 || true'"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "comment": "Consolidate at session end",
+            "command": "bash -c 'echo \"🧠 Consolidating ReasoningBank...\"; npx claude-flow@alpha memory consolidate --reasoningbank 2>/dev/null && echo \"✅ Memory consolidated\" || echo \"⚠️ Consolidation skipped\"'"
+          }
+        ]
+      }
+    ]
+  }
+}

package/.claude/skills/agentdb-memory-patterns/SKILL.md

@@ -0,0 +1,166 @@
+---
+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.
+
+## Prerequisites
+
+- agentic-flow v1.5.11+ or agentdb v1.0.4+
+- Node.js 18+
+- Understanding of agent architectures
+
+## Quick Start
+
+```typescript
+import { AgentDB, MemoryManager } from 'agentdb';
+
+// Initialize memory system
+const memory = new MemoryManager({
+  agentId: 'assistant-001',
+  persist: true,
+  ttl: 3600 * 24 * 30 // 30 days
+});
+
+// Store interaction
+await memory.store({
+  role: 'user',
+  content: 'What is the capital of France?',
+  timestamp: Date.now()
+});
+
+await memory.store({
+  role: 'assistant',
+  content: 'The capital of France is Paris.',
+  timestamp: Date.now()
+});
+
+// Retrieve context
+const context = await memory.getRecentContext({ limit: 10 });
+```
+
+## 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
+});
+```
+
+## Integration with ReasoningBank
+
+```typescript
+import { ReasoningBank } from 'agentic-flow/reasoningbank';
+
+// Connect memory to reasoning
+const rb = new ReasoningBank({
+  memory: memory,
+  learningRate: 0.1
+});
+
+// Learn from outcomes
+await rb.recordOutcome({
+  task: 'summarize_document',
+  approach: 'extractive',
+  success: true,
+  metrics: { accuracy: 0.95 }
+});
+
+// Get optimal strategy
+const strategy = await rb.getOptimalStrategy('summarize_document');
+```
+
+## Best Practices
+
+1. **Prune regularly**: Remove outdated or low-value memories
+2. **Use TTL**: Set time-to-live for ephemeral data
+3. **Index metadata**: Enable fast filtering by sessionId, userId
+4. **Compress old data**: Archive infrequently accessed memories
+
+## Troubleshooting
+
+### Issue: Memory growing too large
+**Solution**: Enable auto-pruning or set TTL values
+
+### Issue: Context not relevant
+**Solution**: Use vector search for semantic memory retrieval
+
+## Learn More
+
+- Memory API: packages/agentdb/docs/memory-api.md
+- ReasoningBank: agentic-flow/src/reasoningbank/README.md

package/.claude/skills/agentdb-vector-search/SKILL.md

@@ -0,0 +1,126 @@
+---
+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. Enables similarity search, hybrid search (vector + metadata), and real-time embedding generation.
+
+## Prerequisites
+
+- agentic-flow v1.5.11+ or agentdb v1.0.4+
+- Node.js 18+
+- OpenAI API key (for embeddings) or custom embedding model
+
+## Quick Start
+
+```typescript
+import { AgentDB } from 'agentdb';
+
+// Initialize AgentDB with vector support
+const db = new AgentDB({
+  persist: true,
+  vectorDimensions: 1536, // OpenAI ada-002 dimensions
+  enableVectorIndex: true
+});
+
+// Store documents with vectors
+await db.storeMemory({
+  text: "The quantum computer achieved 100 qubits",
+  metadata: { category: "technology", date: "2025-01-15" },
+  embedding: await generateEmbedding(text) // Your embedding function
+});
+
+// Semantic search
+const results = await db.searchSimilar(
+  queryEmbedding,
+  { limit: 10, threshold: 0.7 }
+);
+```
+
+## 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
+})));
+```
+
+## Performance Tips
+
+- **Indexing**: Enable vector index for 10-100x faster searches
+- **Batch Size**: Use batch operations for 1000+ documents
+- **Dimensions**: Match embedding model (1536 for OpenAI ada-002)
+- **Threshold**: Start at 0.7 for quality results
+
+## Troubleshooting
+
+### Issue: Slow search performance
+**Solution**: Enable vector index: `enableVectorIndex: true`
+
+### Issue: Poor relevance
+**Solution**: Adjust similarity threshold or use hybrid search
+
+## Learn More
+
+- AgentDB Docs: packages/agentdb/README.md
+- Vector DB API: packages/agentdb/docs/vector-api.md
+- Performance Guide: docs/agentdb/performance.md