agentic-flow 1.6.5 → 1.7.2

package/.claude/agents/test-neural.md

@@ -1,3 +1,8 @@
+---
+name: test-neural
+description: Test agent for validating neural network tool access
+---
+
 # Test Neural Agent
 
 Test agent for validating neural network tool access.

package/.claude/settings.json

@@ -9,32 +9,33 @@
   },
   "permissions": {
     "allow": [
-      "Bash(npx claude-flow *)",
+      "Bash(npx claude-flow:*)",
       "Bash(npm run lint)",
       "Bash(npm run test:*)",
-      "Bash(npm test *)",
+      "Bash(npm test:*)",
       "Bash(git status)",
-      "Bash(git diff *)",
-      "Bash(git log *)",
-      "Bash(git add *)",
-      "Bash(git commit *)",
+      "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(git config:*)",
+      "Bash(git tag:*)",
+      "Bash(git branch:*)",
+      "Bash(git checkout:*)",
+      "Bash(git stash:*)",
+      "Bash(jq:*)",
+      "Bash(node:*)",
+      "Bash(which:*)",
       "Bash(pwd)",
-      "Bash(ls *)"
+      "Bash(ls:*)",
+      "mcp__ruv-swarm",
+      "mcp__claude-flow@alpha",
+      "mcp__flow-nexus",
+      "WebSearch"
     ],
     "deny": [
-      "Bash(rm -rf /)",
-      "Bash(curl * | bash)",
-      "Bash(wget * | sh)",
-      "Bash(eval *)"
+      "Bash(rm -rf /)"
     ]
   },
   "hooks": {

package/.claude/skills/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}

package/.claude/skills/.claude-flow/metrics/performance.json

@@ -0,0 +1,87 @@
+{
+  "startTime": 1760906504131,
+  "sessionId": "session-1760906504131",
+  "lastActivity": 1760906504131,
+  "sessionDuration": 0,
+  "totalTasks": 1,
+  "successfulTasks": 1,
+  "failedTasks": 0,
+  "totalAgents": 0,
+  "activeAgents": 0,
+  "neuralEvents": 0,
+  "memoryMode": {
+    "reasoningbankOperations": 0,
+    "basicOperations": 0,
+    "autoModeSelections": 0,
+    "modeOverrides": 0,
+    "currentMode": "auto"
+  },
+  "operations": {
+    "store": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "retrieve": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "query": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "list": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "delete": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "search": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    },
+    "init": {
+      "count": 0,
+      "totalDuration": 0,
+      "errors": 0
+    }
+  },
+  "performance": {
+    "avgOperationDuration": 0,
+    "minOperationDuration": null,
+    "maxOperationDuration": null,
+    "slowOperations": 0,
+    "fastOperations": 0,
+    "totalOperationTime": 0
+  },
+  "storage": {
+    "totalEntries": 0,
+    "reasoningbankEntries": 0,
+    "basicEntries": 0,
+    "databaseSize": 0,
+    "lastBackup": null,
+    "growthRate": 0
+  },
+  "errors": {
+    "total": 0,
+    "byType": {},
+    "byOperation": {},
+    "recent": []
+  },
+  "reasoningbank": {
+    "semanticSearches": 0,
+    "sqlFallbacks": 0,
+    "embeddingGenerated": 0,
+    "consolidations": 0,
+    "avgQueryTime": 0,
+    "cacheHits": 0,
+    "cacheMisses": 0
+  }
+}

package/.claude/skills/.claude-flow/metrics/task-metrics.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "cmd-hooks-1760906504281",
+    "type": "hooks",
+    "success": true,
+    "duration": 7.810163999999986,
+    "timestamp": 1760906504289,
+    "metadata": {}
+  }
+]

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

package/.claude/skills/agentic-flow/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