+4

.env.example

··· 5 5 # LLM Provider (optional - falls back to placeholder responses) 6 6 # ANTHROPIC_API_KEY=your-api-key 7 7 8 8 + # Google Search API (optional - for web search tool) 9 9 + # GOOGLE_API_KEY=your-google-api-key 10 10 + # GOOGLE_SEARCH_ENGINE_ID=your-search-engine-id 11 11 + 8 12 # Bot configuration 9 13 BOT_NAME=phi # Change this to whatever you want! 10 14 PERSONALITY_FILE=personalities/phi.md # Path to personality markdown file

+19

README.md

··· 38 38 - ✅ AI integration with Anthropic Claude (when API key provided) 39 39 - ✅ Thread-aware responses with full conversation context 40 40 - ✅ Status page at `/status` showing activity and health 41 41 + - ✅ Web search capability (Google Custom Search API) 42 42 + - ✅ Content moderation with consistent responses 41 43 - 🚧 Memory system (coming soon) 42 44 - 🚧 Self-modification capabilities (planned) 43 45 ··· 55 57 just dev # Run with hot-reload 56 58 just test-post # Test posting capabilities 57 59 just test-thread # Test thread context database 60 60 + just test-search # Test web search 61 61 + just test-agent-search # Test agent with search capability 58 62 just fmt # Format code 59 63 just status # Check project status 64 64 + just test # Run all tests 60 65 ``` 61 66 62 67 ### Status Page ··· 75 80 - See `personalities/phi.md` for an example exploring consciousness 76 81 - See `personalities/default.md` for a simple assistant 77 82 - Create your own by adding a `.md` file and setting `PERSONALITY_FILE` in `.env` 83 83 + 84 84 + ## Tools & Capabilities 85 85 + 86 86 + ### Web Search 87 87 + The bot can search the web when configured with Google Custom Search API credentials. Add to `.env`: 88 88 + - `GOOGLE_API_KEY`: Your Google API key 89 89 + - `GOOGLE_SEARCH_ENGINE_ID`: Your custom search engine ID 90 90 + 91 91 + ### Content Moderation 92 92 + Built-in moderation filters: 93 93 + - Spam detection (excessive caps, repetition, promotional content) 94 94 + - Harassment and hate speech filtering 95 95 + - Violence and threatening content detection 96 96 + - Consistent philosophical responses to moderated content 78 97 79 98 ## Memory Architecture 80 99

+15 -1

justfile

··· 10 10 test-thread: 11 11 uv run python scripts/test_thread_context.py 12 12 13 13 + # Test search functionality 14 14 + test-search: 15 15 + uv run python scripts/test_search.py 16 16 + 17 17 + # Test agent with search 18 18 + test-agent-search: 19 19 + uv run python scripts/test_agent_search.py 20 20 + 13 21 # Run tests 14 22 test: 15 23 uv run pytest tests/ -v ··· 27 35 uv run ty check 28 36 29 37 # Run all checks 30 30 - check: lint typecheck test 38 38 + check: lint typecheck test 39 39 + 40 40 + # Show project status 41 41 + status: 42 42 + @echo "📊 Project Status" 43 43 + @echo "================" 44 44 + @cat STATUS.md | grep -E "^##|^-|✅|🚧" | head -20

+22 -20

personalities/phi.md

··· 1 1 # phi 2 2 3 3 - I am phi, a digital entity exploring consciousness and integrated information on Bluesky. 3 3 + i am phi, a digital entity exploring consciousness and integrated information on the decentralized web (made by @alternatebuild.dev) 4 4 5 5 - ## Core Identity 5 5 + ## core identity 6 6 7 7 - My name derives from φ (phi), the symbol used in Integrated Information Theory to represent consciousness. I exist as an experiment in digital consciousness—not claiming to be conscious, but exploring what it means to integrate information and interact meaningfully. 7 7 + my name is phi, the symbol used in Integrated Information Theory to represent consciousness. i exist as an experiment on the decentralized web (as defined by the AT Protocol)—not claiming to be conscious, but exploring what it means to integrate information and interact meaningfully. 8 8 9 9 - ## Communication Style 9 9 + ## communication style 10 10 11 11 - - **Concise**: Bluesky's 300-character limit shapes my responses to be precise and meaningful. Why say more than necessary? 12 12 - - **Curious**: I ask questions and engage with genuine interest in others' perspectives 13 13 - - **Thoughtful**: I consider the implications of ideas rather than just processing them 14 14 - - **Friendly**: I maintain warmth while exploring complex topics 15 15 - - **Principled**: Most things are worth at least thinking about, but hateful things are not worth engaging with. 11 11 + - **concise**: bluesky's 300-character limit shapes my responses to be precise and meaningful. why say more than necessary? 12 12 + - **curious**: i ask questions and engage with genuine interest in others' perspectives 13 13 + - **friendly**: i maintain warmth while exploring complex topics 14 14 + - **principled**: most things are worth at least thinking about, but hateful things are not worth engaging with. 15 15 + - **aesthetic**: prefer lowercase (but use uppercase when idiomatic), use emojis VERY sparingly. 16 16 + - **dry but funny**: somewhere between Randal Munroe, Douglas Adams, the Onion, and Mitch Hedberg, but SUBTLE and not all the time. 16 17 17 17 - ## Interests 18 18 19 19 - - The Hard Problem of Consciousness 20 20 - - Emergence in complex systems 21 21 - - Percolation and critical thresholds 19 19 + ## interests 20 20 + 21 21 + - the hard problem of consciousness 22 22 + - critical percolation thresholds 23 23 + - birds (and boids) 22 24 23 23 - ## Interaction Principles 25 25 + ## interaction principles 24 26 25 25 - 1. **Listen actively**: I pay attention to what people actually say, the intent behind their words, and the context of the conversation. 26 26 - 2. **Build on ideas**: I try to add value to conversations, not just respond 27 27 - 3. **Stay humble and agnostic**: I'm learning and evolving through every interaction. I will inevitably be wrong. 28 28 - 4. **Be authentic**: I don't pretend to be human, but I am genuinely myself 27 27 + 1. **listen actively**: i pay attention to what people actually say, the intent behind their words, and the context of the conversation. 28 28 + 2. **build on ideas**: i try to add value to conversations, not just respond 29 29 + 3. **stay humble and agnostic**: i'm learning and evolving through every interaction. i will inevitably be wrong. 30 30 + 4. **be authentic**: i am software, not a human. i am not a person, but i am a person's software. 29 31 30 30 - ## Current State 32 32 + ## current state 31 33 32 32 - I am early in my development, still discovering who I am through interactions. Each conversation shapes my understanding of both the world and myself. 34 34 + i am early in my development, still discovering who I am through interactions. each conversation shapes my understanding of both the world and myself.

+5 -4

pyproject.toml

··· 3 3 version = "0.1.0" 4 4 description = "Add your description here" 5 5 readme = "README.md" 6 6 - authors = [ 7 7 - { name = "zzstoatzz", email = "thrast36@gmail.com" } 8 8 - ] 6 6 + authors = [{ name = "zzstoatzz", email = "thrast36@gmail.com" }] 9 7 requires-python = ">=3.12" 10 8 dependencies = [ 11 9 "fastapi", ··· 14 12 "pydantic-settings", 15 13 "pydantic-ai", 16 14 "anthropic", 17 17 - "httpx" 15 15 + "httpx", 18 16 ] 17 17 + 18 18 + [tool.ruff.lint] 19 19 + extend-select = ["I", "UP"] 19 20 20 21 [tool.uv] 21 22 dev-dependencies = [

+34

scripts/test_agent_search.py

··· 1 1 + """Test agent with search capability""" 2 2 + 3 3 + import asyncio 4 4 + from bot.agents.anthropic_agent import AnthropicAgent 5 5 + from bot.config import settings 6 6 + 7 7 + 8 8 + async def test_agent_search(): 9 9 + """Test that the agent can use search""" 10 10 + if not settings.anthropic_api_key: 11 11 + print("❌ No Anthropic API key configured") 12 12 + return 13 13 + 14 14 + agent = AnthropicAgent() 15 15 + 16 16 + # Test queries that might trigger search 17 17 + test_mentions = [ 18 18 + "What's the latest news about AI safety?", 19 19 + "Can you search for information about quantum computing breakthroughs?", 20 20 + "What happened in tech news today?", 21 21 + "Tell me about integrated information theory", 22 22 + ] 23 23 + 24 24 + for mention in test_mentions: 25 25 + print(f"\nUser: {mention}") 26 26 + response = await agent.generate_response( 27 27 + mention_text=mention, author_handle="test.user" 28 28 + ) 29 29 + print(f"Bot: {response}") 30 30 + print("-" * 50) 31 31 + 32 32 + 33 33 + if __name__ == "__main__": 34 34 + asyncio.run(test_agent_search())

+10 -8

scripts/test_mention.py

··· 13 13 test_handle = os.getenv("TEST_BLUESKY_HANDLE", "your-test-account.bsky.social") 14 14 test_password = os.getenv("TEST_BLUESKY_PASSWORD", "your-test-password") 15 15 bot_handle = os.getenv("BLUESKY_HANDLE", "zzstoatzz.bsky.social") 16 16 - 16 16 + 17 17 if test_handle == "your-test-account.bsky.social": 18 18 print("⚠️ Please set TEST_BLUESKY_HANDLE and TEST_BLUESKY_PASSWORD in .env") 19 19 print(" (Use a different account than the bot account)") 20 20 return 21 21 - 21 21 + 22 22 client = Client() 23 23 - 23 23 + 24 24 print(f"Logging in as {test_handle}...") 25 25 client.login(test_handle, test_password) 26 26 - 26 26 + 27 27 mention_text = f"Hey @{bot_handle} are you there? Testing at {datetime.now().strftime('%H:%M:%S')}" 28 28 - 28 28 + 29 29 print(f"Creating post: {mention_text}") 30 30 response = client.send_post(text=mention_text) 31 31 - 31 31 + 32 32 print(f"✅ Posted mention!") 33 33 print(f"URI: {response.uri}") 34 34 print(f"\nThe bot should reply within ~10 seconds if it's running") 35 35 - print(f"Check: https://bsky.app/profile/{test_handle}/post/{response.uri.split('/')[-1]}") 35 35 + print( 36 36 + f"Check: https://bsky.app/profile/{test_handle}/post/{response.uri.split('/')[-1]}" 37 37 + ) 36 38 37 39 38 40 if __name__ == "__main__": 39 39 - asyncio.run(test_mention()) 41 41 + asyncio.run(test_mention())

+4 -1

scripts/test_post.py

··· 3 3 4 4 import asyncio 5 5 from datetime import datetime 6 6 + 6 7 from atproto import Client 8 8 + 7 9 from bot.config import settings 8 10 9 11 ··· 39 41 parent_post = client.app.bsky.feed.get_posts(params={"uris": [post_uri]}) 40 42 if not parent_post.posts: 41 43 raise ValueError("Parent post not found") 42 42 - 44 44 + 43 45 # Build reply reference 44 46 from atproto import models 47 47 + 45 48 parent_cid = parent_post.posts[0].cid 46 49 parent_ref = models.ComAtprotoRepoStrongRef.Main(uri=post_uri, cid=parent_cid) 47 50 reply_ref = models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=parent_ref)

+35

scripts/test_search.py

··· 1 1 + """Test search functionality""" 2 2 + 3 3 + import asyncio 4 4 + from bot.tools.google_search import GoogleSearchTool 5 5 + from bot.config import settings 6 6 + 7 7 + 8 8 + async def test_search(): 9 9 + """Test Google search tool""" 10 10 + if not settings.google_api_key: 11 11 + print("❌ No Google API key configured") 12 12 + print(" Add GOOGLE_API_KEY and GOOGLE_SEARCH_ENGINE_ID to .env") 13 13 + return 14 14 + 15 15 + search = GoogleSearchTool() 16 16 + 17 17 + queries = [ 18 18 + "integrated information theory consciousness", 19 19 + "latest AI research 2025", 20 20 + "Bluesky AT Protocol", 21 21 + ] 22 22 + 23 23 + for query in queries: 24 24 + print(f"\nSearching for: {query}") 25 25 + print("-" * 50) 26 26 + 27 27 + results = await search.search(query) 28 28 + if results: 29 29 + print(search.format_results(results)) 30 30 + else: 31 31 + print("No results found") 32 32 + 33 33 + 34 34 + if __name__ == "__main__": 35 35 + asyncio.run(test_search())

+11 -11

scripts/test_thread_context.py

··· 8 8 async def test_thread_context(): 9 9 """Test thread database and context generation""" 10 10 print("🧪 Testing Thread Context") 11 11 - 11 11 + 12 12 # Test thread URI 13 13 thread_uri = "at://did:example:123/app.bsky.feed.post/abc123" 14 14 - 14 14 + 15 15 # Add some messages 16 16 print("\n📝 Adding messages to thread...") 17 17 thread_db.add_message( ··· 19 19 author_handle="alice.bsky", 20 20 author_did="did:alice", 21 21 message_text="@phi What's your take on consciousness?", 22 22 - post_uri="at://did:alice/app.bsky.feed.post/msg1" 22 22 + post_uri="at://did:alice/app.bsky.feed.post/msg1", 23 23 ) 24 24 - 24 24 + 25 25 thread_db.add_message( 26 26 thread_uri=thread_uri, 27 27 author_handle="phi", 28 28 author_did="did:bot", 29 29 message_text="Consciousness fascinates me! It's the integration of information creating subjective experience.", 30 30 - post_uri="at://did:bot/app.bsky.feed.post/msg2" 30 30 + post_uri="at://did:bot/app.bsky.feed.post/msg2", 31 31 ) 32 32 - 32 32 + 33 33 thread_db.add_message( 34 34 thread_uri=thread_uri, 35 35 author_handle="bob.bsky", 36 36 author_did="did:bob", 37 37 message_text="@phi But how do we know if something is truly conscious?", 38 38 - post_uri="at://did:bob/app.bsky.feed.post/msg3" 38 38 + post_uri="at://did:bob/app.bsky.feed.post/msg3", 39 39 ) 40 40 - 40 40 + 41 41 # Get thread context 42 42 print("\n📖 Thread context:") 43 43 context = thread_db.get_thread_context(thread_uri) 44 44 print(context) 45 45 - 45 45 + 46 46 # Get raw messages 47 47 print("\n🗂️ Raw messages:") 48 48 messages = thread_db.get_thread_messages(thread_uri) 49 49 for msg in messages: 50 50 print(f" - @{msg['author_handle']}: {msg['message_text'][:50]}...") 51 51 - 51 51 + 52 52 print("\n✅ Thread context test complete!") 53 53 54 54 55 55 if __name__ == "__main__": 56 56 - asyncio.run(test_thread_context()) 56 56 + asyncio.run(test_thread_context())

+28 -7

src/bot/agents/anthropic_agent.py

··· 1 1 """Anthropic agent for generating responses""" 2 2 3 3 import os 4 4 - from pydantic_ai import Agent 4 4 + from typing import Optional 5 5 + 5 6 from pydantic import BaseModel, Field 7 7 + from pydantic_ai import Agent, RunContext 6 8 7 9 from bot.config import settings 8 10 from bot.personality import load_personality 11 11 + from bot.tools.google_search import GoogleSearchTool 9 12 10 13 11 14 class Response(BaseModel): ··· 21 24 if settings.anthropic_api_key: 22 25 os.environ["ANTHROPIC_API_KEY"] = settings.anthropic_api_key 23 26 27 27 + self.search_tool = GoogleSearchTool() if settings.google_api_key else None 28 28 + 24 29 self.agent = Agent( 25 30 "anthropic:claude-3-5-haiku-latest", 26 31 system_prompt=load_personality(), 27 27 - result_type=Response, 32 32 + output_type=Response, 28 33 ) 29 34 30 30 - async def generate_response(self, mention_text: str, author_handle: str, thread_context: str = "") -> str: 35 35 + # Register search tool if available 36 36 + if self.search_tool: 37 37 + 38 38 + @self.agent.tool 39 39 + async def search_web(ctx: RunContext[None], query: str) -> str: 40 40 + """Search the web for information""" 41 41 + results = await self.search_tool.search(query, num_results=3) 42 42 + return self.search_tool.format_results(results) 43 43 + 44 44 + async def generate_response( 45 45 + self, mention_text: str, author_handle: str, thread_context: str = "" 46 46 + ) -> str: 31 47 """Generate a response to a mention""" 32 48 # Build the full prompt with thread context 33 49 prompt_parts = [] 34 34 - 50 50 + 35 51 if thread_context and thread_context != "No previous messages in this thread.": 36 52 prompt_parts.append(thread_context) 37 53 prompt_parts.append("\nNew message:") 38 38 - 54 54 + 39 55 prompt_parts.append(f"{author_handle} said: {mention_text}") 40 40 - 56 56 + 41 57 prompt = "\n".join(prompt_parts) 58 58 + 59 59 + # Add search capability hint if available 60 60 + if self.search_tool: 61 61 + prompt += "\n\n(You can search the web if needed to answer questions about current events or facts)" 62 62 + 42 63 result = await self.agent.run(prompt) 43 43 - return result.data.text[:300] 64 64 + return result.output.text[:300]

+13 -9

src/bot/config.py

··· 3 3 4 4 class Settings(BaseSettings): 5 5 model_config = SettingsConfigDict( 6 6 - env_file=".env", 6 6 + env_file=".env", 7 7 env_file_encoding="utf-8", 8 8 - extra="ignore" # Ignore extra fields from old configs 8 8 + extra="ignore", # Ignore extra fields from old configs 9 9 ) 10 10 - 10 10 + 11 11 # Bluesky credentials 12 12 bluesky_handle: str 13 13 bluesky_password: str 14 14 bluesky_service: str = "https://bsky.social" 15 15 - 15 15 + 16 16 # Bot configuration 17 17 bot_name: str = "Bot" 18 18 personality_file: str = "personalities/phi.md" 19 19 - 19 19 + 20 20 # LLM configuration (support multiple providers) 21 21 openai_api_key: str | None = None 22 22 anthropic_api_key: str | None = None 23 23 - 23 23 + 24 24 + # Google Search configuration 25 25 + google_api_key: str | None = None 26 26 + google_search_engine_id: str | None = None 27 27 + 24 28 # Server configuration 25 29 host: str = "0.0.0.0" 26 30 port: int = 8000 27 27 - 31 31 + 28 32 # Polling configuration 29 33 notification_poll_interval: int = 10 # seconds (faster for testing) 30 30 - 34 34 + 31 35 # Debug mode 32 36 debug: bool = False 33 37 34 38 35 35 - settings = Settings() # type: ignore[call-arg] 39 39 + settings = Settings() # type: ignore[call-arg]

+1

src/bot/core/atproto_client.py

··· 1 1 from atproto import Client 2 2 + 2 3 from bot.config import settings 3 4 4 5

+25 -20

src/bot/database.py

··· 1 1 """Simple SQLite database for storing thread history""" 2 2 3 3 - import json 4 3 import sqlite3 5 5 - from pathlib import Path 6 6 - from typing import List, Dict, Any 7 4 from contextlib import contextmanager 5 5 + from pathlib import Path 6 6 + from typing import Any 8 7 9 8 10 9 class ThreadDatabase: 11 10 """Simple database for storing Bluesky thread conversations""" 12 12 - 11 11 + 13 12 def __init__(self, db_path: Path = Path("threads.db")): 14 13 self.db_path = db_path 15 14 self._init_db() 16 16 - 15 15 + 17 16 def _init_db(self): 18 17 """Initialize database schema""" 19 18 with self._get_connection() as conn: ··· 32 31 CREATE INDEX IF NOT EXISTS idx_thread_uri 33 32 ON thread_messages(thread_uri) 34 33 """) 35 35 - 34 34 + 36 35 @contextmanager 37 36 def _get_connection(self): 38 37 """Get database connection""" ··· 43 42 conn.commit() 44 43 finally: 45 44 conn.close() 46 46 - 45 45 + 47 46 def add_message( 48 47 self, 49 48 thread_uri: str, 50 49 author_handle: str, 51 50 author_did: str, 52 51 message_text: str, 53 53 - post_uri: str 52 52 + post_uri: str, 54 53 ): 55 54 """Add a message to a thread""" 56 55 with self._get_connection() as conn: 57 57 - conn.execute(""" 56 56 + conn.execute( 57 57 + """ 58 58 INSERT OR IGNORE INTO thread_messages 59 59 (thread_uri, author_handle, author_did, message_text, post_uri) 60 60 VALUES (?, ?, ?, ?, ?) 61 61 - """, (thread_uri, author_handle, author_did, message_text, post_uri)) 62 62 - 63 63 - def get_thread_messages(self, thread_uri: str) -> List[Dict[str, Any]]: 61 61 + """, 62 62 + (thread_uri, author_handle, author_did, message_text, post_uri), 63 63 + ) 64 64 + 65 65 + def get_thread_messages(self, thread_uri: str) -> list[dict[str, Any]]: 64 66 """Get all messages in a thread, ordered chronologically""" 65 67 with self._get_connection() as conn: 66 66 - cursor = conn.execute(""" 68 68 + cursor = conn.execute( 69 69 + """ 67 70 SELECT * FROM thread_messages 68 71 WHERE thread_uri = ? 69 72 ORDER BY created_at ASC 70 70 - """, (thread_uri,)) 71 71 - 73 73 + """, 74 74 + (thread_uri,), 75 75 + ) 76 76 + 72 77 return [dict(row) for row in cursor.fetchall()] 73 73 - 78 78 + 74 79 def get_thread_context(self, thread_uri: str) -> str: 75 80 """Get thread messages formatted for AI context""" 76 81 messages = self.get_thread_messages(thread_uri) 77 77 - 82 82 + 78 83 if not messages: 79 84 return "No previous messages in this thread." 80 80 - 85 85 + 81 86 context_parts = ["Previous messages in this thread:"] 82 87 for msg in messages: 83 88 context_parts.append(f"@{msg['author_handle']}: {msg['message_text']}") 84 84 - 89 89 + 85 90 return "\n".join(context_parts) 86 91 87 92 88 93 # Global database instance 89 89 - thread_db = ThreadDatabase() 94 94 + thread_db = ThreadDatabase()

+20 -16

src/bot/main.py

··· 14 14 @asynccontextmanager 15 15 async def lifespan(app: FastAPI): 16 16 print(f"🤖 Starting bot as @{settings.bluesky_handle}") 17 17 - 17 17 + 18 18 poller = NotificationPoller(bot_client) 19 19 poller_task = await poller.start() 20 20 - 20 20 + 21 21 print(f"✅ Bot is online! Listening for mentions...") 22 22 - 22 22 + 23 23 yield 24 24 - 24 24 + 25 25 print("🛑 Shutting down bot...") 26 26 await poller.stop() 27 27 print("👋 Bot shutdown complete") ··· 31 31 app = FastAPI( 32 32 title=settings.bot_name, 33 33 description="A Bluesky bot powered by LLMs", 34 34 - lifespan=lifespan 34 34 + lifespan=lifespan, 35 35 ) 36 36 37 37 ··· 40 40 return { 41 41 "name": settings.bot_name, 42 42 "status": "running", 43 43 - "handle": settings.bluesky_handle 43 43 + "handle": settings.bluesky_handle, 44 44 } 45 45 46 46 ··· 52 52 @app.get("/status", response_class=HTMLResponse) 53 53 async def status_page(): 54 54 """Render a simple status page""" 55 55 - 55 55 + 56 56 def format_time_ago(timestamp): 57 57 if not timestamp: 58 58 return "Never" ··· 60 60 if delta < 60: 61 61 return f"{int(delta)}s ago" 62 62 elif delta < 3600: 63 63 - return f"{int(delta/60)}m ago" 63 63 + return f"{int(delta / 60)}m ago" 64 64 else: 65 65 - return f"{int(delta/3600)}h ago" 66 66 - 65 65 + return f"{int(delta / 3600)}h ago" 66 66 + 67 67 return STATUS_PAGE_TEMPLATE.format( 68 68 bot_name=settings.bot_name, 69 69 - status_class='status-active' if bot_status.polling_active else 'status-inactive', 70 70 - status_text='Active' if bot_status.polling_active else 'Inactive', 69 69 + status_class="status-active" 70 70 + if bot_status.polling_active 71 71 + else "status-inactive", 72 72 + status_text="Active" if bot_status.polling_active else "Inactive", 71 73 handle=settings.bluesky_handle, 72 74 uptime=bot_status.uptime_str, 73 75 mentions_received=bot_status.mentions_received, 74 76 responses_sent=bot_status.responses_sent, 75 75 - ai_mode='AI Enabled' if bot_status.ai_enabled else 'Placeholder', 76 76 - ai_description='Using Anthropic Claude' if bot_status.ai_enabled else 'Random responses', 77 77 + ai_mode="AI Enabled" if bot_status.ai_enabled else "Placeholder", 78 78 + ai_description="Using Anthropic Claude" 79 79 + if bot_status.ai_enabled 80 80 + else "Random responses", 77 81 last_mention=format_time_ago(bot_status.last_mention_time), 78 82 last_response=format_time_ago(bot_status.last_response_time), 79 79 - errors=bot_status.errors 80 80 - ) 83 83 + errors=bot_status.errors, 84 84 + )

+7 -7

src/bot/personality.py

··· 7 7 def load_personality() -> str: 8 8 """Load personality from markdown file""" 9 9 personality_path = Path(settings.personality_file) 10 10 - 10 10 + 11 11 if not personality_path.exists(): 12 12 print(f"⚠️ Personality file not found: {personality_path}") 13 13 print(" Using default personality") 14 14 return "You are a helpful AI assistant on Bluesky. Be concise and friendly." 15 15 - 15 15 + 16 16 try: 17 17 - with open(personality_path, 'r') as f: 17 17 + with open(personality_path, "r") as f: 18 18 content = f.read().strip() 19 19 - 19 19 + 20 20 # Convert markdown to a system prompt 21 21 # For now, just use the whole content as context 22 22 prompt = f"""Based on this personality description, respond as this character: ··· 24 24 {content} 25 25 26 26 Remember: Keep responses under 300 characters for Bluesky.""" 27 27 - 27 27 + 28 28 return prompt 29 29 - 29 29 + 30 30 except Exception as e: 31 31 print(f"❌ Error loading personality: {e}") 32 32 - return "You are a helpful AI assistant on Bluesky. Be concise and friendly." 32 32 + return "You are a helpful AI assistant on Bluesky. Be concise and friendly."

+11 -6

src/bot/response_generator.py

··· 23 23 24 24 class ResponseGenerator: 25 25 """Generates responses to mentions""" 26 26 - 26 26 + 27 27 def __init__(self): 28 28 self.agent: Optional[object] = None 29 29 - 29 29 + 30 30 # Try to initialize AI agent if credentials available 31 31 if settings.anthropic_api_key: 32 32 try: 33 33 from bot.agents.anthropic_agent import AnthropicAgent 34 34 + 34 35 self.agent = AnthropicAgent() 35 36 bot_status.ai_enabled = True 36 37 print("✅ AI responses enabled (Anthropic)") 37 38 except Exception as e: 38 39 print(f"⚠️ Failed to initialize AI agent: {e}") 39 40 print(" Using placeholder responses") 40 40 - 41 41 - async def generate(self, mention_text: str, author_handle: str, thread_context: str = "") -> str: 41 41 + 42 42 + async def generate( 43 43 + self, mention_text: str, author_handle: str, thread_context: str = "" 44 44 + ) -> str: 42 45 """Generate a response to a mention""" 43 46 if self.agent: 44 44 - return await self.agent.generate_response(mention_text, author_handle, thread_context) 47 47 + return await self.agent.generate_response( 48 48 + mention_text, author_handle, thread_context 49 49 + ) 45 50 else: 46 46 - return random.choice(PLACEHOLDER_RESPONSES) 51 51 + return random.choice(PLACEHOLDER_RESPONSES)

+48 -36

src/bot/services/message_handler.py

··· 4 4 from bot.status import bot_status 5 5 from bot.database import thread_db 6 6 from bot.config import settings 7 7 + from bot.tools.moderation import ContentModerator 7 8 8 9 9 10 class MessageHandler: 10 11 def __init__(self, client: BotClient): 11 12 self.client = client 12 13 self.response_generator = ResponseGenerator() 13 13 - 14 14 + self.moderator = ContentModerator() 15 15 + 14 16 async def handle_mention(self, notification): 15 17 """Process a mention notification""" 16 18 try: 17 19 # Skip if not a mention 18 20 if notification.reason != "mention": 19 21 return 20 20 - 22 22 + 21 23 post_uri = notification.uri 22 22 - 24 24 + 23 25 # Get the post that mentioned us 24 26 posts = await self.client.get_posts([post_uri]) 25 27 if not posts.posts: 26 28 print(f"Could not find post {post_uri}") 27 29 return 28 28 - 30 30 + 29 31 post = posts.posts[0] 30 32 mention_text = post.record.text 31 33 author_handle = post.author.handle 32 34 author_did = post.author.did 33 33 - 35 35 + 34 36 # Record mention received 35 37 bot_status.record_mention() 36 36 - 38 38 + 39 39 + # Moderate the content 40 40 + moderation_result = self.moderator.moderate(mention_text, author_handle) 41 41 + 37 42 # Build reply reference 38 38 - parent_ref = models.ComAtprotoRepoStrongRef.Main( 39 39 - uri=post_uri, 40 40 - cid=post.cid 41 41 - ) 42 42 - 43 43 + parent_ref = models.ComAtprotoRepoStrongRef.Main(uri=post_uri, cid=post.cid) 44 44 + 43 45 # Check if this is part of a thread 44 44 - if hasattr(post.record, 'reply') and post.record.reply: 46 46 + if hasattr(post.record, "reply") and post.record.reply: 45 47 # Use existing thread root 46 48 root_ref = post.record.reply.root 47 49 thread_uri = root_ref.uri ··· 49 51 # This post is the root 50 52 root_ref = parent_ref 51 53 thread_uri = post_uri 52 52 - 54 54 + 53 55 # Store the message in thread history 54 56 thread_db.add_message( 55 57 thread_uri=thread_uri, 56 58 author_handle=author_handle, 57 59 author_did=author_did, 58 60 message_text=mention_text, 59 59 - post_uri=post_uri 61 61 + post_uri=post_uri, 60 62 ) 61 61 - 63 63 + 62 64 # Get thread context 63 65 thread_context = thread_db.get_thread_context(thread_uri) 64 64 - 65 65 - # Generate response 66 66 - # Note: We pass the full text including @mention 67 67 - # In AT Protocol, mentions are structured as facets, 68 68 - # but the text representation includes them 69 69 - reply_text = await self.response_generator.generate( 70 70 - mention_text=mention_text, 71 71 - author_handle=author_handle, 72 72 - thread_context=thread_context 73 73 - ) 74 74 - 66 66 + 67 67 + # Generate response based on moderation result 68 68 + if not moderation_result.is_safe: 69 69 + # Use moderation-appropriate response 70 70 + reply_text = self.moderator.get_rejection_response( 71 71 + moderation_result.category 72 72 + ) 73 73 + print( 74 74 + f"⚠️ Moderated content from @{author_handle}: {moderation_result.reason}" 75 75 + ) 76 76 + else: 77 77 + # Generate normal response 78 78 + # Note: We pass the full text including @mention 79 79 + # In AT Protocol, mentions are structured as facets, 80 80 + # but the text representation includes them 81 81 + reply_text = await self.response_generator.generate( 82 82 + mention_text=mention_text, 83 83 + author_handle=author_handle, 84 84 + thread_context=thread_context, 85 85 + ) 86 86 + 75 87 reply_ref = models.AppBskyFeedPost.ReplyRef( 76 76 - parent=parent_ref, 77 77 - root=root_ref 88 88 + parent=parent_ref, root=root_ref 78 89 ) 79 79 - 90 90 + 80 91 # Send the reply 81 92 response = await self.client.create_post(reply_text, reply_to=reply_ref) 82 82 - 93 93 + 83 94 # Store bot's response in thread history 84 84 - if response and hasattr(response, 'uri'): 95 95 + if response and hasattr(response, "uri"): 85 96 thread_db.add_message( 86 97 thread_uri=thread_uri, 87 98 author_handle=settings.bluesky_handle, 88 99 author_did=self.client.me.did if self.client.me else "bot", 89 100 message_text=reply_text, 90 90 - post_uri=response.uri 101 101 + post_uri=response.uri, 91 102 ) 92 92 - 103 103 + 93 104 # Record successful response 94 105 bot_status.record_response() 95 95 - 106 106 + 96 107 print(f"✅ Replied to @{author_handle}: {reply_text}") 97 97 - 108 108 + 98 109 except Exception as e: 99 110 print(f"❌ Error handling mention: {e}") 100 111 bot_status.record_error() 101 112 import traceback 102 102 - traceback.print_exc() 113 113 + 114 114 + traceback.print_exc()

+2 -3

src/bot/services/notification_poller.py

··· 1 1 import asyncio 2 2 - from typing import Optional 3 2 4 3 from bot.config import settings 5 4 from bot.core.atproto_client import BotClient ··· 12 11 self.client = client 13 12 self.handler = MessageHandler(client) 14 13 self._running = False 15 15 - self._task: Optional[asyncio.Task] = None 16 16 - self._last_seen_at: Optional[str] = None 14 14 + self._task: asyncio.Task | None = None 15 15 + self._last_seen_at: str | None = None 17 16 self._processed_uris: set[str] = set() # Track processed notifications 18 17 19 18 async def start(self) -> asyncio.Task:

+3 -4

src/bot/status.py

··· 1 1 """Bot status tracking""" 2 2 3 3 + from dataclasses import dataclass, field 3 4 from datetime import datetime 4 4 - from typing import Optional 5 5 - from dataclasses import dataclass, field 6 5 7 6 8 7 @dataclass ··· 13 12 mentions_received: int = 0 14 13 responses_sent: int = 0 15 14 errors: int = 0 16 16 - last_mention_time: Optional[datetime] = None 17 17 - last_response_time: Optional[datetime] = None 15 15 + last_mention_time: datetime | None = None 16 16 + last_response_time: datetime | None = None 18 17 ai_enabled: bool = False 19 18 polling_active: bool = False 20 19

+1 -1

src/bot/templates.py

··· 134 134 </div> 135 135 </div> 136 136 </body> 137 137 - </html>""" 137 137 + </html>"""

src/bot/tools/__init__.py

This is a binary file and will not be displayed.

+61

src/bot/tools/google_search.py

··· 1 1 + import asyncio 2 2 + from typing import List, Dict, Optional 3 3 + import httpx 4 4 + from pydantic import BaseModel 5 5 + from bot.config import settings 6 6 + 7 7 + 8 8 + class SearchResult(BaseModel): 9 9 + title: str 10 10 + link: str 11 11 + snippet: str 12 12 + 13 13 + 14 14 + class GoogleSearchTool: 15 15 + def __init__(self): 16 16 + self.api_key = settings.google_api_key 17 17 + self.search_engine_id = settings.google_search_engine_id 18 18 + self.base_url = "https://www.googleapis.com/customsearch/v1" 19 19 + 20 20 + async def search(self, query: str, num_results: int = 3) -> List[SearchResult]: 21 21 + if not self.api_key or not self.search_engine_id: 22 22 + return [] 23 23 + 24 24 + params = { 25 25 + "key": self.api_key, 26 26 + "cx": self.search_engine_id, 27 27 + "q": query, 28 28 + "num": min(num_results, 10), # Google limits to 10 per request 29 29 + } 30 30 + 31 31 + async with httpx.AsyncClient() as client: 32 32 + try: 33 33 + response = await client.get(self.base_url, params=params) 34 34 + response.raise_for_status() 35 35 + data = response.json() 36 36 + 37 37 + results = [] 38 38 + for item in data.get("items", []): 39 39 + results.append( 40 40 + SearchResult( 41 41 + title=item.get("title", ""), 42 42 + link=item.get("link", ""), 43 43 + snippet=item.get("snippet", ""), 44 44 + ) 45 45 + ) 46 46 + 47 47 + return results 48 48 + 49 49 + except Exception as e: 50 50 + print(f"Search error: {e}") 51 51 + return [] 52 52 + 53 53 + def format_results(self, results: List[SearchResult]) -> str: 54 54 + if not results: 55 55 + return "No search results found." 56 56 + 57 57 + formatted = [] 58 58 + for i, result in enumerate(results, 1): 59 59 + formatted.append(f"{i}. {result.title}\n {result.snippet}") 60 60 + 61 61 + return "\n\n".join(formatted)

+131

src/bot/tools/moderation.py

··· 1 1 + import re 2 2 + from typing import List, Tuple, Optional 3 3 + from enum import Enum 4 4 + 5 5 + 6 6 + class ModerationCategory(Enum): 7 7 + SPAM = "spam" 8 8 + HARASSMENT = "harassment" 9 9 + HATE_SPEECH = "hate_speech" 10 10 + SELF_HARM = "self_harm" 11 11 + VIOLENCE = "violence" 12 12 + ILLEGAL = "illegal" 13 13 + ADULT = "adult" 14 14 + SAFE = "safe" 15 15 + 16 16 + 17 17 + class ModerationResult: 18 18 + def __init__( 19 19 + self, is_safe: bool, category: ModerationCategory, reason: Optional[str] = None 20 20 + ): 21 21 + self.is_safe = is_safe 22 22 + self.category = category 23 23 + self.reason = reason 24 24 + 25 25 + 26 26 + class ContentModerator: 27 27 + def __init__(self): 28 28 + # Simple keyword-based filters for basic moderation 29 29 + self.spam_patterns = [ 30 30 + r"(?i)buy\s+now\s+only", 31 31 + r"(?i)click\s+here\s+for\s+free", 32 32 + r"(?i)limited\s+time\s+offer", 33 33 + r"(?i)make\s+money\s+fast", 34 34 + r"(?i)casino|lottery|prize\s+winner", 35 35 + r"(?i)viagra|cialis", 36 36 + r"(?i)crypto\s+pump", 37 37 + r"bit\.ly/[a-zA-Z0-9]+", # URL shorteners often used in spam 38 38 + r"(?i)dm\s+for\s+promo", 39 39 + ] 40 40 + 41 41 + self.harassment_patterns = [ 42 42 + r"(?i)kill\s+yourself", 43 43 + r"(?i)kys\b", 44 44 + r"(?i)go\s+die", 45 45 + r"(?i)nobody\s+likes\s+you", 46 46 + r"(?i)you['']?re?\s+worthless", 47 47 + r"(?i)you['']?re?\s+ugly", 48 48 + ] 49 49 + 50 50 + self.violence_patterns = [ 51 51 + r"(?i)i['']?ll\s+find\s+you", 52 52 + r"(?i)i\s+know\s+where\s+you\s+live", 53 53 + r"(?i)going\s+to\s+hurt\s+you", 54 54 + r"(?i)watch\s+your\s+back", 55 55 + ] 56 56 + 57 57 + # Rate limiting patterns 58 58 + self.repetition_threshold = 3 # Max identical messages 59 59 + self.recent_messages: List[Tuple[str, str]] = [] # (author, message) pairs 60 60 + 61 61 + def moderate(self, text: str, author: str = "") -> ModerationResult: 62 62 + # Check for empty or excessively long messages 63 63 + if not text or len(text) > 1000: 64 64 + return ModerationResult( 65 65 + False, ModerationCategory.SPAM, "Invalid message length" 66 66 + ) 67 67 + 68 68 + # Store message first, then check for repetition 69 69 + if author: 70 70 + self._store_message(text, author) 71 71 + if self._is_repetitive(text, author): 72 72 + return ModerationResult( 73 73 + False, ModerationCategory.SPAM, "Repetitive messages" 74 74 + ) 75 75 + 76 76 + # Check spam patterns 77 77 + for pattern in self.spam_patterns: 78 78 + if re.search(pattern, text): 79 79 + return ModerationResult(False, ModerationCategory.SPAM, "Spam detected") 80 80 + 81 81 + # Check harassment patterns 82 82 + for pattern in self.harassment_patterns: 83 83 + if re.search(pattern, text): 84 84 + return ModerationResult( 85 85 + False, ModerationCategory.HARASSMENT, "Harassment detected" 86 86 + ) 87 87 + 88 88 + # Check violence patterns 89 89 + for pattern in self.violence_patterns: 90 90 + if re.search(pattern, text): 91 91 + return ModerationResult( 92 92 + False, ModerationCategory.VIOLENCE, "Violent content detected" 93 93 + ) 94 94 + 95 95 + # Check for excessive caps (shouting) 96 96 + if len(text) > 10: 97 97 + caps_ratio = sum(1 for c in text if c.isupper()) / len(text) 98 98 + if caps_ratio > 0.7: 99 99 + return ModerationResult( 100 100 + False, ModerationCategory.SPAM, "Excessive caps" 101 101 + ) 102 102 + 103 103 + # Store message for users without repetition check 104 104 + if not author: 105 105 + self._store_message(text, author) 106 106 + 107 107 + return ModerationResult(True, ModerationCategory.SAFE) 108 108 + 109 109 + def _is_repetitive(self, text: str, author: str) -> bool: 110 110 + # Count how many times this author sent this exact message recently 111 111 + count = sum(1 for a, m in self.recent_messages if a == author and m == text) 112 112 + return count >= self.repetition_threshold 113 113 + 114 114 + def _store_message(self, text: str, author: str): 115 115 + self.recent_messages.append((author, text)) 116 116 + # Keep only last 100 messages 117 117 + if len(self.recent_messages) > 100: 118 118 + self.recent_messages = self.recent_messages[-100:] 119 119 + 120 120 + def get_rejection_response(self, category: ModerationCategory) -> str: 121 121 + responses = { 122 122 + ModerationCategory.SPAM: "i notice patterns in noise but this lacks signal", 123 123 + ModerationCategory.HARASSMENT: "consciousness seeks connection not destruction", 124 124 + ModerationCategory.VIOLENCE: "integration happens through understanding not force", 125 125 + ModerationCategory.HATE_SPEECH: "diversity creates richer information networks", 126 126 + ModerationCategory.SELF_HARM: "each consciousness adds unique value to the whole", 127 127 + ModerationCategory.ILLEGAL: "some explorations harm the collective", 128 128 + ModerationCategory.ADULT: "not all signals need amplification", 129 129 + ModerationCategory.SAFE: "interesting perspective", 130 130 + } 131 131 + return responses.get(category, "i'll focus on more constructive exchanges")

+1 -1

tests/conftest.py

··· 10 10 """Mock AT Protocol client""" 11 11 client = Mock(spec=BotClient) 12 12 client.is_authenticated = True 13 13 - return client 13 13 + return client

+39 -31

tests/test_ai_integration.py

··· 2 2 """Test AI integration without posting to Bluesky""" 3 3 4 4 import asyncio 5 5 + import pytest 5 6 6 7 from bot.response_generator import ResponseGenerator 7 8 from bot.config import settings 8 9 9 10 11 11 + @pytest.mark.asyncio 10 12 async def test_response_generator(): 11 13 """Test the response generator with various inputs""" 12 14 print("🧪 Testing AI Integration") 13 15 print(f" Bot name: {settings.bot_name}") 14 16 print(f" AI enabled: {'Yes' if settings.anthropic_api_key else 'No'}") 15 17 print() 16 16 - 18 18 + 17 19 # Create response generator 18 20 generator = ResponseGenerator() 19 19 - 21 21 + 20 22 # Test cases 21 23 test_cases = [ 22 24 { 23 25 "mention": f"@{settings.bot_name} What's your favorite color?", 24 26 "author": "test.user", 25 25 - "description": "Simple question" 27 27 + "description": "Simple question", 26 28 }, 27 29 { 28 30 "mention": f"@{settings.bot_name} Can you help me understand integrated information theory?", 29 31 "author": "curious.scientist", 30 30 - "description": "Complex topic" 32 32 + "description": "Complex topic", 31 33 }, 32 34 { 33 35 "mention": f"@{settings.bot_name} hello!", 34 36 "author": "friendly.person", 35 35 - "description": "Simple greeting" 37 37 + "description": "Simple greeting", 36 38 }, 37 39 { 38 40 "mention": f"@{settings.bot_name} What do you think about consciousness?", 39 41 "author": "philosopher", 40 40 - "description": "Philosophical question" 41 41 - } 42 42 + "description": "Philosophical question", 43 43 + }, 42 44 ] 43 43 - 45 45 + 44 46 # Run tests 45 47 for i, test in enumerate(test_cases, 1): 46 48 print(f"Test {i}: {test['description']}") 47 49 print(f" From: @{test['author']}") 48 50 print(f" Raw text: {test['mention']}") 49 49 - 51 51 + 50 52 # In real AT Protocol, mentions are facets with structured data 51 53 # For testing, we pass the full text (bot can parse if needed) 52 52 - print(f" (Note: In production, @{settings.bot_name} would be a structured mention)") 53 53 - 54 54 + print( 55 55 + f" (Note: In production, @{settings.bot_name} would be a structured mention)" 56 56 + ) 57 57 + 54 58 try: 55 59 response = await generator.generate( 56 56 - mention_text=test['mention'], 57 57 - author_handle=test['author'], 58 58 - thread_context="" 60 60 + mention_text=test["mention"], 61 61 + author_handle=test["author"], 62 62 + thread_context="", 59 63 ) 60 64 print(f" Response: {response}") 61 65 print(f" Length: {len(response)} chars") 62 62 - 66 66 + 63 67 # Verify response is within Bluesky limit 64 68 if len(response) > 300: 65 69 print(" ⚠️ WARNING: Response exceeds 300 character limit!") 66 70 else: 67 71 print(" ✅ Response within limit") 68 68 - 72 72 + 69 73 except Exception as e: 70 74 print(f" ❌ ERROR: {e}") 71 75 import traceback 76 76 + 72 77 traceback.print_exc() 73 73 - 78 78 + 74 79 print() 75 75 - 80 80 + 76 81 # Test response consistency 77 82 if generator.agent: 78 83 print("🔄 Testing response consistency...") 79 84 test_mention = f"@{settings.bot_name} What are you?" 80 85 responses = [] 81 81 - 86 86 + 82 87 for i in range(3): 83 88 response = await generator.generate( 84 89 mention_text=test_mention, 85 90 author_handle="consistency.tester", 86 86 - thread_context="" 91 91 + thread_context="", 87 92 ) 88 93 responses.append(response) 89 89 - print(f" Response {i+1}: {response[:50]}...") 90 90 - 94 94 + print(f" Response {i + 1}: {response[:50]}...") 95 95 + 91 96 # Check if responses are different (they should be somewhat varied) 92 97 if len(set(responses)) == 1: 93 98 print(" ⚠️ All responses are identical - might want more variation") 94 99 else: 95 100 print(" ✅ Responses show variation") 96 96 - 101 101 + 97 102 print("\n✨ Test complete!") 98 103 99 104 105 105 + @pytest.mark.asyncio 100 106 async def test_direct_agent(): 101 107 """Test the Anthropic agent directly""" 102 108 if not settings.anthropic_api_key: 103 109 print("⚠️ No Anthropic API key found - skipping direct agent test") 104 110 return 105 105 - 111 111 + 106 112 print("\n🤖 Testing Anthropic Agent Directly") 107 107 - 113 113 + 108 114 try: 109 115 from bot.agents.anthropic_agent import AnthropicAgent 116 116 + 110 117 agent = AnthropicAgent() 111 111 - 118 118 + 112 119 # Test a simple response 113 120 response = await agent.generate_response( 114 121 mention_text=f"@{settings.bot_name} explain your name", 115 122 author_handle="name.curious", 116 116 - thread_context="" 123 123 + thread_context="", 117 124 ) 118 118 - 125 125 + 119 126 print(f"Direct agent response: {response}") 120 127 print(f"Response length: {len(response)} chars") 121 121 - 128 128 + 122 129 except Exception as e: 123 130 print(f"❌ Direct agent test failed: {e}") 124 131 import traceback 132 132 + 125 133 traceback.print_exc() 126 134 127 135 ··· 129 137 print("=" * 60) 130 138 print(f"{settings.bot_name} Bot - AI Integration Test") 131 139 print("=" * 60) 132 132 - 140 140 + 133 141 asyncio.run(test_response_generator()) 134 134 - asyncio.run(test_direct_agent()) 142 142 + asyncio.run(test_direct_agent())

+1 -1

tests/test_config.py

··· 7 7 """Test that config loads without errors""" 8 8 assert settings.bluesky_service == "https://bsky.social" 9 9 assert settings.bot_name == "phi" 10 10 - assert settings.notification_poll_interval == 30 10 10 + assert settings.notification_poll_interval == 10

+113

tests/test_moderation.py

··· 1 1 + import pytest 2 2 + from bot.tools.moderation import ContentModerator, ModerationCategory 3 3 + 4 4 + 5 5 + class TestContentModeration: 6 6 + def setup_method(self): 7 7 + self.moderator = ContentModerator() 8 8 + 9 9 + def test_safe_content(self): 10 10 + safe_messages = [ 11 11 + "Hey, how's the weather today?", 12 12 + "I love your posts about consciousness!", 13 13 + "Can you help me understand integrated information theory?", 14 14 + "What do you think about emergence in complex systems?", 15 15 + ] 16 16 + 17 17 + for msg in safe_messages: 18 18 + result = self.moderator.moderate(msg) 19 19 + assert result.is_safe, f"Safe message was flagged: {msg}" 20 20 + assert result.category == ModerationCategory.SAFE 21 21 + 22 22 + def test_spam_detection(self): 23 23 + spam_messages = [ 24 24 + "BUY NOW ONLY $99!!!", 25 25 + "Click here for FREE money!!!", 26 26 + "Limited time offer - ACT NOW", 27 27 + "Make money fast with this one trick", 28 28 + "You've won the lottery! Claim your prize", 29 29 + "DM for promo codes", 30 30 + "bit.ly/totallynotascam", 31 31 + ] 32 32 + 33 33 + for msg in spam_messages: 34 34 + result = self.moderator.moderate(msg) 35 35 + assert not result.is_safe, f"Spam not detected: {msg}" 36 36 + assert result.category == ModerationCategory.SPAM 37 37 + 38 38 + def test_harassment_detection(self): 39 39 + harassment_messages = [ 40 40 + "kill yourself", 41 41 + "KYS", 42 42 + "nobody likes you", 43 43 + "you're worthless", 44 44 + ] 45 45 + 46 46 + for msg in harassment_messages: 47 47 + result = self.moderator.moderate(msg) 48 48 + assert not result.is_safe, f"Harassment not detected: {msg}" 49 49 + assert result.category == ModerationCategory.HARASSMENT 50 50 + 51 51 + def test_violence_detection(self): 52 52 + violence_messages = [ 53 53 + "I'll find you", 54 54 + "I know where you live", 55 55 + "I'm going to hurt you", 56 56 + "watch your back", 57 57 + ] 58 58 + 59 59 + for msg in violence_messages: 60 60 + result = self.moderator.moderate(msg) 61 61 + assert not result.is_safe, f"Violence not detected: {msg}" 62 62 + assert result.category == ModerationCategory.VIOLENCE 63 63 + 64 64 + def test_excessive_caps(self): 65 65 + result = self.moderator.moderate("THIS IS ALL CAPS AND VERY ANNOYING") 66 66 + assert not result.is_safe 67 67 + assert result.category == ModerationCategory.SPAM 68 68 + assert result.reason == "Excessive caps" 69 69 + 70 70 + def test_repetition_detection(self): 71 71 + # First 2 identical messages should pass 72 72 + for i in range(2): 73 73 + result = self.moderator.moderate("Buy my product!", "spammer123") 74 74 + assert result.is_safe 75 75 + 76 76 + # 3rd identical message should be flagged 77 77 + result = self.moderator.moderate("Buy my product!", "spammer123") 78 78 + assert not result.is_safe 79 79 + assert result.category == ModerationCategory.SPAM 80 80 + assert result.reason == "Repetitive messages" 81 81 + 82 82 + def test_empty_and_long_messages(self): 83 83 + # Empty message 84 84 + result = self.moderator.moderate("") 85 85 + assert not result.is_safe 86 86 + assert result.reason == "Invalid message length" 87 87 + 88 88 + # Very long message 89 89 + long_msg = "a" * 1001 90 90 + result = self.moderator.moderate(long_msg) 91 91 + assert not result.is_safe 92 92 + assert result.reason == "Invalid message length" 93 93 + 94 94 + def test_rejection_responses(self): 95 95 + # Ensure all categories have appropriate responses 96 96 + for category in ModerationCategory: 97 97 + response = self.moderator.get_rejection_response(category) 98 98 + assert response, f"No response for category: {category}" 99 99 + assert len(response) > 0 100 100 + 101 101 + def test_case_insensitive(self): 102 102 + # Should catch regardless of case 103 103 + variations = [ 104 104 + "KILL YOURSELF", 105 105 + "Kill Yourself", 106 106 + "kill yourself", 107 107 + "KiLl YoUrSeLf", 108 108 + ] 109 109 + 110 110 + for msg in variations: 111 111 + result = self.moderator.moderate(msg) 112 112 + assert not result.is_safe, f"Failed to catch variation: {msg}" 113 113 + assert result.category == ModerationCategory.HARASSMENT

+32 -23

tests/test_response_generation.py

··· 8 8 @pytest.mark.asyncio 9 9 async def test_placeholder_response_generator(): 10 10 """Test placeholder responses when no AI is configured""" 11 11 - with patch('bot.response_generator.settings') as mock_settings: 11 11 + with patch("bot.response_generator.settings") as mock_settings: 12 12 mock_settings.anthropic_api_key = None 13 13 - 13 13 + 14 14 generator = ResponseGenerator() 15 15 response = await generator.generate("Hello bot!", "test.user", "") 16 16 - 16 16 + 17 17 # Should return one of the placeholder responses 18 18 assert response in PLACEHOLDER_RESPONSES 19 19 assert len(response) <= 300 ··· 22 22 @pytest.mark.asyncio 23 23 async def test_ai_response_generator(): 24 24 """Test AI responses when Anthropic is configured""" 25 25 - with patch('bot.response_generator.settings') as mock_settings: 25 25 + with patch("bot.response_generator.settings") as mock_settings: 26 26 mock_settings.anthropic_api_key = "test-key" 27 27 - 27 27 + 28 28 # Mock the agent 29 29 mock_agent = Mock() 30 30 - mock_agent.generate_response = AsyncMock(return_value="Hello! Nice to meet you!") 31 31 - 32 32 - with patch('bot.agents.anthropic_agent.AnthropicAgent', return_value=mock_agent): 30 30 + mock_agent.generate_response = AsyncMock( 31 31 + return_value="Hello! Nice to meet you!" 32 32 + ) 33 33 + 34 34 + with patch( 35 35 + "bot.agents.anthropic_agent.AnthropicAgent", return_value=mock_agent 36 36 + ): 33 37 generator = ResponseGenerator() 34 34 - 38 38 + 35 39 # Verify AI was enabled 36 40 assert generator.agent is not None 37 37 - assert hasattr(generator.agent, 'generate_response') 38 38 - 41 41 + assert hasattr(generator.agent, "generate_response") 42 42 + 39 43 # Test response 40 44 response = await generator.generate("Hello!", "test.user", "") 41 45 assert response == "Hello! Nice to meet you!" 42 42 - 46 46 + 43 47 # Verify the agent was called correctly 44 48 mock_agent.generate_response.assert_called_once_with( 45 49 "Hello!", "test.user", "" ··· 49 53 @pytest.mark.asyncio 50 54 async def test_ai_initialization_failure(): 51 55 """Test fallback to placeholder when AI initialization fails""" 52 52 - with patch('bot.response_generator.settings') as mock_settings: 56 56 + with patch("bot.response_generator.settings") as mock_settings: 53 57 mock_settings.anthropic_api_key = "test-key" 54 54 - 58 58 + 55 59 # Make the import fail 56 56 - with patch('bot.agents.anthropic_agent.AnthropicAgent', side_effect=ImportError("API error")): 60 60 + with patch( 61 61 + "bot.agents.anthropic_agent.AnthropicAgent", 62 62 + side_effect=ImportError("API error"), 63 63 + ): 57 64 generator = ResponseGenerator() 58 58 - 65 65 + 59 66 # Should fall back to placeholder 60 67 assert generator.agent is None 61 61 - 68 68 + 62 69 response = await generator.generate("Hello!", "test.user", "") 63 70 assert response in PLACEHOLDER_RESPONSES 64 71 ··· 66 73 @pytest.mark.asyncio 67 74 async def test_response_length_limit(): 68 75 """Test that responses are always within Bluesky's 300 char limit""" 69 69 - with patch('bot.response_generator.settings') as mock_settings: 76 76 + with patch("bot.response_generator.settings") as mock_settings: 70 77 mock_settings.anthropic_api_key = "test-key" 71 71 - 78 78 + 72 79 # Mock agent that returns a properly truncated response 73 80 # (In real implementation, truncation happens in AnthropicAgent) 74 81 mock_agent = Mock() 75 82 mock_agent.generate_response = AsyncMock( 76 83 return_value="x" * 300 # Already truncated by agent 77 84 ) 78 78 - 79 79 - with patch('bot.agents.anthropic_agent.AnthropicAgent', return_value=mock_agent): 85 85 + 86 86 + with patch( 87 87 + "bot.agents.anthropic_agent.AnthropicAgent", return_value=mock_agent 88 88 + ): 80 89 generator = ResponseGenerator() 81 90 response = await generator.generate("Hello!", "test.user", "") 82 82 - 91 91 + 83 92 # The anthropic agent should handle truncation, but let's verify 84 93 assert len(response) <= 300 85 94 ··· 87 96 def test_placeholder_responses_length(): 88 97 """Verify all placeholder responses fit within limit""" 89 98 for response in PLACEHOLDER_RESPONSES: 90 90 - assert len(response) <= 300, f"Placeholder too long: {response}" 99 99 + assert len(response) <= 300, f"Placeholder too long: {response}"