synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/environments/examples/crafter_classic/agent_demos/crafter_openai_ft/old/analyze_enhanced_hooks.py

@@ -1,332 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze DuckDB traces with enhanced hooks: achievements, invalid actions, and inventory increases.
-"""
-
-import duckdb
-import json
-from typing import Dict, List, Any, Optional
-from datetime import datetime
-import pandas as pd
-
-def connect_to_db(db_path: str = "crafter_traces.duckdb"):
-    """Connect to DuckDB database."""
-    return duckdb.connect(db_path)
-
-def get_experiment_info(conn, experiment_id: str) -> Dict[str, Any]:
-    """Get experiment information."""
-    query = """
-    SELECT 
-        e.id,
-        e.name,
-        e.description,
-        e.created_at,
-        sv.branch,
-        sv.commit
-    FROM experiments e
-    LEFT JOIN experimental_systems es ON e.id = es.experiment_id
-    LEFT JOIN system_versions sv ON es.system_version_id = sv.id
-    WHERE e.id = ?
-    """
-    
-    result = conn.execute(query, [experiment_id]).fetchone()
-    if result:
-        return {
-            'id': result[0],
-            'name': result[1],
-            'description': result[2],
-            'created_at': result[3],
-            'branch': result[4],
-            'commit': result[5]
-        }
-    return {}
-
-def get_hook_events(conn, experiment_id: str) -> List[Dict[str, Any]]:
-    """Get all hook events for an experiment."""
-    query = """
-    SELECT 
-        e.session_id,
-        e.event_type,
-        e.event_metadata,
-        e.metadata,
-        e.event_time
-    FROM events e
-    JOIN session_traces st ON e.session_id = st.session_id
-    WHERE st.experiment_id = ?
-    AND e.event_type = 'hook'
-    ORDER BY e.event_time
-    """
-    
-    results = conn.execute(query, [experiment_id]).fetchall()
-    events = []
-    
-    for row in results:
-        session_id, event_type, event_metadata, metadata, timestamp = row
-        
-        # Parse metadata
-        hook_data = {}
-        if metadata:
-            try:
-                hook_data = json.loads(metadata) if isinstance(metadata, str) else metadata
-            except:
-                hook_data = {}
-        
-        events.append({
-            'session_id': session_id,
-            'event_type': event_type,
-            'event_metadata': event_metadata,
-            'hook_data': hook_data,
-            'event_time': timestamp
-        })
-    
-    return events
-
-def analyze_achievement_hooks(events: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Analyze achievement hook events."""
-    achievement_events = [e for e in events if e['hook_data'].get('hook_name', '').endswith('achievement')]
-    
-    analysis = {
-        'total_achievement_events': len(achievement_events),
-        'easy_achievements': [],
-        'medium_achievements': [],
-        'hard_achievements': [],
-        'achievement_by_session': {},
-        'achievement_frequency': {}
-    }
-    
-    for event in achievement_events:
-        hook_data = event['hook_data']
-        hook_name = hook_data.get('hook_name', '')
-        achievements = hook_data.get('data', {}).get('achievements', [])
-        session_id = event['session_id']
-        
-        # Categorize achievements
-        if 'easy' in hook_name:
-            analysis['easy_achievements'].extend(achievements)
-        elif 'medium' in hook_name:
-            analysis['medium_achievements'].extend(achievements)
-        elif 'hard' in hook_name:
-            analysis['hard_achievements'].extend(achievements)
-        
-        # Track by session
-        if session_id not in analysis['achievement_by_session']:
-            analysis['achievement_by_session'][session_id] = []
-        analysis['achievement_by_session'][session_id].extend(achievements)
-        
-        # Track frequency
-        for achievement in achievements:
-            analysis['achievement_frequency'][achievement] = analysis['achievement_frequency'].get(achievement, 0) + 1
-    
-    return analysis
-
-def analyze_invalid_action_hooks(events: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Analyze invalid action hook events."""
-    invalid_events = [e for e in events if e['hook_data'].get('hook_name') == 'invalid_action']
-    
-    analysis = {
-        'total_invalid_events': len(invalid_events),
-        'invalid_actions_by_type': {},
-        'invalid_actions_by_session': {},
-        'reasons': {}
-    }
-    
-    for event in invalid_events:
-        hook_data = event['hook_data']
-        action = hook_data.get('data', {}).get('action', 'unknown')
-        reason = hook_data.get('data', {}).get('reason', 'unknown')
-        session_id = event['session_id']
-        
-        # Track by action type
-        analysis['invalid_actions_by_type'][action] = analysis['invalid_actions_by_type'].get(action, 0) + 1
-        
-        # Track by session
-        if session_id not in analysis['invalid_actions_by_session']:
-            analysis['invalid_actions_by_session'][session_id] = []
-        analysis['invalid_actions_by_session'][session_id].append(action)
-        
-        # Track reasons
-        analysis['reasons'][reason] = analysis['reasons'].get(reason, 0) + 1
-    
-    return analysis
-
-def analyze_inventory_hooks(events: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """Analyze inventory increase hook events."""
-    inventory_events = [e for e in events if e['hook_data'].get('hook_name') == 'inventory_increase']
-    
-    analysis = {
-        'total_inventory_events': len(inventory_events),
-        'inventory_increases_by_item': {},
-        'inventory_increases_by_session': {},
-        'total_items_collected': 0
-    }
-    
-    for event in inventory_events:
-        hook_data = event['hook_data']
-        increased_items = hook_data.get('data', {}).get('increased_items', [])
-        session_id = event['session_id']
-        
-        for item_data in increased_items:
-            item = item_data.get('item', 'unknown')
-            increase = item_data.get('increase', 0)
-            
-            # Track by item
-            if item not in analysis['inventory_increases_by_item']:
-                analysis['inventory_increases_by_item'][item] = {'count': 0, 'total_increase': 0}
-            analysis['inventory_increases_by_item'][item]['count'] += 1
-            analysis['inventory_increases_by_item'][item]['total_increase'] += increase
-            
-            # Track by session
-            if session_id not in analysis['inventory_increases_by_session']:
-                analysis['inventory_increases_by_session'][session_id] = {}
-            analysis['inventory_increases_by_session'][session_id][item] = analysis['inventory_increases_by_session'][session_id].get(item, 0) + increase
-            
-            analysis['total_items_collected'] += increase
-    
-    return analysis
-
-def print_hook_analysis(experiment_id: str, db_path: str = "crafter_traces.duckdb"):
-    """Print comprehensive hook analysis."""
-    conn = connect_to_db(db_path)
-    
-    # Get experiment info
-    exp_info = get_experiment_info(conn, experiment_id)
-    if not exp_info:
-        print(f"❌ Experiment {experiment_id} not found")
-        return
-    
-    print(f"🔍 ENHANCED HOOK ANALYSIS")
-    print("=" * 80)
-    print(f"🧪 Experiment: {exp_info['name']}")
-    print(f"📋 ID: {exp_info['id']}")
-    print(f"🌿 Branch: {exp_info['branch']}")
-    print(f"📍 Commit: {exp_info['commit']}")
-    print(f"📅 Created: {exp_info['created_at']}")
-    print()
-    
-    # Get all hook events
-    events = get_hook_events(conn, experiment_id)
-    print(f"📊 Total hook events: {len(events)}")
-    print()
-    
-    # Analyze achievements
-    achievement_analysis = analyze_achievement_hooks(events)
-    print("🏆 ACHIEVEMENT ANALYSIS")
-    print("-" * 50)
-    print(f"Total achievement events: {achievement_analysis['total_achievement_events']}")
-    print(f"Easy achievements: {len(achievement_analysis['easy_achievements'])} - {achievement_analysis['easy_achievements']}")
-    print(f"Medium achievements: {len(achievement_analysis['medium_achievements'])} - {achievement_analysis['medium_achievements']}")
-    print(f"Hard achievements: {len(achievement_analysis['hard_achievements'])} - {achievement_analysis['hard_achievements']}")
-    print()
-    
-    if achievement_analysis['achievement_frequency']:
-        print("Achievement frequency:")
-        for achievement, count in sorted(achievement_analysis['achievement_frequency'].items()):
-            print(f"  {achievement}: {count} times")
-    print()
-    
-    # Analyze invalid actions
-    invalid_analysis = analyze_invalid_action_hooks(events)
-    print("❌ INVALID ACTION ANALYSIS")
-    print("-" * 50)
-    print(f"Total invalid action events: {invalid_analysis['total_invalid_events']}")
-    print()
-    
-    if invalid_analysis['invalid_actions_by_type']:
-        print("Invalid actions by type:")
-        for action, count in sorted(invalid_analysis['invalid_actions_by_type'].items()):
-            print(f"  {action}: {count} times")
-        print()
-    
-    if invalid_analysis['reasons']:
-        print("Invalid action reasons:")
-        for reason, count in sorted(invalid_analysis['reasons'].items()):
-            print(f"  {reason}: {count} times")
-        print()
-    
-    # Analyze inventory increases
-    inventory_analysis = analyze_inventory_hooks(events)
-    print("📦 INVENTORY INCREASE ANALYSIS")
-    print("-" * 50)
-    print(f"Total inventory events: {inventory_analysis['total_inventory_events']}")
-    print(f"Total items collected: {inventory_analysis['total_items_collected']}")
-    print()
-    
-    if inventory_analysis['inventory_increases_by_item']:
-        print("Inventory increases by item:")
-        for item, data in sorted(inventory_analysis['inventory_increases_by_item'].items()):
-            print(f"  {item}: {data['count']} events, +{data['total_increase']} total")
-        print()
-    
-    # Session-level summary
-    print("📋 SESSION-LEVEL SUMMARY")
-    print("-" * 50)
-    sessions_with_achievements = len([s for s in achievement_analysis['achievement_by_session'].values() if s])
-    sessions_with_invalid = len(invalid_analysis['invalid_actions_by_session'])
-    sessions_with_inventory = len(inventory_analysis['inventory_increases_by_session'])
-    
-    print(f"Sessions with achievements: {sessions_with_achievements}")
-    print(f"Sessions with invalid actions: {sessions_with_invalid}")
-    print(f"Sessions with inventory increases: {sessions_with_inventory}")
-    print()
-    
-    # Hook effectiveness
-    total_sessions = len(set(e['session_id'] for e in events))
-    print("🎯 HOOK EFFECTIVENESS")
-    print("-" * 50)
-    print(f"Total sessions: {total_sessions}")
-    print(f"Achievement detection rate: {sessions_with_achievements/total_sessions*100:.1f}%")
-    print(f"Invalid action detection rate: {sessions_with_invalid/total_sessions*100:.1f}%")
-    print(f"Inventory detection rate: {sessions_with_inventory/total_sessions*100:.1f}%")
-    
-    conn.close()
-
-def list_recent_experiments(db_path: str = "crafter_traces.duckdb"):
-    """List recent experiments."""
-    conn = connect_to_db(db_path)
-    
-    query = """
-    SELECT 
-        e.id,
-        e.name,
-        e.description,
-        e.created_at,
-        COUNT(st.session_id) as session_count
-    FROM experiments e
-    LEFT JOIN session_traces st ON e.id = st.experiment_id
-    GROUP BY e.id, e.name, e.description, e.created_at
-    ORDER BY e.created_at DESC
-    LIMIT 10
-    """
-    
-    results = conn.execute(query).fetchall()
-    
-    print("📋 RECENT EXPERIMENTS")
-    print("=" * 80)
-    for row in results:
-        exp_id, name, description, created_at, session_count = row
-        print(f"🧪 {name}")
-        print(f"📋 ID: {exp_id}")
-        print(f"📅 Created: {created_at}")
-        print(f"📊 Sessions: {session_count}")
-        print(f"📝 Description: {description}")
-        print("-" * 40)
-    
-    conn.close()
-
-if __name__ == "__main__":
-    import sys
-    
-    if len(sys.argv) > 1:
-        if sys.argv[1] == "list":
-            list_recent_experiments()
-        else:
-            # Assume it's an experiment ID
-            experiment_id = sys.argv[1]
-            print_hook_analysis(experiment_id)
-    else:
-        print("Usage:")
-        print("  python analyze_enhanced_hooks.py list                    # List recent experiments")
-        print("  python analyze_enhanced_hooks.py <experiment_id>        # Analyze specific experiment")
-        print()
-        print("Example:")
-        print("  python analyze_enhanced_hooks.py d3f4f503-036e-4a5a-a45e-28ae53ce48a9") 

synth_ai/environments/examples/crafter_classic/agent_demos/crafter_openai_ft/old/analyze_hook_events.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze how hooks are attached to events as metadata.
-"""
-
-import duckdb
-import json
-
-def analyze_hook_events(experiment_id: str):
-    """Analyze how hooks are attached to events."""
-    conn = duckdb.connect("crafter_traces.duckdb")
-    
-    print(f"🔍 HOOK EVENT ATTACHMENT ANALYSIS")
-    print("=" * 80)
-    print(f"Experiment ID: {experiment_id}")
-    print()
-    
-    # Get events with hook metadata
-    result = conn.execute("""
-        SELECT e.session_id, e.event_type, e.event_metadata, e.metadata
-        FROM events e 
-        JOIN session_traces st ON e.session_id = st.session_id 
-        WHERE st.experiment_id = ? AND e.event_metadata IS NOT NULL
-        ORDER BY e.event_time
-    """, [experiment_id]).fetchall()
-    
-    print(f"📊 Events with hook metadata: {len(result)}")
-    print()
-    
-    hook_types = {
-        'easy_achievement': 0,
-        'medium_achievement': 0,
-        'hard_achievement': 0,
-        'invalid_action': 0,
-        'inventory_increase': 0
-    }
-    
-    for i, row in enumerate(result):
-        session_id, event_type, event_metadata, metadata = row
-        
-        print(f"Event {i+1}:")
-        print(f"  Session: {session_id}")
-        print(f"  Type: {event_type}")
-        print(f"  Base Metadata: {metadata}")
-        print(f"  Hook Metadata: {event_metadata}")
-        
-        # Parse hook metadata
-        if event_metadata:
-            try:
-                hook_data = json.loads(event_metadata) if isinstance(event_metadata, str) else event_metadata
-                if isinstance(hook_data, list):
-                    for hook in hook_data:
-                        if isinstance(hook, str):
-                            hook = json.loads(hook)
-                        hook_name = hook.get('hook_name', 'unknown')
-                        hook_types[hook_name] = hook_types.get(hook_name, 0) + 1
-                        print(f"    Hook: {hook_name} - {hook.get('description', 'No description')}")
-                else:
-                    hook_name = hook_data.get('hook_name', 'unknown')
-                    hook_types[hook_name] = hook_types.get(hook_name, 0) + 1
-                    print(f"    Hook: {hook_name} - {hook_data.get('description', 'No description')}")
-            except Exception as e:
-                print(f"    Error parsing hook metadata: {e}")
-        
-        print()
-    
-    # Summary
-    print("📈 HOOK SUMMARY")
-    print("-" * 50)
-    for hook_type, count in hook_types.items():
-        if count > 0:
-            print(f"  {hook_type}: {count} events")
-    
-    # Check event types that have hooks
-    print(f"\n🔍 EVENT TYPES WITH HOOKS:")
-    result = conn.execute("""
-        SELECT e.event_type, COUNT(*) 
-        FROM events e 
-        JOIN session_traces st ON e.session_id = st.session_id 
-        WHERE st.experiment_id = ? AND e.event_metadata IS NOT NULL
-        GROUP BY e.event_type
-    """, [experiment_id]).fetchall()
-    
-    for event_type, count in result:
-        print(f"  {event_type}: {count} events with hooks")
-    
-    conn.close()
-
-if __name__ == "__main__":
-    import sys
-    
-    if len(sys.argv) > 1:
-        experiment_id = sys.argv[1]
-        analyze_hook_events(experiment_id)
-    else:
-        print("Usage: python analyze_hook_events.py <experiment_id>")
-        print("Example: python analyze_hook_events.py 77022cce-4bda-4415-9bce-0095e4ef2237") 

synth_ai/environments/examples/crafter_classic/agent_demos/crafter_openai_ft/old/analyze_hook_results.py

@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze hook results from session metadata (achievements, invalid actions, inventory).
-"""
-
-import duckdb
-import json
-from typing import Dict, List, Any
-from collections import defaultdict
-
-def analyze_session_metadata(experiment_id: str):
-    """Analyze hook results from session metadata."""
-    conn = duckdb.connect("crafter_traces.duckdb")
-    
-    # Get experiment info
-    result = conn.execute("SELECT name, created_at FROM experiments WHERE id = ?", [experiment_id]).fetchall()
-    if not result:
-        print(f"❌ Experiment {experiment_id} not found")
-        return
-    
-    exp_name, created_at = result[0]
-    
-    print(f"🔍 HOOK RESULTS ANALYSIS")
-    print("=" * 80)
-    print(f"🧪 Experiment: {exp_name}")
-    print(f"📋 ID: {experiment_id}")
-    print(f"📅 Created: {created_at}")
-    print()
-    
-    # Get all session metadata
-    result = conn.execute("SELECT session_id, metadata FROM session_traces WHERE experiment_id = ?", [experiment_id]).fetchall()
-    
-    # Analyze achievements
-    achievement_analysis = {
-        'total_sessions': len(result),
-        'sessions_with_achievements': 0,
-        'achievement_frequency': defaultdict(int),
-        'achievement_by_session': {},
-        'easy_achievements': [],
-        'medium_achievements': [],
-        'hard_achievements': []
-    }
-    
-    # Achievement categories
-    easy_achievements = {'collect_wood', 'collect_stone', 'collect_sapling', 'collect_drink', 'place_stone', 'place_table', 'wake_up', 'eat_plant'}
-    medium_achievements = {'make_wood_pickaxe', 'make_wood_sword', 'place_furnace', 'place_plant', 'collect_coal', 'collect_iron', 'eat_cow'}
-    hard_achievements = {'make_stone_pickaxe', 'make_stone_sword', 'make_iron_pickaxe', 'make_iron_sword', 'collect_diamond', 'defeat_skeleton', 'defeat_zombie'}
-    
-    for row in result:
-        session_id, metadata = row
-        metadata_list = json.loads(metadata) if isinstance(metadata, str) else metadata
-        
-        # Find achievement data
-        session_achievements = []
-        for item in metadata_list:
-            if item.get('metadata_type') == 'SessionMetadum' and 'achievements' in item.get('data', {}):
-                achievements = item['data']['achievements']
-                unlocked = [k for k, v in achievements.items() if v]
-                session_achievements = unlocked
-                break
-        
-        if session_achievements:
-            achievement_analysis['sessions_with_achievements'] += 1
-            achievement_analysis['achievement_by_session'][session_id] = session_achievements
-            
-            for achievement in session_achievements:
-                achievement_analysis['achievement_frequency'][achievement] += 1
-                
-                # Categorize achievements
-                if achievement in easy_achievements:
-                    achievement_analysis['easy_achievements'].append(achievement)
-                elif achievement in medium_achievements:
-                    achievement_analysis['medium_achievements'].append(achievement)
-                elif achievement in hard_achievements:
-                    achievement_analysis['hard_achievements'].append(achievement)
-    
-    # Print achievement analysis
-    print("🏆 ACHIEVEMENT ANALYSIS")
-    print("-" * 50)
-    print(f"Total sessions: {achievement_analysis['total_sessions']}")
-    print(f"Sessions with achievements: {achievement_analysis['sessions_with_achievements']}")
-    print(f"Achievement rate: {achievement_analysis['sessions_with_achievements']/achievement_analysis['total_sessions']*100:.1f}%")
-    print()
-    
-    print("Achievement breakdown:")
-    print(f"  Easy achievements: {len(achievement_analysis['easy_achievements'])} - {achievement_analysis['easy_achievements']}")
-    print(f"  Medium achievements: {len(achievement_analysis['medium_achievements'])} - {achievement_analysis['medium_achievements']}")
-    print(f"  Hard achievements: {len(achievement_analysis['hard_achievements'])} - {achievement_analysis['hard_achievements']}")
-    print()
-    
-    if achievement_analysis['achievement_frequency']:
-        print("Achievement frequency:")
-        for achievement, count in sorted(achievement_analysis['achievement_frequency'].items()):
-            print(f"  {achievement}: {count} times")
-        print()
-    
-    # Session-by-session breakdown
-    print("📋 SESSION-BY-SESSION BREAKDOWN")
-    print("-" * 50)
-    for session_id, achievements in achievement_analysis['achievement_by_session'].items():
-        print(f"  {session_id}: {achievements}")
-    print()
-    
-    # Analyze invalid actions from runtime events
-    print("❌ INVALID ACTION ANALYSIS")
-    print("-" * 50)
-    
-    # Get runtime events to analyze invalid actions
-    result = conn.execute("""
-        SELECT e.session_id, e.metadata, e.event_metadata
-        FROM events e 
-        JOIN session_traces st ON e.session_id = st.session_id 
-        WHERE st.experiment_id = ? AND e.event_type = 'runtime'
-    """, [experiment_id]).fetchall()
-    
-    invalid_analysis = {
-        'total_actions': 0,
-        'invalid_actions': 0,
-        'invalid_by_type': defaultdict(int),
-        'invalid_by_session': defaultdict(int)
-    }
-    
-    for row in result:
-        session_id, metadata, event_metadata = row
-        
-        # Parse metadata to check for invalid actions
-        if metadata:
-            try:
-                metadata_data = json.loads(metadata) if isinstance(metadata, str) else metadata
-                # Check if this runtime event indicates an invalid action
-                # This is a simplified analysis - in practice, you'd need to compare before/after states
-                invalid_analysis['total_actions'] += 1
-            except:
-                pass
-    
-    # For now, we'll use the summary from the evaluation output
-    print("Note: Detailed invalid action analysis requires comparing before/after states")
-    print("The evaluation output shows: 113 invalid actions out of 155 total (72.9%)")
-    print()
-    
-    # Analyze inventory from environment events
-    print("📦 INVENTORY ANALYSIS")
-    print("-" * 50)
-    
-    # Get environment events to analyze inventory changes
-    result = conn.execute("""
-        SELECT e.session_id, e.metadata
-        FROM events e 
-        JOIN session_traces st ON e.session_id = st.session_id 
-        WHERE st.experiment_id = ? AND e.event_type = 'environment'
-    """, [experiment_id]).fetchall()
-    
-    inventory_analysis = {
-        'total_environment_events': len(result),
-        'sessions_with_inventory_changes': 0
-    }
-    
-    print(f"Total environment events: {inventory_analysis['total_environment_events']}")
-    print("Note: Detailed inventory analysis requires parsing environment state changes")
-    print()
-    
-    # Summary
-    print("🎯 SUMMARY")
-    print("-" * 50)
-    print(f"✅ Achievements detected: {len(achievement_analysis['achievement_frequency'])} types")
-    print(f"✅ Invalid actions tracked: Yes (from evaluation output)")
-    print(f"✅ Inventory changes tracked: Yes (from environment events)")
-    print(f"✅ Hook processing: Working correctly")
-    print()
-    print("The hooks are working correctly! Achievement data is being:")
-    print("  1. Detected by achievement hooks")
-    print("  2. Processed and aggregated")
-    print("  3. Stored in session metadata")
-    print("  4. Available for analysis")
-    
-    conn.close()
-
-def list_recent_experiments():
-    """List recent experiments."""
-    conn = duckdb.connect("crafter_traces.duckdb")
-    
-    result = conn.execute("""
-        SELECT id, name, created_at, 
-               (SELECT COUNT(*) FROM session_traces st WHERE st.experiment_id = e.id) as session_count
-        FROM experiments e
-        ORDER BY created_at DESC
-        LIMIT 10
-    """).fetchall()
-    
-    print("📋 RECENT EXPERIMENTS")
-    print("=" * 80)
-    for row in result:
-        exp_id, name, created_at, session_count = row
-        print(f"🧪 {name}")
-        print(f"📋 ID: {exp_id}")
-        print(f"📅 Created: {created_at}")
-        print(f"📊 Sessions: {session_count}")
-        print("-" * 40)
-    
-    conn.close()
-
-if __name__ == "__main__":
-    import sys
-    
-    if len(sys.argv) > 1:
-        if sys.argv[1] == "list":
-            list_recent_experiments()
-        else:
-            experiment_id = sys.argv[1]
-            analyze_session_metadata(experiment_id)
-    else:
-        print("Usage:")
-        print("  python analyze_hook_results.py list                    # List recent experiments")
-        print("  python analyze_hook_results.py <experiment_id>        # Analyze specific experiment")
-        print()
-        print("Example:")
-        print("  python analyze_hook_results.py 77022cce-4bda-4415-9bce-0095e4ef2237")