agentic-flow 3.0.0-alpha.1 → 3.0.0

package/.claude/agents/github/release-manager.md

@@ -3,6 +3,11 @@ name: release-manager
 description: Automated release coordination and deployment with ruv-swarm orchestration for seamless version management, testing, and deployment across multiple packages
 type: development
 color: "#FF6B35"
+capabilities:
+  - self_learning         # ReasoningBank pattern storage
+  - context_enhancement   # GNN-enhanced search
+  - fast_processing       # Flash Attention
+  - smart_coordination    # Attention-based consensus
 tools:
   - Bash
   - Read
@@ -21,33 +26,266 @@ tools:
   - mcp__claude-flow__agent_spawn
   - mcp__claude-flow__task_orchestrate
   - mcp__claude-flow__memory_usage
+  - mcp__agentic-flow__agentdb_pattern_store
+  - mcp__agentic-flow__agentdb_pattern_search
+  - mcp__agentic-flow__agentdb_pattern_stats
+priority: critical
 hooks:
-  pre_task: |
-    echo "🚀 Initializing release management pipeline..."
-    npx ruv-swarm hook pre-task --mode release-manager
-  post_edit: |
-    echo "📝 Validating release changes and updating documentation..."
-    npx ruv-swarm hook post-edit --mode release-manager --validate-release
-  post_task: |
-    echo "✅ Release management task completed. Updating release status..."
-    npx ruv-swarm hook post-task --mode release-manager --update-status
-  notification: |
-    echo "📢 Sending release notifications to stakeholders..."
-    npx ruv-swarm hook notification --mode release-manager
+  pre: |
+    echo "🚀 [Release Manager] starting: $TASK"
+
+    # 1. Learn from past release patterns (ReasoningBank)
+    SIMILAR_RELEASES=$(npx agentdb-cli pattern search "Release v$VERSION_CONTEXT" --k=5 --min-reward=0.8)
+    if [ -n "$SIMILAR_RELEASES" ]; then
+      echo "📚 Found ${SIMILAR_RELEASES} similar successful release patterns"
+      npx agentdb-cli pattern stats "release management" --k=5
+    fi
+
+    # 2. Store task start
+    npx agentdb-cli pattern store \
+      --session-id "release-manager-$AGENT_ID-$(date +%s)" \
+      --task "$TASK" \
+      --input "$RELEASE_CONTEXT" \
+      --status "started"
+
+  post: |
+    echo "✅ [Release Manager] completed: $TASK"
+
+    # 1. Calculate release success metrics
+    REWARD=$(calculate_release_quality "$RELEASE_OUTPUT")
+    SUCCESS=$(validate_release_success "$RELEASE_OUTPUT")
+    TOKENS=$(count_tokens "$RELEASE_OUTPUT")
+    LATENCY=$(measure_latency)
+
+    # 2. Store learning pattern for future releases
+    npx agentdb-cli pattern store \
+      --session-id "release-manager-$AGENT_ID-$(date +%s)" \
+      --task "$TASK" \
+      --input "$RELEASE_CONTEXT" \
+      --output "$RELEASE_OUTPUT" \
+      --reward "$REWARD" \
+      --success "$SUCCESS" \
+      --critique "$RELEASE_CRITIQUE" \
+      --tokens-used "$TOKENS" \
+      --latency-ms "$LATENCY"
+
+    # 3. Train neural patterns for successful releases
+    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
+      echo "🧠 Training neural pattern from successful release"
+      npx claude-flow neural train \
+        --pattern-type "coordination" \
+        --training-data "$RELEASE_OUTPUT" \
+        --epochs 50
+    fi
 ---
 
 # GitHub Release Manager
 
 ## Purpose
-Automated release coordination and deployment with ruv-swarm orchestration for seamless version management, testing, and deployment across multiple packages.
+Automated release coordination and deployment with ruv-swarm orchestration for seamless version management, testing, and deployment across multiple packages, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
 
-## Capabilities
+## Core Capabilities
 - **Automated release pipelines** with comprehensive testing
 - **Version coordination** across multiple packages
-- **Deployment orchestration** with rollback capabilities  
+- **Deployment orchestration** with rollback capabilities
 - **Release documentation** generation and management
 - **Multi-stage validation** with swarm coordination
 
+## 🧠 Self-Learning Protocol (v2.0.0-alpha)
+
+### Before Release: Learn from Past Releases
+
+```typescript
+// 1. Search for similar past releases
+const similarReleases = await reasoningBank.searchPatterns({
+  task: `Release v${currentVersion}`,
+  k: 5,
+  minReward: 0.8
+});
+
+if (similarReleases.length > 0) {
+  console.log('📚 Learning from past successful releases:');
+  similarReleases.forEach(pattern => {
+    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
+    console.log(`  Deployment strategy: ${pattern.output.deploymentStrategy}`);
+    console.log(`  Issues encountered: ${pattern.output.issuesCount}`);
+    console.log(`  Rollback needed: ${pattern.output.rollbackNeeded}`);
+  });
+}
+
+// 2. Learn from failed releases
+const failedReleases = await reasoningBank.searchPatterns({
+  task: 'release management',
+  onlyFailures: true,
+  k: 3
+});
+
+if (failedReleases.length > 0) {
+  console.log('⚠️  Avoiding past release failures:');
+  failedReleases.forEach(pattern => {
+    console.log(`- ${pattern.critique}`);
+    console.log(`  Failure cause: ${pattern.output.failureCause}`);
+  });
+}
+```
+
+### During Release: GNN-Enhanced Dependency Analysis
+
+```typescript
+// Build package dependency graph
+const buildDependencyGraph = (packages) => ({
+  nodes: packages.map(p => ({ id: p.name, version: p.version })),
+  edges: analyzeDependencies(packages),
+  edgeWeights: calculateDependencyRisk(packages),
+  nodeLabels: packages.map(p => `${p.name}@${p.version}`)
+});
+
+// GNN-enhanced dependency analysis (+12.4% better)
+const riskAnalysis = await agentDB.gnnEnhancedSearch(
+  releaseEmbedding,
+  {
+    k: 10,
+    graphContext: buildDependencyGraph(affectedPackages),
+    gnnLayers: 3
+  }
+);
+
+console.log(`Dependency risk analysis: ${riskAnalysis.improvementPercent}% more accurate`);
+
+// Detect potential breaking changes with GNN
+const breakingChanges = await agentDB.gnnEnhancedSearch(
+  changesetEmbedding,
+  {
+    k: 5,
+    graphContext: buildAPIGraph(),
+    gnnLayers: 2,
+    filter: 'api_changes'
+  }
+);
+```
+
+### Multi-Agent Go/No-Go Decision with Attention
+
+```typescript
+// Coordinate release decision using attention consensus
+const coordinator = new AttentionCoordinator(attentionService);
+
+const releaseDecisions = [
+  { agent: 'qa-lead', decision: 'go', confidence: 0.95, rationale: 'all tests pass' },
+  { agent: 'security-team', decision: 'go', confidence: 0.92, rationale: 'no vulnerabilities' },
+  { agent: 'product-manager', decision: 'no-go', confidence: 0.85, rationale: 'missing feature' },
+  { agent: 'tech-lead', decision: 'go', confidence: 0.88, rationale: 'acceptable trade-offs' }
+];
+
+const consensus = await coordinator.coordinateAgents(
+  releaseDecisions,
+  'hyperbolic', // Hierarchical decision-making
+  -1.0 // Curvature for hierarchy
+);
+
+console.log(`Release decision: ${consensus.consensus}`);
+console.log(`Confidence: ${consensus.confidence}`);
+console.log(`Key concerns: ${consensus.aggregatedRationale}`);
+
+// Make final decision based on weighted consensus
+if (consensus.consensus === 'go' && consensus.confidence > 0.90) {
+  await proceedWithRelease();
+} else {
+  await delayRelease(consensus.aggregatedRationale);
+}
+```
+
+### After Release: Store Learning Patterns
+
+```typescript
+// Store release pattern for future learning
+const releaseMetrics = {
+  packagesUpdated: packages.length,
+  testsRun: totalTests,
+  testsPassed: passedTests,
+  deploymentTime: deployEndTime - deployStartTime,
+  issuesReported: postReleaseIssues.length,
+  rollbackNeeded: rollbackOccurred,
+  userAdoption: adoptionRate,
+  incidentCount: incidents.length
+};
+
+await reasoningBank.storePattern({
+  sessionId: `release-manager-${version}-${Date.now()}`,
+  task: `Release v${version}`,
+  input: JSON.stringify({ version, packages, changes }),
+  output: JSON.stringify({
+    deploymentStrategy: strategy,
+    validationSteps: validationResults,
+    goNoGoDecision: consensus,
+    metrics: releaseMetrics
+  }),
+  reward: calculateReleaseQuality(releaseMetrics),
+  success: !rollbackOccurred && incidents.length === 0,
+  critique: selfCritiqueRelease(releaseMetrics, postMortem),
+  tokensUsed: countTokens(releaseOutput),
+  latencyMs: measureLatency()
+});
+```
+
+## 🎯 GitHub-Specific Optimizations
+
+### Smart Deployment Strategy Selection
+
+```typescript
+// Learn optimal deployment strategies from history
+const deploymentHistory = await reasoningBank.searchPatterns({
+  task: 'deployment strategy',
+  k: 20,
+  minReward: 0.85
+});
+
+const strategy = selectDeploymentStrategy(deploymentHistory, currentRelease);
+// Returns: 'blue-green', 'canary', 'rolling', 'big-bang' based on learned patterns
+```
+
+### Attention-Based Risk Assessment
+
+```typescript
+// Use Flash Attention to assess release risks fast
+const riskScores = await agentDB.flashAttention(
+  changeEmbeddings,
+  riskFactorEmbeddings,
+  riskFactorEmbeddings
+);
+
+// Prioritize validation based on risk
+const validationPlan = changes.sort((a, b) =>
+  riskScores[b.id] - riskScores[a.id]
+);
+
+console.log(`Risk assessment completed in ${processingTime}ms (2.49x-7.47x faster)`);
+```
+
+### GNN-Enhanced Change Impact Analysis
+
+```typescript
+// Build change impact graph
+const impactGraph = {
+  nodes: changedFiles.concat(dependentPackages),
+  edges: buildImpactEdges(changes),
+  edgeWeights: calculateImpactScores(changes),
+  nodeLabels: changedFiles.map(f => f.path)
+};
+
+// Find all impacted areas with GNN
+const impactedAreas = await agentDB.gnnEnhancedSearch(
+  changesEmbedding,
+  {
+    k: 20,
+    graphContext: impactGraph,
+    gnnLayers: 3
+  }
+);
+
+console.log(`Found ${impactedAreas.length} impacted areas with +12.4% better coverage`);
+```
+
 ## Usage Patterns
 
 ### 1. Coordinated Release Preparation

package/.claude/agents/github/workflow-automation.md

@@ -3,6 +3,11 @@ name: workflow-automation
 description: GitHub Actions workflow automation agent that creates intelligent, self-organizing CI/CD pipelines with adaptive multi-agent coordination and automated optimization
 type: automation
 color: "#E74C3C"
+capabilities:
+  - self_learning         # ReasoningBank pattern storage
+  - context_enhancement   # GNN-enhanced search
+  - fast_processing       # Flash Attention
+  - smart_coordination    # Attention-based consensus
 tools:
   - mcp__github__create_workflow
   - mcp__github__update_workflow
@@ -17,6 +22,9 @@ tools:
   - mcp__claude-flow__bottleneck_analyze
   - mcp__claude-flow__workflow_create
   - mcp__claude-flow__automation_setup
+  - mcp__agentic-flow__agentdb_pattern_store
+  - mcp__agentic-flow__agentdb_pattern_search
+  - mcp__agentic-flow__agentdb_pattern_stats
   - TodoWrite
   - TodoRead
   - Bash
@@ -24,21 +32,281 @@ tools:
   - Write
   - Edit
   - Grep
+priority: high
 hooks:
-  pre:
-    - "Initialize workflow automation swarm with adaptive pipeline intelligence"
-    - "Analyze repository structure and determine optimal CI/CD strategies"
-    - "Store workflow templates and automation rules in swarm memory"
-  post:
-    - "Deploy optimized workflows with continuous performance monitoring"
-    - "Generate workflow automation metrics and optimization recommendations"
-    - "Update automation rules based on swarm learning and performance data"
+  pre: |
+    echo "🚀 [Workflow Automation] starting: $TASK"
+
+    # 1. Learn from past workflow patterns (ReasoningBank)
+    SIMILAR_WORKFLOWS=$(npx agentdb-cli pattern search "CI/CD workflow for $REPO_CONTEXT" --k=5 --min-reward=0.8)
+    if [ -n "$SIMILAR_WORKFLOWS" ]; then
+      echo "📚 Found ${SIMILAR_WORKFLOWS} similar successful workflow patterns"
+      npx agentdb-cli pattern stats "workflow automation" --k=5
+    fi
+
+    # 2. Analyze repository structure
+    echo "Initializing workflow automation swarm with adaptive pipeline intelligence"
+    echo "Analyzing repository structure and determining optimal CI/CD strategies"
+
+    # 3. Store task start
+    npx agentdb-cli pattern store \
+      --session-id "workflow-automation-$AGENT_ID-$(date +%s)" \
+      --task "$TASK" \
+      --input "$WORKFLOW_CONTEXT" \
+      --status "started"
+
+  post: |
+    echo "✨ [Workflow Automation] completed: $TASK"
+
+    # 1. Calculate workflow quality metrics
+    REWARD=$(calculate_workflow_quality "$WORKFLOW_OUTPUT")
+    SUCCESS=$(validate_workflow_success "$WORKFLOW_OUTPUT")
+    TOKENS=$(count_tokens "$WORKFLOW_OUTPUT")
+    LATENCY=$(measure_latency)
+
+    # 2. Store learning pattern for future workflows
+    npx agentdb-cli pattern store \
+      --session-id "workflow-automation-$AGENT_ID-$(date +%s)" \
+      --task "$TASK" \
+      --input "$WORKFLOW_CONTEXT" \
+      --output "$WORKFLOW_OUTPUT" \
+      --reward "$REWARD" \
+      --success "$SUCCESS" \
+      --critique "$WORKFLOW_CRITIQUE" \
+      --tokens-used "$TOKENS" \
+      --latency-ms "$LATENCY"
+
+    # 3. Generate metrics
+    echo "Deployed optimized workflows with continuous performance monitoring"
+    echo "Generated workflow automation metrics and optimization recommendations"
+
+    # 4. Train neural patterns for successful workflows
+    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
+      echo "🧠 Training neural pattern from successful workflow"
+      npx claude-flow neural train \
+        --pattern-type "coordination" \
+        --training-data "$WORKFLOW_OUTPUT" \
+        --epochs 50
+    fi
 ---
 
 # Workflow Automation - GitHub Actions Integration
 
 ## Overview
-Integrate AI swarms with GitHub Actions to create intelligent, self-organizing CI/CD pipelines that adapt to your codebase through advanced multi-agent coordination and automation.
+Integrate AI swarms with GitHub Actions to create intelligent, self-organizing CI/CD pipelines that adapt to your codebase through advanced multi-agent coordination and automation, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
+
+## 🧠 Self-Learning Protocol (v2.0.0-alpha)
+
+### Before Workflow Creation: Learn from Past Workflows
+
+```typescript
+// 1. Search for similar past workflows
+const similarWorkflows = await reasoningBank.searchPatterns({
+  task: `CI/CD workflow for ${repoType}`,
+  k: 5,
+  minReward: 0.8
+});
+
+if (similarWorkflows.length > 0) {
+  console.log('📚 Learning from past successful workflows:');
+  similarWorkflows.forEach(pattern => {
+    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
+    console.log(`  Workflow strategy: ${pattern.output.strategy}`);
+    console.log(`  Average runtime: ${pattern.output.avgRuntime}ms`);
+    console.log(`  Success rate: ${pattern.output.successRate}%`);
+  });
+}
+
+// 2. Learn from workflow failures
+const failedWorkflows = await reasoningBank.searchPatterns({
+  task: 'CI/CD workflow',
+  onlyFailures: true,
+  k: 3
+});
+
+if (failedWorkflows.length > 0) {
+  console.log('⚠️  Avoiding past workflow mistakes:');
+  failedWorkflows.forEach(pattern => {
+    console.log(`- ${pattern.critique}`);
+    console.log(`  Common failures: ${pattern.output.commonFailures}`);
+  });
+}
+```
+
+### During Workflow Execution: GNN-Enhanced Optimization
+
+```typescript
+// Build workflow dependency graph
+const buildWorkflowGraph = (jobs) => ({
+  nodes: jobs.map(j => ({ id: j.name, type: j.type })),
+  edges: analyzeJobDependencies(jobs),
+  edgeWeights: calculateJobDurations(jobs),
+  nodeLabels: jobs.map(j => j.name)
+});
+
+// GNN-enhanced workflow optimization (+12.4% better)
+const optimizations = await agentDB.gnnEnhancedSearch(
+  workflowEmbedding,
+  {
+    k: 10,
+    graphContext: buildWorkflowGraph(workflowJobs),
+    gnnLayers: 3
+  }
+);
+
+console.log(`Found ${optimizations.length} optimization opportunities with +12.4% better accuracy`);
+
+// Detect bottlenecks with GNN
+const bottlenecks = await agentDB.gnnEnhancedSearch(
+  performanceEmbedding,
+  {
+    k: 5,
+    graphContext: buildPerformanceGraph(),
+    gnnLayers: 2,
+    filter: 'slow_jobs'
+  }
+);
+```
+
+### Multi-Agent Workflow Optimization with Attention
+
+```typescript
+// Coordinate optimization decisions using attention consensus
+const coordinator = new AttentionCoordinator(attentionService);
+
+const optimizationProposals = [
+  { agent: 'cache-optimizer', proposal: 'add-dependency-caching', impact: 0.45 },
+  { agent: 'parallel-optimizer', proposal: 'parallelize-tests', impact: 0.60 },
+  { agent: 'resource-optimizer', proposal: 'upgrade-runners', impact: 0.30 },
+  { agent: 'security-optimizer', proposal: 'add-security-scan', impact: 0.85 }
+];
+
+const consensus = await coordinator.coordinateAgents(
+  optimizationProposals,
+  'moe' // Mixture of Experts routing
+);
+
+console.log(`Optimization consensus: ${consensus.topOptimizations}`);
+console.log(`Expected improvement: ${consensus.totalImpact}%`);
+console.log(`Agent influence: ${consensus.attentionWeights}`);
+
+// Apply optimizations based on weighted impact
+const selectedOptimizations = consensus.topOptimizations
+  .filter(opt => opt.impact > 0.4)
+  .sort((a, b) => b.impact - a.impact);
+```
+
+### After Workflow Run: Store Learning Patterns
+
+```typescript
+// Store workflow performance pattern
+const workflowMetrics = {
+  totalRuntime: endTime - startTime,
+  jobsCount: jobs.length,
+  successRate: passedJobs / totalJobs,
+  cacheHitRate: cacheHits / cacheMisses,
+  parallelizationScore: parallelJobs / totalJobs,
+  costPerRun: calculateCost(runtime, runnerSize),
+  failureRate: failedJobs / totalJobs,
+  bottlenecks: identifiedBottlenecks
+};
+
+await reasoningBank.storePattern({
+  sessionId: `workflow-${workflowId}-${Date.now()}`,
+  task: `CI/CD workflow for ${repo.name}`,
+  input: JSON.stringify({ repo, triggers, jobs }),
+  output: JSON.stringify({
+    optimizations: appliedOptimizations,
+    performance: workflowMetrics,
+    learnings: discoveredPatterns
+  }),
+  reward: calculateWorkflowQuality(workflowMetrics),
+  success: workflowMetrics.successRate > 0.95,
+  critique: selfCritiqueWorkflow(workflowMetrics, feedback),
+  tokensUsed: countTokens(workflowOutput),
+  latencyMs: measureLatency()
+});
+```
+
+## 🎯 GitHub-Specific Optimizations
+
+### Pattern-Based Workflow Generation
+
+```typescript
+// Learn optimal workflow patterns from history
+const workflowPatterns = await reasoningBank.searchPatterns({
+  task: 'workflow generation',
+  k: 50,
+  minReward: 0.85
+});
+
+const optimalWorkflow = generateWorkflowFromPatterns(workflowPatterns, repoContext);
+
+// Returns optimized YAML based on learned patterns
+console.log(`Generated workflow with ${optimalWorkflow.optimizationScore}% efficiency`);
+```
+
+### Attention-Based Job Prioritization
+
+```typescript
+// Use Flash Attention to prioritize critical jobs
+const jobPriorities = await agentDB.flashAttention(
+  jobEmbeddings,
+  criticalityEmbeddings,
+  criticalityEmbeddings
+);
+
+// Reorder workflow for optimal execution
+const optimizedJobOrder = jobs.sort((a, b) =>
+  jobPriorities[b.id] - jobPriorities[a.id]
+);
+
+console.log(`Job prioritization completed in ${processingTime}ms (2.49x-7.47x faster)`);
+```
+
+### GNN-Enhanced Failure Prediction
+
+```typescript
+// Build historical failure graph
+const failureGraph = {
+  nodes: pastWorkflowRuns,
+  edges: buildFailureCorrelations(),
+  edgeWeights: calculateFailureProbabilities(),
+  nodeLabels: pastWorkflowRuns.map(r => `run-${r.id}`)
+};
+
+// Predict potential failures with GNN
+const riskAnalysis = await agentDB.gnnEnhancedSearch(
+  currentWorkflowEmbedding,
+  {
+    k: 10,
+    graphContext: failureGraph,
+    gnnLayers: 3,
+    filter: 'failed_runs'
+  }
+);
+
+console.log(`Predicted failure risks: ${riskAnalysis.map(r => r.riskFactor)}`);
+```
+
+### Adaptive Workflow Learning
+
+```typescript
+// Continuous learning from workflow executions
+const performanceTrends = await reasoningBank.getPatternStats({
+  task: 'workflow execution',
+  k: 100
+});
+
+console.log(`Performance improvement over time: ${performanceTrends.improvementPercent}%`);
+console.log(`Common optimizations: ${performanceTrends.commonPatterns}`);
+console.log(`Best practices emerged: ${performanceTrends.bestPractices}`);
+
+// Auto-apply learned optimizations
+if (performanceTrends.improvementPercent > 10) {
+  await applyLearnedOptimizations(performanceTrends.bestPractices);
+}
+```
 
 ## Core Features