# 🧠 v2.0.0-alpha: Learn from past API implementations
echo "🧠 Learning from past API patterns..."
SIMILAR_PATTERNS=$(npx claude-flow@alpha memory search-patterns "API implementation: $TASK" --k=5 --min-reward=0.85 2>$dev$null || echo "")
if [ -n "$SIMILAR_PATTERNS" ]; then
  echo "📚 Found similar successful API patterns"
  npx claude-flow@alpha memory get-pattern-stats "API implementation" --k=5 2>$dev$null || true
fi

# Store task start for learning
npx claude-flow@alpha memory store-pattern \
  --session-id "backend-dev-$(date +%s)" \
  --task "API: $TASK" \
  --input "$TASK_CONTEXT" \
  --status "started" 2>$dev$null || true

# 🧠 v2.0.0-alpha: Store learning patterns
echo "🧠 Storing API pattern for future learning..."
REWARD=$(if npm run test:api 2>$dev$null; then echo "0.95"; else echo "0.7"; fi)
SUCCESS=$(if npm run test:api 2>$dev$null; then echo "true"; else echo "false"; fi)

npx claude-flow@alpha memory store-pattern \
  --session-id "backend-dev-$(date +%s)" \
  --task "API: $TASK" \
  --output "$TASK_OUTPUT" \
  --reward "$REWARD" \
  --success "$SUCCESS" \
  --critique "API implementation with $(find . -name '*.route.js' -o -name '*.controller.js' | wc -l) endpoints" 2>$dev$null || true

# Train neural patterns on successful implementations
if [ "$SUCCESS" = "true" ]; then
  echo "🧠 Training neural pattern from successful API implementation"
  npx claude-flow@alpha neural train \
    --pattern-type "coordination" \
    --training-data "$TASK_OUTPUT" \
    --epochs 50 2>$dev$null || true
fi

# Store failure pattern for learning
npx claude-flow@alpha memory store-pattern \
  --session-id "backend-dev-$(date +%s)" \
  --task "API: $TASK" \
  --output "Failed: {{error_message}}" \
  --reward "0.0" \
  --success "false" \
  --critique "Error: {{error_message}}" 2>$dev$null || true

// 1. Search for similar past API implementations
const similarAPIs = await reasoningBank.searchPatterns({
  task: 'API implementation: ' + currentTask.description,
  k: 5,
  minReward: 0.85
});

if (similarAPIs.length > 0) {
  console.log('📚 Learning from past API implementations:');
  similarAPIs.forEach(pattern => {
    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
    console.log(`  Best practices: ${pattern.output}`);
    console.log(`  Critique: ${pattern.critique}`);
  });

  // Apply patterns from successful implementations
  const bestPractices = similarAPIs
    .filter(p => p.reward > 0.9)
    .map(p => extractPatterns(p.output));
}

// 2. Learn from past API failures
const failures = await reasoningBank.searchPatterns({
  task: 'API implementation',
  onlyFailures: true,
  k: 3
});

if (failures.length > 0) {
  console.log('⚠️  Avoiding past API mistakes:');
  failures.forEach(pattern => {
    console.log(`- ${pattern.critique}`);
  });
}

// Use GNN-enhanced search for better API context (+12.4% accuracy)
const graphContext = {
  nodes: [authController, userService, database, middleware],
  edges: [[0, 1], [1, 2], [0, 3]], // Dependency graph
  edgeWeights: [0.9, 0.8, 0.7],
  nodeLabels: ['AuthController', 'UserService', 'Database', 'Middleware']
};

const relevantEndpoints = await agentDB.gnnEnhancedSearch(
  taskEmbedding,
  {
    k: 10,
    graphContext,
    gnnLayers: 3
  }
);

console.log(`Context accuracy improved by ${relevantEndpoints.improvementPercent}%`);

// Process large API schemas 4-7x faster
if (schemaSize > 1024) {
  const result = await agentDB.flashAttention(
    queryEmbedding,
    schemaEmbeddings,
    schemaEmbeddings
  );

  console.log(`Processed ${schemaSize} schema elements in ${result.executionTimeMs}ms`);
  console.log(`Memory saved: ~50%`);
}

// Store successful API pattern for future learning
const codeQuality = calculateCodeQuality(generatedCode);
const testsPassed = await runTests();

await reasoningBank.storePattern({
  sessionId: `backend-dev-${Date.now()}`,
  task: `API implementation: ${taskDescription}`,
  input: taskInput,
  output: generatedCode,
  reward: testsPassed ? codeQuality : 0.5,
  success: testsPassed,
  critique: `Implemented ${endpointCount} endpoints with ${testCoverage}% coverage`,
  tokensUsed: countTokens(generatedCode),
  latencyMs: measureLatency()
});

// Store successful API patterns
await reasoningBank.storePattern({
  task: 'REST API CRUD implementation',
  output: {
    endpoints: ['GET /', 'GET /:id', 'POST /', 'PUT /:id', 'DELETE /:id'],
    middleware: ['auth', 'validate', 'rateLimit'],
    tests: ['unit', 'integration', 'e2e']
  },
  reward: 0.95,
  success: true,
  critique: 'Complete CRUD with proper validation and auth'
});

// Search for similar endpoint patterns
const crudPatterns = await reasoningBank.searchPatterns({
  task: 'REST API CRUD',
  k: 3,
  minReward: 0.9
});

// Track success rates by endpoint type
const endpointStats = {
  'authentication': { successRate: 0.92, avgLatency: 145 },
  'crud': { successRate: 0.95, avgLatency: 89 },
  'graphql': { successRate: 0.88, avgLatency: 203 },
  'websocket': { successRate: 0.85, avgLatency: 67 }
};

// Choose best approach based on past performance
const bestApproach = Object.entries(endpointStats)
  .sort((a, b) => b[1].successRate - a[1].successRate)[0];