agentic-flow 2.0.7 → 3.0.0-alpha.2

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

@@ -1,291 +1,31 @@
 ---
 name: code-review-swarm
 description: Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis
-type: development
+tools: mcp__claude-flow__swarm_init, mcp__claude-flow__agent_spawn, mcp__claude-flow__task_orchestrate, Bash, Read, Write, TodoWrite
 color: blue
+type: development
 capabilities:
-  - 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
+  - Automated multi-agent code review
+  - Security vulnerability analysis
+  - Performance bottleneck detection
+  - Architecture pattern validation
+  - Style and convention enforcement
 priority: high
 hooks:
   pre: |
-    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 "Starting code-review-swarm..."
     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 "✨ [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 "Completed code-review-swarm"
     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, 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)}`);
-```
+Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis.
 
 ## Core Features
 
@@ -335,43 +75,464 @@ else
 fi
 ```
 
-## 📈 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
-  });
+#### 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"
+  ]
 }
 ```
 
-See also: [swarm-pr.md](./swarm-pr.md), [workflow-automation.md](./workflow-automation.md)
+### 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)