import { HybridReasoningBank, AdvancedMemorySystem } from 'agentic-flow/reasoningbank';
// ✅ SUCCESS! (Previously failed in v1.7.1)

// v1.7.1 package.json exports
"./reasoningbank": {
  "node": "./dist/reasoningbank/index.js",  // ❌ Pointed to old v1.7.0 exports
}

// v1.7.1 had features in index-new.js, not index.js
import { HybridReasoningBank } from 'agentic-flow/reasoningbank';
// ❌ Error: does not provide an export named 'HybridReasoningBank'

// v1.7.4 package.json exports (CORRECTED)
"./reasoningbank": {
  "node": "./dist/reasoningbank/index.ts",  // ✅ Now exports all features
}

// v1.7.4 standard imports
import { HybridReasoningBank } from 'agentic-flow/reasoningbank';
// ✅ SUCCESS!

const {
  HybridReasoningBank,
  AdvancedMemorySystem,
  ReflexionMemory,
  CausalRecall,
  NightlyLearner,
  SkillLibrary,
  EmbeddingService,
  CausalMemoryGraph
} = await import('agentic-flow/reasoningbank');

✅ HybridReasoningBank: function
✅ AdvancedMemorySystem: function
✅ ReflexionMemory: function
✅ CausalRecall: function
✅ NightlyLearner: function
✅ SkillLibrary: function
✅ EmbeddingService: function
✅ CausalMemoryGraph: function

const rb = new HybridReasoningBank({
  preferWasm: false,
  enableCaching: true,
  queryTTL: 60000
});

✅ storePattern(pattern)
✅ retrievePatterns(query, options)
✅ learnStrategy(task)
✅ autoConsolidate(minUses, minSuccessRate, lookbackDays)
✅ whatIfAnalysis(action)
✅ searchSkills(query, k)
✅ getStats()
✅ loadWasmModule()

const memory = new AdvancedMemorySystem();

✅ autoConsolidate(options)
✅ replayFailures(task, limit)
✅ whatIfAnalysis(action)
✅ composeSkills(task, k)
✅ runLearningCycle()
✅ getStats()
✅ extractCritique(trajectory)
✅ analyzeFailure(episode)
✅ generateFixes(failure)

const {
  initialize,
  retrieveMemories,
  judgeTrajectory,
  distillMemories,
  consolidate
} = await import('agentic-flow/reasoningbank');

✅ initialize: function
✅ retrieveMemories: function
✅ judgeTrajectory: function
✅ distillMemories: function
✅ consolidate: function

import {
  ReflexionMemory,      // ✅ Episodic memory with causal tracking
  CausalRecall,         // ✅ Utility-based ranking (α=0.6, β=0.3, γ=0.1)
  NightlyLearner,       // ✅ Doubly robust learning
  SkillLibrary,         // ✅ Skill storage and retrieval
  EmbeddingService,     // ✅ Vector embeddings
  CausalMemoryGraph,    // ✅ Causal edge tracking
  ExplainableRecall,    // ✅ Provenance chains
  LearningSystem        // ✅ Learning coordination
} from 'agentic-flow/reasoningbank';

# Simple upgrade (recommended)
npm update agentic-flow

# Or with version constraint
npm install agentic-flow@^1.7.4

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

npm install agentic-flow@latest
# or
npm install [email protected]

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

const rb = new HybridReasoningBank({ preferWasm: true });

// Store learning pattern
await rb.storePattern({
  sessionId: 'session-1',
  task: 'Implement user authentication',
  input: 'Need secure login system',
  output: 'Implemented JWT-based auth with refresh tokens',
  critique: 'Good security, consider 2FA',
  success: true,
  reward: 0.95
});

// Retrieve similar patterns
const patterns = await rb.retrievePatterns('authentication', {
  k: 5,
  minReward: 0.8
});

// Learn from history
const strategy = await rb.learnStrategy('authentication');
console.log(strategy.recommendation);
// "Strong evidence for success (12 patterns, +15.0% uplift)"

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
});

console.log(`Created ${result.skillsCreated} skills`);

// What-if causal analysis
const insight = await memory.whatIfAnalysis('add rate limiting');
console.log(insight.expectedImpact);
// "Moderately beneficial: Expected +18.0% improvement"

// Learn from failures
const failures = await memory.replayFailures('database migration', 5);
failures.forEach(f => {
  console.log('What went wrong:', f.whatWentWrong);
  console.log('How to fix:', f.howToFix);
});

import {
  HybridReasoningBank,
  AdvancedMemorySystem,
  ReflexionMemory,
  CausalRecall
} from 'agentic-flow/reasoningbank';

// Initialize ReflexionMemory (creates database tables)
const reflexion = new ReflexionMemory({
  dbPath: './memory.db',
  embeddingProvider: 'xenova'
});

// Use HybridReasoningBank with CausalRecall ranking
const rb = new HybridReasoningBank({
  preferWasm: true,       // 116x faster search
  enableCaching: true,    // 90%+ hit rate
  queryTTL: 60000        // 1-minute cache
});

// Use AdvancedMemorySystem for learning
const memory = new AdvancedMemorySystem();

// Run automated learning cycle
const learningResult = await memory.runLearningCycle();
console.log(`Created ${learningResult.skillsCreated} new skills`);

[HybridReasoningBank] WASM unavailable, using TypeScript:
WASM load failed: TypeError [ERR_UNKNOWN_FILE_EXTENSION]: Unknown file extension ".wasm"

SqliteError: no such table: episodes

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

// Initialize database (creates tables)
const reflexion = new ReflexionMemory({
  dbPath: './memory.db',
  embeddingProvider: 'xenova'
});

// Now HybridReasoningBank can use database
const rb = new HybridReasoningBank({ preferWasm: false });

import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __dirname = dirname(fileURLToPath(import.meta.url));
const indexNewPath = join(__dirname, '../node_modules/agentic-flow/dist/reasoningbank/index-new.js');

const { HybridReasoningBank } = await import(indexNewPath);

import { HybridReasoningBank } from 'agentic-flow/reasoningbank';
// ✅ Just works!

// ✅ All v1.7.0 APIs still work
import { retrieveMemories, judgeTrajectory } from 'agentic-flow/reasoningbank';
import * as ReasoningBank from 'agentic-flow/reasoningbank';

# Run verification test
node tests/test-agentic-flow-v174-complete.mjs

# Expected output:
# ✅ All imports successful
# ✅ HybridReasoningBank operational
# ✅ AdvancedMemorySystem operational
# ✅ Backwards compatibility maintained