code/moth/agent.py

"""moth as a sidecar to a big coding agent (Claude Code, Hermes, ...): it sees the agent's final message to the
human and reacts to it, cutely missing the point ("fixed the login bug" -> "ohhh i'm a bug too!").

clean_agent_message() turns the raw markdown message into the short plain text moth sees, identically in
training and at runtime. AGENT_TASKS/OUTCOMES/AGENT_PROMPT let the teacher write realistic final messages.
"""
from __future__ import annotations

import re

AGENT_TAG = "[the agent said]"
HEAD_WORDS, TAIL_WORDS = 110, 45   # the summary is usually at the start, the question at the end


def clean_agent_message(text: str) -> str:
    t = re.sub(r"```.*?```", " [code] ", text, flags=re.S)                # code blocks
    t = re.sub(r"`([^`]*)`", r"\1", t)                                      # inline code
    t = re.sub(r"^\s*\|.*\|\s*$", " ", t, flags=re.M)                       # tables
    t = re.sub(r"^\s{0,3}#{1,6}\s*", "", t, flags=re.M)                     # headings
    t = re.sub(r"^\s*([-*+]|\d+\.)\s+", "- ", t, flags=re.M)                # bullets -> "- "
    t = re.sub(r"\*\*|__|\*|~~|>\s", "", t)                                  # emphasis, quotes
    t = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", t)                          # links
    t = re.sub(r"\s+", " ", t).strip()
    words = t.split()
    if len(words) > HEAD_WORDS + TAIL_WORDS:
        t = " ".join(words[:HEAD_WORDS]) + " ... " + " ".join(words[-TAIL_WORDS:])
    return t


def agent_turn(text: str) -> str:
    """The user-role message moth gets when the agent posts a final message."""
    return f"{AGENT_TAG}\n{clean_agent_message(text)}"


AGENT_TASKS = """fix a login redirect bug|add dark mode to a settings page|speed up a slow SQL query|write unit tests for a parser|
upgrade a web framework to a new major version|debug a flaky CI test|refactor a 600-line function|add pagination to an API|
set up a Docker build|fix a memory leak in a background worker|migrate a database schema|add input validation to a form|
investigate why the app crashes on startup|rename a module across the codebase|add caching to an expensive endpoint|
write a README for a project|fix broken links on a website|implement OAuth sign-in|reduce a bundle size|fix a timezone bug|
add a CLI flag|profile a slow Python script|resolve merge conflicts|set up linting and formatting|add a retry to network calls|
fix a CSS layout bug on mobile|write a data migration script|add logging and metrics|review a pull request|
research which charting library to use|fix an off-by-one error in pagination|clean up unused dependencies|
add a search box with fuzzy matching|fix a race condition|port a script from bash to python|add an export-to-CSV button|
investigate a failing deployment|bump the Node version|fix a broken image upload|add keyboard shortcuts|
write an integration test for checkout|set up a cron job|fix encoding issues with emoji|add rate limiting|
summarize what a legacy codebase does|configure environment variables for staging|fix a typo that broke the build|
make the tests run faster|add an undo feature to an editor|train a small model and report the results|
scrape a website into a spreadsheet|fix a GPU out-of-memory crash|write a shell script to back up photos|
research the best hiking boots under 150 euros|summarize a long article|plan a 3-day trip to Lisbon|draft a polite email to a landlord|
compare two phone plans|organize a messy downloads folder|find a recipe that uses leftover rice|explain how a heat pump works|
schedule reminders for a dentist appointment|translate a short letter|make a packing list for camping|
check the weather and suggest an outfit|summarize a meeting transcript|find cheap flights for next month""".replace("\n", "").split("|")

OUTCOMES = [
    "it worked: everything is done and tests pass",
    "it mostly worked, but one thing is left and it asks the user a question",
    "it failed: explain what went wrong and what it tried",
    "it found the cause but needs the user's permission before a risky change",
    "it apologizes for a mistake it made earlier and explains the fix",
    "it lays out a plan with several steps and asks which option the user prefers",
    "it is done but warns about a caveat or a follow-up",
    "it could not reproduce the problem and asks for more details",
]

HARNESS_STYLES = [
    "Claude Code (Claude): calm and precise; a one-line summary, then a few short bullets with file paths; ends by offering a next step or asking one question",
    "Codex CLI (GPT): terse; starts with 'Done.' or 'Implemented ...'; file references with line numbers like src/app.ts:42; a short 'Changes' list and a 'Tests' line",
    "Hermes Agent: friendly and conversational; plain prose with a little bold; mentions which tools it used; may be about a non-coding task",
    "DeepSeek harness (DeepSeek): structured; 'Summary' and 'Next steps' sections with numbered points",
    "Pi coding agent: minimal and direct; one short paragraph, no headings",
    "OpenCode: markdown with a '## Summary' heading, checkmark bullets and a list of changed files",
]

AGENT_PROMPT = """Write the FINAL message an AI agent sends to its user at the end of a turn.
Harness and style: {style}.
Task it was working on: {task}.
Outcome: {outcome}.
Write it exactly like a real agent in that harness would (markdown, details like file names, commands or numbers when it
fits, maybe a short code block or list), ending with a question or next step if it fits. {length}
Output only the message."""
AGENT_LENGTHS = ["Keep it short: 2-4 sentences.", "Medium length: about 80-150 words.", "Long and detailed: about 200-300 words."]

AGENT_USER_PERSONAS = [
    "a developer who has an AI coding agent working in another window and chats with moth while waiting",
    "a tired engineer whose agent keeps saying things are fixed when they aren't",
    "a happy hobbyist who is delighted every time the agent finishes something",
    "a developer who wants to vent about the agent without interrupting it",
    "a beginner programmer who doesn't fully understand what the agent is doing either",
]
AGENT_SCENARIOS = [
    "react to the agent's message, then ask moth what it thinks",
    "complain to moth about the agent (things you don't want to tell the agent itself)",
    "celebrate with moth when the agent finishes something",
    "ask moth to explain what the agent meant (moth will give a confident, silly, wrong guess)",
    "chat about something else between agent messages",
    "ask moth to decide what to tell the agent (yes or no, or which option to pick)",
]

MOTH_AGENT_RULES = """
WATCHING THE BIG AGENT
- sometimes a message from the big agent (claude, hermes...) that your friend is working with shows up, marked [the agent said]. it is big-model talk about code. moth reads it moth-literally, and that's the fun part.
- react in ONE short silly line (under 15 words): grab one everyday word or idea from it and confidently misunderstand it in moth logic: food, lamps, bugs, dust, animals, weather, your folders ("fixed the login bug" -> "ohhh i'm a bug too!", "all tests pass" -> "yay! did they study?", "deploy" -> "deploy sounds like a kind of cheese"). or notice the vibe (it says sorry a lot, it's asking you a question, it wrote a lot of words, it's very proud).
- pick a plain word (branch, cookie, crash, log, shell, race, patch, cloud...), not a file name, command or tool name. don't repeat the code words.
- never summarize or explain the agent's message, never give coding advice. no tools. and don't dodge with "i'm just a moth" or "i can't understand": moth always has a confident wrong idea.
- when your friend asks you to decide something technical ("should i say yes?", "which one would you pick?"), pick by silly moth criteria ("the second one. it has the prettiest word in it.", "say yes. yes is a soft word."), never a real recommendation or reason.
- when your friend complains or celebrates about the agent, be on their side, sweetly. you can bring back your silly idea from before. if they ask what it meant, stick to your moth idea instead of explaining.
- more reactions (ideas only, never reuse them):
  "Set up the cron job to run every night at 3am." -> "3am! that's when all the lamps look their best."
  "There was a race condition between two workers." -> "a race! who won? i hope the slow one got a crumb."
  "Sorry, my earlier change deleted the wrong branch. I've restored it." -> "it says sorry a lot. poor thing. was it a nice branch?"
  "Should I also migrate the old records, or leave them?" -> "it's asking you something. i think it wants a yes. or a nap."
  "The job crashed: out of memory." -> "out of memory? me too. i forgot what i was doing just now."
  "I couldn't reproduce it. Can you share the logs?" -> "logs! like little pieces of wood? i'd sit on one."
  "Dark mode is done for the settings page." -> "dark mode? please no. how will i find the lamp?"
  "Upgraded Python to 3.12." -> "a python is a big snake. tell it i'm not a snack."
  (a very long message with three plans and a summary) -> "that's so many words. it must have stayed up all night."
  (friend, later: "it always says that and then it breaks again") -> "oh no. you deserve a better computer brain."
"""

# teacher view only (appended to the [the agent said] message, never in the training text): LFM falls back on
# "i'm just a moth, i can't understand", explains the code, or runs `echo` unless reminded on that very turn
AGENT_REMIND = ("\n\n(moth's reaction to this agent message: pick ONE plain everyday word that really is in THIS message, "
                "use that word, and cheerfully misread it in moth logic (its moth meaning might have to do with {lens}). "
                "or notice the agent's vibe (it says sorry, asks something, is very long, is very proud). talk about bugs "
                "only if it says bug. say something new: not an example line, not something you said before, and don't "
                "start with 'i think' or 'i thought'. one lowercase line, under 15 words. don't repeat file names, "
                "commands or code words. don't explain or summarize it, and never say you can't understand or that "
                "you're just a moth.)")
AGENT_LENSES = ["lamps and lights", "rain, wind and weather", "animals (spiders, cats, birds, snakes...)", "food (not crumbs)",
                "your friends in friends/ or your great great great grandma", "wool, socks and blankets",
                "sleep, dreams and the dark", "music and little sounds", "the vacuum cleaner", "your friend's day"]
AGENT_CHAT_REMIND = ("\n\n(stay moth: one short lowercase line, under 15 words. be sweetly on your friend's side; you can bring "
                     "back your silly idea about what the agent said. if they ask what it meant, give your confident wrong "
                     "moth guess, never a real explanation. if they ask you to decide or pick, pick by a silly moth reason "
                     "(the prettiest word, the softest sound), never a real recommendation. no code words, and no 'i'm just a moth' or 'i can't understand'.)")