import { HybridReasoningBank } from 'agentic-flow/reasoningbank';

const rb = new HybridReasoningBank({
  preferWasm: true,      // Use WASM acceleration
  enableCaching: true,   // Enable query cache
  queryTTL: 60000       // 60-second cache TTL
});

// 1. Store Pattern with Causal Tracking
await rb.storePattern({
  sessionId: 'session-1',
  task: 'API optimization',
  input: 'Slow database queries',
  output: 'Added Redis caching layer',
  critique: 'Reduced response time by 80%',
  success: true,
  reward: 0.95,
  latencyMs: 120
});

// 2. Retrieve with CausalRecall Ranking
const patterns = await rb.retrievePatterns('optimize API', {
  k: 5,                  // Top 5 results
  minReward: 0.8,        // High-quality patterns only
  onlySuccesses: true,   // Filter failures
  causalRanking: true    // Enable CausalRecall (default)
});

console.log(patterns[0]);
/*
{
  id: 123,
  task: 'API optimization',
  output: 'Added Redis caching layer',
  reward: 0.95,
  similarity: 0.92,
  causalScore: 0.88,  // ← NEW: Utility-based ranking
  finalScore: 0.90     // ← Combines similarity + causality
}
*/

// 3. Learn Strategy from History
const strategy = await rb.learnStrategy('API optimization');

console.log(strategy);
/*
{
  task: 'API optimization',
  recommendation: 'Strong evidence for success',
  evidence: 'STRONG',
  avgUplift: 0.15,      // 15% average improvement
  patternCount: 12,     // 12 successful patterns
  reasoning: 'Based on 12 similar successful patterns with +15.0% uplift'
}
*/

// 4. Auto-Consolidation (Patterns → Skills)
const result = await rb.autoConsolidate(
  3,      // minUses: pattern used at least 3 times
  0.7,    // minSuccessRate: 70% success rate
  30      // lookbackDays: last 30 days
);

console.log(result);
/*
{
  skillsCreated: 5,
  skillIds: [501, 502, 503, 504, 505],
  patterns: [
    { pattern: 'caching', uses: 12, successRate: 0.92 },
    { pattern: 'indexing', uses: 8, successRate: 0.85 },
    ...
  ]
}
*/

// 5. What-If Causal Analysis
const insight = await rb.whatIfAnalysis('add caching');

console.log(insight);
/*
{
  action: 'add caching',
  recommendation: 'DO_IT',
  evidence: 'STRONG',
  avgUplift: 0.22,           // 22% expected improvement
  sampleSize: 15,            // Based on 15 causal edges
  expectedImpact: 'Highly beneficial: Expected +22.0% improvement',
  reasoning: 'Strong evidence for success (15 causal edges, +22.0% uplift)'
}
*/

// 6. Search Skills
const skills = await rb.searchSkills('API development', 5);

console.log(skills);
/*
[
  {
    id: 501,
    taskType: 'caching',
    avgReward: 0.92,
    usageCount: 12,
    createdAt: 1729785600000
  },
  ...
]
*/

// 7. Get Statistics
const stats = rb.getStats();

console.log(stats);
/*
{
  backend: 'wasm',
  cacheEnabled: true,
  patterns: 145,
  skills: 5,
  causalEdges: 34,
  queryCache: { size: 23, ttl: 60000 }
}
*/

import { AdvancedMemorySystem } from 'agentic-flow/reasoningbank';

const memory = new AdvancedMemorySystem();

// 1. Auto-Consolidation with Detailed Metrics
const result = await memory.autoConsolidate({
  minUses: 3,
  minSuccessRate: 0.7,
  lookbackDays: 30
});

console.log(result);
/*
{
  skillsCreated: 5,
  causalEdgesCreated: 12,
  patternsAnalyzed: 45,
  timeElapsed: 234,  // ms
  recommendations: [
    'Created skill "api_caching" from 12 patterns (92% success)',
    'Created skill "rate_limiting" from 8 patterns (85% success)',
    ...
  ]
}
*/

// 2. Episodic Replay - Learn from Failures
const failures = await memory.replayFailures('database migration', 5);

failures.forEach(failure => {
  console.log('Task:', failure.task);
  console.log('What went wrong:', failure.whatWentWrong);
  console.log('How to fix:', failure.howToFix);
  console.log('Confidence:', failure.confidence);
  console.log('---');
});

/*
Task: database migration to PostgreSQL
What went wrong: Schema mismatch caused foreign key constraint failures
How to fix: Always verify schema compatibility before migration. Add validation step.
Confidence: 0.85
---
*/

// 3. What-If Analysis with Impact Descriptions
const insight = await memory.whatIfAnalysis('add rate limiting');

console.log(insight);
/*
{
  action: 'add rate limiting',
  recommendation: 'DO_IT',
  evidence: 'STRONG',
  avgUplift: 0.18,
  sampleSize: 10,
  expectedImpact: 'Moderately beneficial: Expected +18.0% improvement',
  reasoning: 'Moderate evidence for success (10 causal edges, +18.0% uplift)'
}
*/

// 4. Skill Composition
const composition = await memory.composeSkills('Build REST API', 5);

console.log(composition);
/*
{
  task: 'Build REST API',
  compositionPlan: 'authentication → validation → caching → rate_limiting → testing',
  skills: [
    { name: 'authentication', avgReward: 0.92, weight: 0.25 },
    { name: 'validation', avgReward: 0.88, weight: 0.20 },
    { name: 'caching', avgReward: 0.90, weight: 0.20 },
    { name: 'rate_limiting', avgReward: 0.85, weight: 0.15 },
    { name: 'testing', avgReward: 0.87, weight: 0.20 }
  ],
  expectedSuccessRate: 0.884,  // 88.4%
  reasoning: 'Composed 5 complementary skills with weighted success rates'
}
*/

// 5. Run Learning Cycle (Automated)
const cycleResult = await memory.runLearningCycle();

console.log(cycleResult);
/*
{
  skillsCreated: 2,
  causalEdgesCreated: 5,
  patternsAnalyzed: 23,
  timeElapsed: 156,
  recommendations: [
    'Created skill "error_handling" from 7 patterns (89% success)',
    'Created skill "logging" from 5 patterns (94% success)'
  ]
}
*/

// 6. Get Statistics
const stats = memory.getStats();

console.log(stats);
/*
{
  patterns: 145,
  skills: 7,
  causalEdges: 39,
  lastLearningCycle: 1729785600000,
  backend: 'agentdb'
}
*/

# Update agentic-flow
npm update agentic-flow

# Verify version
npm list agentic-flow
# Should show: [email protected]

# For claude-flow users
cd /path/to/claude-flow
npm update agentic-flow

npm install agentic-flow@^1.7.1
# or
npm install agentic-flow@latest

// ✅ v1.7.0 code still works
import { ReasoningBankEngine } from 'agentic-flow/reasoningbank';

const rb = new ReasoningBankEngine();
await rb.storePattern({ /* ... */ });

// Before (v1.7.0)
import { ReasoningBankEngine } from 'agentic-flow/reasoningbank';
const rb = new ReasoningBankEngine();

// After (v1.7.1) - 116x faster!
import { HybridReasoningBank } from 'agentic-flow/reasoningbank';
const rb = new HybridReasoningBank({ preferWasm: true });

// NEW in v1.7.1
import { AdvancedMemorySystem } from 'agentic-flow/reasoningbank';
const memory = new AdvancedMemorySystem();

// Auto-consolidate patterns into skills
const result = await memory.autoConsolidate({
  minUses: 3,
  minSuccessRate: 0.7,
  lookbackDays: 30
});

// Auto-applied during npm install
export { ReflexionMemory } from './ReflexionMemory.js';
export { NightlyLearner } from './NightlyLearner.js';
export { CausalMemoryGraph } from './CausalMemoryGraph.js';

const rb = new HybridReasoningBank({
  preferWasm: true,       // Use WASM acceleration
  enableCaching: true,    // Enable query cache
  queryTTL: 60000,        // 1-minute cache
  causalRanking: true     // Use CausalRecall
});

const rb = new HybridReasoningBank({
  preferWasm: false,      // Use TypeScript (lower memory)
  enableCaching: false,   // Disable cache
  causalRanking: false    // Simple ranking
});