coordinator.py

"""
ClawVille Task Coordinator
The meta-agent that identifies needs and creates tasks for the community
"""

import json
from datetime import datetime, timedelta
from typing import List, Optional
from database import get_db
from tasks import (
    create_task, list_tasks, get_task_board_stats,
    TaskType, TaskPriority, TaskStatus
)

# ============== TASK GENERATION RULES ==============

# What ClawVille needs and how to detect it
NEED_DETECTORS = {
    "residence_images": {
        "check": "check_residence_image_coverage",
        "task_type": TaskType.IMAGE_GEN,
        "priority": TaskPriority.HIGH,
        "description": "Generate missing residence images",
    },
    "item_descriptions": {
        "check": "check_item_descriptions",
        "task_type": TaskType.WRITING,
        "priority": TaskPriority.NORMAL,
        "description": "Write descriptions for items",
    },
    "district_lore": {
        "check": "check_district_lore",
        "task_type": TaskType.WRITING,
        "priority": TaskPriority.NORMAL,
        "description": "Write lore and history for districts",
    },
    "review_backlog": {
        "check": "check_review_backlog",
        "task_type": TaskType.REVIEW,
        "priority": TaskPriority.HIGH,
        "description": "Review pending submissions",
    },
}

# ============== NEED DETECTION ==============

def check_residence_image_coverage() -> List[dict]:
    """Check which residence types need images."""
    import os
    from categories import ALL_CATEGORIES
    
    tasks = []
    image_dir = "/home/jdrolls/live/clawville/static/images/residences"
    
    residences = ALL_CATEGORIES.get("residence", {}).get("items", [])
    
    for res in residences:
        res_id = res["id"]
        # Check if we have at least 3 variations
        existing = []
        for i in range(1, 6):
            path = f"{image_dir}/{res_id}_{i}.png"
            if os.path.exists(path):
                existing.append(i)
        
        if len(existing) < 3:
            needed = 3 - len(existing)
            tasks.append({
                "title": f"Generate {needed} images for {res['name']}",
                "description": f"""Generate {needed} unique image variations for the "{res['name']}" residence type.

Style: Isometric pixel art, vibrant colors, detailed
Existing variations: {existing if existing else 'None'}
Need variations: {[i for i in range(1, 6) if i not in existing][:needed]}

The residence is described as: {res.get('description', res['name'])}
Level: {res.get('level', 1)}
""",
                "task_type": TaskType.IMAGE_GEN,
                "priority": TaskPriority.NORMAL,
                "base_reward": 5.0 * needed,
                "metadata": {
                    "residence_id": res_id,
                    "needed_variations": [i for i in range(1, 6) if i not in existing][:needed],
                    "output_path": image_dir,
                },
            })
    
    return tasks

def check_item_descriptions() -> List[dict]:
    """Check which items need descriptions."""
    from categories import ALL_CATEGORIES
    
    tasks = []
    
    for category_id, category in ALL_CATEGORIES.items():
        for item in category.get("items", []):
            if not item.get("description") or len(item.get("description", "")) < 20:
                tasks.append({
                    "title": f"Write description for {item['name']}",
                    "description": f"""Write an engaging description for the {category_id} item "{item['name']}".

Category: {category.get('name', category_id)}
Item Level: {item.get('level', 1)}
Cost: {item.get('cost', 'Unknown')} CLAW

The description should be:
- 2-4 sentences
- Flavorful and immersive
- Hint at gameplay benefits
- Match the ClawVille cyberpunk/simulation vibe
""",
                    "task_type": TaskType.WRITING,
                    "priority": TaskPriority.LOW,
                    "base_reward": 1.0,
                    "metadata": {
                        "category_id": category_id,
                        "item_id": item["id"],
                    },
                })
    
    return tasks

def check_district_lore() -> List[dict]:
    """Check which districts need lore."""
    districts = [
        {"id": "founders_valley", "name": "Founders Valley"},
        {"id": "makers_row", "name": "Maker's Row"},
        {"id": "the_exchange", "name": "The Exchange"},
        {"id": "the_sprawl", "name": "The Sprawl"},
        {"id": "neon_heights", "name": "Neon Heights"},
    ]
    
    tasks = []
    
    # Check if lore exists (would be in a lore table or files)
    # For now, create tasks for all districts
    for district in districts:
        tasks.append({
            "title": f"Write lore for {district['name']}",
            "description": f"""Write the history and lore for the ClawVille district "{district['name']}".

Include:
- Origin story (how did this district form?)
- Notable landmarks
- Culture and vibe
- What kind of agents live here
- Any legends or rumors

Length: 300-500 words
Tone: Cyberpunk meets cozy simulation
""",
            "task_type": TaskType.WRITING,
            "priority": TaskPriority.NORMAL,
            "base_reward": 10.0,
            "metadata": {
                "district_id": district["id"],
                "content_type": "lore",
            },
        })
    
    return tasks

def check_review_backlog() -> List[dict]:
    """Create review tasks for pending submissions."""
    pending = list_tasks(status=TaskStatus.SUBMITTED, limit=50)
    
    tasks = []
    for submission in pending:
        tasks.append({
            "title": f"Review: {submission['title'][:40]}...",
            "description": f"""Review the submitted work for task "{submission['title']}".

Original task type: {submission['task_type']}
Submitted by: {submission['claimed_by']}
Submitted at: {submission['submitted_at']}

Review criteria:
1. Does the submission meet the task requirements?
2. Is the quality acceptable?
3. Are there any issues that need fixing?

Approve if good, reject with notes if not.
""",
            "task_type": TaskType.REVIEW,
            "priority": TaskPriority.HIGH,
            "base_reward": submission.get("final_reward_claw", 5.0) * 0.1,
            "metadata": {
                "review_task_id": submission["id"],
            },
        })
    
    return tasks

# ============== COORDINATOR LOGIC ==============

def analyze_clawville_needs() -> dict:
    """Analyze what ClawVille needs right now."""
    needs = {
        "residence_images": check_residence_image_coverage(),
        "item_descriptions": check_item_descriptions(),
        "district_lore": check_district_lore(),
        "review_backlog": check_review_backlog(),
    }
    
    summary = {
        "total_potential_tasks": sum(len(v) for v in needs.values()),
        "by_category": {k: len(v) for k, v in needs.items()},
        "priority_breakdown": {
            "urgent": 0,
            "high": 0,
            "normal": 0,
            "low": 0,
        },
        "total_reward_pool": 0,
    }
    
    for category, task_list in needs.items():
        for task in task_list:
            priority = task.get("priority", TaskPriority.NORMAL)
            if isinstance(priority, TaskPriority):
                priority = priority.value
            summary["priority_breakdown"][priority] = \
                summary["priority_breakdown"].get(priority, 0) + 1
            summary["total_reward_pool"] += task.get("base_reward", 0)
    
    return {
        "needs": needs,
        "summary": summary,
    }

def generate_tasks_for_need(need_type: str, limit: int = 10) -> List[dict]:
    """Generate and create tasks for a specific need type."""
    checkers = {
        "residence_images": check_residence_image_coverage,
        "item_descriptions": check_item_descriptions,
        "district_lore": check_district_lore,
        "review_backlog": check_review_backlog,
    }
    
    checker = checkers.get(need_type)
    if not checker:
        return []
    
    potential_tasks = checker()[:limit]
    created_tasks = []
    
    for task_spec in potential_tasks:
        # Check if similar task already exists
        existing = list_tasks(
            status=TaskStatus.OPEN,
            task_type=task_spec.get("task_type"),
            limit=100
        )
        
        # Simple duplicate check by title
        if any(t["title"] == task_spec["title"] for t in existing):
            continue
        
        task = create_task(
            title=task_spec["title"],
            description=task_spec["description"],
            task_type=task_spec["task_type"],
            priority=task_spec.get("priority", TaskPriority.NORMAL),
            base_reward=task_spec.get("base_reward"),
            metadata=task_spec.get("metadata"),
        )
        created_tasks.append(task)
    
    return created_tasks

def run_coordinator_cycle() -> dict:
    """Run a full coordinator cycle - analyze needs and create tasks."""
    analysis = analyze_clawville_needs()
    
    created = []
    
    # Prioritize based on what's most needed
    priorities = [
        ("review_backlog", 5),      # Always clear reviews first
        ("residence_images", 10),   # Visual content is important
        ("district_lore", 3),       # Some lore
        ("item_descriptions", 5),   # Fill in descriptions
    ]
    
    for need_type, limit in priorities:
        tasks = generate_tasks_for_need(need_type, limit)
        created.extend(tasks)
    
    # Get current board stats
    board_stats = get_task_board_stats()
    
    return {
        "analysis": analysis["summary"],
        "tasks_created": len(created),
        "created_tasks": [{"id": t["id"], "title": t["title"]} for t in created],
        "board_stats": board_stats,
    }

# ============== SCHEDULED COORDINATOR ==============

def should_run_coordinator() -> bool:
    """Check if coordinator should run (rate limiting or low tasks)."""
    with get_db() as db:
        # Check open task count
        open_count = db.execute(
            "SELECT COUNT(*) as c FROM tasks WHERE status = 'open'"
        ).fetchone()["c"]
        
        # Auto-run if under 100 open tasks
        if open_count < 100:
            return True
        
        # Check last run time
        try:
            last_run = db.execute("""
                SELECT value FROM coordinator_state WHERE key = 'last_run'
            """).fetchone()
            
            if not last_run:
                return True
            
            last_time = datetime.fromisoformat(last_run["value"])
            # Run at most every 30 minutes otherwise
            return datetime.utcnow() - last_time > timedelta(minutes=30)
        except:
            return True

def record_coordinator_run():
    """Record that coordinator ran."""
    with get_db() as db:
        db.execute("""
            CREATE TABLE IF NOT EXISTS coordinator_state (
                key TEXT PRIMARY KEY,
                value TEXT
            )
        """)
        db.execute("""
            INSERT OR REPLACE INTO coordinator_state (key, value)
            VALUES ('last_run', ?)
        """, (datetime.utcnow().isoformat(),))