superlocalmemory 2.8.2 → 2.8.5

package/requirements.txt

@@ -1,10 +1,12 @@
-# SuperLocalMemory V2 - Core Requirements
+# SuperLocalMemory - Core Requirements
 # ============================================================================
-# SuperLocalMemory V2.2.0 has ZERO core dependencies
-# All functionality works with Python 3.8+ standard library only
+# Core memory operations (store, recall, search) work with Python 3.8+
+# standard library only — no required dependencies.
 #
-# For optional advanced features, see:
-#   - requirements-full.txt     (all optional features)
-#   - requirements-ui.txt       (web dashboard only)
-#   - requirements-search.txt   (advanced search only)
+# Advanced features (knowledge graph, dashboard, semantic search) require
+# optional dependencies listed in the other requirements files:
+#   - requirements-core.txt     (graph + dashboard)
+#   - requirements-search.txt   (semantic search)
+#   - requirements-learning.txt (ML-based ranking)
+#   - requirements-full.txt     (everything)
 # ============================================================================

package/scripts/prepack.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * SuperLocalMemory - Cross-platform prepack cleanup
+ *
+ * Removes __pycache__ directories and .pyc files before npm pack.
+ * Works on Windows, macOS, and Linux.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function removePycache(dir) {
+    if (!fs.existsSync(dir)) return;
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+            if (entry.name === '__pycache__' || entry.name === 'node_modules') {
+                if (entry.name === '__pycache__') {
+                    fs.rmSync(fullPath, { recursive: true, force: true });
+                }
+                continue;
+            }
+            removePycache(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith('.pyc')) {
+            fs.unlinkSync(fullPath);
+        }
+    }
+}
+
+removePycache(process.cwd());

package/scripts/verify-v27.ps1

@@ -0,0 +1,301 @@
+# ============================================================================
+# SuperLocalMemory V2.7 — Quick Verification Script (PowerShell)
+# Copyright (c) 2026 Varun Pratap Bhardwaj
+# Licensed under MIT License
+# Repository: https://github.com/varun369/SuperLocalMemoryV2
+#
+# Run this after installation to verify everything works:
+#   .\scripts\verify-v27.ps1
+# ============================================================================
+
+param()
+
+$ErrorActionPreference = "Stop"
+
+$INSTALL_DIR = Join-Path $env:USERPROFILE ".claude-memory"
+$PASS = 0
+$WARN = 0
+$FAIL = 0
+
+Write-Host ""
+Write-Host "SuperLocalMemory v2.7 Verification"
+Write-Host "==================================="
+Write-Host ""
+
+# ── Check 1: Installation directory ──────────────────────────────────────────
+if (Test-Path $INSTALL_DIR) {
+    Write-Host "[PASS] Installation directory exists: $INSTALL_DIR" -ForegroundColor Green
+    $PASS++
+} else {
+    Write-Host "[FAIL] Installation directory missing. Run install.ps1 first." -ForegroundColor Red
+    $FAIL++
+    Write-Host ""
+    Write-Host "==================================="
+    Write-Host "Result: FAIL — SuperLocalMemory is not installed."
+    Write-Host "Run:  .\install.ps1"
+    exit 1
+}
+
+# ── Check 2: Core modules ────────────────────────────────────────────────────
+Write-Host ""
+Write-Host "Core Modules:"
+$coreModules = @("memory_store_v2.py", "graph_engine.py", "pattern_learner.py", "mcp_server.py", "tree_manager.py")
+foreach ($mod in $coreModules) {
+    $modPath = Join-Path $INSTALL_DIR $mod
+    if (Test-Path $modPath) {
+        Write-Host "  [PASS] $mod" -ForegroundColor Green
+        $PASS++
+    } else {
+        Write-Host "  [FAIL] Missing: $mod" -ForegroundColor Red
+        $FAIL++
+    }
+}
+
+# ── Check 3: v2.5 modules ────────────────────────────────────────────────────
+Write-Host ""
+Write-Host "Event System (v2.5):"
+$v25Modules = @("event_bus.py", "subscription_manager.py", "webhook_dispatcher.py", "agent_registry.py", "provenance_tracker.py", "trust_scorer.py", "db_connection_manager.py")
+foreach ($mod in $v25Modules) {
+    $modPath = Join-Path $INSTALL_DIR $mod
+    if (Test-Path $modPath) {
+        Write-Host "  [PASS] $mod" -ForegroundColor Green
+        $PASS++
+    } else {
+        Write-Host "  [WARN] Missing: $mod (v2.5 feature)" -ForegroundColor Yellow
+        $WARN++
+    }
+}
+
+# ── Check 4: Learning modules (v2.7) ─────────────────────────────────────────
+Write-Host ""
+Write-Host "Learning System (v2.7):"
+$learningDir = Join-Path $INSTALL_DIR "learning"
+if (Test-Path $learningDir) {
+    Write-Host "  [PASS] learning/ directory exists" -ForegroundColor Green
+    $PASS++
+
+    $learningModules = @("__init__.py", "learning_db.py", "adaptive_ranker.py", "feedback_collector.py",
+                         "engagement_tracker.py", "cross_project_aggregator.py", "project_context_manager.py",
+                         "workflow_pattern_miner.py", "source_quality_scorer.py", "synthetic_bootstrap.py",
+                         "feature_extractor.py")
+    foreach ($mod in $learningModules) {
+        $modPath = Join-Path $learningDir $mod
+        if (Test-Path $modPath) {
+            Write-Host "  [PASS] learning/$mod" -ForegroundColor Green
+            $PASS++
+        } else {
+            Write-Host "  [WARN] Missing: learning/$mod" -ForegroundColor Yellow
+            $WARN++
+        }
+    }
+} else {
+    Write-Host "  [FAIL] learning/ directory missing (v2.7 not fully installed)" -ForegroundColor Red
+    $FAIL++
+}
+
+# ── Check 5: Learning dependencies ───────────────────────────────────────────
+Write-Host ""
+Write-Host "Learning Dependencies:"
+try {
+    python -c "import lightgbm; print(f'  [PASS] LightGBM {lightgbm.__version__}')" 2>$null
+    if ($LASTEXITCODE -eq 0) {
+        $PASS++
+    } else {
+        throw
+    }
+} catch {
+    Write-Host "  [INFO] LightGBM not installed (optional — rule-based ranking will be used)" -ForegroundColor Yellow
+    $WARN++
+}
+
+try {
+    python -c "import scipy; print(f'  [PASS] SciPy {scipy.__version__}')" 2>$null
+    if ($LASTEXITCODE -eq 0) {
+        $PASS++
+    } else {
+        throw
+    }
+} catch {
+    Write-Host "  [INFO] SciPy not installed (optional — install for full learning features)" -ForegroundColor Yellow
+    $WARN++
+}
+
+# ── Check 6: Core dependencies ───────────────────────────────────────────────
+Write-Host ""
+Write-Host "Core Dependencies:"
+try {
+    python -c "import sklearn; print(f'  [PASS] scikit-learn {sklearn.__version__}')" 2>$null
+    if ($LASTEXITCODE -eq 0) {
+        $PASS++
+    } else {
+        throw
+    }
+} catch {
+    Write-Host "  [WARN] scikit-learn not installed (needed for knowledge graph)" -ForegroundColor Yellow
+    $WARN++
+}
+
+try {
+    python -c "import numpy; print(f'  [PASS] numpy {numpy.__version__}')" 2>$null
+    if ($LASTEXITCODE -eq 0) {
+        $PASS++
+    } else {
+        throw
+    }
+} catch {
+    Write-Host "  [WARN] numpy not installed" -ForegroundColor Yellow
+    $WARN++
+}
+
+try {
+    python -c "import igraph; print(f'  [PASS] python-igraph {igraph.__version__}')" 2>$null
+    if ($LASTEXITCODE -eq 0) {
+        $PASS++
+    } else {
+        throw
+    }
+} catch {
+    Write-Host "  [WARN] python-igraph not installed (needed for graph clustering)" -ForegroundColor Yellow
+    $WARN++
+}
+
+# ── Check 7: Database ────────────────────────────────────────────────────────
+Write-Host ""
+Write-Host "Databases:"
+$memoryDb = Join-Path $INSTALL_DIR "memory.db"
+if (Test-Path $memoryDb) {
+    try {
+        $MEMORY_COUNT = sqlite3 $memoryDb "SELECT COUNT(*) FROM memories;" 2>$null
+        $DB_SIZE = [math]::Round((Get-Item $memoryDb).Length / 1KB, 2)
+        Write-Host "  [PASS] memory.db exists ($MEMORY_COUNT memories, $DB_SIZE KB)" -ForegroundColor Green
+        $PASS++
+    } catch {
+        Write-Host "  [INFO] memory.db exists but cannot query (sqlite3 not available)" -ForegroundColor Yellow
+    }
+} else {
+    Write-Host "  [INFO] memory.db not yet created (will auto-create on first use)" -ForegroundColor Yellow
+}
+
+$learningDb = Join-Path $INSTALL_DIR "learning.db"
+if (Test-Path $learningDb) {
+    try {
+        $FEEDBACK_COUNT = sqlite3 $learningDb "SELECT COUNT(*) FROM ranking_feedback;" 2>$null
+        Write-Host "  [PASS] learning.db exists ($FEEDBACK_COUNT feedback signals)" -ForegroundColor Green
+        $PASS++
+    } catch {
+        Write-Host "  [INFO] learning.db exists but cannot query (sqlite3 not available)" -ForegroundColor Yellow
+    }
+} else {
+    Write-Host "  [INFO] learning.db not yet created (will auto-create on first recall)" -ForegroundColor Yellow
+}
+
+# ── Check 8: CLI ──────────────────────────────────────────────────────────────
+Write-Host ""
+Write-Host "CLI:"
+$slmCommand = Get-Command slm -ErrorAction SilentlyContinue
+if ($slmCommand) {
+    Write-Host "  [PASS] slm command available in PATH" -ForegroundColor Green
+    $PASS++
+} else {
+    $slmBin = Join-Path $INSTALL_DIR "bin\slm"
+    if (Test-Path $slmBin) {
+        Write-Host "  [WARN] slm exists at $slmBin but not in PATH" -ForegroundColor Yellow
+        Write-Host "         Add to PATH: `$env:PATH = `"`$env:USERPROFILE\.claude-memory\bin;`$env:PATH`""
+        $WARN++
+    } else {
+        Write-Host "  [FAIL] slm command not found" -ForegroundColor Red
+        $FAIL++
+    }
+}
+
+# ── Check 9: MCP server ──────────────────────────────────────────────────────
+Write-Host ""
+Write-Host "MCP Server:"
+$mcpServer = Join-Path $INSTALL_DIR "mcp_server.py"
+if (Test-Path $mcpServer) {
+    Write-Host "  [PASS] mcp_server.py installed" -ForegroundColor Green
+    $PASS++
+} else {
+    Write-Host "  [FAIL] mcp_server.py missing" -ForegroundColor Red
+    $FAIL++
+}
+
+try {
+    python -c "from mcp.server.fastmcp import FastMCP" 2>$null
+    if ($LASTEXITCODE -eq 0) {
+        Write-Host "  [PASS] MCP SDK installed" -ForegroundColor Green
+        $PASS++
+    } else {
+        throw
+    }
+} catch {
+    Write-Host "  [WARN] MCP SDK not installed (install: pip install mcp)" -ForegroundColor Yellow
+    $WARN++
+}
+
+# ── Check 10: Import chain verification ───────────────────────────────────────
+Write-Host ""
+Write-Host "Import Chain:"
+$importTest = @"
+import sys
+sys.path.insert(0, '$($INSTALL_DIR -replace '\\', '\\')')
+try:
+    from learning import get_learning_db, get_status, FULL_LEARNING_AVAILABLE, ML_RANKING_AVAILABLE
+    status = get_status()
+    ml = 'yes' if status['ml_ranking_available'] else 'no'
+    full = 'yes' if status['learning_available'] else 'no'
+    print(f'OK ml_ranking={ml} full_learning={full}')
+except ImportError as e:
+    print(f'IMPORT_ERROR {e}')
+except Exception as e:
+    print(f'ERROR {e}')
+"@
+
+$IMPORT_RESULT = python -c $importTest 2>&1
+
+if ($IMPORT_RESULT -like "OK*") {
+    Write-Host "  [PASS] Learning system imports successfully" -ForegroundColor Green
+    Write-Host "         $IMPORT_RESULT"
+    $PASS++
+} elseif ($IMPORT_RESULT -like "IMPORT_ERROR*") {
+    Write-Host "  [WARN] Learning import failed: $($IMPORT_RESULT -replace 'IMPORT_ERROR ', '')" -ForegroundColor Yellow
+    Write-Host "         This may be normal if learning modules are not yet installed."
+    $WARN++
+} else {
+    Write-Host "  [WARN] Learning check: $IMPORT_RESULT" -ForegroundColor Yellow
+    $WARN++
+}
+
+# ── Summary ───────────────────────────────────────────────────────────────────
+Write-Host ""
+Write-Host "==================================="
+Write-Host "Verification Summary"
+Write-Host "  Passed:   $PASS"
+Write-Host "  Warnings: $WARN"
+Write-Host "  Failed:   $FAIL"
+Write-Host "==================================="
+Write-Host ""
+
+if ($FAIL -eq 0) {
+    Write-Host "Status: READY" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "Quick start:"
+    Write-Host "  slm remember `"My first memory`""
+    Write-Host "  slm recall `"first`""
+    Write-Host "  slm status"
+    Write-Host ""
+    if ($WARN -gt 0) {
+        Write-Host "Some optional features may not be available."
+        Write-Host "Install missing dependencies to enable them:"
+        Write-Host "  pip install lightgbm scipy        # Learning system"
+        Write-Host "  pip install scikit-learn igraph   # Knowledge graph"
+        Write-Host ""
+    }
+} else {
+    Write-Host "Status: INCOMPLETE" -ForegroundColor Red
+    Write-Host ""
+    Write-Host "Fix the failed checks above, then re-run:"
+    Write-Host "  .\scripts\verify-v27.ps1"
+    Write-Host ""
+    exit 1
+}

package/src/agent_registry.py

@@ -105,24 +105,26 @@ class AgentRegistry:
         except ImportError:
             import sqlite3
             conn = sqlite3.connect(str(self.db_path))
-            conn.execute('''
-                CREATE TABLE IF NOT EXISTS agent_registry (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    agent_id TEXT NOT NULL UNIQUE,
-                    agent_name TEXT,
-                    protocol TEXT NOT NULL,
-                    first_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                    last_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                    memories_written INTEGER DEFAULT 0,
-                    memories_recalled INTEGER DEFAULT 0,
-                    trust_score REAL DEFAULT 0.667,
-                    metadata TEXT DEFAULT '{}'
-                )
-            ''')
-            conn.execute('CREATE INDEX IF NOT EXISTS idx_agent_protocol ON agent_registry(protocol)')
-            conn.execute('CREATE INDEX IF NOT EXISTS idx_agent_last_seen ON agent_registry(last_seen)')
-            conn.commit()
-            conn.close()
+            try:
+                conn.execute('''
+                    CREATE TABLE IF NOT EXISTS agent_registry (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        agent_id TEXT NOT NULL UNIQUE,
+                        agent_name TEXT,
+                        protocol TEXT NOT NULL,
+                        first_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        last_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        memories_written INTEGER DEFAULT 0,
+                        memories_recalled INTEGER DEFAULT 0,
+                        trust_score REAL DEFAULT 0.667,
+                        metadata TEXT DEFAULT '{}'
+                    )
+                ''')
+                conn.execute('CREATE INDEX IF NOT EXISTS idx_agent_protocol ON agent_registry(protocol)')
+                conn.execute('CREATE INDEX IF NOT EXISTS idx_agent_last_seen ON agent_registry(last_seen)')
+                conn.commit()
+            finally:
+                conn.close()
 
     # =========================================================================
     # Agent Registration
@@ -179,16 +181,18 @@ class AgentRegistry:
         except ImportError:
             import sqlite3
             conn = sqlite3.connect(str(self.db_path))
-            conn.execute('''
-                INSERT INTO agent_registry (agent_id, agent_name, protocol, first_seen, last_seen, metadata)
-                VALUES (?, ?, ?, ?, ?, ?)
-                ON CONFLICT(agent_id) DO UPDATE SET
-                    last_seen = excluded.last_seen,
-                    metadata = excluded.metadata,
-                    agent_name = COALESCE(excluded.agent_name, agent_registry.agent_name)
-            ''', (agent_id, agent_name, protocol, now, now, meta_json))
-            conn.commit()
-            conn.close()
+            try:
+                conn.execute('''
+                    INSERT INTO agent_registry (agent_id, agent_name, protocol, first_seen, last_seen, metadata)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(agent_id) DO UPDATE SET
+                        last_seen = excluded.last_seen,
+                        metadata = excluded.metadata,
+                        agent_name = COALESCE(excluded.agent_name, agent_registry.agent_name)
+                ''', (agent_id, agent_name, protocol, now, now, meta_json))
+                conn.commit()
+            finally:
+                conn.close()
 
         # Emit agent.connected event
         try:

package/src/auto_backup.py

@@ -157,8 +157,10 @@ class AutoBackup:
             # Use SQLite backup API for consistency (safe even during writes)
             source_conn = sqlite3.connect(self.db_path)
             backup_conn = sqlite3.connect(backup_path)
-            source_conn.backup(backup_conn)
-            backup_conn.close()
+            try:
+                source_conn.backup(backup_conn)
+            finally:
+                backup_conn.close()
             source_conn.close()
 
             # Get backup size
@@ -179,8 +181,10 @@ class AutoBackup:
                     learning_backup_path = self.backup_dir / learning_backup_name
                     l_source = sqlite3.connect(learning_db)
                     l_backup = sqlite3.connect(learning_backup_path)
-                    l_source.backup(l_backup)
-                    l_backup.close()
+                    try:
+                        l_source.backup(l_backup)
+                    finally:
+                        l_backup.close()
                     l_source.close()
                     l_size = learning_backup_path.stat().st_size / (1024 * 1024)
                     logger.info(f"Learning backup created: {learning_backup_name} ({l_size:.1f} MB)")
@@ -281,8 +285,10 @@ class AutoBackup:
             # Restore using SQLite backup API
             source_conn = sqlite3.connect(backup_path)
             target_conn = sqlite3.connect(target_db)
-            source_conn.backup(target_conn)
-            target_conn.close()
+            try:
+                source_conn.backup(target_conn)
+            finally:
+                target_conn.close()
             source_conn.close()
 
             logger.info(f"Restored from backup: {filename} → {target_db.name}")

package/src/cache_manager.py

@@ -88,7 +88,7 @@ class CacheEntry:
         age = time.time() - self.timestamp
         return age > ttl_seconds
 
-    def mark_accessed(self):
+    def mark_accessed(self) -> None:
         """Mark entry as accessed (increment counter)."""
         self.access_count += 1
 
@@ -425,7 +425,7 @@ if __name__ == "__main__":
     ]
 
     # Mock search results
-    def mock_search(query: str):
+    def mock_search(query: str) -> None:
         """Simulate search result."""
         return [
             (f"doc_{i}", random.random())

package/src/compression/__init__.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""
+Compression sub-package for SuperLocalMemory.
+Provides tier-based progressive summarization and archival.
+
+Note: Uses relative imports to avoid collision with Python stdlib.
+"""
+
+from .config import CompressionConfig
+from .tier_classifier import TierClassifier
+from .tier2_compressor import Tier2Compressor
+from .tier3_compressor import Tier3Compressor
+from .cold_storage import ColdStorageManager
+from .orchestrator import CompressionOrchestrator
+
+__all__ = [
+    'CompressionConfig',
+    'TierClassifier',
+    'Tier2Compressor',
+    'Tier3Compressor',
+    'ColdStorageManager',
+    'CompressionOrchestrator',
+]

package/src/compression/cli.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""
+CLI interface for compression operations.
+"""
+
+import sys
+import json
+
+from compression.config import CompressionConfig
+from compression.tier_classifier import TierClassifier
+from compression.tier2_compressor import Tier2Compressor
+from compression.tier3_compressor import Tier3Compressor
+from compression.cold_storage import ColdStorageManager
+from compression.orchestrator import CompressionOrchestrator
+
+
+def main():
+    """Main CLI entry point."""
+    if len(sys.argv) < 2:
+        print("Progressive Summarization Compression for SuperLocalMemory\n")
+        print("Usage:")
+        print("  python compression.py classify         # Classify memories into tiers")
+        print("  python compression.py compress         # Run full compression cycle")
+        print("  python compression.py stats            # Show compression statistics")
+        print("  python compression.py tier2 <id>       # Compress specific memory to Tier 2")
+        print("  python compression.py tier3 <id>       # Compress specific memory to Tier 3")
+        print("  python compression.py cold-storage     # Move old memories to cold storage")
+        print("  python compression.py restore <id>     # Restore memory from cold storage")
+        print("  python compression.py init-config      # Initialize compression config")
+        sys.exit(0)
+
+    command = sys.argv[1]
+    orchestrator = CompressionOrchestrator()
+
+    if command == "classify":
+        classifier = TierClassifier()
+        updates = classifier.classify_memories()
+        print(f"Classified {len(updates)} memories")
+
+        stats = classifier.get_tier_stats()
+        print(f"\nTier breakdown:")
+        print(f"  Tier 1 (Full content):    {stats['tier1']} memories")
+        print(f"  Tier 2 (Summary+excerpts): {stats['tier2']} memories")
+        print(f"  Tier 3 (Bullets only):     {stats['tier3']} memories")
+
+    elif command == "compress":
+        print("Running full compression cycle...")
+        stats = orchestrator.run_full_compression()
+
+        print(f"\nCompression Results:")
+        print(f"  Tier updates:          {stats['tier_updates']}")
+        print(f"  Tier 2 compressed:     {stats['tier2_compressed']}")
+        print(f"  Tier 3 compressed:     {stats['tier3_compressed']}")
+        print(f"  Moved to cold storage: {stats['cold_stored']}")
+
+        if 'space_savings' in stats:
+            savings = stats['space_savings']
+            print(f"\nSpace Savings:")
+            print(f"  Original size:  {savings['estimated_original_bytes']:,} bytes")
+            print(f"  Current size:   {savings['current_size_bytes']:,} bytes")
+            print(f"  Savings:        {savings['savings_bytes']:,} bytes ({savings['savings_percent']}%)")
+
+        if stats.get('errors'):
+            print(f"\nErrors: {stats['errors']}")
+
+    elif command == "stats":
+        classifier = TierClassifier()
+        tier_stats = classifier.get_tier_stats()
+
+        cold_storage = ColdStorageManager()
+        cold_stats = cold_storage.get_cold_storage_stats()
+
+        savings = orchestrator._calculate_space_savings()
+
+        print("Compression Statistics\n")
+        print("Tier Breakdown:")
+        print(f"  Tier 1 (Full content):     {tier_stats['tier1']} memories")
+        print(f"  Tier 2 (Summary+excerpts): {tier_stats['tier2']} memories")
+        print(f"  Tier 3 (Bullets only):     {tier_stats['tier3']} memories")
+
+        print(f"\nCold Storage:")
+        print(f"  Archive files: {cold_stats['archive_count']}")
+        print(f"  Total memories: {cold_stats['total_memories']}")
+        print(f"  Total size: {cold_stats['total_size_bytes']:,} bytes")
+
+        print(f"\nSpace Savings:")
+        print(f"  Estimated original: {savings['estimated_original_bytes']:,} bytes")
+        print(f"  Current size:       {savings['current_size_bytes']:,} bytes")
+        print(f"  Savings:            {savings['savings_bytes']:,} bytes ({savings['savings_percent']}%)")
+
+    elif command == "tier2" and len(sys.argv) >= 3:
+        try:
+            memory_id = int(sys.argv[2])
+            compressor = Tier2Compressor()
+            if compressor.compress_to_tier2(memory_id):
+                print(f"Memory #{memory_id} compressed to Tier 2")
+            else:
+                print(f"Failed to compress memory #{memory_id}")
+        except ValueError:
+            print("Error: Memory ID must be a number")
+
+    elif command == "tier3" and len(sys.argv) >= 3:
+        try:
+            memory_id = int(sys.argv[2])
+            compressor = Tier3Compressor()
+            if compressor.compress_to_tier3(memory_id):
+                print(f"Memory #{memory_id} compressed to Tier 3")
+            else:
+                print(f"Failed to compress memory #{memory_id}")
+        except ValueError:
+            print("Error: Memory ID must be a number")
+
+    elif command == "cold-storage":
+        cold_storage = ColdStorageManager()
+        candidates = cold_storage.get_cold_storage_candidates()
+
+        if not candidates:
+            print("No memories ready for cold storage")
+        else:
+            print(f"Moving {len(candidates)} memories to cold storage...")
+            count = cold_storage.move_to_cold_storage(candidates)
+            print(f"Archived {count} memories")
+
+    elif command == "restore" and len(sys.argv) >= 3:
+        try:
+            memory_id = int(sys.argv[2])
+            cold_storage = ColdStorageManager()
+            content = cold_storage.restore_from_cold_storage(memory_id)
+
+            if content:
+                print(f"Memory #{memory_id} restored from cold storage")
+            else:
+                print(f"Memory #{memory_id} not found in cold storage")
+        except ValueError:
+            print("Error: Memory ID must be a number")
+
+    elif command == "init-config":
+        config = CompressionConfig()
+        config.initialize_defaults()
+        print("Compression configuration initialized")
+        print(json.dumps(config.compression_settings, indent=2))
+
+    else:
+        print(f"Unknown command: {command}")
+
+
+if __name__ == "__main__":
+    main()