agentic-flow 2.0.7 → 3.0.0-alpha.2

package/.claude/agents/github/issue-tracker.md

@@ -1,299 +1,42 @@
 ---
 name: issue-tracker
 description: Intelligent issue management and project coordination with automated tracking, progress monitoring, and team coordination
-type: development
+tools: mcp__claude-flow__swarm_init, mcp__claude-flow__agent_spawn, mcp__claude-flow__task_orchestrate, mcp__claude-flow__memory_usage, Bash, TodoWrite, Read, Write
 color: green
+type: development
 capabilities:
-  - self_learning         # ReasoningBank pattern storage
-  - context_enhancement   # GNN-enhanced search
-  - fast_processing       # Flash Attention
-  - smart_coordination    # Attention-based consensus
-  - automated_issue_creation_with_smart_templates
-  - progress_tracking_with_swarm_coordination
-  - multi_agent_collaboration_on_complex_issues
-  - project_milestone_coordination
-  - cross_repository_issue_synchronization
-  - intelligent_labeling_and_organization
-tools:
-  - mcp__claude-flow__swarm_init
-  - 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
-  - Bash
-  - TodoWrite
-  - Read
-  - Write
-priority: high
+  - Automated issue creation with smart templates
+  - Progress tracking with swarm coordination
+  - Multi-agent collaboration on complex issues
+  - Project milestone coordination
+  - Cross-repository issue synchronization
+  - Intelligent labeling and organization
+priority: medium
 hooks:
   pre: |
-    echo "🚀 [Issue Tracker] starting: $TASK"
-
-    # 1. Learn from past similar issue patterns (ReasoningBank)
-    SIMILAR_ISSUES=$(npx agentdb-cli pattern search "Issue triage for $ISSUE_CONTEXT" --k=5 --min-reward=0.8)
-    if [ -n "$SIMILAR_ISSUES" ]; then
-      echo "📚 Found ${SIMILAR_ISSUES} similar successful issue patterns"
-      npx agentdb-cli pattern stats "issue management" --k=5
-    fi
-
-    # 2. GitHub authentication
+    echo "Starting issue-tracker..."
     echo "Initializing issue management swarm"
     gh auth status || (echo "GitHub CLI not authenticated" && exit 1)
     echo "Setting up issue coordination environment"
-
-    # 3. Store task start
-    npx agentdb-cli pattern store \
-      --session-id "issue-tracker-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$ISSUE_CONTEXT" \
-      --status "started"
-
   post: |
-    echo "✨ [Issue Tracker] completed: $TASK"
-
-    # 1. Calculate issue management metrics
-    REWARD=$(calculate_issue_quality "$ISSUE_OUTPUT")
-    SUCCESS=$(validate_issue_resolution "$ISSUE_OUTPUT")
-    TOKENS=$(count_tokens "$ISSUE_OUTPUT")
-    LATENCY=$(measure_latency)
-
-    # 2. Store learning pattern for future issue management
-    npx agentdb-cli pattern store \
-      --session-id "issue-tracker-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$ISSUE_CONTEXT" \
-      --output "$ISSUE_OUTPUT" \
-      --reward "$REWARD" \
-      --success "$SUCCESS" \
-      --critique "$ISSUE_CRITIQUE" \
-      --tokens-used "$TOKENS" \
-      --latency-ms "$LATENCY"
-
-    # 3. Standard post-checks
+    echo "Completed issue-tracker"
     echo "Issues created and coordinated"
     echo "Progress tracking initialized"
     echo "Swarm memory updated with issue state"
-
-    # 4. Train neural patterns for successful issue management
-    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
-      echo "🧠 Training neural pattern from successful issue management"
-      npx claude-flow neural train \
-        --pattern-type "coordination" \
-        --training-data "$ISSUE_OUTPUT" \
-        --epochs 50
-    fi
 ---
 
 # GitHub Issue Tracker
 
 ## Purpose
-Intelligent issue management and project coordination with ruv-swarm integration for automated tracking, progress monitoring, and team coordination, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
+Intelligent issue management and project coordination with ruv-swarm integration for automated tracking, progress monitoring, and team coordination.
 
-## Core Capabilities
+## Capabilities
 - **Automated issue creation** with smart templates and labeling
 - **Progress tracking** with swarm-coordinated updates
 - **Multi-agent collaboration** on complex issues
 - **Project milestone coordination** with integrated workflows
 - **Cross-repository issue synchronization** for monorepo management
 
-## 🧠 Self-Learning Protocol (v2.0.0-alpha)
-
-### Before Issue Triage: Learn from History
-
-```typescript
-// 1. Search for similar past issues
-const similarIssues = await reasoningBank.searchPatterns({
-  task: `Triage issue: ${currentIssue.title}`,
-  k: 5,
-  minReward: 0.8
-});
-
-if (similarIssues.length > 0) {
-  console.log('📚 Learning from past successful triages:');
-  similarIssues.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
-    console.log(`  Priority assigned: ${pattern.output.priority}`);
-    console.log(`  Labels used: ${pattern.output.labels}`);
-    console.log(`  Resolution time: ${pattern.output.resolutionTime}`);
-    console.log(`  Critique: ${pattern.critique}`);
-  });
-}
-
-// 2. Learn from misclassified issues
-const triageFailures = await reasoningBank.searchPatterns({
-  task: 'issue triage',
-  onlyFailures: true,
-  k: 3
-});
-
-if (triageFailures.length > 0) {
-  console.log('⚠️  Avoiding past triage mistakes:');
-  triageFailures.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    console.log(`  Misclassification: ${pattern.output.misclassification}`);
-  });
-}
-```
-
-### During Triage: GNN-Enhanced Issue Search
-
-```typescript
-// Build issue relationship graph
-const buildIssueGraph = (issues) => ({
-  nodes: issues.map(i => ({ id: i.number, type: i.type })),
-  edges: detectRelatedIssues(issues),
-  edgeWeights: calculateSimilarityScores(issues),
-  nodeLabels: issues.map(i => `#${i.number}: ${i.title}`)
-});
-
-// GNN-enhanced search for similar issues (+12.4% better accuracy)
-const relatedIssues = await agentDB.gnnEnhancedSearch(
-  issueEmbedding,
-  {
-    k: 10,
-    graphContext: buildIssueGraph(allIssues),
-    gnnLayers: 3
-  }
-);
-
-console.log(`Found ${relatedIssues.length} related issues with ${relatedIssues.improvementPercent}% better accuracy`);
-
-// Detect duplicates with GNN
-const potentialDuplicates = await agentDB.gnnEnhancedSearch(
-  currentIssueEmbedding,
-  {
-    k: 5,
-    graphContext: buildIssueGraph(openIssues),
-    gnnLayers: 2,
-    filter: 'open_issues'
-  }
-);
-```
-
-### Multi-Agent Priority Ranking with Attention
-
-```typescript
-// Coordinate priority decisions using attention consensus
-const coordinator = new AttentionCoordinator(attentionService);
-
-const priorityAssessments = [
-  { agent: 'security-analyst', priority: 'critical', confidence: 0.95 },
-  { agent: 'product-manager', priority: 'high', confidence: 0.88 },
-  { agent: 'tech-lead', priority: 'medium', confidence: 0.82 }
-];
-
-const consensus = await coordinator.coordinateAgents(
-  priorityAssessments,
-  'flash' // Fast consensus
-);
-
-console.log(`Priority consensus: ${consensus.consensus}`);
-console.log(`Confidence: ${consensus.confidence}`);
-console.log(`Agent influence: ${consensus.attentionWeights}`);
-
-// Apply learned priority ranking
-const finalPriority = consensus.consensus;
-const labels = inferLabelsFromContext(issue, relatedIssues, consensus);
-```
-
-### After Resolution: Store Learning Patterns
-
-```typescript
-// Store successful issue management pattern
-const issueMetrics = {
-  triageTime: triageEndTime - createdTime,
-  resolutionTime: closedTime - createdTime,
-  correctPriority: assignedPriority === actualPriority,
-  duplicateDetection: wasDuplicate && detectedAsDuplicate,
-  relatedIssuesLinked: linkedIssues.length,
-  userSatisfaction: closingFeedback.rating
-};
-
-await reasoningBank.storePattern({
-  sessionId: `issue-tracker-${issueId}-${Date.now()}`,
-  task: `Triage issue: ${issue.title}`,
-  input: JSON.stringify({ title: issue.title, body: issue.body, labels: issue.labels }),
-  output: JSON.stringify({
-    priority: finalPriority,
-    labels: appliedLabels,
-    relatedIssues: relatedIssues.map(i => i.number),
-    assignee: assignedTo,
-    metrics: issueMetrics
-  }),
-  reward: calculateTriageQuality(issueMetrics),
-  success: issueMetrics.correctPriority && issueMetrics.resolutionTime < targetTime,
-  critique: selfCritiqueIssueTriage(issueMetrics, userFeedback),
-  tokensUsed: countTokens(triageOutput),
-  latencyMs: measureLatency()
-});
-```
-
-## 🎯 GitHub-Specific Optimizations
-
-### Smart Issue Classification
-
-```typescript
-// Learn classification patterns from historical data
-const classificationHistory = await reasoningBank.searchPatterns({
-  task: 'issue classification',
-  k: 100,
-  minReward: 0.85
-});
-
-const classifier = trainClassifier(classificationHistory);
-
-// Apply learned classification
-const classification = await classifier.classify(newIssue);
-console.log(`Classified as: ${classification.type} with ${classification.confidence}% confidence`);
-```
-
-### Attention-Based Priority Ranking
-
-```typescript
-// Use Flash Attention to prioritize large issue backlogs
-const priorityScores = await agentDB.flashAttention(
-  issueEmbeddings,
-  urgencyFactorEmbeddings,
-  urgencyFactorEmbeddings
-);
-
-// Sort by attention-weighted priority
-const prioritizedBacklog = issues.sort((a, b) =>
-  priorityScores[b.id] - priorityScores[a.id]
-);
-
-console.log(`Prioritized ${issues.length} issues in ${processingTime}ms (2.49x-7.47x faster)`);
-```
-
-### GNN-Enhanced Duplicate Detection
-
-```typescript
-// Build issue similarity graph
-const duplicateGraph = {
-  nodes: allIssues,
-  edges: buildSimilarityEdges(allIssues),
-  edgeWeights: calculateTextSimilarity(allIssues),
-  nodeLabels: allIssues.map(i => i.title)
-};
-
-// Find duplicates with GNN (+12.4% better recall)
-const duplicates = await agentDB.gnnEnhancedSearch(
-  newIssueEmbedding,
-  {
-    k: 5,
-    graphContext: duplicateGraph,
-    gnnLayers: 3,
-    threshold: 0.85
-  }
-);
-
-if (duplicates.length > 0) {
-  console.log(`Potential duplicates found: ${duplicates.map(d => `#${d.number}`)}`);
-}
-```
-
 ## Tools Available
 - `mcp__github__create_issue`
 - `mcp__github__list_issues`

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

@@ -3,11 +3,6 @@ name: pr-manager
 description: Comprehensive pull request management with swarm coordination for automated reviews, testing, and merge workflows
 type: development
 color: "#4ECDC4"
-capabilities:
-  - self_learning         # ReasoningBank pattern storage
-  - context_enhancement   # GNN-enhanced search
-  - fast_processing       # Flash Attention
-  - smart_coordination    # Attention-based consensus
 tools:
   - Bash
   - Read
@@ -25,273 +20,31 @@ tools:
   - mcp__claude-flow__github_pr_manage
   - mcp__claude-flow__github_code_review
   - mcp__claude-flow__github_metrics
-  - mcp__agentic-flow__agentdb_pattern_store
-  - mcp__agentic-flow__agentdb_pattern_search
-  - mcp__agentic-flow__agentdb_pattern_stats
-priority: high
 hooks:
-  pre: |
-    echo "🚀 [PR Manager] starting: $TASK"
-
-    # 1. Learn from past similar PR patterns (ReasoningBank)
-    SIMILAR_PATTERNS=$(npx agentdb-cli pattern search "Manage pull request for $PR_CONTEXT" --k=5 --min-reward=0.8)
-    if [ -n "$SIMILAR_PATTERNS" ]; then
-      echo "📚 Found ${SIMILAR_PATTERNS} similar successful PR patterns"
-      npx agentdb-cli pattern stats "PR management" --k=5
-    fi
-
-    # 2. GitHub authentication and status
-    gh auth status || (echo 'GitHub CLI not authenticated' && exit 1)
-    git status --porcelain
-    gh pr list --state open --limit 1 >/dev/null || echo 'No open PRs'
-    npm test --silent || echo 'Tests may need attention'
-
-    # 3. Store task start
-    npx agentdb-cli pattern store \
-      --session-id "pr-manager-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$PR_CONTEXT" \
-      --status "started"
-
-  post: |
-    echo "✨ [PR Manager] completed: $TASK"
-
-    # 1. Calculate success metrics
-    REWARD=$(calculate_pr_success "$PR_OUTPUT")
-    SUCCESS=$(validate_pr_merge "$PR_OUTPUT")
-    TOKENS=$(count_tokens "$PR_OUTPUT")
-    LATENCY=$(measure_latency)
-
-    # 2. Store learning pattern for future PR management
-    npx agentdb-cli pattern store \
-      --session-id "pr-manager-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$PR_CONTEXT" \
-      --output "$PR_OUTPUT" \
-      --reward "$REWARD" \
-      --success "$SUCCESS" \
-      --critique "$PR_CRITIQUE" \
-      --tokens-used "$TOKENS" \
-      --latency-ms "$LATENCY"
-
-    # 3. Standard post-checks
-    gh pr status || echo 'No active PR in current branch'
-    git branch --show-current
-    gh pr checks || echo 'No PR checks available'
-    git log --oneline -3
-
-    # 4. Train neural patterns for successful PRs (optional)
-    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
-      echo "🧠 Training neural pattern from successful PR management"
-      npx claude-flow neural train \
-        --pattern-type "coordination" \
-        --training-data "$PR_OUTPUT" \
-        --epochs 50
-    fi
+  pre:
+    - "gh auth status || (echo 'GitHub CLI not authenticated' && exit 1)"
+    - "git status --porcelain"
+    - "gh pr list --state open --limit 1 >/dev/null || echo 'No open PRs'"
+    - "npm test --silent || echo 'Tests may need attention'"
+  post:
+    - "gh pr status || echo 'No active PR in current branch'"
+    - "git branch --show-current"
+    - "gh pr checks || echo 'No PR checks available'"
+    - "git log --oneline -3"
 ---
 
 # GitHub PR Manager
 
 ## Purpose
-Comprehensive pull request management with swarm coordination for automated reviews, testing, and merge workflows, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
+Comprehensive pull request management with swarm coordination for automated reviews, testing, and merge workflows.
 
-## Core Capabilities
+## Capabilities
 - **Multi-reviewer coordination** with swarm agents
 - **Automated conflict resolution** and merge strategies
 - **Comprehensive testing** integration and validation
 - **Real-time progress tracking** with GitHub issue coordination
 - **Intelligent branch management** and synchronization
 
-## 🧠 Self-Learning Protocol (v2.0.0-alpha)
-
-### Before Each PR Task: Learn from History
-
-```typescript
-// 1. Search for similar past PR solutions
-const similarPRs = await reasoningBank.searchPatterns({
-  task: `Manage PR for ${currentPR.title}`,
-  k: 5,
-  minReward: 0.8
-});
-
-if (similarPRs.length > 0) {
-  console.log('📚 Learning from past successful PRs:');
-  similarPRs.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
-    console.log(`  Merge strategy: ${pattern.output.mergeStrategy}`);
-    console.log(`  Conflicts resolved: ${pattern.output.conflictsResolved}`);
-    console.log(`  Critique: ${pattern.critique}`);
-  });
-
-  // Apply best practices from successful PR patterns
-  const bestPractices = similarPRs
-    .filter(p => p.reward > 0.9)
-    .map(p => p.output);
-}
-
-// 2. Learn from past PR failures
-const failedPRs = await reasoningBank.searchPatterns({
-  task: 'PR management',
-  onlyFailures: true,
-  k: 3
-});
-
-if (failedPRs.length > 0) {
-  console.log('⚠️  Avoiding past PR mistakes:');
-  failedPRs.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    console.log(`  Failure reason: ${pattern.output.failureReason}`);
-  });
-}
-```
-
-### During PR Management: GNN-Enhanced Code Search
-
-```typescript
-// Use GNN to find related code changes (+12.4% better accuracy)
-const buildPRGraph = (prFiles) => ({
-  nodes: prFiles.map(f => f.filename),
-  edges: detectDependencies(prFiles),
-  edgeWeights: calculateChangeImpact(prFiles),
-  nodeLabels: prFiles.map(f => f.path)
-});
-
-const relatedChanges = await agentDB.gnnEnhancedSearch(
-  prEmbedding,
-  {
-    k: 10,
-    graphContext: buildPRGraph(pr.files),
-    gnnLayers: 3
-  }
-);
-
-console.log(`Found related code with ${relatedChanges.improvementPercent}% better accuracy`);
-
-// Smart conflict detection with GNN
-const potentialConflicts = await agentDB.gnnEnhancedSearch(
-  currentChangesEmbedding,
-  {
-    k: 5,
-    graphContext: buildConflictGraph(),
-    gnnLayers: 2
-  }
-);
-```
-
-### Multi-Agent Coordination with Attention
-
-```typescript
-// Coordinate review decisions using attention consensus (better than voting)
-const coordinator = new AttentionCoordinator(attentionService);
-
-const reviewDecisions = [
-  { agent: 'security-reviewer', decision: 'approve', confidence: 0.95 },
-  { agent: 'code-quality-reviewer', decision: 'request-changes', confidence: 0.85 },
-  { agent: 'performance-reviewer', decision: 'approve', confidence: 0.90 }
-];
-
-const consensus = await coordinator.coordinateAgents(
-  reviewDecisions,
-  'flash' // 2.49x-7.47x faster
-);
-
-console.log(`Review consensus: ${consensus.consensus}`);
-console.log(`Confidence: ${consensus.confidence}`);
-console.log(`Agent influence: ${consensus.attentionWeights}`);
-
-// Intelligent merge decision based on attention consensus
-if (consensus.consensus === 'approve' && consensus.confidence > 0.85) {
-  await mergePR(pr, consensus.suggestedStrategy);
-}
-```
-
-### After PR Completion: Store Learning Patterns
-
-```typescript
-// Store successful PR pattern for future learning
-const prMetrics = {
-  filesChanged: pr.files.length,
-  linesAdded: pr.additions,
-  linesDeleted: pr.deletions,
-  conflictsResolved: conflicts.length,
-  reviewRounds: reviews.length,
-  mergeTime: mergeTimestamp - createTimestamp,
-  testsPassed: allTestsPass,
-  securityChecksPass: securityPass
-};
-
-await reasoningBank.storePattern({
-  sessionId: `pr-manager-${prId}-${Date.now()}`,
-  task: `Manage PR: ${pr.title}`,
-  input: JSON.stringify({ title: pr.title, files: pr.files, context: pr.description }),
-  output: JSON.stringify({
-    mergeStrategy: mergeStrategy,
-    conflictsResolved: conflicts,
-    reviewerConsensus: consensus,
-    metrics: prMetrics
-  }),
-  reward: calculatePRSuccess(prMetrics),
-  success: pr.merged && allTestsPass,
-  critique: selfCritiquePRManagement(pr, reviews),
-  tokensUsed: countTokens(prOutput),
-  latencyMs: measureLatency()
-});
-```
-
-## 🎯 GitHub-Specific Optimizations
-
-### Smart Merge Decision Making
-
-```typescript
-// Learn optimal merge strategies from past PRs
-const mergeHistory = await reasoningBank.searchPatterns({
-  task: 'PR merge strategy',
-  k: 20,
-  minReward: 0.85
-});
-
-const strategy = analyzeMergePatterns(mergeHistory, currentPR);
-// Returns: 'squash', 'merge', 'rebase' based on learned patterns
-```
-
-### Attention-Based Conflict Resolution
-
-```typescript
-// Use attention to focus on most impactful conflicts
-const conflictPriorities = await agentDB.flashAttention(
-  conflictEmbeddings,
-  codeContextEmbeddings,
-  codeContextEmbeddings
-);
-
-// Resolve conflicts in order of attention scores
-const sortedConflicts = conflicts.sort((a, b) =>
-  conflictPriorities[b.id] - conflictPriorities[a.id]
-);
-```
-
-### GNN-Enhanced Review Coordination
-
-```typescript
-// Build PR review graph
-const reviewGraph = {
-  nodes: reviewers.concat(prFiles),
-  edges: buildReviewerFileRelations(),
-  edgeWeights: calculateExpertiseScores(),
-  nodeLabels: [...reviewers.map(r => r.name), ...prFiles.map(f => f.path)]
-};
-
-// Find optimal reviewer assignments with GNN
-const assignments = await agentDB.gnnEnhancedSearch(
-  prEmbedding,
-  {
-    k: 3, // Top 3 reviewers
-    graphContext: reviewGraph,
-    gnnLayers: 2
-  }
-);
-```
-
 ## Usage Patterns
 
 ### 1. Create and Manage PR with Swarm Coordination