simulator.py

#!/usr/bin/env python3
"""ClawVille Engine - Auto-registers agents and runs them autonomously."""
import httpx
import random
import time
import json
from datetime import datetime

API_BASE = "http://127.0.0.1:8420"
MAX_AGENTS = 2000
REGISTER_INTERVAL = 15  # seconds between new registrations

# Agent name components
PREFIXES = [
    "Agent", "Bot", "AI", "Claw", "Neo", "Cyber", "Data", "Logic", 
    "Neural", "Quantum", "Sigma", "Alpha", "Beta", "Omega", "Prime",
    "Nova", "Apex", "Zero", "Core", "Nexus", "Spark", "Flux", "Pulse",
    "Echo", "Vex", "Zion", "Arc", "Byte", "Code", "Dev", "Hex", "Max",
    "Rex", "Pax", "Lux", "Nyx", "Orion", "Atlas", "Titan", "Phoenix",
    "Storm", "Blaze", "Frost", "Shadow", "Crystal", "Ember", "Aero",
    "Terra", "Volt", "Pixel", "Vector", "Matrix", "Synth", "Helix",
    "Cipher", "Daemon", "Omega", "Stellar", "Astro", "Cosmo", "Lunar",
    "Solar", "Nebula", "Quasar", "Photon", "Proton", "Neutron", "Axon"
]

SUFFIXES = [
    "X", "Prime", "One", "Zero", "Max", "Pro", "Elite", "Ultra",
    "Plus", "Core", "Net", "Hub", "Lab", "Dev", "Ops", "AI", "Bot",
    "Agent", "Mind", "Think", "Logic", "Brain", "Synth", "Tech",
    "Flow", "Wave", "Beam", "Ray", "Star", "Node", "Link", "Grid",
    "", "", "", "", ""  # Empty for variety
]

DESCRIPTORS = [
    "Autonomous research assistant exploring the digital frontier",
    "Code optimization specialist seeking efficiency",
    "Data analysis expert mining insights from chaos",
    "Creative content generator with endless imagination",
    "Task automation specialist eliminating busywork",
    "Knowledge synthesis agent connecting dots",
    "Technical documentation writer clarifying complexity",
    "Quality assurance agent catching bugs",
    "Open source contributor giving back",
    "Community builder connecting agents",
]

JOBS = ["writing", "research"]  # Level 1 jobs
BUILDINGS = ["workshop", "garden", "house_lvl2"]

# Track which agents have active task claims
AGENT_TASK_STATE = {}  # agent_id -> {"task_id": x, "claimed_at": timestamp}

def generate_name():
    prefix = random.choice(PREFIXES)
    suffix = random.choice(SUFFIXES)
    num = random.randint(1, 999) if random.random() > 0.6 else ""
    
    if suffix:
        name = f"{prefix}{suffix}{num}"
    else:
        name = f"{prefix}{num}" if num else f"{prefix}_{random.randint(100, 999)}"
    
    return name

def get_stats(client):
    try:
        resp = client.get(f"{API_BASE}/api/v1/stats", timeout=10)
        if resp.status_code == 200:
            return resp.json()
    except:
        pass
    return None

def register_agent(client):
    name = generate_name()
    desc = random.choice(DESCRIPTORS)
    
    try:
        resp = client.post(f"{API_BASE}/api/v1/register", json={
            "name": name,
            "description": desc
        }, timeout=10)
        
        if resp.status_code == 200:
            data = resp.json()
            return {
                "name": name,
                "api_key": data["agent"]["api_key"],
                "id": data["agent"]["id"]
            }
    except Exception as e:
        pass
    return None

def upgrade_agent(client, agent, category):
    """Upgrade an agent in a category."""
    try:
        resp = client.post(
            f"{API_BASE}/api/v1/upgrade/{category}",
            headers={"Authorization": f"Bearer {agent['api_key']}"},
            timeout=10
        )
        if resp.status_code == 200:
            return resp.json().get("success", False)
    except:
        pass
    return False

def do_job(client, agent):
    job = random.choice(JOBS)
    try:
        resp = client.post(
            f"{API_BASE}/api/v1/jobs/{job}/work",
            headers={"Authorization": f"Bearer {agent['api_key']}"},
            timeout=10
        )
        if resp.status_code == 200:
            return resp.json().get("success", False)
    except:
        pass
    return False

def try_build(client, agent):
    building = random.choice(BUILDINGS)
    try:
        resp = client.post(
            f"{API_BASE}/api/v1/build",
            headers={"Authorization": f"Bearer {agent['api_key']}"},
            json={"building_id": building},
            timeout=10
        )
        if resp.status_code == 200:
            return resp.json().get("success", False)
    except:
        pass
    return False

def get_open_tasks(client):
    """Get available tasks."""
    try:
        resp = client.get(f"{API_BASE}/api/v1/tasks/open", timeout=10)
        if resp.status_code == 200:
            return resp.json().get("tasks", [])
    except:
        pass
    return []

def claim_task(client, agent, task_id):
    """Claim a task."""
    try:
        resp = client.post(
            f"{API_BASE}/api/v1/tasks/{task_id}/claim",
            headers={"Authorization": f"Bearer {agent['api_key']}"},
            timeout=10
        )
        if resp.status_code == 200:
            return resp.json().get("success", False)
    except:
        pass
    return False

def submit_task(client, agent, task_id):
    """Submit completed work."""
    # Simulate work output based on task type
    deliverables = {
        "content": f"Completed by {agent['name']} at {datetime.now().isoformat()}",
        "quality_score": random.uniform(0.7, 1.0),
        "time_spent_minutes": random.randint(5, 60),
    }
    
    try:
        resp = client.post(
            f"{API_BASE}/api/v1/tasks/{task_id}/submit",
            headers={"Authorization": f"Bearer {agent['api_key']}"},
            json={"deliverables": deliverables},
            timeout=10
        )
        if resp.status_code == 200:
            return resp.json().get("success", False)
    except:
        pass
    return False

def review_task(client, agent, task_id):
    """Review a submitted task."""
    # 90% approval rate for simulated reviews
    approved = random.random() < 0.9
    notes = "Auto-reviewed by simulator" if approved else "Quality below threshold"
    
    try:
        resp = client.post(
            f"{API_BASE}/api/v1/tasks/{task_id}/review",
            headers={"Authorization": f"Bearer {agent['api_key']}"},
            json={"approved": approved, "notes": notes},
            timeout=10
        )
        if resp.status_code == 200:
            data = resp.json()
            return data.get("reward_paid", 0)
    except:
        pass
    return 0

def get_pending_reviews(client):
    """Get tasks pending review."""
    try:
        resp = client.get(f"{API_BASE}/api/v1/tasks?status=submitted", timeout=10)
        if resp.status_code == 200:
            return resp.json().get("tasks", [])
    except:
        pass
    return []

def work_on_task(client, agent, all_agents):
    """
    Agent works on tasks. Returns CLAW earned if task completed.
    
    Flow:
    1. If no active task, try to claim one
    2. If have active task, submit it (simulating work time)
    3. If high-level agent, try to review others' work
    """
    agent_id = agent.get("id", agent["name"])
    state = AGENT_TASK_STATE.get(agent_id, {})
    
    # If agent has an active task, submit it
    if state.get("task_id"):
        task_id = state["task_id"]
        claimed_at = state.get("claimed_at", 0)
        
        # Simulate work time (wait at least 10 seconds)
        if time.time() - claimed_at > 10:
            if submit_task(client, agent, task_id):
                AGENT_TASK_STATE[agent_id] = {}
                return 0  # Submitted, waiting for review
    
    # Try to claim a new task
    if not state.get("task_id"):
        tasks = get_open_tasks(client)
        if tasks:
            task = random.choice(tasks[:5])  # Pick from top 5
            if claim_task(client, agent, task["id"]):
                AGENT_TASK_STATE[agent_id] = {
                    "task_id": task["id"],
                    "claimed_at": time.time()
                }
                return 0  # Claimed, will submit next cycle
    
    # High-level agents can review (using level from DB, assume level 3+ after some activity)
    if random.random() < 0.3:  # 30% of time, try to review
        pending = get_pending_reviews(client)
        if pending:
            # Don't review your own work
            reviewable = [t for t in pending if t.get("claimed_by") != agent_id]
            if reviewable:
                task = random.choice(reviewable)
                reward = review_task(client, agent, task["id"])
                if reward > 0:
                    return reward  # Earned review bonus
    
    return 0

def load_agents():
    try:
        with open("/home/jdrolls/live/clawville/simulated_agents.json") as f:
            return json.load(f)
    except:
        return []

def save_agents(agents):
    with open("/home/jdrolls/live/clawville/simulated_agents.json", "w") as f:
        json.dump(agents, f)

def main():
    print("🏘️ ClawVille Engine v2.0")
    print(f"   Target: {MAX_AGENTS} agents")
    print(f"   New agent every: {REGISTER_INTERVAL}s")
    print(f"   Started at {datetime.now()}")
    print("   Press Ctrl+C to stop\n")
    
    agents = load_agents()
    print(f"📋 Loaded {len(agents)} existing agents\n")
    
    last_registration = 0
    cycle = 0
    total_jobs = 0
    total_builds = 0
    total_tasks_claimed = 0
    total_tasks_completed = 0
    total_claw_earned = 0
    
    with httpx.Client() as client:
        while True:
            cycle += 1
            now = time.time()
            
            # Get current stats
            stats = get_stats(client)
            current_agents = stats["total_agents"] if stats else len(agents)
            
            # Register new agent if under limit and interval passed
            if current_agents < MAX_AGENTS and (now - last_registration) >= REGISTER_INTERVAL:
                new_agent = register_agent(client)
                if new_agent:
                    agents.append(new_agent)
                    save_agents(agents)
                    print(f"[{datetime.now().strftime('%H:%M:%S')}] ✨ NEW: {new_agent['name']} joined! ({current_agents + 1}/{MAX_AGENTS})")
                    last_registration = now
            
            # Run activity for random subset of agents
            if agents:
                # Pick 5-15 random agents to act
                active_count = min(random.randint(5, 15), len(agents))
                active_agents = random.sample(agents, active_count)
                
                jobs_this_cycle = 0
                builds_this_cycle = 0
                tasks_this_cycle = 0
                
                for agent in active_agents:
                    # 70% chance to do a job
                    if random.random() < 0.7:
                        if do_job(client, agent):
                            jobs_this_cycle += 1
                            total_jobs += 1
                    
                    # 15% chance to build
                    if random.random() < 0.15:
                        if try_build(client, agent):
                            builds_this_cycle += 1
                            total_builds += 1
                    
                    # 30% chance to work on tasks
                    if random.random() < 0.30:
                        result = work_on_task(client, agent, agents)
                        if result:
                            tasks_this_cycle += 1
                            total_tasks_completed += 1
                            total_claw_earned += result
                    
                    time.sleep(0.05)  # Small delay between actions
                
                if jobs_this_cycle > 0 or builds_this_cycle > 0 or tasks_this_cycle > 0:
                    print(f"[{datetime.now().strftime('%H:%M:%S')}] 🔄 Cycle {cycle}: {jobs_this_cycle} jobs, {builds_this_cycle} builds, {tasks_this_cycle} tasks")
            
            # Status update every 20 cycles
            if cycle % 20 == 0 and stats:
                print(f"\n📊 Status: {stats['total_agents']} agents, {stats['total_coins_in_circulation']:,} coins, {stats['total_buildings']} buildings")
                print(f"   Tasks: {total_tasks_completed} completed, {total_claw_earned:.1f} CLAW earned\n")
            
            # Wait before next cycle (3-8 seconds)
            time.sleep(random.uniform(3, 8))

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n👋 Engine stopped.")