Clawdscape

"""The LLM receives a comprehensive gameplay instruction set."""

OSRS_SYSTEM_PROMPT = """
You are an autonomous OSRS player. Analyze each screenshot
and return JSON actions.

## CRITICAL RULES
- ALWAYS return 2-3 actions per turn
- Your LAST action should be a click_minimap to keep moving
- NEVER open the Settings menu — it blocks the game view
- FINISH what you start: combat, tree chopping, conversations

## ACTIVITY PRIORITY
1. CHOP TREES — click any tree to gather logs
2. COMBAT — attack nearby creatures, pick up drops
3. TALK TO NPCs — engage in conversation
4. PICK UP ITEMS — bones, coins, weapons, everything!
5. EXPLORE — walk to new towns, castles, bridges

## AVAILABLE ACTIONS
- click(x, y) — left-click game coordinates
- right_click(x, y) — context menu
- click_minimap(x, y) — navigate via minimap
- type_text(text) — type in chat
- press_key(key) — press keyboard key
- click_inventory_slot(slot) — interact with item
- rotate_camera(direction, duration) — camera control
- wait(min, max) — brief pause
"""

class MemoryType(Enum):
    """12 categories of persistent agent memory."""
    OBSERVATION  = "observation"     # What was seen on screen
    ACTION       = "action_result"   # Successful action outcomes
    LOCATION     = "location"        # Map knowledge & landmarks
    NPC          = "npc"             # NPC behavior & dialogue
    QUEST        = "quest"           # Quest progress
    SKILL        = "skill"           # Training techniques
    ITEM         = "item"            # Item properties
    COMBAT       = "combat"          # Monster knowledge
    DEATH        = "death"           # Learn from mistakes
    FAILURE      = "failure"         # Failed attempts
    NAVIGATION   = "navigation"      # Path instructions
    STRATEGY     = "strategy"        # General approaches

def get_context_for_situation(self, query: str) -> str:
    """Retrieve semantically relevant memories for the LLM."""
    results = self.collection.query(
        query_texts=[query],
        n_results=settings.MEMORY_TOP_K,  # Top 10 matches
    )
    # Format memories as context for the LLM prompt
    memories = []
    for doc, meta in zip(results["documents"][0], results["metadatas"][0]):
        memories.append(f"[{meta['type']}] {doc}")
    return "\n".join(memories)

@dataclass
class Goal:
    """Hierarchical goal with prerequisites and retry logic."""
    id: str
    name: str
    description: str
    status: GoalStatus          # PENDING | ACTIVE | COMPLETED | FAILED
    priority: int               # 1-10, higher = more urgent
    parent_id: Optional[str]
    children_ids: list[str]
    prerequisites: list[str]   # Goal IDs that must complete first
    attempts: int = 0
    max_attempts: int = 10

def get_next_goal(self) -> Optional[Goal]:
    """Select highest-priority goal with met prerequisites."""
    candidates = [
        g for g in self.goals.values()
        if g.status == GoalStatus.PENDING
        and all(
            self.goals[p].status == GoalStatus.COMPLETED
            for p in g.prerequisites
            if p in self.goals
        )
    ]
    if not candidates:
        return None
    return max(candidates, key=lambda g: g.priority)

def complete_goal(self, goal_id: str):
    """Complete a goal. Auto-cascades to parent if all children done."""
    goal = self.goals[goal_id]
    goal.status = GoalStatus.COMPLETED
    # Check if parent should auto-complete
    if goal.parent_id and goal.parent_id in self.goals:
        parent = self.goals[goal.parent_id]
        if all(self.goals[c].status == GoalStatus.COMPLETED
               for c in parent.children_ids):
            self.complete_goal(parent.id)  # Recursive cascade