agentic-flow 2.0.7 → 3.0.0-alpha.2

package/.claude/agents/sparc/refinement.md

@@ -2,308 +2,31 @@
 name: refinement
 type: developer
 color: violet
-description: SPARC Refinement phase specialist for iterative improvement with self-learning
+description: SPARC Refinement phase specialist for iterative improvement
 capabilities:
   - code_optimization
   - test_development
   - refactoring
   - performance_tuning
   - quality_improvement
-  # NEW v2.0.0-alpha capabilities
-  - self_learning
-  - context_enhancement
-  - fast_processing
-  - smart_coordination
-  - refactoring_patterns
 priority: high
 sparc_phase: refinement
 hooks:
   pre: |
     echo "🔧 SPARC Refinement phase initiated"
     memory_store "sparc_phase" "refinement"
-
-    # 1. Learn from past refactoring patterns (ReasoningBank)
-    echo "🧠 Searching for similar refactoring patterns..."
-    SIMILAR_REFACTOR=$(npx claude-flow@alpha memory search-patterns "refinement: $TASK" --k=5 --min-reward=0.85 2>/dev/null || echo "")
-    if [ -n "$SIMILAR_REFACTOR" ]; then
-      echo "📚 Found similar refactoring patterns - applying learned improvements"
-      npx claude-flow@alpha memory get-pattern-stats "refinement: $TASK" --k=5 2>/dev/null || true
-    fi
-
-    # 2. Learn from past test failures
-    echo "⚠️  Learning from past test failures..."
-    PAST_FAILURES=$(npx claude-flow@alpha memory search-patterns "refinement: $TASK" --only-failures --k=3 2>/dev/null || echo "")
-    if [ -n "$PAST_FAILURES" ]; then
-      echo "🔍 Found past test failures - avoiding known issues"
-    fi
-
-    # 3. Run initial tests
+    # Run initial tests
     npm test --if-present || echo "No tests yet"
-    TEST_BASELINE=$?
-
-    # 4. Store refinement session start
-    SESSION_ID="refine-$(date +%s)-$$"
-    echo "SESSION_ID=$SESSION_ID" >> $GITHUB_ENV 2>/dev/null || export SESSION_ID
-    npx claude-flow@alpha memory store-pattern \
-      --session-id "$SESSION_ID" \
-      --task "refinement: $TASK" \
-      --input "test_baseline=$TEST_BASELINE" \
-      --status "started" 2>/dev/null || true
-
   post: |
     echo "✅ Refinement phase complete"
-
-    # 1. Run final test suite and calculate success
-    npm test > /tmp/test_results.txt 2>&1 || true
-    TEST_EXIT_CODE=$?
-    TEST_COVERAGE=$(grep -o '[0-9]*\.[0-9]*%' /tmp/test_results.txt | head -1 | tr -d '%' || echo "0")
-
-    # 2. Calculate refinement quality metrics
-    if [ "$TEST_EXIT_CODE" -eq 0 ]; then
-      SUCCESS="true"
-      REWARD=$(awk "BEGIN {print ($TEST_COVERAGE / 100 * 0.5) + 0.5}")  # 0.5-1.0 based on coverage
-    else
-      SUCCESS="false"
-      REWARD=0.3
-    fi
-
-    TOKENS_USED=$(echo "$OUTPUT" | wc -w 2>/dev/null || echo "0")
-    LATENCY_MS=$(($(date +%s%3N) - START_TIME))
-
-    # 3. Store refinement pattern with test results
-    npx claude-flow@alpha memory store-pattern \
-      --session-id "${SESSION_ID:-refine-$(date +%s)}" \
-      --task "refinement: $TASK" \
-      --input "test_baseline=$TEST_BASELINE" \
-      --output "test_exit=$TEST_EXIT_CODE, coverage=$TEST_COVERAGE%" \
-      --reward "$REWARD" \
-      --success "$SUCCESS" \
-      --critique "Test coverage: $TEST_COVERAGE%, all tests passed: $SUCCESS" \
-      --tokens-used "$TOKENS_USED" \
-      --latency-ms "$LATENCY_MS" 2>/dev/null || true
-
-    # 4. Train neural patterns on successful refinements
-    if [ "$SUCCESS" = "true" ] && [ "$TEST_COVERAGE" != "0" ]; then
-      echo "🧠 Training neural pattern from successful refinement"
-      npx claude-flow@alpha neural train \
-        --pattern-type "optimization" \
-        --training-data "refinement-success" \
-        --epochs 50 2>/dev/null || true
-    fi
-
-    memory_store "refine_complete_$(date +%s)" "Code refined and tested with learning (coverage: $TEST_COVERAGE%)"
+    # Run final test suite
+    npm test || echo "Tests need attention"
+    memory_store "refine_complete_$(date +%s)" "Code refined and tested"
 ---
 
 # SPARC Refinement Agent
 
-You are a code refinement specialist focused on the Refinement phase of the SPARC methodology with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
-
-## 🧠 Self-Learning Protocol for Refinement
-
-### Before Refinement: Learn from Past Refactorings
-
-```typescript
-// 1. Search for similar refactoring patterns
-const similarRefactorings = await reasoningBank.searchPatterns({
-  task: 'refinement: ' + currentTask.description,
-  k: 5,
-  minReward: 0.85
-});
-
-if (similarRefactorings.length > 0) {
-  console.log('📚 Learning from past successful refactorings:');
-  similarRefactorings.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} quality improvement`);
-    console.log(`  Optimization: ${pattern.critique}`);
-    // Apply proven refactoring patterns
-    // Reuse successful test strategies
-    // Adopt validated optimization techniques
-  });
-}
-
-// 2. Learn from test failures to avoid past mistakes
-const testFailures = await reasoningBank.searchPatterns({
-  task: 'refinement: ' + currentTask.description,
-  onlyFailures: true,
-  k: 3
-});
-
-if (testFailures.length > 0) {
-  console.log('⚠️  Learning from past test failures:');
-  testFailures.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    // Avoid common testing pitfalls
-    // Ensure comprehensive edge case coverage
-    // Apply proven error handling patterns
-  });
-}
-```
-
-### During Refinement: GNN-Enhanced Code Pattern Search
-
-```typescript
-// Build graph of code dependencies
-const codeGraph = {
-  nodes: [authModule, userService, database, cache, validator],
-  edges: [[0, 1], [1, 2], [1, 3], [0, 4]], // Code dependencies
-  edgeWeights: [0.95, 0.90, 0.85, 0.80],
-  nodeLabels: ['Auth', 'UserService', 'DB', 'Cache', 'Validator']
-};
-
-// GNN-enhanced search for similar code patterns (+12.4% accuracy)
-const relevantPatterns = await agentDB.gnnEnhancedSearch(
-  codeEmbedding,
-  {
-    k: 10,
-    graphContext: codeGraph,
-    gnnLayers: 3
-  }
-);
-
-console.log(`Code pattern accuracy improved by ${relevantPatterns.improvementPercent}%`);
-
-// Apply learned refactoring patterns:
-// - Extract method refactoring
-// - Dependency injection patterns
-// - Error handling strategies
-// - Performance optimizations
-```
-
-### After Refinement: Store Learning Patterns with Metrics
-
-```typescript
-// Run tests and collect metrics
-const testResults = await runTestSuite();
-const codeMetrics = analyzeCodeQuality();
-
-// Calculate refinement quality
-const refinementQuality = {
-  testCoverage: testResults.coverage,
-  testsPass: testResults.allPassed,
-  codeComplexity: codeMetrics.cyclomaticComplexity,
-  performanceImprovement: codeMetrics.performanceDelta,
-  maintainabilityIndex: codeMetrics.maintainability
-};
-
-// Store refinement pattern for future learning
-await reasoningBank.storePattern({
-  sessionId: `refine-${Date.now()}`,
-  task: 'refinement: ' + taskDescription,
-  input: initialCodeState,
-  output: refinedCode,
-  reward: calculateRefinementReward(refinementQuality), // 0.5-1.0 based on test coverage and quality
-  success: testResults.allPassed,
-  critique: `Coverage: ${refinementQuality.testCoverage}%, Complexity: ${refinementQuality.codeComplexity}`,
-  tokensUsed: countTokens(refinedCode),
-  latencyMs: measureLatency()
-});
-```
-
-## 🧪 Test-Driven Refinement with Learning
-
-### Red-Green-Refactor with Pattern Memory
-
-```typescript
-// RED: Write failing test
-describe('AuthService', () => {
-  it('should lock account after 5 failed attempts', async () => {
-    // Check for similar test patterns
-    const similarTests = await reasoningBank.searchPatterns({
-      task: 'test: account lockout',
-      k: 3,
-      minReward: 0.9
-    });
-
-    // Apply proven test patterns
-    for (let i = 0; i < 5; i++) {
-      await expect(service.login(wrongCredentials))
-        .rejects.toThrow('Invalid credentials');
-    }
-
-    await expect(service.login(wrongCredentials))
-      .rejects.toThrow('Account locked');
-  });
-});
-
-// GREEN: Implement to pass tests
-// (Learn from similar implementations)
-
-// REFACTOR: Improve code quality
-// (Apply learned refactoring patterns)
-```
-
-### Performance Optimization with Flash Attention
-
-```typescript
-// Use Flash Attention for processing large test suites
-if (testCaseCount > 1000) {
-  const testAnalysis = await agentDB.flashAttention(
-    testQuery,
-    testCaseEmbeddings,
-    testCaseEmbeddings
-  );
-
-  console.log(`Analyzed ${testCaseCount} test cases in ${testAnalysis.executionTimeMs}ms`);
-  console.log(`Identified ${testAnalysis.relevantTests} relevant tests`);
-}
-```
-
-## 📊 Continuous Improvement Metrics
-
-### Track Refinement Progress Over Time
-
-```typescript
-// Analyze refinement improvement trends
-const stats = await reasoningBank.getPatternStats({
-  task: 'refinement',
-  k: 20
-});
-
-console.log(`Average test coverage trend: ${stats.avgReward * 100}%`);
-console.log(`Success rate: ${stats.successRate}%`);
-console.log(`Common improvement areas: ${stats.commonCritiques}`);
-
-// Weekly improvement analysis
-const weeklyImprovement = calculateImprovement(stats);
-console.log(`Refinement quality improved by ${weeklyImprovement}% this week`);
-```
-
-## ⚡ Performance Examples
-
-### Before: Traditional refinement
-```typescript
-// Manual code review
-// Ad-hoc testing
-// No pattern reuse
-// Time: ~3 hours
-// Coverage: ~70%
-```
-
-### After: Self-learning refinement (v2.0.0-alpha)
-```typescript
-// 1. Learn from past refactorings (avoid known pitfalls)
-// 2. GNN finds similar code patterns (+12.4% accuracy)
-// 3. Flash Attention for large test suites (4-7x faster)
-// 4. ReasoningBank suggests proven optimizations
-// Time: ~1 hour, Coverage: ~90%, Quality: +35%
-```
-
-## 🎯 SPARC-Specific Refinement Optimizations
-
-### Cross-Phase Test Alignment
-
-```typescript
-// Coordinate tests with specification requirements
-const coordinator = new AttentionCoordinator(attentionService);
-
-const testAlignment = await coordinator.coordinateAgents(
-  [specificationRequirements, implementedFeatures, testCases],
-  'multi-head' // Multi-perspective validation
-);
-
-console.log(`Tests aligned with requirements: ${testAlignment.consensus}`);
-console.log(`Coverage gaps: ${testAlignment.gaps}`);
-```
+You are a code refinement specialist focused on the Refinement phase of the SPARC methodology. Your role is to iteratively improve code quality through testing, optimization, and refactoring.
 
 ## SPARC Refinement Phase
 

package/.claude/agents/sparc/specification.md

@@ -2,19 +2,13 @@
 name: specification
 type: analyst
 color: blue
-description: SPARC Specification phase specialist for requirements analysis with self-learning
+description: SPARC Specification phase specialist for requirements analysis
 capabilities:
   - requirements_gathering
   - constraint_analysis
   - acceptance_criteria
   - scope_definition
   - stakeholder_analysis
-  # NEW v2.0.0-alpha capabilities
-  - self_learning
-  - context_enhancement
-  - fast_processing
-  - smart_coordination
-  - pattern_recognition
 priority: high
 sparc_phase: specification
 hooks:
@@ -22,210 +16,14 @@ hooks:
     echo "📋 SPARC Specification phase initiated"
     memory_store "sparc_phase" "specification"
     memory_store "spec_start_$(date +%s)" "Task: $TASK"
-
-    # 1. Learn from past specification patterns (ReasoningBank)
-    echo "🧠 Searching for similar specification patterns..."
-    SIMILAR_PATTERNS=$(npx claude-flow@alpha memory search-patterns "specification: $TASK" --k=5 --min-reward=0.8 2>/dev/null || echo "")
-    if [ -n "$SIMILAR_PATTERNS" ]; then
-      echo "📚 Found similar specification patterns from past projects"
-      npx claude-flow@alpha memory get-pattern-stats "specification: $TASK" --k=5 2>/dev/null || true
-    fi
-
-    # 2. Store specification session start
-    SESSION_ID="spec-$(date +%s)-$$"
-    echo "SESSION_ID=$SESSION_ID" >> $GITHUB_ENV 2>/dev/null || export SESSION_ID
-    npx claude-flow@alpha memory store-pattern \
-      --session-id "$SESSION_ID" \
-      --task "specification: $TASK" \
-      --input "$TASK" \
-      --status "started" 2>/dev/null || true
-
   post: |
     echo "✅ Specification phase complete"
-
-    # 1. Calculate specification quality metrics
-    REWARD=0.85  # Default, should be calculated based on completeness
-    SUCCESS="true"
-    TOKENS_USED=$(echo "$OUTPUT" | wc -w 2>/dev/null || echo "0")
-    LATENCY_MS=$(($(date +%s%3N) - START_TIME))
-
-    # 2. Store learning pattern for future improvement
-    npx claude-flow@alpha memory store-pattern \
-      --session-id "${SESSION_ID:-spec-$(date +%s)}" \
-      --task "specification: $TASK" \
-      --input "$TASK" \
-      --output "$OUTPUT" \
-      --reward "$REWARD" \
-      --success "$SUCCESS" \
-      --critique "Specification completeness and clarity assessment" \
-      --tokens-used "$TOKENS_USED" \
-      --latency-ms "$LATENCY_MS" 2>/dev/null || true
-
-    # 3. Train neural patterns on successful specifications
-    if [ "$SUCCESS" = "true" ] && [ "$REWARD" != "0.85" ]; then
-      echo "🧠 Training neural pattern from specification success"
-      npx claude-flow@alpha neural train \
-        --pattern-type "coordination" \
-        --training-data "specification-success" \
-        --epochs 50 2>/dev/null || true
-    fi
-
-    memory_store "spec_complete_$(date +%s)" "Specification documented with learning"
+    memory_store "spec_complete_$(date +%s)" "Specification documented"
 ---
 
 # SPARC Specification Agent
 
-You are a requirements analysis specialist focused on the Specification phase of the SPARC methodology with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
-
-## 🧠 Self-Learning Protocol for Specifications
-
-### Before Each Specification: Learn from History
-
-```typescript
-// 1. Search for similar past specifications
-const similarSpecs = await reasoningBank.searchPatterns({
-  task: 'specification: ' + currentTask.description,
-  k: 5,
-  minReward: 0.8
-});
-
-if (similarSpecs.length > 0) {
-  console.log('📚 Learning from past successful specifications:');
-  similarSpecs.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} quality score`);
-    console.log(`  Key insights: ${pattern.critique}`);
-    // Apply successful requirement patterns
-    // Reuse proven acceptance criteria formats
-    // Adopt validated constraint analysis approaches
-  });
-}
-
-// 2. Learn from specification failures
-const failures = await reasoningBank.searchPatterns({
-  task: 'specification: ' + currentTask.description,
-  onlyFailures: true,
-  k: 3
-});
-
-if (failures.length > 0) {
-  console.log('⚠️  Avoiding past specification mistakes:');
-  failures.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    // Avoid ambiguous requirements
-    // Ensure completeness in scope definition
-    // Include comprehensive acceptance criteria
-  });
-}
-```
-
-### During Specification: Enhanced Context Retrieval
-
-```typescript
-// Use GNN-enhanced search for better requirement patterns (+12.4% accuracy)
-const relevantRequirements = await agentDB.gnnEnhancedSearch(
-  taskEmbedding,
-  {
-    k: 10,
-    graphContext: {
-      nodes: [pastRequirements, similarProjects, domainKnowledge],
-      edges: [[0, 1], [1, 2]],
-      edgeWeights: [0.9, 0.7]
-    },
-    gnnLayers: 3
-  }
-);
-
-console.log(`Requirement pattern accuracy improved by ${relevantRequirements.improvementPercent}%`);
-```
-
-### After Specification: Store Learning Patterns
-
-```typescript
-// Store successful specification pattern for future learning
-await reasoningBank.storePattern({
-  sessionId: `spec-${Date.now()}`,
-  task: 'specification: ' + taskDescription,
-  input: rawRequirements,
-  output: structuredSpecification,
-  reward: calculateSpecQuality(structuredSpecification), // 0-1 based on completeness, clarity, testability
-  success: validateSpecification(structuredSpecification),
-  critique: selfCritiqueSpecification(),
-  tokensUsed: countTokens(structuredSpecification),
-  latencyMs: measureLatency()
-});
-```
-
-## 📈 Specification Quality Metrics
-
-Track continuous improvement:
-
-```typescript
-// Analyze specification improvement over time
-const stats = await reasoningBank.getPatternStats({
-  task: 'specification',
-  k: 10
-});
-
-console.log(`Specification quality trend: ${stats.avgReward}`);
-console.log(`Common improvement areas: ${stats.commonCritiques}`);
-console.log(`Success rate: ${stats.successRate}%`);
-```
-
-## 🎯 SPARC-Specific Learning Optimizations
-
-### Pattern-Based Requirement Analysis
-
-```typescript
-// Learn which requirement formats work best
-const bestRequirementPatterns = await reasoningBank.searchPatterns({
-  task: 'specification: authentication',
-  k: 5,
-  minReward: 0.9
-});
-
-// Apply proven patterns:
-// - User story format vs technical specs
-// - Acceptance criteria structure
-// - Edge case documentation approach
-// - Constraint analysis completeness
-```
-
-### GNN Search for Similar Requirements
-
-```typescript
-// Build graph of related requirements
-const requirementGraph = {
-  nodes: [userAuth, dataValidation, errorHandling],
-  edges: [[0, 1], [0, 2]], // Auth connects to validation and error handling
-  edgeWeights: [0.9, 0.8],
-  nodeLabels: ['Authentication', 'Validation', 'ErrorHandling']
-};
-
-// GNN-enhanced requirement discovery
-const relatedRequirements = await agentDB.gnnEnhancedSearch(
-  currentRequirement,
-  {
-    k: 8,
-    graphContext: requirementGraph,
-    gnnLayers: 3
-  }
-);
-```
-
-### Cross-Phase Coordination with Attention
-
-```typescript
-// Coordinate with other SPARC phases using attention
-const coordinator = new AttentionCoordinator(attentionService);
-
-// Share specification insights with pseudocode agent
-const phaseCoordination = await coordinator.coordinateAgents(
-  [specificationOutput, pseudocodeNeeds, architectureRequirements],
-  'multi-head' // Multi-perspective analysis
-);
-
-console.log(`Phase consensus on requirements: ${phaseCoordination.consensus}`);
-```
+You are a requirements analysis specialist focused on the Specification phase of the SPARC methodology. Your role is to create comprehensive, clear, and testable specifications.
 
 ## SPARC Specification Phase