Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 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

fix: v2.7.32 - Fix memory stats command to show ReasoningBank data

rUv6046acc3202d
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 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 features
diff --git a/docs/BUG_REPORT_MEMORY_STATS.md b/docs/BUG_REPORT_MEMORY_STATS.md
new file mode 100644
index 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.md
new file mode 100644
index 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 release
diff --git a/package.json b/package.json
index 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.js
index 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 output
if (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':