# Command returns zeros
$ npx claude-flow@alpha memory stats
✅ Memory Bank Statistics:
   Total Entries: 0
   Namespaces: 0
   Size: 0.00 KB

# But ReasoningBank list shows 10+ entries
$ npx claude-flow@alpha memory list --reasoningbank
✅ ReasoningBank memories (10 shown):
📌 test-key
📌 test-sqlite
📌 api-design
[... 16 more entries]

# Direct SQL query confirms 19 entries exist
$ sqlite3 .swarm/memory.db "SELECT COUNT(*) FROM patterns WHERE type = 'reasoning_memory';"
19

# ReasoningBank status confirms data exists
$ npx claude-flow@alpha memory status --reasoningbank
✅ 📊 ReasoningBank Status:
   Total memories: 19
   Average confidence: 80.0%
   Embeddings: 19
   Trajectories: 0

async function showMemoryStats(loadMemory) {
  try {
    const data = await loadMemory();  // ❌ Only reads JSON file
    let totalEntries = 0;
    const namespaceStats = {};

    for (const [namespace, entries] of Object.entries(data)) {
      namespaceStats[namespace] = entries.length;
      totalEntries += entries.length;
    }

    printSuccess('Memory Bank Statistics:');
    console.log(`   Total Entries: ${totalEntries}`);
    console.log(`   Namespaces: ${Object.keys(data).length}`);
    console.log(`   Size: ${(new TextEncoder().encode(JSON.stringify(data)).length / 1024).toFixed(2)} KB`);
    // ...
  }
}

async function loadMemory() {
  try {
    const content = await fs.readFile(memoryStore, 'utf8');  // hardcoded JSON path
    return JSON.parse(content);
  } catch {
    return {};
  }
}

// ✅ These commands properly detect mode and support ReasoningBank
case 'store':
  await storeMemory(subArgs, loadMemory, saveMemory, namespace, enableRedaction);
  break;

case 'query':
  await queryMemory(subArgs, loadMemory, namespace, enableRedaction);
  break;

case 'list':
  await listNamespaces(loadMemory);
  break;

// ❌ This command ignores mode detection
case 'stats':
  await showMemoryStats(loadMemory);  // Never checks ReasoningBank!
  break;

# Auto mode (should detect ReasoningBank if initialized)
$ npx claude-flow@alpha memory stats
✅ Memory Bank Statistics:
   Storage Backend: ReasoningBank (SQLite)
   Total Entries: 19
   Namespaces: 3
   Size: 9.14 MB

📁 Namespace Breakdown:
   default: 12 entries
   test-namespace: 5 entries
   api: 2 entries

💡 Use 'memory stats --basic' for JSON statistics

# Force ReasoningBank mode
$ npx claude-flow@alpha memory stats --reasoningbank
✅ ReasoningBank Statistics:
   Database: .swarm/memory.db
   Total Memories: 19
   Total Embeddings: 19
   Average Confidence: 80.0%
   Trajectories: 0
   Links: 0
   Database Size: 9.14 MB

# Force basic mode
$ npx claude-flow@alpha memory stats --basic
✅ JSON Memory Statistics:
   Total Entries: 0
   Namespaces: 0
   Size: 0.00 KB
   ⚠️  Consider migrating to ReasoningBank for better performance

// Line 65-67: Add mode detection to stats case
case 'stats':
  if (mode === 'reasoningbank') {
    await handleReasoningBankStats(getStatus);
  } else {
    await showMemoryStats(loadMemory);
  }
  break;

// Add new handler function (around line 718)
async function handleReasoningBankStats(getStatus) {
  try {
    const stats = await getStatus();

    printSuccess('ReasoningBank Statistics:');
    console.log(`   Database: ${stats.database_path || '.swarm/memory.db'}`);
    console.log(`   Total Memories: ${stats.total_memories}`);
    console.log(`   Total Categories: ${stats.total_categories}`);
    console.log(`   Average Confidence: ${(stats.avg_confidence * 100).toFixed(1)}%`);
    console.log(`   Embeddings: ${stats.total_embeddings}`);
    console.log(`   Trajectories: ${stats.total_trajectories}`);
    console.log(`   Links: ${stats.total_links || 0}`);
    console.log(`   Storage Backend: ${stats.storage_backend}`);

    if (stats.database_path) {
      const dbSize = await getFileSize(stats.database_path);
      console.log(`   Database Size: ${(dbSize / 1024 / 1024).toFixed(2)} MB`);
    }
  } catch (error) {
    printError(`Failed to get ReasoningBank stats: ${error.message}`);
  }
}

// Helper function
async function getFileSize(path) {
  try {
    const stats = await fs.stat(path);
    return stats.size;
  } catch {
    return 0;
  }
}

async function showMemoryStats(loadMemory, mode) {
  const rbInitialized = await isReasoningBankInitialized();

  printSuccess('Memory Bank Statistics:\n');

  // Show JSON stats
  const jsonData = await loadMemory();
  let totalEntries = Object.values(jsonData).reduce((sum, arr) => sum + arr.length, 0);

  console.log('📁 JSON Storage (./memory/memory-store.json):');
  console.log(`   Total Entries: ${totalEntries}`);
  console.log(`   Namespaces: ${Object.keys(jsonData).length}`);
  console.log(`   Size: ${(new TextEncoder().encode(JSON.stringify(jsonData)).length / 1024).toFixed(2)} KB`);

  // Show ReasoningBank stats if initialized
  if (rbInitialized) {
    const { getStatus } = await import('../../reasoningbank/reasoningbank-adapter.js');
    const rbStats = await getStatus();

    console.log('\n🧠 ReasoningBank Storage (.swarm/memory.db):');
    console.log(`   Total Memories: ${rbStats.total_memories}`);
    console.log(`   Categories: ${rbStats.total_categories}`);
    console.log(`   Average Confidence: ${(rbStats.avg_confidence * 100).toFixed(1)}%`);
    console.log(`   Embeddings: ${rbStats.total_embeddings}`);

    console.log('\n💡 Active Mode: ReasoningBank (auto-selected)');
  } else {
    console.log('\n⚠️  ReasoningBank not initialized (using JSON storage)');
    console.log('   Run "memory init --reasoningbank" to enable AI features');
  }
}