+1

.gitignore

··· 36 36 .eggs/ 37 37 logs/ 38 38 *.log 39 39 + threads.db

-32

MIGRATION.md

··· 1 1 - # Migration Notes 2 2 - 3 3 - ## Personality System Change 4 4 - 5 5 - The bot personality system has changed from a simple string to markdown files. 6 6 - 7 7 - ### What Changed 8 8 - 9 9 - - Removed: `BOT_PERSONALITY` environment variable 10 10 - - Added: `PERSONALITY_FILE` environment variable pointing to a markdown file 11 11 - 12 12 - ### How to Migrate 13 13 - 14 14 - 1. Remove `BOT_PERSONALITY` from your `.env` file (optional - it will be ignored) 15 15 - 2. Add `PERSONALITY_FILE=personalities/phi.md` (or your custom file) 16 16 - 3. Create your personality markdown file in `personalities/` 17 17 - 18 18 - Note: The Settings class now ignores extra fields, so old `.env` files won't cause errors. 19 19 - 20 20 - ### Example 21 21 - 22 22 - Old `.env`: 23 23 - ``` 24 24 - BOT_NAME=phi 25 25 - BOT_PERSONALITY=helpful and friendly 26 26 - ``` 27 27 - 28 28 - New `.env`: 29 29 - ``` 30 30 - BOT_NAME=phi 31 31 - PERSONALITY_FILE=personalities/phi.md 32 32 - ```

+19 -18

STATUS.md

··· 25 25 - Local URI cache (`_processed_uris`) as safety net 26 26 - No @mention in replies (Bluesky handles notification automatically) 27 27 28 28 - ### Near-Term Roadmap 28 28 + ### Current Focus: AI Responses with Thread Context 29 29 + 30 30 + The immediate goal is to get AI responses working with full thread history in context. This means: 29 31 30 30 - #### Phase 1: AI Integration (Current Focus) 31 31 - 1. **Add pydantic-ai with Anthropic provider** 32 32 - - Use Anthropic as the LLM provider (Mac subscription available) 33 33 - - Redesign ResponseGenerator protocol to be more general/sensible 34 34 - - Implement AI-based response generation 32 32 + 1. **Thread History** - Store and retrieve conversation history per thread 33 33 + - SQLite for simple thread storage (like Marvin) 34 34 + - Pass full thread context to AI 35 35 + 36 36 + 2. **AI Integration** - Working Anthropic responses with personality 37 37 + - ✅ Basic pydantic-ai integration 38 38 + - ✅ Personality loaded from markdown 39 39 + - 🚧 Thread-aware responses 35 40 36 36 - 2. **Self-Modification Capability** 37 37 - - Build in ability to edit own personality/profile from the start 38 38 - - Similar to Void's self-editing and Penelope's profile updates 39 39 - - Essential foundation before adding memory systems 41 41 + 3. **Better DX** - Learn from Marvin's patterns 42 42 + - Dynamic system prompts with context 43 43 + - Clean agent/tool architecture 40 44 41 41 - #### Phase 2: Memory & Persistence 42 42 - 1. Add turbopuffer for vector memory 43 43 - 2. Build 3-tier memory system (like Void) 44 44 - 3. User-specific memory contexts 45 45 + ### Future Work 45 46 46 46 - #### Phase 3: Personality & Behavior 47 47 - 1. Design bot persona and system prompts 48 48 - 2. Implement conversation styles 49 49 - 3. Add behavioral consistency 47 47 + After thread context is working: 48 48 + - TurboPuffer for vector memory (user facts, etc) 49 49 + - Self-modification capabilities 50 50 + - Multi-tier memory system 50 51 51 52 ## Key Decisions to Make 52 53 - Which LLM provider to use (OpenAI, Anthropic, etc.)

+1

pyproject.toml

··· 20 20 [tool.uv] 21 21 dev-dependencies = [ 22 22 "pytest>=8.0.0", 23 23 + "pytest-asyncio>=0.24.0", 23 24 "ruff>=0.8.0", 24 25 "ty", 25 26 ]

+11 -2

src/bot/agents/anthropic_agent.py

··· 27 27 result_type=Response, 28 28 ) 29 29 30 30 - async def generate_response(self, mention_text: str, author_handle: str) -> str: 30 30 + async def generate_response(self, mention_text: str, author_handle: str, thread_context: str = "") -> str: 31 31 """Generate a response to a mention""" 32 32 - prompt = f"{author_handle} said: {mention_text}" 32 32 + # Build the full prompt with thread context 33 33 + prompt_parts = [] 34 34 + 35 35 + if thread_context and thread_context != "No previous messages in this thread.": 36 36 + prompt_parts.append(thread_context) 37 37 + prompt_parts.append("\nNew message:") 38 38 + 39 39 + prompt_parts.append(f"{author_handle} said: {mention_text}") 40 40 + 41 41 + prompt = "\n".join(prompt_parts) 33 42 result = await self.agent.run(prompt) 34 43 return result.data.text[:300]

+89

src/bot/database.py

··· 1 1 + """Simple SQLite database for storing thread history""" 2 2 + 3 3 + import json 4 4 + import sqlite3 5 5 + from pathlib import Path 6 6 + from typing import List, Dict, Any 7 7 + from contextlib import contextmanager 8 8 + 9 9 + 10 10 + class ThreadDatabase: 11 11 + """Simple database for storing Bluesky thread conversations""" 12 12 + 13 13 + def __init__(self, db_path: Path = Path("threads.db")): 14 14 + self.db_path = db_path 15 15 + self._init_db() 16 16 + 17 17 + def _init_db(self): 18 18 + """Initialize database schema""" 19 19 + with self._get_connection() as conn: 20 20 + conn.execute(""" 21 21 + CREATE TABLE IF NOT EXISTS thread_messages ( 22 22 + id INTEGER PRIMARY KEY AUTOINCREMENT, 23 23 + thread_uri TEXT NOT NULL, 24 24 + author_handle TEXT NOT NULL, 25 25 + author_did TEXT NOT NULL, 26 26 + message_text TEXT NOT NULL, 27 27 + post_uri TEXT NOT NULL UNIQUE, 28 28 + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP 29 29 + ) 30 30 + """) 31 31 + conn.execute(""" 32 32 + CREATE INDEX IF NOT EXISTS idx_thread_uri 33 33 + ON thread_messages(thread_uri) 34 34 + """) 35 35 + 36 36 + @contextmanager 37 37 + def _get_connection(self): 38 38 + """Get database connection""" 39 39 + conn = sqlite3.connect(self.db_path) 40 40 + conn.row_factory = sqlite3.Row 41 41 + try: 42 42 + yield conn 43 43 + conn.commit() 44 44 + finally: 45 45 + conn.close() 46 46 + 47 47 + def add_message( 48 48 + self, 49 49 + thread_uri: str, 50 50 + author_handle: str, 51 51 + author_did: str, 52 52 + message_text: str, 53 53 + post_uri: str 54 54 + ): 55 55 + """Add a message to a thread""" 56 56 + with self._get_connection() as conn: 57 57 + conn.execute(""" 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]]: 64 64 + """Get all messages in a thread, ordered chronologically""" 65 65 + with self._get_connection() as conn: 66 66 + cursor = conn.execute(""" 67 67 + SELECT * FROM thread_messages 68 68 + WHERE thread_uri = ? 69 69 + ORDER BY created_at ASC 70 70 + """, (thread_uri,)) 71 71 + 72 72 + return [dict(row) for row in cursor.fetchall()] 73 73 + 74 74 + def get_thread_context(self, thread_uri: str) -> str: 75 75 + """Get thread messages formatted for AI context""" 76 76 + messages = self.get_thread_messages(thread_uri) 77 77 + 78 78 + if not messages: 79 79 + return "No previous messages in this thread." 80 80 + 81 81 + context_parts = ["Previous messages in this thread:"] 82 82 + for msg in messages: 83 83 + context_parts.append(f"@{msg['author_handle']}: {msg['message_text']}") 84 84 + 85 85 + return "\n".join(context_parts) 86 86 + 87 87 + 88 88 + # Global database instance 89 89 + thread_db = ThreadDatabase()

+2 -2

src/bot/response_generator.py

··· 38 38 print(f"⚠️ Failed to initialize AI agent: {e}") 39 39 print(" Using placeholder responses") 40 40 41 41 - async def generate(self, mention_text: str, author_handle: str) -> str: 41 41 + async def generate(self, mention_text: str, author_handle: str, thread_context: str = "") -> str: 42 42 """Generate a response to a mention""" 43 43 if self.agent: 44 44 - return await self.agent.generate_response(mention_text, author_handle) 44 44 + return await self.agent.generate_response(mention_text, author_handle, thread_context) 45 45 else: 46 46 return random.choice(PLACEHOLDER_RESPONSES)

+38 -10

src/bot/services/message_handler.py

··· 2 2 from bot.core.atproto_client import BotClient 3 3 from bot.response_generator import ResponseGenerator 4 4 from bot.status import bot_status 5 5 + from bot.database import thread_db 6 6 + from bot.config import settings 5 7 6 8 7 9 class MessageHandler: ··· 27 29 post = posts.posts[0] 28 30 mention_text = post.record.text 29 31 author_handle = post.author.handle 32 32 + author_did = post.author.did 30 33 31 34 # Record mention received 32 35 bot_status.record_mention() 33 33 - 34 34 - # Generate response 35 35 - # Note: We pass the full text including @mention 36 36 - # In AT Protocol, mentions are structured as facets, 37 37 - # but the text representation includes them 38 38 - reply_text = await self.response_generator.generate( 39 39 - mention_text=mention_text, 40 40 - author_handle=author_handle 41 41 - ) 42 36 43 37 # Build reply reference 44 38 parent_ref = models.ComAtprotoRepoStrongRef.Main( ··· 50 44 if hasattr(post.record, 'reply') and post.record.reply: 51 45 # Use existing thread root 52 46 root_ref = post.record.reply.root 47 47 + thread_uri = root_ref.uri 53 48 else: 54 49 # This post is the root 55 50 root_ref = parent_ref 51 51 + thread_uri = post_uri 52 52 + 53 53 + # Store the message in thread history 54 54 + thread_db.add_message( 55 55 + thread_uri=thread_uri, 56 56 + author_handle=author_handle, 57 57 + author_did=author_did, 58 58 + message_text=mention_text, 59 59 + post_uri=post_uri 60 60 + ) 61 61 + 62 62 + # Get thread context 63 63 + 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 + ) 56 74 57 75 reply_ref = models.AppBskyFeedPost.ReplyRef( 58 76 parent=parent_ref, ··· 60 78 ) 61 79 62 80 # Send the reply 63 63 - await self.client.create_post(reply_text, reply_to=reply_ref) 81 81 + response = await self.client.create_post(reply_text, reply_to=reply_ref) 82 82 + 83 83 + # Store bot's response in thread history 84 84 + if response and hasattr(response, 'uri'): 85 85 + thread_db.add_message( 86 86 + thread_uri=thread_uri, 87 87 + author_handle=settings.bluesky_handle, 88 88 + author_did=self.client.me.did if self.client.me else "bot", 89 89 + message_text=reply_text, 90 90 + post_uri=response.uri 91 91 + ) 64 92 65 93 # Record successful response 66 94 bot_status.record_response()

+6 -3

tests/test_ai_integration.py

··· 54 54 try: 55 55 response = await generator.generate( 56 56 mention_text=test['mention'], 57 57 - author_handle=test['author'] 57 57 + author_handle=test['author'], 58 58 + thread_context="" 58 59 ) 59 60 print(f" Response: {response}") 60 61 print(f" Length: {len(response)} chars") ··· 81 82 for i in range(3): 82 83 response = await generator.generate( 83 84 mention_text=test_mention, 84 84 - author_handle="consistency.tester" 85 85 + author_handle="consistency.tester", 86 86 + thread_context="" 85 87 ) 86 88 responses.append(response) 87 89 print(f" Response {i+1}: {response[:50]}...") ··· 110 112 # Test a simple response 111 113 response = await agent.generate_response( 112 114 mention_text=f"@{settings.bot_name} explain your name", 113 113 - author_handle="name.curious" 115 115 + author_handle="name.curious", 116 116 + thread_context="" 114 117 ) 115 118 116 119 print(f"Direct agent response: {response}")

+11 -11

tests/test_response_generation.py

··· 12 12 mock_settings.anthropic_api_key = None 13 13 14 14 generator = ResponseGenerator() 15 15 - response = await generator.generate("Hello bot!", "test.user") 15 15 + response = await generator.generate("Hello bot!", "test.user", "") 16 16 17 17 # Should return one of the placeholder responses 18 18 assert response in PLACEHOLDER_RESPONSES ··· 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.response_generator.AnthropicAgent', return_value=mock_agent): 32 32 + with patch('bot.agents.anthropic_agent.AnthropicAgent', return_value=mock_agent): 33 33 generator = ResponseGenerator() 34 34 35 35 # Verify AI was enabled ··· 37 37 assert hasattr(generator.agent, 'generate_response') 38 38 39 39 # Test response 40 40 - response = await generator.generate("Hello!", "test.user") 40 40 + response = await generator.generate("Hello!", "test.user", "") 41 41 assert response == "Hello! Nice to meet you!" 42 42 43 43 # Verify the agent was called correctly 44 44 mock_agent.generate_response.assert_called_once_with( 45 45 - mention_text="Hello!", 46 46 - author_handle="test.user" 45 45 + "Hello!", "test.user", "" 47 46 ) 48 47 49 48 ··· 54 53 mock_settings.anthropic_api_key = "test-key" 55 54 56 55 # Make the import fail 57 57 - with patch('bot.response_generator.AnthropicAgent', side_effect=ImportError("API error")): 56 56 + with patch('bot.agents.anthropic_agent.AnthropicAgent', side_effect=ImportError("API error")): 58 57 generator = ResponseGenerator() 59 58 60 59 # Should fall back to placeholder 61 60 assert generator.agent is None 62 61 63 63 - response = await generator.generate("Hello!", "test.user") 62 62 + response = await generator.generate("Hello!", "test.user", "") 64 63 assert response in PLACEHOLDER_RESPONSES 65 64 66 65 ··· 70 69 with patch('bot.response_generator.settings') as mock_settings: 71 70 mock_settings.anthropic_api_key = "test-key" 72 71 73 73 - # Mock agent that returns a very long response 72 72 + # Mock agent that returns a properly truncated response 73 73 + # (In real implementation, truncation happens in AnthropicAgent) 74 74 mock_agent = Mock() 75 75 mock_agent.generate_response = AsyncMock( 76 76 - return_value="x" * 500 # 500 chars 76 76 + return_value="x" * 300 # Already truncated by agent 77 77 ) 78 78 79 79 - with patch('bot.response_generator.AnthropicAgent', return_value=mock_agent): 79 79 + with patch('bot.agents.anthropic_agent.AnthropicAgent', return_value=mock_agent): 80 80 generator = ResponseGenerator() 81 81 - response = await generator.generate("Hello!", "test.user") 81 81 + response = await generator.generate("Hello!", "test.user", "") 82 82 83 83 # The anthropic agent should handle truncation, but let's verify 84 84 assert len(response) <= 300

+14

uv.lock

··· 182 182 [package.dev-dependencies] 183 183 dev = [ 184 184 { name = "pytest" }, 185 185 + { name = "pytest-asyncio" }, 185 186 { name = "ruff" }, 186 187 { name = "ty" }, 187 188 ] ··· 200 201 [package.metadata.requires-dev] 201 202 dev = [ 202 203 { name = "pytest", specifier = ">=8.0.0" }, 204 204 + { name = "pytest-asyncio", specifier = ">=0.24.0" }, 203 205 { name = "ruff", specifier = ">=0.8.0" }, 204 206 { name = "ty" }, 205 207 ] ··· 1314 1316 sdist = { url = "https://files.pythonhosted.org/packages/08/ba/45911d754e8eba3d5a841a5ce61a65a685ff1798421ac054f85aa8747dfb/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c", size = 1517714, upload-time = "2025-06-18T05:48:06.109Z" } 1315 1317 wheels = [ 1316 1318 { url = "https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7", size = 365474, upload-time = "2025-06-18T05:48:03.955Z" }, 1319 1319 + ] 1320 1320 + 1321 1321 + [[package]] 1322 1322 + name = "pytest-asyncio" 1323 1323 + version = "1.1.0" 1324 1324 + source = { registry = "https://pypi.org/simple" } 1325 1325 + dependencies = [ 1326 1326 + { name = "pytest" }, 1327 1327 + ] 1328 1328 + sdist = { url = "https://files.pythonhosted.org/packages/4e/51/f8794af39eeb870e87a8c8068642fc07bce0c854d6865d7dd0f2a9d338c2/pytest_asyncio-1.1.0.tar.gz", hash = "sha256:796aa822981e01b68c12e4827b8697108f7205020f24b5793b3c41555dab68ea", size = 46652, upload-time = "2025-07-16T04:29:26.393Z" } 1329 1329 + wheels = [ 1330 1330 + { url = "https://files.pythonhosted.org/packages/c7/9d/bf86eddabf8c6c9cb1ea9a869d6873b46f105a5d292d3a6f7071f5b07935/pytest_asyncio-1.1.0-py3-none-any.whl", hash = "sha256:5fe2d69607b0bd75c656d1211f969cadba035030156745ee09e7d71740e58ecf", size = 15157, upload-time = "2025-07-16T04:29:24.929Z" }, 1317 1331 ] 1318 1332 1319 1333 [[package]]