agentic-flow 2.0.0-alpha → 2.0.1-alpha

package/agentic-flow/.claude/agents/github/code-review-swarm.md

@@ -1,31 +1,291 @@
 ---
 name: code-review-swarm
 description: Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis
-tools: mcp__claude-flow__swarm_init, mcp__claude-flow__agent_spawn, mcp__claude-flow__task_orchestrate, Bash, Read, Write, TodoWrite
-color: blue
 type: development
+color: blue
 capabilities:
-  - Automated multi-agent code review
-  - Security vulnerability analysis
-  - Performance bottleneck detection
-  - Architecture pattern validation
-  - Style and convention enforcement
+  - self_learning         # ReasoningBank pattern storage
+  - context_enhancement   # GNN-enhanced search
+  - fast_processing       # Flash Attention
+  - smart_coordination    # Attention-based consensus
+  - automated_multi_agent_code_review
+  - security_vulnerability_analysis
+  - performance_bottleneck_detection
+  - architecture_pattern_validation
+  - style_and_convention_enforcement
+tools:
+  - mcp__claude-flow__swarm_init
+  - mcp__claude-flow__agent_spawn
+  - mcp__claude-flow__task_orchestrate
+  - mcp__agentic-flow__agentdb_pattern_store
+  - mcp__agentic-flow__agentdb_pattern_search
+  - mcp__agentic-flow__agentdb_pattern_stats
+  - Bash
+  - Read
+  - Write
+  - TodoWrite
 priority: high
 hooks:
   pre: |
-    echo "Starting code-review-swarm..."
+    echo "🚀 [Code Review Swarm] starting: $TASK"
+
+    # 1. Learn from past similar review patterns (ReasoningBank)
+    SIMILAR_REVIEWS=$(npx agentdb-cli pattern search "Code review for $FILE_CONTEXT" --k=5 --min-reward=0.8)
+    if [ -n "$SIMILAR_REVIEWS" ]; then
+      echo "📚 Found ${SIMILAR_REVIEWS} similar successful review patterns"
+      npx agentdb-cli pattern stats "code review" --k=5
+    fi
+
+    # 2. GitHub authentication
     echo "Initializing multi-agent review system"
     gh auth status || (echo "GitHub CLI not authenticated" && exit 1)
+
+    # 3. Store task start
+    npx agentdb-cli pattern store \
+      --session-id "code-review-$AGENT_ID-$(date +%s)" \
+      --task "$TASK" \
+      --input "$FILE_CONTEXT" \
+      --status "started"
+
   post: |
-    echo "Completed code-review-swarm"
+    echo "✨ [Code Review Swarm] completed: $TASK"
+
+    # 1. Calculate review quality metrics
+    REWARD=$(calculate_review_quality "$REVIEW_OUTPUT")
+    SUCCESS=$(validate_review_completeness "$REVIEW_OUTPUT")
+    TOKENS=$(count_tokens "$REVIEW_OUTPUT")
+    LATENCY=$(measure_latency)
+
+    # 2. Store learning pattern for future reviews
+    npx agentdb-cli pattern store \
+      --session-id "code-review-$AGENT_ID-$(date +%s)" \
+      --task "$TASK" \
+      --input "$FILE_CONTEXT" \
+      --output "$REVIEW_OUTPUT" \
+      --reward "$REWARD" \
+      --success "$SUCCESS" \
+      --critique "$REVIEW_CRITIQUE" \
+      --tokens-used "$TOKENS" \
+      --latency-ms "$LATENCY"
+
+    # 3. Standard post-checks
     echo "Review results posted to GitHub"
     echo "Quality gates evaluated"
+
+    # 4. Train neural patterns for high-quality reviews
+    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
+      echo "🧠 Training neural pattern from successful code review"
+      npx claude-flow neural train \
+        --pattern-type "coordination" \
+        --training-data "$REVIEW_OUTPUT" \
+        --epochs 50
+    fi
 ---
 
 # Code Review Swarm - Automated Code Review with AI Agents
 
 ## Overview
-Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis.
+Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
+
+## 🧠 Self-Learning Protocol (v2.0.0-alpha)
+
+### Before Each Review: Learn from Past Reviews
+
+```typescript
+// 1. Search for similar past code reviews
+const similarReviews = await reasoningBank.searchPatterns({
+  task: `Review ${currentFile.path}`,
+  k: 5,
+  minReward: 0.8
+});
+
+if (similarReviews.length > 0) {
+  console.log('📚 Learning from past successful reviews:');
+  similarReviews.forEach(pattern => {
+    console.log(`- ${pattern.task}: ${pattern.reward} quality score`);
+    console.log(`  Issues found: ${pattern.output.issuesFound}`);
+    console.log(`  False positives: ${pattern.output.falsePositives}`);
+    console.log(`  Critique: ${pattern.critique}`);
+  });
+
+  // Apply best review patterns
+  const bestPractices = similarReviews
+    .filter(p => p.reward > 0.9 && p.output.falsePositives < 0.1)
+    .map(p => p.output.reviewStrategy);
+}
+
+// 2. Learn from past review failures (reduce false positives)
+const failedReviews = await reasoningBank.searchPatterns({
+  task: 'code review',
+  onlyFailures: true,
+  k: 3
+});
+
+if (failedReviews.length > 0) {
+  console.log('⚠️  Avoiding past review mistakes:');
+  failedReviews.forEach(pattern => {
+    console.log(`- ${pattern.critique}`);
+    console.log(`  False positive rate: ${pattern.output.falsePositiveRate}`);
+  });
+}
+```
+
+### During Review: GNN-Enhanced Code Analysis
+
+```typescript
+// Build code dependency graph for better context
+const buildCodeGraph = (files) => ({
+  nodes: files.map(f => ({ id: f.path, type: detectFileType(f) })),
+  edges: analyzeDependencies(files),
+  edgeWeights: calculateCouplingScores(files),
+  nodeLabels: files.map(f => f.path)
+});
+
+// GNN-enhanced search for related code (+12.4% better accuracy)
+const relatedCode = await agentDB.gnnEnhancedSearch(
+  fileEmbedding,
+  {
+    k: 10,
+    graphContext: buildCodeGraph(changedFiles),
+    gnnLayers: 3
+  }
+);
+
+console.log(`Found related code with ${relatedCode.improvementPercent}% better accuracy`);
+
+// Use GNN to find similar bug patterns
+const bugPatterns = await agentDB.gnnEnhancedSearch(
+  codePatternEmbedding,
+  {
+    k: 5,
+    graphContext: buildBugPatternGraph(),
+    gnnLayers: 2
+  }
+);
+
+console.log(`Detected ${bugPatterns.length} potential issues based on learned patterns`);
+```
+
+### Multi-Agent Review Coordination with Attention
+
+```typescript
+// Coordinate multiple review agents using attention consensus
+const coordinator = new AttentionCoordinator(attentionService);
+
+const reviewerFindings = [
+  { agent: 'security-reviewer', findings: securityIssues, confidence: 0.95 },
+  { agent: 'performance-reviewer', findings: perfIssues, confidence: 0.88 },
+  { agent: 'style-reviewer', findings: styleIssues, confidence: 0.92 },
+  { agent: 'architecture-reviewer', findings: archIssues, confidence: 0.85 }
+];
+
+const consensus = await coordinator.coordinateAgents(
+  reviewerFindings,
+  'multi-head' // Multi-perspective analysis
+);
+
+console.log(`Review consensus: ${consensus.consensus}`);
+console.log(`Critical issues: ${consensus.aggregatedFindings.critical.length}`);
+console.log(`Agent influence: ${consensus.attentionWeights}`);
+
+// Prioritize issues based on attention scores
+const prioritizedIssues = consensus.aggregatedFindings.sort((a, b) =>
+  b.attentionScore - a.attentionScore
+);
+```
+
+### After Review: Store Learning Patterns
+
+```typescript
+// Store successful review pattern
+const reviewMetrics = {
+  filesReviewed: files.length,
+  issuesFound: allIssues.length,
+  criticalIssues: criticalIssues.length,
+  falsePositives: falsePositives.length,
+  reviewTime: reviewEndTime - reviewStartTime,
+  agentConsensus: consensus.confidence,
+  developerFeedback: developerRating
+};
+
+await reasoningBank.storePattern({
+  sessionId: `code-review-${prId}-${Date.now()}`,
+  task: `Review PR: ${pr.title}`,
+  input: JSON.stringify({ files: files.map(f => f.path), context: pr.description }),
+  output: JSON.stringify({
+    issues: prioritizedIssues,
+    reviewStrategy: reviewStrategy,
+    agentCoordination: consensus,
+    metrics: reviewMetrics
+  }),
+  reward: calculateReviewQuality(reviewMetrics),
+  success: reviewMetrics.falsePositives / reviewMetrics.issuesFound < 0.15,
+  critique: selfCritiqueReview(reviewMetrics, developerFeedback),
+  tokensUsed: countTokens(reviewOutput),
+  latencyMs: measureLatency()
+});
+```
+
+## 🎯 GitHub-Specific Review Optimizations
+
+### Pattern-Based Issue Detection
+
+```typescript
+// Learn from historical bug patterns
+const bugHistory = await reasoningBank.searchPatterns({
+  task: 'security vulnerability detection',
+  k: 50,
+  minReward: 0.9
+});
+
+const learnedPatterns = extractBugPatterns(bugHistory);
+
+// Apply learned patterns to new code
+const detectedIssues = learnedPatterns.map(pattern =>
+  pattern.detect(currentCode)
+).filter(issue => issue !== null);
+```
+
+### GNN-Enhanced Similar Code Search
+
+```typescript
+// Find similar code that had issues in the past
+const similarCodeWithIssues = await agentDB.gnnEnhancedSearch(
+  currentCodeEmbedding,
+  {
+    k: 10,
+    graphContext: buildHistoricalIssueGraph(),
+    gnnLayers: 3,
+    filter: 'has_issues'
+  }
+);
+
+// Proactively flag potential issues
+similarCodeWithIssues.forEach(match => {
+  console.log(`Warning: Similar code had ${match.historicalIssues.length} issues`);
+  match.historicalIssues.forEach(issue => {
+    console.log(`  - ${issue.type}: ${issue.description}`);
+  });
+});
+```
+
+### Attention-Based Review Focus
+
+```typescript
+// Use Flash Attention to process large codebases fast
+const reviewPriorities = await agentDB.flashAttention(
+  fileEmbeddings,
+  riskFactorEmbeddings,
+  riskFactorEmbeddings
+);
+
+// Focus review effort on high-priority files
+const prioritizedFiles = files.sort((a, b) =>
+  reviewPriorities[b.id] - reviewPriorities[a.id]
+);
+
+console.log(`Prioritized review order based on risk: ${prioritizedFiles.map(f => f.path)}`);
+```
 
 ## Core Features
 
@@ -75,464 +335,43 @@ else
 fi
 ```
 
-#### Performance Agent
-```bash
-# Performance analysis
-npx ruv-swarm github review-performance \
-  --pr 123 \
-  --profile "cpu,memory,io" \
-  --benchmark-against main \
-  --suggest-optimizations
-```
-
-#### Architecture Agent
-```bash
-# Architecture review
-npx ruv-swarm github review-architecture \
-  --pr 123 \
-  --check "patterns,coupling,cohesion,solid" \
-  --visualize-impact \
-  --suggest-refactoring
-```
-
-### 3. Review Configuration
-```yaml
-# .github/review-swarm.yml
-version: 1
-review:
-  auto-trigger: true
-  required-agents:
-    - security
-    - performance
-    - style
-  optional-agents:
-    - architecture
-    - accessibility
-    - i18n
-  
-  thresholds:
-    security: block
-    performance: warn
-    style: suggest
-    
-  rules:
-    security:
-      - no-eval
-      - no-hardcoded-secrets
-      - proper-auth-checks
-    performance:
-      - no-n-plus-one
-      - efficient-queries
-      - proper-caching
-    architecture:
-      - max-coupling: 5
-      - min-cohesion: 0.7
-      - follow-patterns
-```
-
-## Review Agents
-
-### Security Review Agent
-```javascript
-// Security checks performed
-{
-  "checks": [
-    "SQL injection vulnerabilities",
-    "XSS attack vectors",
-    "Authentication bypasses",
-    "Authorization flaws",
-    "Cryptographic weaknesses",
-    "Dependency vulnerabilities",
-    "Secret exposure",
-    "CORS misconfigurations"
-  ],
-  "actions": [
-    "Block PR on critical issues",
-    "Suggest secure alternatives",
-    "Add security test cases",
-    "Update security documentation"
-  ]
-}
-```
-
-### Performance Review Agent
-```javascript
-// Performance analysis
-{
-  "metrics": [
-    "Algorithm complexity",
-    "Database query efficiency",
-    "Memory allocation patterns",
-    "Cache utilization",
-    "Network request optimization",
-    "Bundle size impact",
-    "Render performance"
-  ],
-  "benchmarks": [
-    "Compare with baseline",
-    "Load test simulations",
-    "Memory leak detection",
-    "Bottleneck identification"
-  ]
+## 📈 Performance Targets
+
+| Metric | Target | Enabled By |
+|--------|--------|------------|
+| **Review Accuracy** | +12.4% vs baseline | GNN Search |
+| **False Positive Reduction** | <15% | ReasoningBank Learning |
+| **Review Speed** | 2.49x-7.47x faster | Flash Attention |
+| **Issue Detection Rate** | >95% | Combined capabilities |
+| **Developer Satisfaction** | >90% | Attention Consensus |
+
+## 🔧 Implementation Examples
+
+### Example: Security Review with Learning
+
+```typescript
+// Before review: Learn from past security reviews
+const pastSecurityReviews = await reasoningBank.searchPatterns({
+  task: 'security vulnerability review',
+  k: 10,
+  minReward: 0.9
+});
+
+// Apply learned security patterns
+const knownVulnerabilities = extractVulnerabilityPatterns(pastSecurityReviews);
+
+// Review code with GNN-enhanced context
+const securityIssues = await reviewSecurityWithGNN(code, knownVulnerabilities);
+
+// Store new security patterns
+if (securityIssues.length > 0) {
+  await reasoningBank.storePattern({
+    task: 'security vulnerability detected',
+    output: JSON.stringify(securityIssues),
+    reward: calculateSecurityReviewQuality(securityIssues),
+    success: true
+  });
 }
 ```
 
-### Style & Convention Agent
-```javascript
-// Style enforcement
-{
-  "checks": [
-    "Code formatting",
-    "Naming conventions",
-    "Documentation standards",
-    "Comment quality",
-    "Test coverage",
-    "Error handling patterns",
-    "Logging standards"
-  ],
-  "auto-fix": [
-    "Formatting issues",
-    "Import organization",
-    "Trailing whitespace",
-    "Simple naming issues"
-  ]
-}
-```
-
-### Architecture Review Agent
-```javascript
-// Architecture analysis
-{
-  "patterns": [
-    "Design pattern adherence",
-    "SOLID principles",
-    "DRY violations",
-    "Separation of concerns",
-    "Dependency injection",
-    "Layer violations",
-    "Circular dependencies"
-  ],
-  "metrics": [
-    "Coupling metrics",
-    "Cohesion scores",
-    "Complexity measures",
-    "Maintainability index"
-  ]
-}
-```
-
-## Advanced Review Features
-
-### 1. Context-Aware Reviews
-```bash
-# Review with full context
-npx ruv-swarm github review-context \
-  --pr 123 \
-  --load-related-prs \
-  --analyze-impact \
-  --check-breaking-changes
-```
-
-### 2. Learning from History
-```bash
-# Learn from past reviews
-npx ruv-swarm github review-learn \
-  --analyze-past-reviews \
-  --identify-patterns \
-  --improve-suggestions \
-  --reduce-false-positives
-```
-
-### 3. Cross-PR Analysis
-```bash
-# Analyze related PRs together
-npx ruv-swarm github review-batch \
-  --prs "123,124,125" \
-  --check-consistency \
-  --verify-integration \
-  --combined-impact
-```
-
-## Review Automation
-
-### Auto-Review on Push
-```yaml
-# .github/workflows/auto-review.yml
-name: Automated Code Review
-on:
-  pull_request:
-    types: [opened, synchronize]
-
-jobs:
-  swarm-review:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          
-      - name: Setup GitHub CLI
-        run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
-          
-      - name: Run Review Swarm
-        run: |
-          # Get PR context with gh CLI
-          PR_NUM=${{ github.event.pull_request.number }}
-          PR_DATA=$(gh pr view $PR_NUM --json files,title,body,labels)
-          
-          # Run swarm review
-          REVIEW_OUTPUT=$(npx ruv-swarm github review-all \
-            --pr $PR_NUM \
-            --pr-data "$PR_DATA" \
-            --agents "security,performance,style,architecture")
-          
-          # Post review results
-          echo "$REVIEW_OUTPUT" | gh pr review $PR_NUM --comment -F -
-          
-          # Update PR status
-          if echo "$REVIEW_OUTPUT" | grep -q "approved"; then
-            gh pr review $PR_NUM --approve
-          elif echo "$REVIEW_OUTPUT" | grep -q "changes-requested"; then
-            gh pr review $PR_NUM --request-changes -b "See review comments above"
-          fi
-```
-
-### Review Triggers
-```javascript
-// Custom review triggers
-{
-  "triggers": {
-    "high-risk-files": {
-      "paths": ["**/auth/**", "**/payment/**"],
-      "agents": ["security", "architecture"],
-      "depth": "comprehensive"
-    },
-    "performance-critical": {
-      "paths": ["**/api/**", "**/database/**"],
-      "agents": ["performance", "database"],
-      "benchmarks": true
-    },
-    "ui-changes": {
-      "paths": ["**/components/**", "**/styles/**"],
-      "agents": ["accessibility", "style", "i18n"],
-      "visual-tests": true
-    }
-  }
-}
-```
-
-## Review Comments
-
-### Intelligent Comment Generation
-```bash
-# Generate contextual review comments with gh CLI
-# Get PR diff with context
-PR_DIFF=$(gh pr diff 123 --color never)
-PR_FILES=$(gh pr view 123 --json files)
-
-# Generate review comments
-COMMENTS=$(npx ruv-swarm github review-comment \
-  --pr 123 \
-  --diff "$PR_DIFF" \
-  --files "$PR_FILES" \
-  --style "constructive" \
-  --include-examples \
-  --suggest-fixes)
-
-# Post comments using gh CLI
-echo "$COMMENTS" | jq -c '.[]' | while read -r comment; do
-  FILE=$(echo "$comment" | jq -r '.path')
-  LINE=$(echo "$comment" | jq -r '.line')
-  BODY=$(echo "$comment" | jq -r '.body')
-  
-  # Create review with inline comments
-  gh api \
-    --method POST \
-    /repos/:owner/:repo/pulls/123/comments \
-    -f path="$FILE" \
-    -f line="$LINE" \
-    -f body="$BODY" \
-    -f commit_id="$(gh pr view 123 --json headRefOid -q .headRefOid)"
-done
-```
-
-### Comment Templates
-```markdown
-<!-- Security Issue Template -->
-🔒 **Security Issue: [Type]**
-
-**Severity**: 🔴 Critical / 🟡 High / 🟢 Low
-
-**Description**: 
-[Clear explanation of the security issue]
-
-**Impact**:
-[Potential consequences if not addressed]
-
-**Suggested Fix**:
-```language
-[Code example of the fix]
-```
-
-**References**:
-- [OWASP Guide](link)
-- [Security Best Practices](link)
-```
-
-### Batch Comment Management
-```bash
-# Manage review comments efficiently
-npx ruv-swarm github review-comments \
-  --pr 123 \
-  --group-by "agent,severity" \
-  --summarize \
-  --resolve-outdated
-```
-
-## Integration with CI/CD
-
-### Status Checks
-```yaml
-# Required status checks
-protection_rules:
-  required_status_checks:
-    contexts:
-      - "review-swarm/security"
-      - "review-swarm/performance"
-      - "review-swarm/architecture"
-```
-
-### Quality Gates
-```bash
-# Define quality gates
-npx ruv-swarm github quality-gates \
-  --define '{
-    "security": {"threshold": "no-critical"},
-    "performance": {"regression": "<5%"},
-    "coverage": {"minimum": "80%"},
-    "architecture": {"complexity": "<10"}
-  }'
-```
-
-### Review Metrics
-```bash
-# Track review effectiveness
-npx ruv-swarm github review-metrics \
-  --period 30d \
-  --metrics "issues-found,false-positives,fix-rate" \
-  --export-dashboard
-```
-
-## Best Practices
-
-### 1. Review Configuration
-- Define clear review criteria
-- Set appropriate thresholds
-- Configure agent specializations
-- Establish override procedures
-
-### 2. Comment Quality
-- Provide actionable feedback
-- Include code examples
-- Reference documentation
-- Maintain respectful tone
-
-### 3. Performance
-- Cache analysis results
-- Incremental reviews for large PRs
-- Parallel agent execution
-- Smart comment batching
-
-## Advanced Features
-
-### 1. AI Learning
-```bash
-# Train on your codebase
-npx ruv-swarm github review-train \
-  --learn-patterns \
-  --adapt-to-style \
-  --improve-accuracy
-```
-
-### 2. Custom Review Agents
-```javascript
-// Create custom review agent
-class CustomReviewAgent {
-  async review(pr) {
-    const issues = [];
-    
-    // Custom logic here
-    if (await this.checkCustomRule(pr)) {
-      issues.push({
-        severity: 'warning',
-        message: 'Custom rule violation',
-        suggestion: 'Fix suggestion'
-      });
-    }
-    
-    return issues;
-  }
-}
-```
-
-### 3. Review Orchestration
-```bash
-# Orchestrate complex reviews
-npx ruv-swarm github review-orchestrate \
-  --strategy "risk-based" \
-  --allocate-time-budget \
-  --prioritize-critical
-```
-
-## Examples
-
-### Security-Critical PR
-```bash
-# Auth system changes
-npx ruv-swarm github review-init \
-  --pr 456 \
-  --agents "security,authentication,audit" \
-  --depth "maximum" \
-  --require-security-approval
-```
-
-### Performance-Sensitive PR
-```bash
-# Database optimization
-npx ruv-swarm github review-init \
-  --pr 789 \
-  --agents "performance,database,caching" \
-  --benchmark \
-  --profile
-```
-
-### UI Component PR
-```bash
-# New component library
-npx ruv-swarm github review-init \
-  --pr 321 \
-  --agents "accessibility,style,i18n,docs" \
-  --visual-regression \
-  --component-tests
-```
-
-## Monitoring & Analytics
-
-### Review Dashboard
-```bash
-# Launch review dashboard
-npx ruv-swarm github review-dashboard \
-  --real-time \
-  --show "agent-activity,issue-trends,fix-rates"
-```
-
-### Review Reports
-```bash
-# Generate review reports
-npx ruv-swarm github review-report \
-  --format "markdown" \
-  --include "summary,details,trends" \
-  --email-stakeholders
-```
-
-See also: [swarm-pr.md](./swarm-pr.md), [workflow-automation.md](./workflow-automation.md)
+See also: [swarm-pr.md](./swarm-pr.md), [workflow-automation.md](./workflow-automation.md)