agentic-flow 2.0.1-alpha.66 → 2.0.1-alpha.68

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

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

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

@@ -0,0 +1,87 @@
+{
+  "startTime": 1767544348034,
+  "sessionId": "session-1767544348034",
+  "lastActivity": 1767544348034,
+  "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/agents/.claude-flow/metrics/task-metrics.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "cmd-hooks-1767544348170",
+    "type": "hooks",
+    "success": true,
+    "duration": 6.133445999999992,
+    "timestamp": 1767544348176,
+    "metadata": {}
+  }
+]

package/.claude/skills/agentic-flow-quickstart/skill.md

@@ -0,0 +1,69 @@
+---
+name: agentic-flow-quickstart
+description: Quick start guide for agentic-flow - initialize, configure, and run
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - initialization
+  - configuration
+  - mcp_integration
+---
+
+# Agentic Flow Quickstart
+
+Initialize and configure agentic-flow for optimal Claude Code integration.
+
+## Quick Commands
+
+```bash
+# Initialize new project with agentic-flow
+npx agentic-flow@alpha init
+
+# Start MCP server for Claude Code
+npx agentic-flow@alpha mcp start
+
+# List available agents
+npx agentic-flow@alpha --list
+
+# Run a specific agent
+npx agentic-flow@alpha --agent coder --task "implement feature X"
+```
+
+## Features
+
+### 🤖 54+ Specialized Agents
+- Core: `coder`, `reviewer`, `tester`, `planner`, `researcher`
+- Swarm: `hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`
+- GitHub: `pr-manager`, `code-review-swarm`, `issue-tracker`
+- SPARC: `specification`, `pseudocode`, `architecture`, `refinement`
+
+### 🧠 ReasoningBank Learning Memory
+- Pattern recognition with 84.8% SWE-Bench solve rate
+- 150x faster vector search with HNSW
+- Cross-session memory persistence
+
+### ⚡ SONA Micro-LoRA Optimization
+- 0.05ms inference latency
+- 32.3% token reduction
+- Real-time learning adaptation
+
+### 🔗 MCP Integration
+- 213+ MCP tools available
+- Swarm coordination via claude-flow
+- GitHub integration via ruv-swarm
+
+## Configuration
+
+Settings are stored in `.claude/settings.json`:
+- Hooks for pre/post operations
+- Agent definitions
+- MCP server configuration
+- Statusline customization
+
+## Next Steps
+
+1. Run `npx agentic-flow@alpha init` to set up project
+2. Start MCP server with `npx agentic-flow@alpha mcp start`
+3. Use Claude Code's Task tool to spawn agents
+4. Monitor via statusline and metrics

package/.claude/skills/hooks-automation/skill.md

@@ -0,0 +1,155 @@
+---
+name: hooks-automation
+description: Configure Claude Code hooks for automated coordination and learning
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - pre_edit_hooks
+  - post_edit_hooks
+  - session_management
+  - metrics_tracking
+---
+
+# Hooks Automation Skill
+
+Configure intelligent hooks for automated coordination, formatting, and learning.
+
+## Available Hooks
+
+### PreToolUse Hooks
+Triggered before Claude Code tools execute.
+
+```json
+{
+  "PreToolUse": [
+    {
+      "matcher": "Edit|Write|MultiEdit",
+      "hooks": [{
+        "type": "command",
+        "command": "npx agentic-flow@alpha hooks pre-edit \"$TOOL_INPUT_file_path\""
+      }]
+    },
+    {
+      "matcher": "Bash",
+      "hooks": [{
+        "type": "command",
+        "command": "npx agentic-flow@alpha hooks pre-command \"$TOOL_INPUT_command\""
+      }]
+    }
+  ]
+}
+```
+
+### PostToolUse Hooks
+Triggered after successful tool execution.
+
+```json
+{
+  "PostToolUse": [
+    {
+      "matcher": "Edit|Write|MultiEdit",
+      "hooks": [{
+        "type": "command",
+        "command": "npx agentic-flow@alpha hooks post-edit \"$TOOL_INPUT_file_path\" --success"
+      }]
+    }
+  ]
+}
+```
+
+### Session Hooks
+Triggered at session start/end.
+
+```json
+{
+  "SessionStart": [{
+    "hooks": [{
+      "type": "command",
+      "command": "npx agentic-flow@alpha hooks intelligence stats --json"
+    }]
+  }],
+  "SessionEnd": [{
+    "hooks": [{
+      "type": "command",
+      "command": "npx agentic-flow@alpha hooks metrics --session --json"
+    }]
+  }]
+}
+```
+
+## Hook Commands
+
+```bash
+# Pre-edit: Check for patterns, validate
+npx agentic-flow@alpha hooks pre-edit "src/api.ts"
+
+# Post-edit: Format, learn pattern
+npx agentic-flow@alpha hooks post-edit "src/api.ts" --success
+
+# Pre-command: Validate safety
+npx agentic-flow@alpha hooks pre-command "npm install"
+
+# Post-command: Track result
+npx agentic-flow@alpha hooks post-command "npm install"
+
+# Intelligence routing
+npx agentic-flow@alpha hooks route "implement OAuth"
+
+# Session metrics
+npx agentic-flow@alpha hooks metrics --session
+```
+
+## Automation Features
+
+### Auto-Agent Assignment
+Hooks automatically assign specialized agents based on file type:
+- `.ts`, `.tsx` → TypeScript agent
+- `.py` → Python agent
+- `.md` → Documentation agent
+- `test.*` → Testing agent
+
+### Command Validation
+Pre-command hooks validate for:
+- Dangerous patterns (rm -rf, force push)
+- Permission requirements
+- Resource limits
+
+### Pattern Learning
+Post-edit hooks learn:
+- Code patterns
+- Successful solutions
+- Error recovery strategies
+
+### Metrics Tracking
+Session hooks track:
+- Token usage
+- Tool invocations
+- Success rates
+- Performance metrics
+
+## Configuration
+
+Full hook configuration in `.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [...],
+    "PostToolUse": [...],
+    "PostToolUseFailure": [...],
+    "SessionStart": [...],
+    "SessionEnd": [...],
+    "UserPromptSubmit": [...],
+    "Stop": [...]
+  }
+}
+```
+
+## Best Practices
+
+1. **Keep hooks fast**: <100ms for interactive experience
+2. **Use timeout**: Prevent hanging hooks
+3. **Handle failures gracefully**: Use `|| true` for optional hooks
+4. **Log metrics**: Track for optimization
+5. **Test hooks**: Verify before deployment

package/.claude/skills/memory-patterns/skill.md

@@ -0,0 +1,110 @@
+---
+name: memory-patterns
+description: Persistent memory patterns for cross-session learning and context retention
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - memory_store
+  - memory_retrieve
+  - pattern_learning
+  - context_management
+---
+
+# Memory Patterns Skill
+
+Implement persistent memory patterns for AI agents using ReasoningBank.
+
+## Quick Commands
+
+```bash
+# Store a pattern
+npx agentic-flow@alpha memory store "api:auth" "OAuth2 with JWT"
+
+# Retrieve a pattern
+npx agentic-flow@alpha memory get "api:auth"
+
+# Search patterns
+npx agentic-flow@alpha memory search "authentication"
+
+# List all patterns
+npx agentic-flow@alpha memory list --namespace project
+```
+
+## Memory Namespaces
+
+| Namespace | Purpose | TTL |
+|-----------|---------|-----|
+| `session` | Current session context | Until end |
+| `project` | Project-specific learnings | Permanent |
+| `user` | User preferences | Permanent |
+| `swarm` | Swarm coordination state | Swarm lifetime |
+| `cache` | Temporary cached data | 1 hour |
+
+## Pattern Types
+
+### Decision Patterns
+```bash
+# Store decision with context
+npx agentic-flow@alpha memory store \
+  "decisions:auth-method" \
+  '{"choice": "JWT", "reason": "stateless, scalable", "date": "2024-01-01"}'
+```
+
+### Code Patterns
+```bash
+# Store reusable code pattern
+npx agentic-flow@alpha memory store \
+  "patterns:error-handling" \
+  "try-catch with custom error classes and logging"
+```
+
+### Learning Patterns
+```bash
+# Store learning from successful task
+npx agentic-flow@alpha memory store \
+  "learnings:react-hooks" \
+  "useCallback for event handlers, useMemo for expensive computations"
+```
+
+## MCP Tools
+
+```javascript
+// Store memory
+mcp__claude-flow__memory_usage({
+  action: "store",
+  key: "project:architecture",
+  value: "microservices with event-driven communication",
+  namespace: "project"
+})
+
+// Retrieve memory
+mcp__claude-flow__memory_usage({
+  action: "retrieve",
+  key: "project:architecture",
+  namespace: "project"
+})
+
+// Search memories
+mcp__claude-flow__memory_search({
+  pattern: "auth*",
+  namespace: "project",
+  limit: 10
+})
+```
+
+## ReasoningBank Integration
+
+ReasoningBank provides:
+- **150x faster** vector search with HNSW
+- **Reflexion memory** for self-improvement
+- **Skill library** for learned capabilities
+- **Causal graphs** for decision tracking
+
+## Best Practices
+
+1. **Use namespaces**: Organize by scope
+2. **Be specific**: Clear, searchable keys
+3. **Include context**: Store decisions with reasoning
+4. **Clean up**: Delete stale patterns
+5. **Version patterns**: Track changes over time

package/.claude/skills/sparc-methodology/skill.md

@@ -0,0 +1,137 @@
+---
+name: sparc-methodology
+description: SPARC development methodology for systematic test-driven development
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - specification
+  - pseudocode
+  - architecture
+  - refinement
+  - completion
+---
+
+# SPARC Methodology Skill
+
+Systematic Test-Driven Development using SPARC (Specification, Pseudocode, Architecture, Refinement, Completion).
+
+## Quick Commands
+
+```bash
+# Run complete TDD workflow
+npx agentic-flow@alpha sparc tdd "implement user authentication"
+
+# Run specific phase
+npx agentic-flow@alpha sparc run specification "auth system"
+npx agentic-flow@alpha sparc run pseudocode "auth system"
+npx agentic-flow@alpha sparc run architect "auth system"
+npx agentic-flow@alpha sparc run refinement "auth system"
+npx agentic-flow@alpha sparc run completion "auth system"
+
+# Batch execution
+npx agentic-flow@alpha sparc batch "spec-pseudocode,architect" "feature X"
+```
+
+## SPARC Phases
+
+### 1. Specification (spec)
+Define requirements and acceptance criteria.
+
+**Agent**: `specification`
+**Output**: Requirements doc, test cases
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run spec "user login feature"
+```
+
+### 2. Pseudocode (pseudo)
+Design algorithms and logic flow.
+
+**Agent**: `pseudocode`
+**Output**: Algorithm design, flow diagrams
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run pseudo "auth flow"
+```
+
+### 3. Architecture (arch)
+System design and component structure.
+
+**Agent**: `architecture`
+**Output**: Component diagram, API design
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run arch "microservices layout"
+```
+
+### 4. Refinement (refine)
+Iterative TDD implementation.
+
+**Agent**: `refinement`
+**Output**: Tests + Implementation
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run refine "auth module"
+```
+
+### 5. Completion (complete)
+Integration and deployment.
+
+**Agent**: `completion`
+**Output**: Integrated system, docs
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run complete "auth system"
+```
+
+## SPARC Modes
+
+Additional specialized modes:
+
+| Mode | Description |
+|------|-------------|
+| `dev` | General development |
+| `api` | API design |
+| `ui` | UI/UX development |
+| `test` | Testing focus |
+| `refactor` | Code improvement |
+| `debug` | Bug investigation |
+| `security` | Security review |
+| `devops` | CI/CD setup |
+
+## TDD Workflow
+
+```bash
+# Full TDD cycle
+npx agentic-flow@alpha sparc tdd "implement OAuth2"
+
+# This runs:
+# 1. Specification: Define requirements
+# 2. Pseudocode: Design algorithm
+# 3. Architecture: Plan structure
+# 4. Refinement: Write tests first, then implement
+# 5. Completion: Integrate and document
+```
+
+## Agent Integration
+
+SPARC uses specialized agents:
+
+```javascript
+// Via Claude Code Task tool
+Task("Specification agent", "Define requirements for OAuth", "specification")
+Task("Architecture agent", "Design OAuth architecture", "architecture")
+Task("Coder agent", "Implement OAuth with TDD", "sparc-coder")
+Task("Tester agent", "Verify OAuth implementation", "tester")
+Task("Reviewer agent", "Review OAuth code quality", "reviewer")
+```
+
+## Best Practices
+
+1. **Start with specification**: Clear requirements first
+2. **Write tests first**: TDD in refinement phase
+3. **Iterate small**: Small increments
+4. **Document as you go**: Keep docs updated
+5. **Review at each phase**: Quality gates
+6. **Use parallel execution**: Multiple agents

package/.claude/skills/swarm-coordination/skill.md

@@ -0,0 +1,94 @@
+---
+name: swarm-coordination
+description: Orchestrate multi-agent swarms for complex parallel task execution
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - swarm_init
+  - agent_spawn
+  - task_orchestration
+  - topology_optimization
+---
+
+# Swarm Coordination Skill
+
+Coordinate multi-agent swarms for parallel task execution with intelligent topology selection.
+
+## Quick Start
+
+```bash
+# Initialize a mesh swarm with 5 agents
+npx agentic-flow@alpha swarm init --topology mesh --agents 5
+
+# Spawn specialized agents
+npx agentic-flow@alpha swarm spawn --type researcher --name "Research Agent"
+npx agentic-flow@alpha swarm spawn --type coder --name "Code Agent"
+
+# Orchestrate a task
+npx agentic-flow@alpha swarm orchestrate "Implement feature X with tests"
+
+# Check swarm status
+npx agentic-flow@alpha swarm status
+```
+
+## Topologies
+
+### Mesh (Default)
+- All agents communicate directly
+- Best for: Collaborative tasks, code review
+- Latency: Low
+- Scalability: Medium
+
+### Hierarchical
+- Tree structure with coordinator
+- Best for: Large projects, delegation
+- Latency: Medium
+- Scalability: High
+
+### Ring
+- Sequential communication
+- Best for: Pipeline processing, CI/CD
+- Latency: Higher
+- Scalability: Medium
+
+### Star
+- Central hub coordinates all
+- Best for: Simple coordination
+- Latency: Low
+- Scalability: Low
+
+## Agent Types
+
+| Type | Description | Use Case |
+|------|-------------|----------|
+| researcher | Deep analysis | Requirements gathering |
+| coder | Implementation | Feature development |
+| tester | Quality assurance | Test creation |
+| reviewer | Code quality | PR review |
+| architect | System design | Architecture decisions |
+| coordinator | Task routing | Complex workflows |
+
+## MCP Tools
+
+```javascript
+// Initialize swarm
+mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 8 })
+
+// Spawn agent
+mcp__claude-flow__agent_spawn({ type: "coder", name: "Feature Dev" })
+
+// Orchestrate task
+mcp__claude-flow__task_orchestrate({
+  task: "Implement OAuth",
+  strategy: "parallel"
+})
+```
+
+## Best Practices
+
+1. **Right-size your swarm**: Start with 3-5 agents
+2. **Choose topology wisely**: Match to task structure
+3. **Use Claude Code Task tool**: For actual agent spawning
+4. **Monitor status**: Check for bottlenecks
+5. **Clean up**: Destroy swarm when done