verify_complete.py

#!/usr/bin/env python3
"""Complete verification of Bob's system"""

import asyncio
import sys
import json
from src.memory.postgres_client import PostgresMemory
from src.memory.redis_client import RedisSTM
from src.config import settings

async def verify_complete():
    print("🧠 Complete Bob System Verification")
    print("=" * 60)
    
    errors = []
    warnings = []
    
    # 1. Configuration Check
    print("\n1. Configuration Check:")
    print(f"   ✓ Default Model: {settings.default_model}")
    if settings.default_model != "claude-3.5-sonnet":
        errors.append("Default model is not claude-3.5-sonnet!")
    
    print(f"   ✓ Database: {settings.postgres_db}")
    print(f"   ✓ OpenRouter API: {'Configured' if settings.openrouter_api_key else 'MISSING'}")
    if not settings.openrouter_api_key:
        errors.append("OpenRouter API key is missing!")
    
    # 2. PostgreSQL Check
    print("\n2. PostgreSQL + pg_singularity Check:")
    postgres = PostgresMemory()
    try:
        await postgres.initialize()
        print("   ✓ Connection established")
        
        # Test bob.remember()
        memories = await postgres.remember("Chris", limit=5)
        print(f"   ✓ bob.remember() working - {len(memories)} memories found")
        
        # Test bob.think()
        thought_id = await postgres.think(
            "System verification complete",
            context="verification",
            importance=0.1
        )
        print(f"   ✓ bob.think() working - ID: {thought_id[:8]}...")
        
        # Check memory content
        chris_found = any("Chris" in str(m.get('concept', '')) + str(m.get('context', '')) for m in memories)
        dlmsy_found = any("DLMSY" in str(m.get('concept', '')) + str(m.get('context', '')) for m in memories)
        
        print(f"   ✓ Knows Chris: {'Yes' if chris_found else 'No'}")
        print(f"   ✓ DLMSY trust: {'Yes' if dlmsy_found else 'No'}")
        
        if not chris_found:
            warnings.append("Bob doesn't seem to remember Chris!")
        if not dlmsy_found:
            warnings.append("Bob doesn't remember DLMSY trust level!")
            
        # Check kb_source
        async with postgres.acquire() as conn:
            kb_check = await conn.fetchval(
                "SELECT COUNT(DISTINCT kb_source) FROM bob.memories"
            )
            print(f"   ✓ Distinct knowledge bases: {kb_check}")
            
        await postgres.close()
        
    except Exception as e:
        errors.append(f"PostgreSQL error: {e}")
        print(f"   ✗ Error: {e}")
    
    # 3. Redis Check
    print("\n3. Redis STM Check:")
    redis = RedisSTM()
    try:
        await redis.initialize()
        print("   ✓ Connection established")
        
        # Test basic operations
        test_thread = "verify_test"
        await redis.set_thread_metadata(test_thread, {"test": True})
        metadata = await redis.get_thread_metadata(test_thread)
        print(f"   ✓ Metadata operations working")
        
        await redis.close()
        
    except Exception as e:
        errors.append(f"Redis error: {e}")
        print(f"   ✗ Error: {e}")
    
    # 4. Model Configuration
    print("\n4. Model Configuration:")
    print(f"   ✓ Default: {settings.default_model}")
    
    # Check for hardcoded models
    import glob
    hardcoded_gpt4 = []
    for py_file in glob.glob("**/*.py", recursive=True):
        if "venv" in py_file or "__pycache__" in py_file:
            continue
        try:
            with open(py_file, 'r') as f:
                content = f.read()
                if 'gpt-4' in content and 'claude-3.5-sonnet' not in content:
                    hardcoded_gpt4.append(py_file)
        except:
            pass
    
    if hardcoded_gpt4:
        warnings.append(f"Found hardcoded GPT-4 in: {', '.join(hardcoded_gpt4)}")
        print(f"   ⚠ Found hardcoded GPT-4 references")
    else:
        print(f"   ✓ No hardcoded GPT-4 references")
    
    # 5. Memory Recall Check
    print("\n5. Aggressive Memory Recall:")
    with open("src/worker/prompt.py", 'r') as f:
        prompt_content = f.read()
        has_aggressive = "MEMORY CONTINUITY - AGGRESSIVE RECALL" in prompt_content
        has_chris_search = "search your memories for context about Chris" in prompt_content
        
    print(f"   ✓ Aggressive recall: {'Yes' if has_aggressive else 'No'}")
    print(f"   ✓ Chris search: {'Yes' if has_chris_search else 'No'}")
    
    if not has_aggressive:
        errors.append("Missing aggressive memory recall in prompt!")
    if not has_chris_search:
        errors.append("Missing Chris memory search in prompt!")
    
    # Summary
    print("\n" + "=" * 60)
    if errors:
        print("❌ ERRORS FOUND:")
        for error in errors:
            print(f"   • {error}")
    
    if warnings:
        print("\n⚠️  WARNINGS:")
        for warning in warnings:
            print(f"   • {warning}")
    
    if not errors:
        print("✅ Bob is fully operational and ready to chat!")
        print("\nTo start chatting:")
        print("  python bob_cli.py chat")
        print("  python bob_cli.py chat --model claude-3-opus")
        return True
    else:
        print("\n❌ Bob needs fixes before he can operate properly!")
        return False

if __name__ == "__main__":
    result = asyncio.run(verify_complete())
    sys.exit(0 if result else 1)