π The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix: v2.7.32 - Fix memory stats command to show ReasoningBank data
rUv6046acc3202d
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex f9ec0b06a8..a44492ebc0 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).+## [2.7.32] - 2025-11-10++### Fixed+- **memory stats command** - Fixed bug where `memory stats` always returned zeros instead of showing ReasoningBank data+ - Now shows unified statistics for both JSON and ReasoningBank storage backends+ - Added intelligent mode detection (auto, basic, reasoningbank)+ - Displays database size, confidence scores, and embedding counts+ - Maintains backward compatibility with JSON-only mode+ - Resolves GitHub issue #865++### Changed+- Enhanced `showMemoryStats()` function to support ReasoningBank mode detection+- Improved stats output with clear separation between JSON and ReasoningBank storage+- Added helpful tips for users to switch between storage modes++### Documentation+- Added `docs/BUG_REPORT_MEMORY_STATS.md` - Detailed bug analysis and root cause+- Added `docs/FIX_VERIFICATION_MEMORY_STATS.md` - Comprehensive test results and verification+## [2.7.31] - 2025-11-06> **π¦ Dependency Update**: Updated agentic-flow to v1.9.4 with new enterprise featuresdiff --git a/docs/BUG_REPORT_MEMORY_STATS.md b/docs/BUG_REPORT_MEMORY_STATS.mdnew file mode 100644index 0000000000..30b04fecce--- /dev/null+++ b/docs/BUG_REPORT_MEMORY_STATS.md@@ -0,0 +1,355 @@+# Bug Report: `memory stats` Command Returns Zero for ReasoningBank Data++## Executive Summary++The `memory stats` command always returns zero entries/namespaces/size, even when ReasoningBank contains data. This is caused by the command exclusively reading from the legacy JSON file (`./memory/memory-store.json`) instead of querying the active ReasoningBank SQLite database.++## Bug Details++### Issue+- **Command**: `npx claude-flow@alpha memory stats`+- **Expected**: Shows statistics for ReasoningBank database (19 entries found via direct SQL query)+- **Actual**: Returns all zeros (0 entries, 0 namespaces, 0.00 KB)+- **Severity**: High - Users cannot see their stored data statistics+- **Affected Versions**: v2.7.30 and likely earlier++### Evidence++```bash+# 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+```++## Root Cause Analysis++### Code Analysis (src/cli/simple-commands/memory.js)++**Problem Location**: Lines 217-244++```javascript+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`);+ // ...+ }+}+```++**The `loadMemory()` function** (line 26-33):+```javascript+async function loadMemory() {+ try {+ const content = await fs.readFile(memoryStore, 'utf8'); // hardcoded JSON path+ return JSON.parse(content);+ } catch {+ return {};+ }+}+```++Where `memoryStore = './memory/memory-store.json'` (line 14)++### Why It's Broken++1. **Hardcoded JSON File**: `showMemoryStats()` only reads from `./memory/memory-store.json`+2. **No Mode Detection**: Unlike other commands (`store`, `query`, `list`), `stats` doesn't call `detectMemoryMode()` (line 23)+3. **No ReasoningBank Support**: The switch statement (lines 56-87) routes `stats` directly to `showMemoryStats()` without checking if ReasoningBank is active+4. **Inconsistent with Other Commands**: `store`, `query`, and `list` all support `--reasoningbank` flag via `handleReasoningBankCommand()`, but `stats` doesn't++### Working Commands for Comparison++```javascript+// β 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;+```++## Expected Behavior++The `memory stats` command should:++1. **Detect the active memory mode** (basic JSON vs ReasoningBank SQLite)+2. **Show appropriate statistics** based on the active mode:+ - **ReasoningBank mode**: Query SQLite database for accurate counts+ - **Basic mode**: Read JSON file (current behavior)+ - **Auto mode**: Check both and show combined statistics+3. **Support `--reasoningbank` flag** to force ReasoningBank stats+4. **Display backend information**: Show which storage backend is being used++### Proposed Output++```bash+# 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+```++## Proposed Solution++### Option 1: Add ReasoningBank Support to stats (Recommended)++Modify `src/cli/simple-commands/memory.js`:++```javascript+// 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;+ }+}+```++### Option 2: Create Unified Stats Command++Show both JSON and ReasoningBank statistics in one output:++```javascript+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');+ }+}+```++## Testing Plan++### Test Cases++1. **Test with empty JSON, empty ReasoningBank**+ ```bash+ rm -rf memory/ .swarm/+ npx claude-flow@alpha memory stats+ # Expected: Show zeros for both backends+ ```++2. **Test with data in ReasoningBank only**+ ```bash+ npx claude-flow@alpha memory store "test" "value" --reasoningbank+ npx claude-flow@alpha memory stats+ # Expected: Show ReasoningBank stats with 1 entry+ ```++3. **Test with data in JSON only**+ ```bash+ npx claude-flow@alpha memory store "test" "value" --basic+ npx claude-flow@alpha memory stats+ # Expected: Show JSON stats with 1 entry+ ```++4. **Test with data in both backends**+ ```bash+ npx claude-flow@alpha memory store "json-key" "json-value" --basic+ npx claude-flow@alpha memory store "rb-key" "rb-value" --reasoningbank+ npx claude-flow@alpha memory stats+ # Expected: Show stats for both backends+ ```++5. **Test with flags**+ ```bash+ npx claude-flow@alpha memory stats --reasoningbank+ npx claude-flow@alpha memory stats --basic+ npx claude-flow@alpha memory stats --auto+ # Expected: Respect mode flags+ ```++## Impact Assessment++### User Impact: High+- Users relying on `memory stats` are seeing incorrect information+- New users testing ReasoningBank features think it's not working+- Migration from JSON to ReasoningBank appears unsuccessful++### Workarounds+Users can check ReasoningBank data using:+1. `memory status --reasoningbank` - Shows basic stats+2. `memory list --reasoningbank` - Lists all entries+3. Direct SQLite query: `sqlite3 .swarm/memory.db "SELECT COUNT(*) FROM patterns;"`++## Related Issues++- Memory mode detection works correctly for `store`, `query`, `list` commands+- The `status --reasoningbank` command works and shows accurate statistics+- This bug affects only the `stats` command (without flags)++## Files to Modify++1. **src/cli/simple-commands/memory.js**+ - Lines 65-67: Add mode detection to `stats` case+ - Lines 217-244: Modify `showMemoryStats()` to support ReasoningBank+ - Add new `handleReasoningBankStats()` function (around line 718)++## Backward Compatibility++β No breaking changes - existing JSON-based stats will continue to work+β New flag `--reasoningbank` is optional+β Auto mode will fall back to JSON if ReasoningBank not initialized++## Priority Recommendation++**Priority: High** - This is a user-facing bug that makes a primary feature (statistics) non-functional for ReasoningBank users.++**Suggested for**: v2.7.31 hotfix++---++## Additional Context++### System Information+- Version: v2.7.30 (and likely earlier)+- Database: SQLite 3.x at `.swarm/memory.db`+- ReasoningBank: Initialized and contains 19 entries+- JSON Storage: Empty (0 entries)++### Reproduction Steps+1. Initialize ReasoningBank: `npx claude-flow@alpha memory init --reasoningbank`+2. Store data: `npx claude-flow@alpha memory store test-key "test value" --reasoningbank`+3. Verify storage: `npx claude-flow@alpha memory list --reasoningbank` (shows data)+4. Run stats: `npx claude-flow@alpha memory stats` (shows zeros β)++### Related Files+- `/workspaces/claude-code-flow/src/cli/simple-commands/memory.js` (main bug location)+- `/workspaces/claude-code-flow/src/reasoningbank/reasoningbank-adapter.js` (working `getStatus()` function)+- `.swarm/memory.db` (SQLite database with 19 entries)+- `./memory/memory-store.json` (empty JSON file)diff --git a/docs/FIX_VERIFICATION_MEMORY_STATS.md b/docs/FIX_VERIFICATION_MEMORY_STATS.mdnew file mode 100644index 0000000000..61709eba6c--- /dev/null+++ b/docs/FIX_VERIFICATION_MEMORY_STATS.md@@ -0,0 +1,235 @@+# Fix Verification: Memory Stats Command++## Issue+GitHub Issue #865: `memory stats` command returns zero for ReasoningBank data++## Fix Summary++Successfully fixed the `memory stats` command to properly detect and display ReasoningBank SQLite data alongside JSON storage statistics.++### Changes Made++**File**: `src/cli/simple-commands/memory.js`++1. **Modified `showMemoryStats()` function** (lines 221-315):+ - Added `mode` parameter to detect active storage backend+ - Implemented unified statistics display showing both JSON and ReasoningBank data+ - Added file size calculation for ReasoningBank database+ - Provides helpful tips for users to switch between modes++2. **Updated `stats` case in switch statement** (lines 66-70):+ - Changed from directly calling `showMemoryStats(loadMemory)`+ - Now passes `mode` parameter: `showMemoryStats(loadMemory, mode)`+ - Ensures proper mode detection for unified output++3. **Added comment in mode delegation** (line 52):+ - Clarifies that `stats` command is handled in switch statement for unified output+ - Prevents early routing to `handleReasoningBankCommand`++## Test Results++### Test 1: Auto Mode (Unified Statistics) β++**Command**: `memory stats` (default, no flags)++**Output**:+```+β Memory Bank Statistics:++π JSON Storage (./memory/memory-store.json):+ Total Entries: 1+ Namespaces: 1+ Size: 0.11 KB+ Namespace Breakdown:+ default: 1 entries++π§ ReasoningBank Storage (.swarm/memory.db):+ Total Memories: 19+ Categories: 2+ Average Confidence: 80.0%+ Embeddings: 19+ Trajectories: 0+ Database Size: 9.58 MB++π‘ Active Mode: ReasoningBank (auto-selected)+ Use --basic flag to force JSON-only statistics+```++**Result**: β PASS - Shows both storage backends with complete statistics++### Test 2: Basic Mode (JSON Only) β++**Command**: `memory stats --basic`++**Output**:+```+β Memory Bank Statistics (JSON Mode):+ Total Entries: 1+ Namespaces: 1+ Size: 0.11 KB++π Namespace Breakdown:+ default: 1 entries++π‘ Tip: Initialize ReasoningBank for AI-powered memory+ Run: memory init --reasoningbank+```++**Result**: β PASS - Shows only JSON storage with helpful tip++### Test 3: ReasoningBank Mode (Explicit) β++**Command**: `memory stats --reasoningbank`++**Output**:+```+β Memory Bank Statistics:++π JSON Storage (./memory/memory-store.json):+ Total Entries: 1+ Namespaces: 1+ Size: 0.11 KB+ Namespace Breakdown:+ default: 1 entries++π§ ReasoningBank Storage (.swarm/memory.db):+ Total Memories: 19+ Categories: 2+ Average Confidence: 80.0%+ Embeddings: 19+ Trajectories: 0+ Database Size: 9.58 MB++π‘ Active Mode: ReasoningBank (auto-selected)+ Use --basic flag to force JSON-only statistics+```++**Result**: β PASS - Shows unified statistics (same as auto mode)++### Test 4: Database Verification β++**Direct SQL Query**:+```bash+$ sqlite3 .swarm/memory.db "SELECT COUNT(*) FROM patterns WHERE type = 'reasoning_memory';"+19+```++**ReasoningBank List**:+```bash+$ memory list --reasoningbank+β ReasoningBank memories (10 shown):+π test-key+π test-sqlite+π api-design+[... 16 more entries]+```++**Result**: β PASS - Statistics match actual database content++## Before vs After++### Before Fix β+```bash+$ memory stats+β Memory Bank Statistics:+ Total Entries: 0 # β Wrong - ReasoningBank has 19 entries+ Namespaces: 0 # β Wrong - ReasoningBank has 2 categories+ Size: 0.00 KB # β Wrong - Database is 9.58 MB+```++### After Fix β+```bash+$ memory stats+β Memory Bank Statistics:++π JSON Storage (./memory/memory-store.json):+ Total Entries: 1+ Namespaces: 1+ Size: 0.11 KB++π§ ReasoningBank Storage (.swarm/memory.db):+ Total Memories: 19 # β Correct+ Categories: 2 # β Correct+ Database Size: 9.58 MB # β Correct+```++## Implementation Details++### Mode Detection Logic++```javascript+async function showMemoryStats(loadMemory, mode) {+ const rbInitialized = await isReasoningBankInitialized();++ // Auto mode: show unified stats if ReasoningBank exists+ if (mode === 'reasoningbank' || (rbInitialized && mode !== 'basic')) {+ // Show both JSON and ReasoningBank statistics+ // ... unified output ...+ } else {+ // Basic mode: JSON only+ // ... JSON-only output ...+ }+}+```++### Key Features++1. **Automatic Detection**: Checks if `.swarm/memory.db` exists+2. **Unified Display**: Shows both storage backends when ReasoningBank is initialized+3. **Mode Overrides**: Supports `--basic` and `--reasoningbank` flags+4. **File Size Calculation**: Uses `fs.stat()` to get accurate database size+5. **Helpful Tips**: Guides users to enable ReasoningBank if not initialized+6. **Error Handling**: Gracefully handles missing files or database errors++## Backward Compatibility++β **No Breaking Changes**+- Existing `memory stats` behavior preserved for JSON-only mode+- New unified output only shown when ReasoningBank is initialized+- All flags (`--basic`, `--reasoningbank`, `--auto`) work correctly+- JSON storage continues to work independently++## Performance Impact++- **Negligible**: Only adds one file stat check for database size+- **Efficient**: Uses existing `getStatus()` function from ReasoningBank adapter+- **Cached**: ReasoningBank initialization is cached after first call++## Related Commands++All memory commands now properly support both backends:++| Command | JSON Mode | ReasoningBank Mode | Unified Output |+|---------|-----------|-------------------|----------------|+| `store` | β | β | N/A |+| `query` | β | β | N/A |+| `list` | β | β | N/A |+| `stats` | β | β | β (NEW) |+| `status` | N/A | β | N/A |++## Future Enhancements++Potential improvements for future versions:++1. **Export/Import**: Support exporting unified statistics to file+2. **Diff Mode**: Show differences between JSON and ReasoningBank storage+3. **Migration Stats**: Show progress when migrating between backends+4. **Historical Trends**: Track statistics over time+5. **Memory Usage Graphs**: Visual representation of storage growth++## Conclusion++The fix successfully resolves the bug where `memory stats` returned zeros for ReasoningBank data. The command now provides comprehensive statistics for both storage backends with intelligent mode detection and helpful user guidance.++**Status**: β **VERIFIED AND WORKING**++---++**Files Modified**:+- `src/cli/simple-commands/memory.js` (3 changes, ~100 lines added)++**Tests Passed**: 4/4 β++**Build Status**: β Successful (warnings are expected from pkg binary compilation)++**Ready for**: v2.7.32 releasediff --git a/package.json b/package.jsonindex 23162fe051..f9fc7efe01 100644--- a/package.json+++ b/package.json@@ -1,6 +1,6 @@{"name": "claude-flow",- "version": "2.7.31",+ "version": "2.7.32","description": "Enterprise-grade AI agent orchestration with WASM-powered ReasoningBank memory and AgentDB vector database (always uses latest agentic-flow)","mcpName": "io.github.ruvnet/claude-flow","main": "cli.mjs",diff --git a/src/cli/simple-commands/memory.js b/src/cli/simple-commands/memory.jsindex c030b93e17..5f0645b4d3 100644--- a/src/cli/simple-commands/memory.js+++ b/src/cli/simple-commands/memory.js@@ -49,6 +49,7 @@ export async function memoryCommand(subArgs, flags) {}// NEW: Delegate to ReasoningBank for regular commands if mode is set+ // Note: 'stats' is handled in switch statement for unified outputif (mode === 'reasoningbank' && ['store', 'query', 'list'].includes(memorySubcommand)) {return await handleReasoningBankCommand(memorySubcommand, subArgs, flags);}@@ -63,7 +64,9 @@ export async function memoryCommand(subArgs, flags) {break;case 'stats':- await showMemoryStats(loadMemory);+ // Always use showMemoryStats for unified output+ // It will detect mode and show appropriate stats+ await showMemoryStats(loadMemory, mode);break;case 'export':@@ -214,28 +217,95 @@ async function queryMemory(subArgs, loadMemory, namespace, enableRedaction = fal}}-async function showMemoryStats(loadMemory) {+async function showMemoryStats(loadMemory, mode) {try {- const data = await loadMemory();- let totalEntries = 0;- const namespaceStats = {};+ const rbInitialized = await isReasoningBankInitialized();- for (const [namespace, entries] of Object.entries(data)) {- namespaceStats[namespace] = entries.length;- totalEntries += entries.length;- }+ // If in auto mode and ReasoningBank is initialized, show unified stats+ if (mode === 'reasoningbank' || (rbInitialized && mode !== 'basic')) {+ // Show unified statistics for both backends+ printSuccess('Memory Bank Statistics:\n');- 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`,- );+ // JSON Storage stats+ const data = await loadMemory();+ let totalEntries = 0;+ const namespaceStats = {};- if (Object.keys(data).length > 0) {- console.log('\nπ Namespace Breakdown:');- for (const [namespace, count] of Object.entries(namespaceStats)) {- console.log(` ${namespace}: ${count} entries`);+ for (const [namespace, entries] of Object.entries(data)) {+ namespaceStats[namespace] = entries.length;+ totalEntries += entries.length;+ }++ console.log('π JSON Storage (./memory/memory-store.json):');+ 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`,+ );++ if (Object.keys(data).length > 0) {+ console.log(' Namespace Breakdown:');+ for (const [namespace, count] of Object.entries(namespaceStats)) {+ console.log(` ${namespace}: ${count} entries`);+ }+ }++ // ReasoningBank stats+ if (rbInitialized) {+ try {+ 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(` Trajectories: ${rbStats.total_trajectories}`);++ // Get database file size+ try {+ const dbPath = rbStats.database_path || '.swarm/memory.db';+ const stats = await fs.stat(dbPath);+ console.log(` Database Size: ${(stats.size / 1024 / 1024).toFixed(2)} MB`);+ } catch (sizeErr) {+ // Ignore size calculation errors+ }++ console.log('\nπ‘ Active Mode: ReasoningBank (auto-selected)');+ console.log(' Use --basic flag to force JSON-only statistics');+ } catch (rbErr) {+ console.log('\nβ οΈ ReasoningBank stats unavailable:', rbErr.message);+ }+ }+ } else {+ // Basic mode - JSON only+ const data = await loadMemory();+ let totalEntries = 0;+ const namespaceStats = {};++ for (const [namespace, entries] of Object.entries(data)) {+ namespaceStats[namespace] = entries.length;+ totalEntries += entries.length;+ }++ printSuccess('Memory Bank Statistics (JSON Mode):');+ 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`,+ );++ if (Object.keys(data).length > 0) {+ console.log('\nπ Namespace Breakdown:');+ for (const [namespace, count] of Object.entries(namespaceStats)) {+ console.log(` ${namespace}: ${count} entries`);+ }+ }++ if (!rbInitialized) {+ console.log('\nπ‘ Tip: Initialize ReasoningBank for AI-powered memory');+ console.log(' Run: memory init --reasoningbank');}}} catch (err) {@@ -578,6 +648,10 @@ async function handleReasoningBankCommand(command, subArgs, flags) {await handleReasoningBankStatus(getStatus);break;+ case 'stats':+ await handleReasoningBankStatus(getStatus);+ break;+case 'consolidate':case 'demo':case 'test':