commit 3fb06f4683c2721b7c84e74f8a912a48456243ab · anil.recoil.org/thicket

.gitignore

···

       203
        
       .streamlit/secrets.toml

     

       204
        
       

     

       205
        
       thicket.yaml

     

       0
        
       
     

       0
        
       
     

       206
        
       bot-config/zuliprc

     

       0
        
       
     

       0

···

       203
        
       .streamlit/secrets.toml

     

       204
        
       

     

       205
        
       thicket.yaml

     

       206
       +
       

     

       207
       +
       # Bot configuration files with secrets

     

       208
        
       bot-config/zuliprc

     

       209
       +
       bot-config/*.key  

     

       210
       +
       bot-config/*.secret

+97

bot-config/README.md

···

       1
       +
       # Thicket Bot Configuration

     

       2
       +
       

     

       3
       +
       This directory contains configuration files for the Thicket Zulip bot.

     

       4
       +
       

     

       5
       +
       ## Setup Instructions

     

       6
       +
       

     

       7
       +
       ### 1. Zulip Bot Configuration

     

       8
       +
       

     

       9
       +
       1. Copy `zuliprc.template` to `zuliprc`:

     

       10
       +
          ```bash

     

       11
       +
          cp bot-config/zuliprc.template bot-config/zuliprc

     

       12
       +
          ```

     

       13
       +
       

     

       14
       +
       2. Create a bot in your Zulip organization:

     

       15
       +
          - Go to Settings > Your bots > Add a new bot

     

       16
       +
          - Choose "Generic bot" type

     

       17
       +
          - Give it a name like "Thicket" and username like "thicket"

     

       18
       +
          - Copy the bot's email and API key

     

       19
       +
       

     

       20
       +
       3. Edit `bot-config/zuliprc` with your bot's credentials:

     

       21
       +
          ```ini

     

       22
       +
          [api]

     

       23
       +
          email=thicket-bot@your-org.zulipchat.com

     

       24
       +
          key=your-actual-api-key-here

     

       25
       +
          site=https://your-org.zulipchat.com

     

       26
       +
          ```

     

       27
       +
       

     

       28
       +
       ### 2. Bot Behavior Configuration (Optional)

     

       29
       +
       

     

       30
       +
       1. Copy `botrc.template` to `botrc` to customize bot behavior:

     

       31
       +
          ```bash

     

       32
       +
          cp bot-config/botrc.template bot-config/botrc

     

       33
       +
          ```

     

       34
       +
       

     

       35
       +
       2. Edit `bot-config/botrc` to customize:

     

       36
       +
          - Sync intervals and batch sizes

     

       37
       +
          - Default stream/topic settings

     

       38
       +
          - Rate limiting parameters

     

       39
       +
          - Notification preferences

     

       40
       +
       

     

       41
       +
       **Note**: The bot will work with default settings if no `botrc` file exists.

     

       42
       +
       

     

       43
       +
       ## File Descriptions

     

       44
       +
       

     

       45
       +
       ### `zuliprc` (Required)

     

       46
       +
       Contains Zulip API credentials for the bot. This file should **never** be committed to version control.

     

       47
       +
       

     

       48
       +
       ### `botrc` (Optional)

     

       49
       +
       Contains bot behavior configuration and defaults. This file can be committed to version control as it contains no secrets.

     

       50
       +
       

     

       51
       +
       ### Template Files

     

       52
       +
       - `zuliprc.template` - Template for Zulip credentials

     

       53
       +
       - `botrc.template` - Template for bot behavior settings

     

       54
       +
       

     

       55
       +
       ## Running the Bot

     

       56
       +
       

     

       57
       +
       Once configured, run the bot with:

     

       58
       +
       

     

       59
       +
       ```bash

     

       60
       +
       # Run in foreground

     

       61
       +
       thicket bot run

     

       62
       +
       

     

       63
       +
       # Run in background (daemon mode)

     

       64
       +
       thicket bot run --daemon

     

       65
       +
       

     

       66
       +
       # Debug mode (sends DMs instead of stream posts)

     

       67
       +
       thicket bot run --debug-user your-thicket-username

     

       68
       +
       

     

       69
       +
       # Custom config paths

     

       70
       +
       thicket bot run --config bot-config/zuliprc --botrc bot-config/botrc

     

       71
       +
       ```

     

       72
       +
       

     

       73
       +
       ## Bot Commands

     

       74
       +
       

     

       75
       +
       Once running, interact with the bot in Zulip:

     

       76
       +
       

     

       77
       +
       - `@thicket help` - Show available commands

     

       78
       +
       - `@thicket status` - Show bot status and configuration  

     

       79
       +
       - `@thicket sync now` - Force immediate sync

     

       80
       +
       - `@thicket schedule` - Show sync schedule

     

       81
       +
       - `@thicket claim <username>` - Claim a thicket username

     

       82
       +
       - `@thicket config <setting> <value>` - Change bot settings

     

       83
       +
       

     

       84
       +
       ## Security Notes

     

       85
       +
       

     

       86
       +
       - **Never commit `zuliprc` with real credentials**

     

       87
       +
       - Add `bot-config/zuliprc` to `.gitignore`

     

       88
       +
       - The `botrc` file contains no secrets and can be safely committed

     

       89
       +
       - Bot settings changed via chat are stored in Zulip's persistent storage

     

       90
       +
       

     

       91
       +
       ## Troubleshooting

     

       92
       +
       

     

       93
       +
       - Check bot status: `thicket bot status`

     

       94
       +
       - View bot logs when running in foreground mode

     

       95
       +
       - Verify Zulip credentials are correct

     

       96
       +
       - Ensure thicket.yaml configuration exists

     

       97
       +
       - Test bot functionality: `thicket bot test`

+28

bot-config/botrc

···

       1
       +
       [bot]

     

       2
       +
       # Default RSS feed polling interval in seconds (minimum 60)

     

       3
       +
       sync_interval = 300

     

       4
       +
       

     

       5
       +
       # Maximum number of entries to post per sync cycle

     

       6
       +
       max_entries_per_sync = 10

     

       7
       +
       

     

       8
       +
       # Default stream and topic for posting (can be overridden via chat commands)

     

       9
       +
       # Leave empty to require configuration via chat

     

       10
       +
       default_stream = 

     

       11
       +
       default_topic = 

     

       12
       +
       

     

       13
       +
       # Rate limiting: seconds to wait between batches of posts

     

       14
       +
       rate_limit_delay = 5

     

       15
       +
       

     

       16
       +
       # Number of posts per batch before applying rate limit

     

       17
       +
       posts_per_batch = 5

     

       18
       +
       

     

       19
       +
       [catchup]

     

       20
       +
       # Number of entries to post on first run (catchup mode)

     

       21
       +
       catchup_entries = 5

     

       22
       +
       

     

       23
       +
       [notifications]

     

       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       +
       config_change_notifications = true

     

       26
       +
       

     

       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       +
       username_claim_notifications = true

+34

bot-config/botrc.template

···

       1
       +
       [bot]

     

       2
       +
       # Default RSS feed polling interval in seconds (minimum 60)

     

       3
       +
       sync_interval = 300

     

       4
       +
       

     

       5
       +
       # Maximum number of entries to post per sync cycle (1-50)

     

       6
       +
       max_entries_per_sync = 10

     

       7
       +
       

     

       8
       +
       # Default stream and topic for posting (can be overridden via chat commands)

     

       9
       +
       # Leave empty to require configuration via chat

     

       10
       +
       default_stream = 

     

       11
       +
       default_topic = 

     

       12
       +
       

     

       13
       +
       # Rate limiting: seconds to wait between batches of posts

     

       14
       +
       rate_limit_delay = 5

     

       15
       +
       

     

       16
       +
       # Number of posts per batch before applying rate limit

     

       17
       +
       posts_per_batch = 5

     

       18
       +
       

     

       19
       +
       [catchup]

     

       20
       +
       # Number of entries to post on first run (catchup mode)

     

       21
       +
       catchup_entries = 5

     

       22
       +
       

     

       23
       +
       [notifications]

     

       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       +
       config_change_notifications = true

     

       26
       +
       

     

       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       +
       username_claim_notifications = true

     

       29
       +
       

     

       30
       +
       # Instructions:

     

       31
       +
       # 1. Copy this file to botrc (without .template extension) to customize bot behavior

     

       32
       +
       # 2. The bot will use these defaults if no botrc file is found

     

       33
       +
       # 3. All settings can be overridden via chat commands (e.g., @mention config interval 600)

     

       34
       +
       # 4. Settings changed via chat are persisted in Zulip storage and take precedence

+16

bot-config/zuliprc.template

···

       1
       +
       [api]

     

       2
       +
       # Your bot's email address (create this in Zulip Settings > Bots)

     

       3
       +
       email=your-bot@your-organization.zulipchat.com

     

       4
       +
       

     

       5
       +
       # Your bot's API key (found in Zulip Settings > Bots)

     

       6
       +
       key=YOUR_BOT_API_KEY_HERE

     

       7
       +
       

     

       8
       +
       # Your Zulip server URL

     

       9
       +
       site=https://your-organization.zulipchat.com

     

       10
       +
       

     

       11
       +
       # Instructions:

     

       12
       +
       # 1. Copy this file to zuliprc (without .template extension)

     

       13
       +
       # 2. Replace the placeholder values with your actual bot credentials

     

       14
       +
       # 3. Create a bot in your Zulip organization at Settings > Bots

     

       15
       +
       # 4. Use the bot's email and API key from the Zulip interface

     

       16
       +
       # 5. Never commit the actual zuliprc file with real credentials to version control

+1 -1

src/thicket/bots/__init__.py

···

       2
        
       

     

       3
        
       from .thicket_bot import ThicketBotHandler

     

       4
        
       

     

       5
       -
       __all__ = ["ThicketBotHandler"]

···

       2
        
       

     

       3
        
       from .thicket_bot import ThicketBotHandler

     

       4
        
       

     

       5
       +
       __all__ = ["ThicketBotHandler"]

+38 -38

src/thicket/bots/test_bot.py

···

       3
        
       import json

     

       4
        
       from pathlib import Path

     

       5
        
       from typing import Any, Dict, Optional

     

       6
       -
       from unittest.mock import Mock

     

       7
        
       

     

       8
       -
       from ..models import AtomEntry, ThicketConfig

     

       9
        
       from .thicket_bot import ThicketBotHandler

     

       10
        
       

     

       11
        
       

     

       12
        
       class MockBotHandler:

     

       13
        
           """Mock BotHandler for testing the Thicket bot."""

     

       14
       -
           

     

       15
        
           def __init__(self) -> None:

     

       16
        
               """Initialize mock bot handler."""

     

       17
        
               self.storage_data: Dict[str, str] = {}

     
···

       20
        
                   "full_name": "Thicket Bot",

     

       21
        
                   "email": "thicket-bot@example.com"

     

       22
        
               }

     

       23
       -
               

     

       24
        
           def get_config_info(self) -> Dict[str, str]:

     

       25
        
               """Return bot configuration info."""

     

       26
        
               return self.config_info

     

       27
       -
               

     

       28
        
           def send_reply(self, message: Dict[str, Any], content: str) -> None:

     

       29
        
               """Mock sending a reply."""

     

       30
        
               reply = {

     
···

       34
        
                   "original_message": message

     

       35
        
               }

     

       36
        
               self.sent_messages.append(reply)

     

       37
       -
               

     

       38
        
           def send_message(self, message: Dict[str, Any]) -> None:

     

       39
        
               """Mock sending a message."""

     

       40
        
               self.sent_messages.append(message)

     

       41
       -
               

     

       42
        
           @property

     

       43
        
           def storage(self) -> 'MockStorage':

     

       44
        
               """Return mock storage."""

     
···

       47
        
       

     

       48
        
       class MockStorage:

     

       49
        
           """Mock storage for bot state."""

     

       50
       -
           

     

       51
        
           def __init__(self, storage_data: Dict[str, str]) -> None:

     

       52
        
               """Initialize with storage data."""

     

       53
        
               self.storage_data = storage_data

     

       54
       -
               

     

       55
        
           def __enter__(self) -> 'MockStorage':

     

       56
        
               """Context manager entry."""

     

       57
        
               return self

     

       58
       -
               

     

       59
        
           def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:

     

       60
        
               """Context manager exit."""

     

       61
        
               pass

     

       62
       -
               

     

       63
        
           def get(self, key: str) -> Optional[str]:

     

       64
        
               """Get value from storage."""

     

       65
        
               return self.storage_data.get(key)

     

       66
       -
               

     

       67
        
           def put(self, key: str, value: str) -> None:

     

       68
        
               """Put value in storage."""

     

       69
        
               self.storage_data[key] = value

     

       70
       -
               

     

       71
        
           def contains(self, key: str) -> bool:

     

       72
        
               """Check if key exists in storage."""

     

       73
        
               return key in self.storage_data

     

       74
        
       

     

       75
        
       

     

       76
        
       def create_test_message(

     

       77
       -
           content: str, 

     

       78
        
           sender: str = "Test User",

     

       79
        
           sender_id: int = 12345,

     

       80
        
           message_type: str = "stream"

     
···

       98
        
       ) -> AtomEntry:

     

       99
        
           """Create a test AtomEntry for testing."""

     

       100
        
           from datetime import datetime

     

       0
        
       
     

       101
        
           from pydantic import HttpUrl

     

       102
       -
           

     

       103
        
           return AtomEntry(

     

       104
        
               id=entry_id,

     

       105
        
               title=title,

     
···

       114
        
       

     

       115
        
       class BotTester:

     

       116
        
           """Helper class for testing bot functionality."""

     

       117
       -
           

     

       118
        
           def __init__(self, config_path: Optional[Path] = None) -> None:

     

       119
        
               """Initialize bot tester."""

     

       120
        
               self.bot = ThicketBotHandler()

     

       121
        
               self.handler = MockBotHandler()

     

       122
       -
               

     

       123
        
               if config_path:

     

       124
        
                   # Configure bot with test config

     

       125
        
                   self.configure_bot(config_path, "test-stream", "test-topic")

     

       126
       -
                   

     

       127
        
           def configure_bot(

     

       128
       -
               self, 

     

       129
       -
               config_path: Path, 

     

       130
       -
               stream: str = "test-stream", 

     

       131
        
               topic: str = "test-topic"

     

       132
        
           ) -> None:

     

       133
        
               """Configure the bot for testing."""

     

       134
        
               # Set bot configuration

     

       135
        
               config_data = {

     

       136
        
                   "stream_name": stream,

     

       137
       -
                   "topic_name": topic, 

     

       138
        
                   "sync_interval": 300,

     

       139
        
                   "max_entries_per_sync": 10,

     

       140
        
                   "config_path": str(config_path)

     

       141
        
               }

     

       142
       -
               

     

       143
        
               self.handler.storage_data["bot_config"] = json.dumps(config_data)

     

       144
       -
               

     

       145
        
               # Initialize bot

     

       146
        
               self.bot._load_bot_config(self.handler)

     

       147
       -
               

     

       148
        
           def send_command(self, command: str, sender: str = "Test User") -> list[Dict[str, Any]]:

     

       149
        
               """Send a command to the bot and return responses."""

     

       150
        
               message = create_test_message(f"@thicket {command}", sender)

     

       151
       -
               

     

       152
        
               # Clear previous messages

     

       153
        
               self.handler.sent_messages.clear()

     

       154
       -
               

     

       155
        
               # Send command

     

       156
        
               self.bot.handle_message(message, self.handler)

     

       157
       -
               

     

       158
        
               return self.handler.sent_messages.copy()

     

       159
       -
               

     

       160
        
           def get_last_response_content(self) -> Optional[str]:

     

       161
        
               """Get the content of the last bot response."""

     

       162
        
               if self.handler.sent_messages:

     

       163
        
                   return self.handler.sent_messages[-1].get("content")

     

       164
        
               return None

     

       165
       -
           

     

       166
        
           def get_last_message(self) -> Optional[Dict[str, Any]]:

     

       167
        
               """Get the last sent message."""

     

       168
        
               if self.handler.sent_messages:

     

       169
        
                   return self.handler.sent_messages[-1]

     

       170
        
               return None

     

       171
       -
               

     

       172
        
           def assert_response_contains(self, text: str) -> None:

     

       173
        
               """Assert that the last response contains specific text."""

     

       174
        
               content = self.get_last_response_content()

     
···

       180
        
       if __name__ == "__main__":

     

       181
        
           # Create a test config file

     

       182
        
           test_config = Path("/tmp/test_thicket.yaml")

     

       183
       -
           

     

       184
        
           # Create bot tester

     

       185
        
           tester = BotTester()

     

       186
       -
           

     

       187
        
           # Test help command

     

       188
        
           responses = tester.send_command("help")

     

       189
        
           print(f"Help response: {tester.get_last_response_content()}")

     

       190
       -
           

     

       191
        
           # Test status command

     

       192
        
           responses = tester.send_command("status")

     

       193
        
           print(f"Status response: {tester.get_last_response_content()}")

     

       194
       -
           

     

       195
        
           # Test configuration

     

       196
        
           responses = tester.send_command("config stream general")

     

       197
        
           tester.assert_response_contains("Stream set to")

     

       198
       -
           

     

       199
        
           responses = tester.send_command("config topic 'Feed Updates'")

     

       200
        
           tester.assert_response_contains("Topic set to")

     

       201
       -
           

     

       202
       -
           print("All tests passed!")

···

       3
        
       import json

     

       4
        
       from pathlib import Path

     

       5
        
       from typing import Any, Dict, Optional

     

       0
        
       
     

       6
        
       

     

       7
       +
       from ..models import AtomEntry

     

       8
        
       from .thicket_bot import ThicketBotHandler

     

       9
        
       

     

       10
        
       

     

       11
        
       class MockBotHandler:

     

       12
        
           """Mock BotHandler for testing the Thicket bot."""

     

       13
       +
       

     

       14
        
           def __init__(self) -> None:

     

       15
        
               """Initialize mock bot handler."""

     

       16
        
               self.storage_data: Dict[str, str] = {}

     
···

       19
        
                   "full_name": "Thicket Bot",

     

       20
        
                   "email": "thicket-bot@example.com"

     

       21
        
               }

     

       22
       +
       

     

       23
        
           def get_config_info(self) -> Dict[str, str]:

     

       24
        
               """Return bot configuration info."""

     

       25
        
               return self.config_info

     

       26
       +
       

     

       27
        
           def send_reply(self, message: Dict[str, Any], content: str) -> None:

     

       28
        
               """Mock sending a reply."""

     

       29
        
               reply = {

     
···

       33
        
                   "original_message": message

     

       34
        
               }

     

       35
        
               self.sent_messages.append(reply)

     

       36
       +
       

     

       37
        
           def send_message(self, message: Dict[str, Any]) -> None:

     

       38
        
               """Mock sending a message."""

     

       39
        
               self.sent_messages.append(message)

     

       40
       +
       

     

       41
        
           @property

     

       42
        
           def storage(self) -> 'MockStorage':

     

       43
        
               """Return mock storage."""

     
···

       46
        
       

     

       47
        
       class MockStorage:

     

       48
        
           """Mock storage for bot state."""

     

       49
       +
       

     

       50
        
           def __init__(self, storage_data: Dict[str, str]) -> None:

     

       51
        
               """Initialize with storage data."""

     

       52
        
               self.storage_data = storage_data

     

       53
       +
       

     

       54
        
           def __enter__(self) -> 'MockStorage':

     

       55
        
               """Context manager entry."""

     

       56
        
               return self

     

       57
       +
       

     

       58
        
           def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:

     

       59
        
               """Context manager exit."""

     

       60
        
               pass

     

       61
       +
       

     

       62
        
           def get(self, key: str) -> Optional[str]:

     

       63
        
               """Get value from storage."""

     

       64
        
               return self.storage_data.get(key)

     

       65
       +
       

     

       66
        
           def put(self, key: str, value: str) -> None:

     

       67
        
               """Put value in storage."""

     

       68
        
               self.storage_data[key] = value

     

       69
       +
       

     

       70
        
           def contains(self, key: str) -> bool:

     

       71
        
               """Check if key exists in storage."""

     

       72
        
               return key in self.storage_data

     

       73
        
       

     

       74
        
       

     

       75
        
       def create_test_message(

     

       76
       +
           content: str,

     

       77
        
           sender: str = "Test User",

     

       78
        
           sender_id: int = 12345,

     

       79
        
           message_type: str = "stream"

     
···

       97
        
       ) -> AtomEntry:

     

       98
        
           """Create a test AtomEntry for testing."""

     

       99
        
           from datetime import datetime

     

       100
       +
       

     

       101
        
           from pydantic import HttpUrl

     

       102
       +
       

     

       103
        
           return AtomEntry(

     

       104
        
               id=entry_id,

     

       105
        
               title=title,

     
···

       114
        
       

     

       115
        
       class BotTester:

     

       116
        
           """Helper class for testing bot functionality."""

     

       117
       +
       

     

       118
        
           def __init__(self, config_path: Optional[Path] = None) -> None:

     

       119
        
               """Initialize bot tester."""

     

       120
        
               self.bot = ThicketBotHandler()

     

       121
        
               self.handler = MockBotHandler()

     

       122
       +
       

     

       123
        
               if config_path:

     

       124
        
                   # Configure bot with test config

     

       125
        
                   self.configure_bot(config_path, "test-stream", "test-topic")

     

       126
       +
       

     

       127
        
           def configure_bot(

     

       128
       +
               self,

     

       129
       +
               config_path: Path,

     

       130
       +
               stream: str = "test-stream",

     

       131
        
               topic: str = "test-topic"

     

       132
        
           ) -> None:

     

       133
        
               """Configure the bot for testing."""

     

       134
        
               # Set bot configuration

     

       135
        
               config_data = {

     

       136
        
                   "stream_name": stream,

     

       137
       +
                   "topic_name": topic,

     

       138
        
                   "sync_interval": 300,

     

       139
        
                   "max_entries_per_sync": 10,

     

       140
        
                   "config_path": str(config_path)

     

       141
        
               }

     

       142
       +
       

     

       143
        
               self.handler.storage_data["bot_config"] = json.dumps(config_data)

     

       144
       +
       

     

       145
        
               # Initialize bot

     

       146
        
               self.bot._load_bot_config(self.handler)

     

       147
       +
       

     

       148
        
           def send_command(self, command: str, sender: str = "Test User") -> list[Dict[str, Any]]:

     

       149
        
               """Send a command to the bot and return responses."""

     

       150
        
               message = create_test_message(f"@thicket {command}", sender)

     

       151
       +
       

     

       152
        
               # Clear previous messages

     

       153
        
               self.handler.sent_messages.clear()

     

       154
       +
       

     

       155
        
               # Send command

     

       156
        
               self.bot.handle_message(message, self.handler)

     

       157
       +
       

     

       158
        
               return self.handler.sent_messages.copy()

     

       159
       +
       

     

       160
        
           def get_last_response_content(self) -> Optional[str]:

     

       161
        
               """Get the content of the last bot response."""

     

       162
        
               if self.handler.sent_messages:

     

       163
        
                   return self.handler.sent_messages[-1].get("content")

     

       164
        
               return None

     

       165
       +
       

     

       166
        
           def get_last_message(self) -> Optional[Dict[str, Any]]:

     

       167
        
               """Get the last sent message."""

     

       168
        
               if self.handler.sent_messages:

     

       169
        
                   return self.handler.sent_messages[-1]

     

       170
        
               return None

     

       171
       +
       

     

       172
        
           def assert_response_contains(self, text: str) -> None:

     

       173
        
               """Assert that the last response contains specific text."""

     

       174
        
               content = self.get_last_response_content()

     
···

       180
        
       if __name__ == "__main__":

     

       181
        
           # Create a test config file

     

       182
        
           test_config = Path("/tmp/test_thicket.yaml")

     

       183
       +
       

     

       184
        
           # Create bot tester

     

       185
        
           tester = BotTester()

     

       186
       +
       

     

       187
        
           # Test help command

     

       188
        
           responses = tester.send_command("help")

     

       189
        
           print(f"Help response: {tester.get_last_response_content()}")

     

       190
       +
       

     

       191
        
           # Test status command

     

       192
        
           responses = tester.send_command("status")

     

       193
        
           print(f"Status response: {tester.get_last_response_content()}")

     

       194
       +
       

     

       195
        
           # Test configuration

     

       196
        
           responses = tester.send_command("config stream general")

     

       197
        
           tester.assert_response_contains("Stream set to")

     

       198
       +
       

     

       199
        
           responses = tester.send_command("config topic 'Feed Updates'")

     

       200
        
           tester.assert_response_contains("Topic set to")

     

       201
       +
       

     

       202
       +
           print("All tests passed!")

+398 -137

src/thicket/bots/thicket_bot.py

···

       5
        
       import logging

     

       6
        
       import os

     

       7
        
       import time

     

       8
       -
       from datetime import datetime

     

       9
        
       from pathlib import Path

     

       10
       -
       from typing import Any, Dict, List, Optional, Set, Tuple

     

       11
        
       

     

       12
        
       from zulip_bots.lib import BotHandler

     

       13
        
       

     

       14
        
       # Handle imports for both direct execution and package import

     

       15
        
       try:

     

       0
        
       
     

       16
        
           from ..core.git_store import GitStore

     

       17
        
           from ..models import AtomEntry, ThicketConfig

     

       18
       -
           from ..cli.commands.sync import sync_feed

     

       19
        
       except ImportError:

     

       20
        
           # When run directly by zulip-bots, add the package to path

     

       21
        
           import sys

     

       22
        
           src_dir = Path(__file__).parent.parent.parent

     

       23
        
           if str(src_dir) not in sys.path:

     

       24
        
               sys.path.insert(0, str(src_dir))

     

       25
       -
           

     

       0
        
       
     

       26
        
           from thicket.core.git_store import GitStore

     

       27
        
           from thicket.models import AtomEntry, ThicketConfig

     

       28
       -
           from thicket.cli.commands.sync import sync_feed

     

       29
        
       

     

       30
        
       

     

       31
        
       class ThicketBotHandler:

     
···

       36
        
               self.logger = logging.getLogger(__name__)

     

       37
        
               self.git_store: Optional[GitStore] = None

     

       38
        
               self.config: Optional[ThicketConfig] = None

     

       39
       -
               self.posted_entries: Set[str] = set()

     

       40
       -
               

     

       41
        
               # Bot configuration from storage

     

       42
        
               self.stream_name: Optional[str] = None

     

       43
        
               self.topic_name: Optional[str] = None

     

       44
        
               self.sync_interval: int = 300  # 5 minutes default

     

       45
        
               self.max_entries_per_sync: int = 10

     

       46
        
               self.config_path: Optional[Path] = None

     

       47
       -
               

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       48
        
               # Debug mode configuration

     

       49
        
               self.debug_user: Optional[str] = None

     

       50
        
               self.debug_zulip_user_id: Optional[str] = None

     

       51
       -
               

     

       52
        
           def usage(self) -> str:

     

       53
        
               """Return bot usage instructions."""

     

       54
        
               return """

     

       55
        
               **Thicket Feed Bot**

     

       56
       -
               

     

       57
        
               This bot automatically monitors thicket feeds and posts new articles.

     

       58
       -
               

     

       59
        
               Commands:

     

       60
       -
               - `@mention status` - Show current bot status and configuration  

     

       61
        
               - `@mention sync now` - Force an immediate sync

     

       62
        
               - `@mention reset` - Clear posting history (will repost recent entries)

     

       63
        
               - `@mention config stream <stream_name>` - Set target stream

     

       64
       -
               - `@mention config topic <topic_name>` - Set target topic  

     

       65
        
               - `@mention config interval <seconds>` - Set sync interval

     

       0
        
       
     

       0
        
       
     

       66
        
               - `@mention help` - Show this help message

     

       67
        
               """

     

       68
        
       

     

       69
        
           def initialize(self, bot_handler: BotHandler) -> None:

     

       70
        
               """Initialize the bot with persistent storage."""

     

       71
        
               self.logger.info("Initializing ThicketBot")

     

       72
       -
               

     

       73
        
               # Get configuration from environment (set by CLI)

     

       74
        
               self.debug_user = os.getenv("THICKET_DEBUG_USER")

     

       75
        
               config_path_env = os.getenv("THICKET_CONFIG_PATH")

     

       76
        
               if config_path_env:

     

       77
        
                   self.config_path = Path(config_path_env)

     

       78
        
                   self.logger.info(f"Using thicket config: {self.config_path}")

     

       79
       -
               

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
               # Load bot configuration from persistent storage

     

       81
        
               self._load_bot_config(bot_handler)

     

       82
       -
               

     

       83
        
               # Initialize thicket components

     

       84
        
               if self.config_path:

     

       85
        
                   try:

     

       86
        
                       self._initialize_thicket()

     

       87
        
                       self._load_posted_entries(bot_handler)

     

       88
       -
                       

     

       89
        
                       # Validate debug mode if enabled

     

       90
        
                       if self.debug_user:

     

       91
        
                           self._validate_debug_mode(bot_handler)

     

       92
       -
                           

     

       93
        
                   except Exception as e:

     

       94
        
                       self.logger.error(f"Failed to initialize thicket: {e}")

     

       95
       -
                       

     

       96
        
               # Start background sync loop

     

       97
        
               self._schedule_sync(bot_handler)

     

       98
        
       

     

       99
       -
           def handle_message(self, message: Dict[str, Any], bot_handler: BotHandler) -> None:

     

       100
        
               """Handle incoming Zulip messages."""

     

       101
        
               content = message["content"].strip()

     

       102
        
               sender = message["sender_full_name"]

     

       103
       -
               

     

       104
        
               # Only respond to mentions

     

       105
        
               if not self._is_mentioned(content, bot_handler):

     

       106
        
                   return

     

       107
       -
                   

     

       108
        
               # Parse command

     

       109
        
               cleaned_content = self._clean_mention(content, bot_handler)

     

       110
        
               command_parts = cleaned_content.split()

     

       111
       -
               

     

       112
        
               if not command_parts:

     

       113
        
                   self._send_help(message, bot_handler)

     

       114
        
                   return

     

       115
       -
                   

     

       116
        
               command = command_parts[0].lower()

     

       117
       -
               

     

       118
        
               try:

     

       119
        
                   if command == "help":

     

       120
        
                       self._send_help(message, bot_handler)

     
···

       126
        
                       self._handle_reset_command(message, bot_handler, sender)

     

       127
        
                   elif command == "config":

     

       128
        
                       self._handle_config_command(message, bot_handler, command_parts[1:], sender)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       129
        
                   else:

     

       130
        
                       bot_handler.send_reply(message, f"Unknown command: {command}. Type `@mention help` for usage.")

     

       131
        
               except Exception as e:

     
···

       143
        
                           return f"@{bot_name}" in content.lower() or f"@**{bot_name}**" in content.lower()

     

       144
        
               except Exception as e:

     

       145
        
                   self.logger.debug(f"Could not get bot profile: {e}")

     

       146
       -
               

     

       147
        
               # Fallback to generic check

     

       148
        
               return "@thicket" in content.lower()

     

       149
       -
               

     

       150
        
           def _clean_mention(self, content: str, bot_handler: BotHandler) -> str:

     

       151
        
               """Remove bot mention from message content."""

     

       152
        
               import re

     

       153
       -
               

     

       154
        
               try:

     

       155
        
                   # Get bot's actual name from Zulip

     

       156
        
                   bot_info = bot_handler._client.get_profile()

     
···

       163
        
                           return content

     

       164
        
               except Exception as e:

     

       165
        
                   self.logger.debug(f"Could not get bot profile for mention cleaning: {e}")

     

       166
       -
               

     

       167
        
               # Fallback to removing @thicket

     

       168
        
               content = re.sub(r'@(?:\*\*)?thicket(?:\*\*)?', '', content, flags=re.IGNORECASE).strip()

     

       169
        
               return content

     

       170
        
       

     

       171
       -
           def _send_help(self, message: Dict[str, Any], bot_handler: BotHandler) -> None:

     

       172
        
               """Send help message."""

     

       173
        
               bot_handler.send_reply(message, self.usage())

     

       174
        
       

     

       175
       -
           def _send_status(self, message: Dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       176
        
               """Send bot status information."""

     

       177
        
               status_lines = [

     

       178
        
                   f"**Thicket Bot Status** (requested by {sender})",

     

       179
        
                   "",

     

       180
        
               ]

     

       181
       -
               

     

       182
        
               # Debug mode status

     

       183
        
               if self.debug_user:

     

       184
        
                   status_lines.extend([

     

       185
       -
                       f"🐛 **Debug Mode:** ENABLED",

     

       186
        
                       f"🎯 **Debug User:** {self.debug_user}",

     

       187
        
                       "",

     

       188
        
                   ])

     
···

       192
        
                       f"📝 **Topic:** {self.topic_name or 'Not configured'}",

     

       193
        
                       "",

     

       194
        
                   ])

     

       195
       -
               

     

       196
        
               status_lines.extend([

     

       197
        
                   f"⏱️ **Sync Interval:** {self.sync_interval}s ({self.sync_interval // 60}m {self.sync_interval % 60}s)",

     

       198
        
                   f"📊 **Max Entries/Sync:** {self.max_entries_per_sync}",

     
···

       201
        
                   f"📄 **Tracked Entries:** {len(self.posted_entries)}",

     

       202
        
                   f"🔄 **Catchup Mode:** {'Active (first run)' if len(self.posted_entries) == 0 else 'Inactive'}",

     

       203
        
                   f"✅ **Thicket Initialized:** {'Yes' if self.git_store else 'No'}",

     

       0
        
       
     

       0
        
       
     

       204
        
               ])

     

       205
       -
               

     

       206
        
               bot_handler.send_reply(message, "\n".join(status_lines))

     

       207
        
       

     

       208
       -
           def _handle_force_sync(self, message: Dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       209
        
               """Handle immediate sync request."""

     

       210
        
               if not self._check_initialization(message, bot_handler):

     

       211
        
                   return

     

       212
       -
                   

     

       213
        
               bot_handler.send_reply(message, f"🔄 Starting immediate sync... (requested by {sender})")

     

       214
       -
               

     

       215
        
               try:

     

       216
        
                   new_entries = self._perform_sync(bot_handler)

     

       217
        
                   bot_handler.send_reply(

     

       218
       -
                       message, 

     

       219
        
                       f"✅ Sync completed! Found {len(new_entries)} new entries."

     

       220
        
                   )

     

       221
        
               except Exception as e:

     

       222
        
                   self.logger.error(f"Force sync failed: {e}")

     

       223
        
                   bot_handler.send_reply(message, f"❌ Sync failed: {str(e)}")

     

       224
        
       

     

       225
       -
           def _handle_reset_command(self, message: Dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       226
        
               """Handle reset command to clear posted entries tracking."""

     

       227
        
               try:

     

       228
        
                   self.posted_entries.clear()

     
···

       236
        
                   self.logger.error(f"Reset failed: {e}")

     

       237
        
                   bot_handler.send_reply(message, f"❌ Reset failed: {str(e)}")

     

       238
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       239
        
           def _handle_config_command(

     

       240
       -
               self, 

     

       241
       -
               message: Dict[str, Any], 

     

       242
       -
               bot_handler: BotHandler, 

     

       243
       -
               args: List[str], 

     

       244
        
               sender: str

     

       245
        
           ) -> None:

     

       246
        
               """Handle configuration commands."""

     

       247
        
               if len(args) < 2:

     

       248
        
                   bot_handler.send_reply(message, "Usage: `@mention config <setting> <value>`")

     

       249
        
                   return

     

       250
       -
                   

     

       251
        
               setting = args[0].lower()

     

       252
        
               value = " ".join(args[1:])

     

       253
       -
               

     

       254
        
               if setting == "stream":

     

       0
        
       
     

       255
        
                   self.stream_name = value

     

       256
        
                   self._save_bot_config(bot_handler)

     

       257
        
                   bot_handler.send_reply(message, f"✅ Stream set to: **{value}** (by {sender})")

     

       258
       -
                   

     

       0
        
       
     

       259
        
               elif setting == "topic":

     

       0
        
       
     

       260
        
                   self.topic_name = value

     

       261
        
                   self._save_bot_config(bot_handler)

     

       262
        
                   bot_handler.send_reply(message, f"✅ Topic set to: **{value}** (by {sender})")

     

       263
       -
                   

     

       0
        
       
     

       264
        
               elif setting == "interval":

     

       265
        
                   try:

     

       266
        
                       interval = int(value)

     

       267
        
                       if interval < 60:

     

       268
        
                           bot_handler.send_reply(message, "❌ Interval must be at least 60 seconds")

     

       269
        
                           return

     

       0
        
       
     

       270
        
                       self.sync_interval = interval

     

       271
        
                       self._save_bot_config(bot_handler)

     

       272
        
                       bot_handler.send_reply(message, f"✅ Sync interval set to: **{interval}s** (by {sender})")

     

       0
        
       
     

       273
        
                   except ValueError:

     

       274
        
                       bot_handler.send_reply(message, "❌ Invalid interval value. Must be a number of seconds.")

     

       275
       -
                       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       276
        
               else:

     

       277
        
                   bot_handler.send_reply(

     

       278
       -
                       message, 

     

       279
       -
                       f"❌ Unknown setting: {setting}. Available: stream, topic, interval"

     

       280
        
                   )

     

       281
        
       

     

       282
        
           def _load_bot_config(self, bot_handler: BotHandler) -> None:

     
···

       286
        
                   if config_data:

     

       287
        
                       config = json.loads(config_data)

     

       288
        
                       self.stream_name = config.get("stream_name")

     

       289
       -
                       self.topic_name = config.get("topic_name") 

     

       290
        
                       self.sync_interval = config.get("sync_interval", 300)

     

       291
        
                       self.max_entries_per_sync = config.get("max_entries_per_sync", 10)

     

       292
       -
               except Exception as e:

     

       0
        
       
     

       293
        
                   # Bot config not found on first run is expected

     

       294
        
                   pass

     

       295
        
       

     
···

       301
        
                       "topic_name": self.topic_name,

     

       302
        
                       "sync_interval": self.sync_interval,

     

       303
        
                       "max_entries_per_sync": self.max_entries_per_sync,

     

       0
        
       
     

       304
        
                   }

     

       305
        
                   bot_handler.storage.put("bot_config", json.dumps(config_data))

     

       306
        
               except Exception as e:

     

       307
        
                   self.logger.error(f"Error saving bot config: {e}")

     

       308
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       309
        
           def _initialize_thicket(self) -> None:

     

       310
        
               """Initialize thicket components."""

     

       311
        
               if not self.config_path or not self.config_path.exists():

     

       312
        
                   raise ValueError("Thicket config file not found")

     

       313
       -
                   

     

       314
        
               # Load thicket configuration

     

       315
        
               import yaml

     

       316
        
               with open(self.config_path) as f:

     

       317
        
                   config_data = yaml.safe_load(f)

     

       318
        
               self.config = ThicketConfig(**config_data)

     

       319
       -
               

     

       320
        
               # Initialize git store

     

       321
        
               self.git_store = GitStore(self.config.git_store)

     

       322
       -
               

     

       323
        
               self.logger.info("Thicket components initialized successfully")

     

       324
       -
           

     

       325
        
           def _validate_debug_mode(self, bot_handler: BotHandler) -> None:

     

       326
        
               """Validate debug mode configuration."""

     

       327
        
               if not self.debug_user or not self.git_store:

     

       328
        
                   return

     

       329
       -
               

     

       330
        
               # Get current Zulip server from environment

     

       331
        
               zulip_site_url = os.getenv("THICKET_ZULIP_SITE_URL", "")

     

       332
        
               server_url = zulip_site_url.replace("https://", "").replace("http://", "")

     

       333
       -
               

     

       334
        
               # Check if debug user exists in thicket

     

       335
        
               user = self.git_store.get_user(self.debug_user)

     

       336
        
               if not user:

     

       337
        
                   raise ValueError(f"Debug user '{self.debug_user}' not found in thicket")

     

       338
       -
               

     

       339
        
               # Check if user has Zulip association for this server

     

       340
        
               if not server_url:

     

       341
        
                   raise ValueError("Could not determine Zulip server URL")

     

       342
       -
               

     

       343
        
               zulip_user_id = user.get_zulip_mention(server_url)

     

       344
        
               if not zulip_user_id:

     

       345
        
                   raise ValueError(f"User '{self.debug_user}' has no Zulip association for server '{server_url}'")

     

       346
       -
               

     

       347
        
               # Try to look up the actual Zulip user ID from the email address

     

       348
        
               # But don't fail if we can't - we'll try again when sending messages

     

       349
        
               actual_user_id = self._lookup_zulip_user_id(bot_handler, zulip_user_id)

     
···

       361
        
               # If it's already a numeric user ID, return it

     

       362
        
               if email_or_id.isdigit():

     

       363
        
                   return email_or_id

     

       364
       -
                   

     

       365
        
               try:

     

       366
        
                   client = bot_handler._client

     

       367
        
                   if not client:

     

       368
        
                       self.logger.error("No Zulip client available for user lookup")

     

       369
        
                       return None

     

       370
       -
                       

     

       371
        
                   # First try the get_user_by_email API if available

     

       372
        
                   try:

     

       373
        
                       user_result = client.get_user_by_email(email_or_id)

     
···

       379
        
                               return str(user_id)

     

       380
        
                   except (AttributeError, Exception):

     

       381
        
                       pass

     

       382
       -
                   

     

       383
        
                   # Fallback: Get all users and search through them

     

       384
        
                   users_result = client.get_users()

     

       385
        
                   if users_result.get('result') == 'success':

     

       386
        
                       for user in users_result['members']:

     

       387
        
                           user_email = user.get('email', '')

     

       388
        
                           delivery_email = user.get('delivery_email', '')

     

       389
       -
                           

     

       390
       -
                           if (user_email == email_or_id or 

     

       391
        
                               delivery_email == email_or_id or

     

       392
        
                               str(user.get('user_id')) == email_or_id):

     

       393
        
                               user_id = user.get('user_id')

     

       394
        
                               return str(user_id)

     

       395
       -
                       

     

       396
        
                       self.logger.error(f"No user found with identifier '{email_or_id}'. Searched {len(users_result['members'])} users.")

     

       397
        
                       return None

     

       398
        
                   else:

     

       399
        
                       self.logger.error(f"Failed to get users: {users_result.get('msg', 'Unknown error')}")

     

       400
        
                       return None

     

       401
       -
                       

     

       402
        
               except Exception as e:

     

       403
        
                   self.logger.error(f"Error looking up user ID for '{email_or_id}': {e}")

     

       404
        
                   return None

     

       405
        
       

     

       406
       -
           def _lookup_zulip_user_info(self, bot_handler: BotHandler, email_or_id: str) -> Tuple[Optional[str], Optional[str]]:

     

       407
        
               """Look up both Zulip user ID and full name from email address."""

     

       408
        
               if email_or_id.isdigit():

     

       409
        
                   return email_or_id, None

     

       410
       -
                   

     

       411
        
               try:

     

       412
        
                   client = bot_handler._client

     

       413
        
                   if not client:

     

       414
        
                       return None, None

     

       415
       -
                       

     

       416
        
                   # Try get_user_by_email API first

     

       417
        
                   try:

     

       418
        
                       user_result = client.get_user_by_email(email_or_id)

     
···

       424
        
                               return str(user_id), full_name

     

       425
        
                   except AttributeError:

     

       426
        
                       pass

     

       427
       -
                   

     

       428
        
                   # Fallback: search all users

     

       429
        
                   users_result = client.get_users()

     

       430
        
                   if users_result.get('result') == 'success':

     

       431
        
                       for user in users_result['members']:

     

       432
       -
                           if (user.get('email') == email_or_id or 

     

       433
        
                               user.get('delivery_email') == email_or_id):

     

       434
        
                               return str(user.get('user_id')), user.get('full_name', '')

     

       435
       -
                               

     

       436
        
                   return None, None

     

       437
       -
                   

     

       438
        
               except Exception as e:

     

       439
        
                   self.logger.error(f"Error looking up user info for '{email_or_id}': {e}")

     

       440
        
                   return None, None

     
···

       456
        
               except Exception as e:

     

       457
        
                   self.logger.error(f"Error saving posted entries: {e}")

     

       458
        
       

     

       459
       -
           def _check_initialization(self, message: Dict[str, Any], bot_handler: BotHandler) -> bool:

     

       460
        
               """Check if thicket is properly initialized."""

     

       461
        
               if not self.git_store or not self.config:

     

       462
        
                   bot_handler.send_reply(

     

       463
       -
                       message, 

     

       464
        
                       "❌ Thicket not initialized. Please check configuration."

     

       465
        
                   )

     

       466
        
                   return False

     

       467
       -
               

     

       468
        
               # In debug mode, we don't need stream/topic configuration

     

       469
        
               if self.debug_user:

     

       470
        
                   return True

     

       471
       -
                   

     

       472
        
               if not self.stream_name or not self.topic_name:

     

       473
        
                   bot_handler.send_reply(

     

       474
        
                       message,

     

       475
        
                       "❌ Stream and topic must be configured first. Use `@mention config stream <name>` and `@mention config topic <name>`"

     

       476
        
                   )

     

       477
        
                   return False

     

       478
       -
                   

     

       479
        
               return True

     

       480
        
       

     

       481
        
           def _schedule_sync(self, bot_handler: BotHandler) -> None:

     
···

       484
        
                   while True:

     

       485
        
                       try:

     

       486
        
                           # Check if we can sync

     

       487
       -
                           can_sync = (self.git_store and 

     

       488
       -
                                     ((self.stream_name and self.topic_name) or 

     

       489
        
                                      self.debug_user))

     

       490
       -
                           

     

       491
        
                           if can_sync:

     

       492
        
                               self._perform_sync(bot_handler)

     

       493
       -
                           

     

       494
        
                           time.sleep(self.sync_interval)

     

       495
        
                       except Exception as e:

     

       496
        
                           self.logger.error(f"Error in sync loop: {e}")

     

       497
        
                           time.sleep(60)  # Wait before retrying

     

       498
       -
                           

     

       499
        
               # Start background thread

     

       500
        
               import threading

     

       501
        
               sync_thread = threading.Thread(target=sync_loop, daemon=True)

     

       502
        
               sync_thread.start()

     

       503
        
       

     

       504
       -
           def _perform_sync(self, bot_handler: BotHandler) -> List[AtomEntry]:

     

       505
        
               """Perform thicket sync and return new entries."""

     

       506
        
               if not self.config or not self.git_store:

     

       507
        
                   return []

     

       508
       -
                   

     

       509
       -
               new_entries: List[Tuple[AtomEntry, str]] = []  # (entry, username) pairs

     

       510
        
               is_first_run = len(self.posted_entries) == 0

     

       511
       -
               

     

       512
        
               # Get all users and their feeds from git store

     

       513
        
               users_with_feeds = self.git_store.list_all_users_with_feeds()

     

       514
       -
               

     

       515
        
               # Sync each user's feeds

     

       516
        
               for username, feed_urls in users_with_feeds:

     

       517
        
                   for feed_url in feed_urls:

     
···

       523
        
                               new_count, _ = loop.run_until_complete(

     

       524
        
                                   sync_feed(self.git_store, username, str(feed_url), dry_run=False)

     

       525
        
                               )

     

       526
       -
                               

     

       527
        
                               entries_to_check = []

     

       528
       -
                               

     

       529
        
                               if new_count > 0:

     

       530
        
                                   # Get the newly added entries

     

       531
        
                                   entries_to_check = self.git_store.list_entries(username, limit=new_count)

     

       532
       -
                               

     

       533
        
                               # Always check for catchup mode on first run

     

       534
        
                               if is_first_run:

     

       535
       -
                                   # Catchup mode: get last 5 entries on first run

     

       536
       -
                                   catchup_entries = self.git_store.list_entries(username, limit=5)

     

       537
        
                                   entries_to_check = catchup_entries if not entries_to_check else entries_to_check

     

       538
       -
                               

     

       539
        
                               for entry in entries_to_check:

     

       540
        
                                   entry_key = f"{username}:{entry.id}"

     

       541
        
                                   if entry_key not in self.posted_entries:

     

       542
        
                                       new_entries.append((entry, username))

     

       543
        
                                       if len(new_entries) >= self.max_entries_per_sync:

     

       544
        
                                           break

     

       545
       -
                                               

     

       546
        
                           finally:

     

       547
        
                               loop.close()

     

       548
       -
                               

     

       549
        
                       except Exception as e:

     

       550
        
                           self.logger.error(f"Error syncing feed {feed_url} for user {username}: {e}")

     

       551
       -
                           

     

       552
        
                       if len(new_entries) >= self.max_entries_per_sync:

     

       553
        
                           break

     

       554
       -
                           

     

       555
        
               # Post new entries to Zulip with rate limiting

     

       556
        
               if new_entries:

     

       557
        
                   posted_count = 0

     

       558
       -
                   

     

       559
        
                   for i, (entry, username) in enumerate(new_entries):

     

       560
        
                       self._post_entry_to_zulip(entry, bot_handler, username)

     

       561
        
                       self.posted_entries.add(f"{username}:{entry.id}")

     

       562
        
                       posted_count += 1

     

       563
       -
                       

     

       564
       -
                       # Rate limiting: pause after every 5 messages

     

       565
       -
                       if posted_count % 5 == 0 and i < len(new_entries) - 1:

     

       566
       -
                           time.sleep(5)

     

       567
       -
                           

     

       568
        
                   self._save_posted_entries(bot_handler)

     

       569
       -
                   

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       570
        
               return [entry for entry, _ in new_entries]

     

       571
        
       

     

       572
        
           def _post_entry_to_zulip(self, entry: AtomEntry, bot_handler: BotHandler, username: str) -> None:

     
···

       575
        
                   # Get current Zulip server from environment

     

       576
        
                   zulip_site_url = os.getenv("THICKET_ZULIP_SITE_URL", "")

     

       577
        
                   server_url = zulip_site_url.replace("https://", "").replace("http://", "")

     

       578
       -
                   

     

       579
        
                   # Build author/date info consistently

     

       580
        
                   mention_info = ""

     

       581
        
                   if server_url and self.git_store:

     
···

       586
        
                               # Look up the actual Zulip full name for proper @mention

     

       587
        
                               _, zulip_full_name = self._lookup_zulip_user_info(bot_handler, zulip_user_id)

     

       588
        
                               display_name = zulip_full_name or user.display_name or username

     

       589
       -
                               

     

       590
        
                               # Check if author is different from the user - avoid redundancy

     

       591
        
                               author_name = entry.author and entry.author.get("name")

     

       592
        
                               if author_name and author_name.lower() != display_name.lower():

     

       593
        
                                   author_info = f" (by {author_name})"

     

       594
        
                               else:

     

       595
        
                                   author_info = ""

     

       596
       -
                               

     

       597
        
                               published_info = ""

     

       598
        
                               if entry.published:

     

       599
        
                                   published_info = f" • {entry.published.strftime('%Y-%m-%d')}"

     

       600
       -
                               

     

       601
        
                               mention_info = f"@**{display_name}** posted{author_info}{published_info}:\n\n"

     

       602
       -
                               

     

       603
        
                   # If no Zulip user found, use consistent format without @mention

     

       604
        
                   if not mention_info:

     

       605
        
                       user = self.git_store.get_user(username) if self.git_store else None

     

       606
        
                       display_name = user.display_name if user else username

     

       607
       -
                       

     

       608
        
                       author_name = entry.author and entry.author.get("name")

     

       609
        
                       if author_name and author_name.lower() != display_name.lower():

     

       610
        
                           author_info = f" (by {author_name})"

     

       611
        
                       else:

     

       612
        
                           author_info = ""

     

       613
       -
                       

     

       614
        
                       published_info = ""

     

       615
        
                       if entry.published:

     

       616
        
                           published_info = f" • {entry.published.strftime('%Y-%m-%d')}"

     

       617
       -
                       

     

       618
        
                       mention_info = f"**{display_name}** posted{author_info}{published_info}:\n\n"

     

       619
       -
                   

     

       620
        
                   # Format the message with HTML processing

     

       621
        
                   message_lines = [

     

       622
        
                       f"**{entry.title}**",

     

       623
        
                       f"🔗 {entry.link}",

     

       624
        
                   ]

     

       625
       -
                   

     

       626
        
                   if entry.summary:

     

       627
        
                       # Process HTML in summary and truncate if needed

     

       628
        
                       processed_summary = self._process_html_content(entry.summary)

     

       629
        
                       if len(processed_summary) > 400:

     

       630
        
                           processed_summary = processed_summary[:397] + "..."

     

       631
        
                       message_lines.append(f"\n{processed_summary}")

     

       632
       -
                   

     

       633
        
                   message_content = mention_info + "\n".join(message_lines)

     

       634
       -
                   

     

       635
        
                   # Choose destination based on mode

     

       636
        
                   if self.debug_user and self.debug_zulip_user_id:

     

       637
        
                       # Debug mode: send DM

     

       638
        
                       debug_message = f"🐛 **DEBUG:** New article from thicket user `{username}`:\n\n{message_content}"

     

       639
       -
                       

     

       640
        
                       # Ensure we have the numeric user ID

     

       641
        
                       user_id_to_use = self.debug_zulip_user_id

     

       642
        
                       if not user_id_to_use.isdigit():

     
···

       648
        
                           else:

     

       649
        
                               self.logger.error(f"Could not resolve user ID for {self.debug_zulip_user_id}")

     

       650
        
                               return

     

       651
       -
                       

     

       652
        
                       try:

     

       653
        
                           # For private messages, user_id needs to be an integer, not string

     

       654
        
                           user_id_int = int(user_id_to_use)

     
···

       661
        
                           # If conversion to int fails, user_id_to_use might be an email

     

       662
        
                           try:

     

       663
        
                               bot_handler.send_message({

     

       664
       -
                                   "type": "private", 

     

       665
        
                                   "to": [user_id_to_use],  # Try as string (email)

     

       666
        
                                   "content": debug_message

     

       667
        
                               })

     
···

       681
        
                           "content": message_content

     

       682
        
                       })

     

       683
        
                       self.logger.info(f"Posted entry to stream: {entry.title} (user: {username})")

     

       684
       -
                   

     

       685
        
               except Exception as e:

     

       686
        
                   self.logger.error(f"Error posting entry to Zulip: {e}")

     

       687
        
       

     
···

       689
        
               """Process HTML content from feeds to clean Zulip-compatible markdown."""

     

       690
        
               if not html_content:

     

       691
        
                   return ""

     

       692
       -
               

     

       693
        
               try:

     

       694
        
                   # Try to use markdownify for proper HTML to Markdown conversion

     

       695
        
                   from markdownify import markdownify as md

     

       696
       -
                   

     

       697
        
                   # Convert HTML to Markdown with compact settings for summaries

     

       698
        
                   markdown = md(

     

       699
        
                       html_content,

     
···

       701
        
                       bullets="-",  # Use - for bullets

     

       702
        
                       convert=['a', 'b', 'strong', 'i', 'em', 'code', 'pre', 'p', 'br', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']

     

       703
        
                   ).strip()

     

       704
       -
                   

     

       705
        
                   # Post-process to convert headings to bold for compact summaries

     

       706
        
                   import re

     

       707
        
                   # Convert markdown headers to bold with period

     

       708
        
                   markdown = re.sub(r'^#{1,6}\s*(.+)$', r'**\1.**', markdown, flags=re.MULTILINE)

     

       709
       -
                   

     

       710
        
                   # Clean up excessive newlines and make more compact

     

       711
        
                   markdown = re.sub(r'\n\s*\n\s*\n+', ' ', markdown)  # Multiple newlines become space

     

       712
        
                   markdown = re.sub(r'\n\s*\n', '. ', markdown)  # Double newlines become sentence breaks

     

       713
        
                   markdown = re.sub(r'\n', ' ', markdown)  # Single newlines become spaces

     

       714
       -
                   

     

       715
        
                   # Clean up double periods and excessive whitespace

     

       716
        
                   markdown = re.sub(r'\.\.+', '.', markdown)

     

       717
        
                   markdown = re.sub(r'\s+', ' ', markdown)

     

       718
        
                   return markdown.strip()

     

       719
       -
                       

     

       720
        
               except ImportError:

     

       721
        
                   # Fallback: manual HTML processing

     

       722
        
                   import re

     

       723
        
                   content = html_content

     

       724
       -
                   

     

       725
        
                   # Convert headings to bold with periods for compact summaries

     

       726
        
                   content = re.sub(r'<h[1-6](?:\s[^>]*)?>([^<]*)</h[1-6]>', r'**\1.** ', content, flags=re.IGNORECASE)

     

       727
       -
                   

     

       728
        
                   # Convert common HTML elements to Markdown

     

       729
        
                   content = re.sub(r'<(?:strong|b)(?:\s[^>]*)?>([^<]*)</(?:strong|b)>', r'**\1**', content, flags=re.IGNORECASE)

     

       730
        
                   content = re.sub(r'<(?:em|i)(?:\s[^>]*)?>([^<]*)</(?:em|i)>', r'*\1*', content, flags=re.IGNORECASE)

     

       731
        
                   content = re.sub(r'<code(?:\s[^>]*)?>([^<]*)</code>', r'`\1`', content, flags=re.IGNORECASE)

     

       732
        
                   content = re.sub(r'<a(?:\s[^>]*?)?\s*href=["\']([^"\']*)["\'](?:\s[^>]*)?>([^<]*)</a>', r'[\2](\1)', content, flags=re.IGNORECASE)

     

       733
       -
                   

     

       734
        
                   # Convert block elements to spaces instead of newlines for compactness

     

       735
        
                   content = re.sub(r'<br\s*/?>', ' ', content, flags=re.IGNORECASE)

     

       736
        
                   content = re.sub(r'</p>\s*<p>', '. ', content, flags=re.IGNORECASE)

     

       737
        
                   content = re.sub(r'</?(?:p|div)(?:\s[^>]*)?>', ' ', content, flags=re.IGNORECASE)

     

       738
       -
                   

     

       739
        
                   # Remove remaining HTML tags

     

       740
        
                   content = re.sub(r'<[^>]+>', '', content)

     

       741
       -
                   

     

       742
        
                   # Clean up whitespace and make compact

     

       743
        
                   content = re.sub(r'\s+', ' ', content)  # Multiple whitespace becomes single space

     

       744
        
                   content = re.sub(r'\.\.+', '.', content)  # Multiple periods become single period

     

       745
        
                   return content.strip()

     

       746
       -
               

     

       747
        
               except Exception as e:

     

       748
        
                   self.logger.error(f"Error processing HTML content: {e}")

     

       749
        
                   # Last resort: just strip HTML tags

     

       750
        
                   import re

     

       751
        
                   return re.sub(r'<[^>]+>', '', html_content).strip()

     

       752
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       753
        
       

     

       754
       -
       handler_class = ThicketBotHandler
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       5
        
       import logging

     

       6
        
       import os

     

       7
        
       import time

     

       0
        
       
     

       8
        
       from pathlib import Path

     

       9
       +
       from typing import Any, Optional

     

       10
        
       

     

       11
        
       from zulip_bots.lib import BotHandler

     

       12
        
       

     

       13
        
       # Handle imports for both direct execution and package import

     

       14
        
       try:

     

       15
       +
           from ..cli.commands.sync import sync_feed

     

       16
        
           from ..core.git_store import GitStore

     

       17
        
           from ..models import AtomEntry, ThicketConfig

     

       0
        
       
     

       18
        
       except ImportError:

     

       19
        
           # When run directly by zulip-bots, add the package to path

     

       20
        
           import sys

     

       21
        
           src_dir = Path(__file__).parent.parent.parent

     

       22
        
           if str(src_dir) not in sys.path:

     

       23
        
               sys.path.insert(0, str(src_dir))

     

       24
       +
       

     

       25
       +
           from thicket.cli.commands.sync import sync_feed

     

       26
        
           from thicket.core.git_store import GitStore

     

       27
        
           from thicket.models import AtomEntry, ThicketConfig

     

       0
        
       
     

       28
        
       

     

       29
        
       

     

       30
        
       class ThicketBotHandler:

     
···

       35
        
               self.logger = logging.getLogger(__name__)

     

       36
        
               self.git_store: Optional[GitStore] = None

     

       37
        
               self.config: Optional[ThicketConfig] = None

     

       38
       +
               self.posted_entries: set[str] = set()

     

       39
       +
       

     

       40
        
               # Bot configuration from storage

     

       41
        
               self.stream_name: Optional[str] = None

     

       42
        
               self.topic_name: Optional[str] = None

     

       43
        
               self.sync_interval: int = 300  # 5 minutes default

     

       44
        
               self.max_entries_per_sync: int = 10

     

       45
        
               self.config_path: Optional[Path] = None

     

       46
       +
       

     

       47
       +
               # Bot behavior settings (loaded from botrc)

     

       48
       +
               self.rate_limit_delay: int = 5

     

       49
       +
               self.posts_per_batch: int = 5

     

       50
       +
               self.catchup_entries: int = 5

     

       51
       +
               self.config_change_notifications: bool = True

     

       52
       +
               self.username_claim_notifications: bool = True

     

       53
       +
       

     

       54
       +
               # Track last sync time for schedule queries

     

       55
       +
               self.last_sync_time: Optional[float] = None

     

       56
       +
       

     

       57
        
               # Debug mode configuration

     

       58
        
               self.debug_user: Optional[str] = None

     

       59
        
               self.debug_zulip_user_id: Optional[str] = None

     

       60
       +
       

     

       61
        
           def usage(self) -> str:

     

       62
        
               """Return bot usage instructions."""

     

       63
        
               return """

     

       64
        
               **Thicket Feed Bot**

     

       65
       +
       

     

       66
        
               This bot automatically monitors thicket feeds and posts new articles.

     

       67
       +
       

     

       68
        
               Commands:

     

       69
       +
               - `@mention status` - Show current bot status and configuration

     

       70
        
               - `@mention sync now` - Force an immediate sync

     

       71
        
               - `@mention reset` - Clear posting history (will repost recent entries)

     

       72
        
               - `@mention config stream <stream_name>` - Set target stream

     

       73
       +
               - `@mention config topic <topic_name>` - Set target topic

     

       74
        
               - `@mention config interval <seconds>` - Set sync interval

     

       75
       +
               - `@mention schedule` - Show sync schedule and next run time

     

       76
       +
               - `@mention claim <username>` - Claim a thicket username for your Zulip account

     

       77
        
               - `@mention help` - Show this help message

     

       78
        
               """

     

       79
        
       

     

       80
        
           def initialize(self, bot_handler: BotHandler) -> None:

     

       81
        
               """Initialize the bot with persistent storage."""

     

       82
        
               self.logger.info("Initializing ThicketBot")

     

       83
       +
       

     

       84
        
               # Get configuration from environment (set by CLI)

     

       85
        
               self.debug_user = os.getenv("THICKET_DEBUG_USER")

     

       86
        
               config_path_env = os.getenv("THICKET_CONFIG_PATH")

     

       87
        
               if config_path_env:

     

       88
        
                   self.config_path = Path(config_path_env)

     

       89
        
                   self.logger.info(f"Using thicket config: {self.config_path}")

     

       90
       +
       

     

       91
       +
               # Load default configuration from botrc file

     

       92
       +
               self._load_botrc_defaults()

     

       93
       +
       

     

       94
        
               # Load bot configuration from persistent storage

     

       95
        
               self._load_bot_config(bot_handler)

     

       96
       +
       

     

       97
        
               # Initialize thicket components

     

       98
        
               if self.config_path:

     

       99
        
                   try:

     

       100
        
                       self._initialize_thicket()

     

       101
        
                       self._load_posted_entries(bot_handler)

     

       102
       +
       

     

       103
        
                       # Validate debug mode if enabled

     

       104
        
                       if self.debug_user:

     

       105
        
                           self._validate_debug_mode(bot_handler)

     

       106
       +
       

     

       107
        
                   except Exception as e:

     

       108
        
                       self.logger.error(f"Failed to initialize thicket: {e}")

     

       109
       +
       

     

       110
        
               # Start background sync loop

     

       111
        
               self._schedule_sync(bot_handler)

     

       112
        
       

     

       113
       +
           def handle_message(self, message: dict[str, Any], bot_handler: BotHandler) -> None:

     

       114
        
               """Handle incoming Zulip messages."""

     

       115
        
               content = message["content"].strip()

     

       116
        
               sender = message["sender_full_name"]

     

       117
       +
       

     

       118
        
               # Only respond to mentions

     

       119
        
               if not self._is_mentioned(content, bot_handler):

     

       120
        
                   return

     

       121
       +
       

     

       122
        
               # Parse command

     

       123
        
               cleaned_content = self._clean_mention(content, bot_handler)

     

       124
        
               command_parts = cleaned_content.split()

     

       125
       +
       

     

       126
        
               if not command_parts:

     

       127
        
                   self._send_help(message, bot_handler)

     

       128
        
                   return

     

       129
       +
       

     

       130
        
               command = command_parts[0].lower()

     

       131
       +
       

     

       132
        
               try:

     

       133
        
                   if command == "help":

     

       134
        
                       self._send_help(message, bot_handler)

     
···

       140
        
                       self._handle_reset_command(message, bot_handler, sender)

     

       141
        
                   elif command == "config":

     

       142
        
                       self._handle_config_command(message, bot_handler, command_parts[1:], sender)

     

       143
       +
                   elif command == "schedule":

     

       144
       +
                       self._handle_schedule_command(message, bot_handler, sender)

     

       145
       +
                   elif command == "claim":

     

       146
       +
                       self._handle_claim_command(message, bot_handler, command_parts[1:], sender)

     

       147
        
                   else:

     

       148
        
                       bot_handler.send_reply(message, f"Unknown command: {command}. Type `@mention help` for usage.")

     

       149
        
               except Exception as e:

     
···

       161
        
                           return f"@{bot_name}" in content.lower() or f"@**{bot_name}**" in content.lower()

     

       162
        
               except Exception as e:

     

       163
        
                   self.logger.debug(f"Could not get bot profile: {e}")

     

       164
       +
       

     

       165
        
               # Fallback to generic check

     

       166
        
               return "@thicket" in content.lower()

     

       167
       +
       

     

       168
        
           def _clean_mention(self, content: str, bot_handler: BotHandler) -> str:

     

       169
        
               """Remove bot mention from message content."""

     

       170
        
               import re

     

       171
       +
       

     

       172
        
               try:

     

       173
        
                   # Get bot's actual name from Zulip

     

       174
        
                   bot_info = bot_handler._client.get_profile()

     
···

       181
        
                           return content

     

       182
        
               except Exception as e:

     

       183
        
                   self.logger.debug(f"Could not get bot profile for mention cleaning: {e}")

     

       184
       +
       

     

       185
        
               # Fallback to removing @thicket

     

       186
        
               content = re.sub(r'@(?:\*\*)?thicket(?:\*\*)?', '', content, flags=re.IGNORECASE).strip()

     

       187
        
               return content

     

       188
        
       

     

       189
       +
           def _send_help(self, message: dict[str, Any], bot_handler: BotHandler) -> None:

     

       190
        
               """Send help message."""

     

       191
        
               bot_handler.send_reply(message, self.usage())

     

       192
        
       

     

       193
       +
           def _send_status(self, message: dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       194
        
               """Send bot status information."""

     

       195
        
               status_lines = [

     

       196
        
                   f"**Thicket Bot Status** (requested by {sender})",

     

       197
        
                   "",

     

       198
        
               ]

     

       199
       +
       

     

       200
        
               # Debug mode status

     

       201
        
               if self.debug_user:

     

       202
        
                   status_lines.extend([

     

       203
       +
                       "🐛 **Debug Mode:** ENABLED",

     

       204
        
                       f"🎯 **Debug User:** {self.debug_user}",

     

       205
        
                       "",

     

       206
        
                   ])

     
···

       210
        
                       f"📝 **Topic:** {self.topic_name or 'Not configured'}",

     

       211
        
                       "",

     

       212
        
                   ])

     

       213
       +
       

     

       214
        
               status_lines.extend([

     

       215
        
                   f"⏱️ **Sync Interval:** {self.sync_interval}s ({self.sync_interval // 60}m {self.sync_interval % 60}s)",

     

       216
        
                   f"📊 **Max Entries/Sync:** {self.max_entries_per_sync}",

     
···

       219
        
                   f"📄 **Tracked Entries:** {len(self.posted_entries)}",

     

       220
        
                   f"🔄 **Catchup Mode:** {'Active (first run)' if len(self.posted_entries) == 0 else 'Inactive'}",

     

       221
        
                   f"✅ **Thicket Initialized:** {'Yes' if self.git_store else 'No'}",

     

       222
       +
                   "",

     

       223
       +
                   self._get_schedule_info(),

     

       224
        
               ])

     

       225
       +
       

     

       226
        
               bot_handler.send_reply(message, "\n".join(status_lines))

     

       227
        
       

     

       228
       +
           def _handle_force_sync(self, message: dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       229
        
               """Handle immediate sync request."""

     

       230
        
               if not self._check_initialization(message, bot_handler):

     

       231
        
                   return

     

       232
       +
       

     

       233
        
               bot_handler.send_reply(message, f"🔄 Starting immediate sync... (requested by {sender})")

     

       234
       +
       

     

       235
        
               try:

     

       236
        
                   new_entries = self._perform_sync(bot_handler)

     

       237
        
                   bot_handler.send_reply(

     

       238
       +
                       message,

     

       239
        
                       f"✅ Sync completed! Found {len(new_entries)} new entries."

     

       240
        
                   )

     

       241
        
               except Exception as e:

     

       242
        
                   self.logger.error(f"Force sync failed: {e}")

     

       243
        
                   bot_handler.send_reply(message, f"❌ Sync failed: {str(e)}")

     

       244
        
       

     

       245
       +
           def _handle_reset_command(self, message: dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       246
        
               """Handle reset command to clear posted entries tracking."""

     

       247
        
               try:

     

       248
        
                   self.posted_entries.clear()

     
···

       256
        
                   self.logger.error(f"Reset failed: {e}")

     

       257
        
                   bot_handler.send_reply(message, f"❌ Reset failed: {str(e)}")

     

       258
        
       

     

       259
       +
           def _handle_schedule_command(self, message: dict[str, Any], bot_handler: BotHandler, sender: str) -> None:

     

       260
       +
               """Handle schedule query command."""

     

       261
       +
               schedule_info = self._get_schedule_info()

     

       262
       +
               bot_handler.send_reply(

     

       263
       +
                   message,

     

       264
       +
                   f"**Thicket Bot Schedule** (requested by {sender})\n\n{schedule_info}"

     

       265
       +
               )

     

       266
       +
       

     

       267
       +
           def _handle_claim_command(

     

       268
       +
               self,

     

       269
       +
               message: dict[str, Any],

     

       270
       +
               bot_handler: BotHandler,

     

       271
       +
               args: list[str],

     

       272
       +
               sender: str

     

       273
       +
           ) -> None:

     

       274
       +
               """Handle username claiming command."""

     

       275
       +
               if not args:

     

       276
       +
                   bot_handler.send_reply(message, "Usage: `@mention claim <username>`")

     

       277
       +
                   return

     

       278
       +
       

     

       279
       +
               if not self._check_initialization(message, bot_handler):

     

       280
       +
                   return

     

       281
       +
       

     

       282
       +
               username = args[0].strip()

     

       283
       +
       

     

       284
       +
               # Get sender's Zulip user info

     

       285
       +
               sender_user_id = message.get("sender_id")

     

       286
       +
               sender_email = message.get("sender_email")

     

       287
       +
       

     

       288
       +
               if not sender_user_id or not sender_email:

     

       289
       +
                   bot_handler.send_reply(message, "❌ Could not determine your Zulip user information.")

     

       290
       +
                   return

     

       291
       +
       

     

       292
       +
               try:

     

       293
       +
                   # Get current Zulip server from environment

     

       294
       +
                   zulip_site_url = os.getenv("THICKET_ZULIP_SITE_URL", "")

     

       295
       +
                   server_url = zulip_site_url.replace("https://", "").replace("http://", "")

     

       296
       +
       

     

       297
       +
                   if not server_url:

     

       298
       +
                       bot_handler.send_reply(message, "❌ Could not determine Zulip server URL.")

     

       299
       +
                       return

     

       300
       +
       

     

       301
       +
                   # Check if username exists in thicket

     

       302
       +
                   user = self.git_store.get_user(username)

     

       303
       +
                   if not user:

     

       304
       +
                       bot_handler.send_reply(

     

       305
       +
                           message,

     

       306
       +
                           f"❌ Username `{username}` not found in thicket. Available users: {', '.join(self.git_store.list_users())}"

     

       307
       +
                       )

     

       308
       +
                       return

     

       309
       +
       

     

       310
       +
                   # Check if username is already claimed for this server

     

       311
       +
                   existing_zulip_id = user.get_zulip_mention(server_url)

     

       312
       +
                   if existing_zulip_id:

     

       313
       +
                       # Check if it's claimed by the same user

     

       314
       +
                       if existing_zulip_id == sender_email or str(existing_zulip_id) == str(sender_user_id):

     

       315
       +
                           bot_handler.send_reply(

     

       316
       +
                               message,

     

       317
       +
                               f"✅ Username `{username}` is already claimed by you on {server_url}!"

     

       318
       +
                           )

     

       319
       +
                       else:

     

       320
       +
                           bot_handler.send_reply(

     

       321
       +
                               message,

     

       322
       +
                               f"❌ Username `{username}` is already claimed by another user on {server_url}."

     

       323
       +
                           )

     

       324
       +
                       return

     

       325
       +
       

     

       326
       +
                   # Claim the username - prefer email for consistency

     

       327
       +
                   success = self.git_store.add_zulip_association(username, server_url, sender_email)

     

       328
       +
       

     

       329
       +
                   if success:

     

       330
       +
                       reply_msg = f"🎉 Successfully claimed username `{username}` for **{sender}** on {server_url}!\n" + \

     

       331
       +
                                  "You will now be mentioned when new articles are posted from this user's feeds."

     

       332
       +
                       bot_handler.send_reply(message, reply_msg)

     

       333
       +
       

     

       334
       +
                       # Send notification to configured stream if enabled and not in debug mode

     

       335
       +
                       if (self.username_claim_notifications and

     

       336
       +
                           not self.debug_user and

     

       337
       +
                           self.stream_name and self.topic_name):

     

       338
       +
                           try:

     

       339
       +
                               notification_msg = f"👋 **{sender}** claimed thicket username `{username}` on {server_url}"

     

       340
       +
                               bot_handler.send_message({

     

       341
       +
                                   "type": "stream",

     

       342
       +
                                   "to": self.stream_name,

     

       343
       +
                                   "subject": self.topic_name,

     

       344
       +
                                   "content": notification_msg

     

       345
       +
                               })

     

       346
       +
                           except Exception as e:

     

       347
       +
                               self.logger.error(f"Failed to send username claim notification: {e}")

     

       348
       +
       

     

       349
       +
                       self.logger.info(f"User {sender} ({sender_email}) claimed username {username} on {server_url}")

     

       350
       +
                   else:

     

       351
       +
                       bot_handler.send_reply(

     

       352
       +
                           message,

     

       353
       +
                           f"❌ Failed to claim username `{username}`. This shouldn't happen - please contact an administrator."

     

       354
       +
                       )

     

       355
       +
       

     

       356
       +
               except Exception as e:

     

       357
       +
                   self.logger.error(f"Error processing claim for {username} by {sender}: {e}")

     

       358
       +
                   bot_handler.send_reply(message, f"❌ Error processing claim: {str(e)}")

     

       359
       +
       

     

       360
        
           def _handle_config_command(

     

       361
       +
               self,

     

       362
       +
               message: dict[str, Any],

     

       363
       +
               bot_handler: BotHandler,

     

       364
       +
               args: list[str],

     

       365
        
               sender: str

     

       366
        
           ) -> None:

     

       367
        
               """Handle configuration commands."""

     

       368
        
               if len(args) < 2:

     

       369
        
                   bot_handler.send_reply(message, "Usage: `@mention config <setting> <value>`")

     

       370
        
                   return

     

       371
       +
       

     

       372
        
               setting = args[0].lower()

     

       373
        
               value = " ".join(args[1:])

     

       374
       +
       

     

       375
        
               if setting == "stream":

     

       376
       +
                   old_value = self.stream_name

     

       377
        
                   self.stream_name = value

     

       378
        
                   self._save_bot_config(bot_handler)

     

       379
        
                   bot_handler.send_reply(message, f"✅ Stream set to: **{value}** (by {sender})")

     

       380
       +
                   self._send_config_change_notification(bot_handler, sender, "stream", old_value, value)

     

       381
       +
       

     

       382
        
               elif setting == "topic":

     

       383
       +
                   old_value = self.topic_name

     

       384
        
                   self.topic_name = value

     

       385
        
                   self._save_bot_config(bot_handler)

     

       386
        
                   bot_handler.send_reply(message, f"✅ Topic set to: **{value}** (by {sender})")

     

       387
       +
                   self._send_config_change_notification(bot_handler, sender, "topic", old_value, value)

     

       388
       +
       

     

       389
        
               elif setting == "interval":

     

       390
        
                   try:

     

       391
        
                       interval = int(value)

     

       392
        
                       if interval < 60:

     

       393
        
                           bot_handler.send_reply(message, "❌ Interval must be at least 60 seconds")

     

       394
        
                           return

     

       395
       +
                       old_value = self.sync_interval

     

       396
        
                       self.sync_interval = interval

     

       397
        
                       self._save_bot_config(bot_handler)

     

       398
        
                       bot_handler.send_reply(message, f"✅ Sync interval set to: **{interval}s** (by {sender})")

     

       399
       +
                       self._send_config_change_notification(bot_handler, sender, "sync interval", f"{old_value}s", f"{interval}s")

     

       400
        
                   except ValueError:

     

       401
        
                       bot_handler.send_reply(message, "❌ Invalid interval value. Must be a number of seconds.")

     

       402
       +
       

     

       403
       +
               elif setting == "max_entries":

     

       404
       +
                   try:

     

       405
       +
                       max_entries = int(value)

     

       406
       +
                       if max_entries < 1 or max_entries > 50:

     

       407
       +
                           bot_handler.send_reply(message, "❌ Max entries must be between 1 and 50")

     

       408
       +
                           return

     

       409
       +
                       old_value = self.max_entries_per_sync

     

       410
       +
                       self.max_entries_per_sync = max_entries

     

       411
       +
                       self._save_bot_config(bot_handler)

     

       412
       +
                       bot_handler.send_reply(message, f"✅ Max entries per sync set to: **{max_entries}** (by {sender})")

     

       413
       +
                       self._send_config_change_notification(bot_handler, sender, "max entries per sync", str(old_value), str(max_entries))

     

       414
       +
                   except ValueError:

     

       415
       +
                       bot_handler.send_reply(message, "❌ Invalid max entries value. Must be a number.")

     

       416
       +
       

     

       417
        
               else:

     

       418
        
                   bot_handler.send_reply(

     

       419
       +
                       message,

     

       420
       +
                       f"❌ Unknown setting: {setting}. Available: stream, topic, interval, max_entries"

     

       421
        
                   )

     

       422
        
       

     

       423
        
           def _load_bot_config(self, bot_handler: BotHandler) -> None:

     
···

       427
        
                   if config_data:

     

       428
        
                       config = json.loads(config_data)

     

       429
        
                       self.stream_name = config.get("stream_name")

     

       430
       +
                       self.topic_name = config.get("topic_name")

     

       431
        
                       self.sync_interval = config.get("sync_interval", 300)

     

       432
        
                       self.max_entries_per_sync = config.get("max_entries_per_sync", 10)

     

       433
       +
                       self.last_sync_time = config.get("last_sync_time")

     

       434
       +
               except Exception:

     

       435
        
                   # Bot config not found on first run is expected

     

       436
        
                   pass

     

       437
        
       

     
···

       443
        
                       "topic_name": self.topic_name,

     

       444
        
                       "sync_interval": self.sync_interval,

     

       445
        
                       "max_entries_per_sync": self.max_entries_per_sync,

     

       446
       +
                       "last_sync_time": self.last_sync_time,

     

       447
        
                   }

     

       448
        
                   bot_handler.storage.put("bot_config", json.dumps(config_data))

     

       449
        
               except Exception as e:

     

       450
        
                   self.logger.error(f"Error saving bot config: {e}")

     

       451
        
       

     

       452
       +
           def _load_botrc_defaults(self) -> None:

     

       453
       +
               """Load default configuration from botrc file."""

     

       454
       +
               try:

     

       455
       +
                   import configparser

     

       456
       +
                   from pathlib import Path

     

       457
       +
       

     

       458
       +
                   botrc_path = Path("bot-config/botrc")

     

       459
       +
                   if not botrc_path.exists():

     

       460
       +
                       self.logger.info("No botrc file found, using hardcoded defaults")

     

       461
       +
                       return

     

       462
       +
       

     

       463
       +
                   config = configparser.ConfigParser()

     

       464
       +
                   config.read(botrc_path)

     

       465
       +
       

     

       466
       +
                   if "bot" in config:

     

       467
       +
                       bot_section = config["bot"]

     

       468
       +
                       self.sync_interval = bot_section.getint("sync_interval", 300)

     

       469
       +
                       self.max_entries_per_sync = bot_section.getint("max_entries_per_sync", 10)

     

       470
       +
                       self.rate_limit_delay = bot_section.getint("rate_limit_delay", 5)

     

       471
       +
                       self.posts_per_batch = bot_section.getint("posts_per_batch", 5)

     

       472
       +
       

     

       473
       +
                       # Set defaults only if not already configured

     

       474
       +
                       default_stream = bot_section.get("default_stream", "").strip()

     

       475
       +
                       default_topic = bot_section.get("default_topic", "").strip()

     

       476
       +
                       if default_stream:

     

       477
       +
                           self.stream_name = default_stream

     

       478
       +
                       if default_topic:

     

       479
       +
                           self.topic_name = default_topic

     

       480
       +
       

     

       481
       +
                   if "catchup" in config:

     

       482
       +
                       catchup_section = config["catchup"]

     

       483
       +
                       self.catchup_entries = catchup_section.getint("catchup_entries", 5)

     

       484
       +
       

     

       485
       +
                   if "notifications" in config:

     

       486
       +
                       notifications_section = config["notifications"]

     

       487
       +
                       self.config_change_notifications = notifications_section.getboolean("config_change_notifications", True)

     

       488
       +
                       self.username_claim_notifications = notifications_section.getboolean("username_claim_notifications", True)

     

       489
       +
       

     

       490
       +
                   self.logger.info(f"Loaded configuration from {botrc_path}")

     

       491
       +
       

     

       492
       +
               except Exception as e:

     

       493
       +
                   self.logger.error(f"Error loading botrc defaults: {e}")

     

       494
       +
                   self.logger.info("Using hardcoded defaults")

     

       495
       +
       

     

       496
        
           def _initialize_thicket(self) -> None:

     

       497
        
               """Initialize thicket components."""

     

       498
        
               if not self.config_path or not self.config_path.exists():

     

       499
        
                   raise ValueError("Thicket config file not found")

     

       500
       +
       

     

       501
        
               # Load thicket configuration

     

       502
        
               import yaml

     

       503
        
               with open(self.config_path) as f:

     

       504
        
                   config_data = yaml.safe_load(f)

     

       505
        
               self.config = ThicketConfig(**config_data)

     

       506
       +
       

     

       507
        
               # Initialize git store

     

       508
        
               self.git_store = GitStore(self.config.git_store)

     

       509
       +
       

     

       510
        
               self.logger.info("Thicket components initialized successfully")

     

       511
       +
       

     

       512
        
           def _validate_debug_mode(self, bot_handler: BotHandler) -> None:

     

       513
        
               """Validate debug mode configuration."""

     

       514
        
               if not self.debug_user or not self.git_store:

     

       515
        
                   return

     

       516
       +
       

     

       517
        
               # Get current Zulip server from environment

     

       518
        
               zulip_site_url = os.getenv("THICKET_ZULIP_SITE_URL", "")

     

       519
        
               server_url = zulip_site_url.replace("https://", "").replace("http://", "")

     

       520
       +
       

     

       521
        
               # Check if debug user exists in thicket

     

       522
        
               user = self.git_store.get_user(self.debug_user)

     

       523
        
               if not user:

     

       524
        
                   raise ValueError(f"Debug user '{self.debug_user}' not found in thicket")

     

       525
       +
       

     

       526
        
               # Check if user has Zulip association for this server

     

       527
        
               if not server_url:

     

       528
        
                   raise ValueError("Could not determine Zulip server URL")

     

       529
       +
       

     

       530
        
               zulip_user_id = user.get_zulip_mention(server_url)

     

       531
        
               if not zulip_user_id:

     

       532
        
                   raise ValueError(f"User '{self.debug_user}' has no Zulip association for server '{server_url}'")

     

       533
       +
       

     

       534
        
               # Try to look up the actual Zulip user ID from the email address

     

       535
        
               # But don't fail if we can't - we'll try again when sending messages

     

       536
        
               actual_user_id = self._lookup_zulip_user_id(bot_handler, zulip_user_id)

     
···

       548
        
               # If it's already a numeric user ID, return it

     

       549
        
               if email_or_id.isdigit():

     

       550
        
                   return email_or_id

     

       551
       +
       

     

       552
        
               try:

     

       553
        
                   client = bot_handler._client

     

       554
        
                   if not client:

     

       555
        
                       self.logger.error("No Zulip client available for user lookup")

     

       556
        
                       return None

     

       557
       +
       

     

       558
        
                   # First try the get_user_by_email API if available

     

       559
        
                   try:

     

       560
        
                       user_result = client.get_user_by_email(email_or_id)

     
···

       566
        
                               return str(user_id)

     

       567
        
                   except (AttributeError, Exception):

     

       568
        
                       pass

     

       569
       +
       

     

       570
        
                   # Fallback: Get all users and search through them

     

       571
        
                   users_result = client.get_users()

     

       572
        
                   if users_result.get('result') == 'success':

     

       573
        
                       for user in users_result['members']:

     

       574
        
                           user_email = user.get('email', '')

     

       575
        
                           delivery_email = user.get('delivery_email', '')

     

       576
       +
       

     

       577
       +
                           if (user_email == email_or_id or

     

       578
        
                               delivery_email == email_or_id or

     

       579
        
                               str(user.get('user_id')) == email_or_id):

     

       580
        
                               user_id = user.get('user_id')

     

       581
        
                               return str(user_id)

     

       582
       +
       

     

       583
        
                       self.logger.error(f"No user found with identifier '{email_or_id}'. Searched {len(users_result['members'])} users.")

     

       584
        
                       return None

     

       585
        
                   else:

     

       586
        
                       self.logger.error(f"Failed to get users: {users_result.get('msg', 'Unknown error')}")

     

       587
        
                       return None

     

       588
       +
       

     

       589
        
               except Exception as e:

     

       590
        
                   self.logger.error(f"Error looking up user ID for '{email_or_id}': {e}")

     

       591
        
                   return None

     

       592
        
       

     

       593
       +
           def _lookup_zulip_user_info(self, bot_handler: BotHandler, email_or_id: str) -> tuple[Optional[str], Optional[str]]:

     

       594
        
               """Look up both Zulip user ID and full name from email address."""

     

       595
        
               if email_or_id.isdigit():

     

       596
        
                   return email_or_id, None

     

       597
       +
       

     

       598
        
               try:

     

       599
        
                   client = bot_handler._client

     

       600
        
                   if not client:

     

       601
        
                       return None, None

     

       602
       +
       

     

       603
        
                   # Try get_user_by_email API first

     

       604
        
                   try:

     

       605
        
                       user_result = client.get_user_by_email(email_or_id)

     
···

       611
        
                               return str(user_id), full_name

     

       612
        
                   except AttributeError:

     

       613
        
                       pass

     

       614
       +
       

     

       615
        
                   # Fallback: search all users

     

       616
        
                   users_result = client.get_users()

     

       617
        
                   if users_result.get('result') == 'success':

     

       618
        
                       for user in users_result['members']:

     

       619
       +
                           if (user.get('email') == email_or_id or

     

       620
        
                               user.get('delivery_email') == email_or_id):

     

       621
        
                               return str(user.get('user_id')), user.get('full_name', '')

     

       622
       +
       

     

       623
        
                   return None, None

     

       624
       +
       

     

       625
        
               except Exception as e:

     

       626
        
                   self.logger.error(f"Error looking up user info for '{email_or_id}': {e}")

     

       627
        
                   return None, None

     
···

       643
        
               except Exception as e:

     

       644
        
                   self.logger.error(f"Error saving posted entries: {e}")

     

       645
        
       

     

       646
       +
           def _check_initialization(self, message: dict[str, Any], bot_handler: BotHandler) -> bool:

     

       647
        
               """Check if thicket is properly initialized."""

     

       648
        
               if not self.git_store or not self.config:

     

       649
        
                   bot_handler.send_reply(

     

       650
       +
                       message,

     

       651
        
                       "❌ Thicket not initialized. Please check configuration."

     

       652
        
                   )

     

       653
        
                   return False

     

       654
       +
       

     

       655
        
               # In debug mode, we don't need stream/topic configuration

     

       656
        
               if self.debug_user:

     

       657
        
                   return True

     

       658
       +
       

     

       659
        
               if not self.stream_name or not self.topic_name:

     

       660
        
                   bot_handler.send_reply(

     

       661
        
                       message,

     

       662
        
                       "❌ Stream and topic must be configured first. Use `@mention config stream <name>` and `@mention config topic <name>`"

     

       663
        
                   )

     

       664
        
                   return False

     

       665
       +
       

     

       666
        
               return True

     

       667
        
       

     

       668
        
           def _schedule_sync(self, bot_handler: BotHandler) -> None:

     
···

       671
        
                   while True:

     

       672
        
                       try:

     

       673
        
                           # Check if we can sync

     

       674
       +
                           can_sync = (self.git_store and

     

       675
       +
                                     ((self.stream_name and self.topic_name) or

     

       676
        
                                      self.debug_user))

     

       677
       +
       

     

       678
        
                           if can_sync:

     

       679
        
                               self._perform_sync(bot_handler)

     

       680
       +
       

     

       681
        
                           time.sleep(self.sync_interval)

     

       682
        
                       except Exception as e:

     

       683
        
                           self.logger.error(f"Error in sync loop: {e}")

     

       684
        
                           time.sleep(60)  # Wait before retrying

     

       685
       +
       

     

       686
        
               # Start background thread

     

       687
        
               import threading

     

       688
        
               sync_thread = threading.Thread(target=sync_loop, daemon=True)

     

       689
        
               sync_thread.start()

     

       690
        
       

     

       691
       +
           def _perform_sync(self, bot_handler: BotHandler) -> list[AtomEntry]:

     

       692
        
               """Perform thicket sync and return new entries."""

     

       693
        
               if not self.config or not self.git_store:

     

       694
        
                   return []

     

       695
       +
       

     

       696
       +
               new_entries: list[tuple[AtomEntry, str]] = []  # (entry, username) pairs

     

       697
        
               is_first_run = len(self.posted_entries) == 0

     

       698
       +
       

     

       699
        
               # Get all users and their feeds from git store

     

       700
        
               users_with_feeds = self.git_store.list_all_users_with_feeds()

     

       701
       +
       

     

       702
        
               # Sync each user's feeds

     

       703
        
               for username, feed_urls in users_with_feeds:

     

       704
        
                   for feed_url in feed_urls:

     
···

       710
        
                               new_count, _ = loop.run_until_complete(

     

       711
        
                                   sync_feed(self.git_store, username, str(feed_url), dry_run=False)

     

       712
        
                               )

     

       713
       +
       

     

       714
        
                               entries_to_check = []

     

       715
       +
       

     

       716
        
                               if new_count > 0:

     

       717
        
                                   # Get the newly added entries

     

       718
        
                                   entries_to_check = self.git_store.list_entries(username, limit=new_count)

     

       719
       +
       

     

       720
        
                               # Always check for catchup mode on first run

     

       721
        
                               if is_first_run:

     

       722
       +
                                   # Catchup mode: get configured number of entries on first run

     

       723
       +
                                   catchup_entries = self.git_store.list_entries(username, limit=self.catchup_entries)

     

       724
        
                                   entries_to_check = catchup_entries if not entries_to_check else entries_to_check

     

       725
       +
       

     

       726
        
                               for entry in entries_to_check:

     

       727
        
                                   entry_key = f"{username}:{entry.id}"

     

       728
        
                                   if entry_key not in self.posted_entries:

     

       729
        
                                       new_entries.append((entry, username))

     

       730
        
                                       if len(new_entries) >= self.max_entries_per_sync:

     

       731
        
                                           break

     

       732
       +
       

     

       733
        
                           finally:

     

       734
        
                               loop.close()

     

       735
       +
       

     

       736
        
                       except Exception as e:

     

       737
        
                           self.logger.error(f"Error syncing feed {feed_url} for user {username}: {e}")

     

       738
       +
       

     

       739
        
                       if len(new_entries) >= self.max_entries_per_sync:

     

       740
        
                           break

     

       741
       +
       

     

       742
        
               # Post new entries to Zulip with rate limiting

     

       743
        
               if new_entries:

     

       744
        
                   posted_count = 0

     

       745
       +
       

     

       746
        
                   for i, (entry, username) in enumerate(new_entries):

     

       747
        
                       self._post_entry_to_zulip(entry, bot_handler, username)

     

       748
        
                       self.posted_entries.add(f"{username}:{entry.id}")

     

       749
        
                       posted_count += 1

     

       750
       +
       

     

       751
       +
                       # Rate limiting: pause after configured number of messages

     

       752
       +
                       if posted_count % self.posts_per_batch == 0 and i < len(new_entries) - 1:

     

       753
       +
                           time.sleep(self.rate_limit_delay)

     

       754
       +
       

     

       755
        
                   self._save_posted_entries(bot_handler)

     

       756
       +
       

     

       757
       +
               # Update last sync time

     

       758
       +
               self.last_sync_time = time.time()

     

       759
       +
       

     

       760
        
               return [entry for entry, _ in new_entries]

     

       761
        
       

     

       762
        
           def _post_entry_to_zulip(self, entry: AtomEntry, bot_handler: BotHandler, username: str) -> None:

     
···

       765
        
                   # Get current Zulip server from environment

     

       766
        
                   zulip_site_url = os.getenv("THICKET_ZULIP_SITE_URL", "")

     

       767
        
                   server_url = zulip_site_url.replace("https://", "").replace("http://", "")

     

       768
       +
       

     

       769
        
                   # Build author/date info consistently

     

       770
        
                   mention_info = ""

     

       771
        
                   if server_url and self.git_store:

     
···

       776
        
                               # Look up the actual Zulip full name for proper @mention

     

       777
        
                               _, zulip_full_name = self._lookup_zulip_user_info(bot_handler, zulip_user_id)

     

       778
        
                               display_name = zulip_full_name or user.display_name or username

     

       779
       +
       

     

       780
        
                               # Check if author is different from the user - avoid redundancy

     

       781
        
                               author_name = entry.author and entry.author.get("name")

     

       782
        
                               if author_name and author_name.lower() != display_name.lower():

     

       783
        
                                   author_info = f" (by {author_name})"

     

       784
        
                               else:

     

       785
        
                                   author_info = ""

     

       786
       +
       

     

       787
        
                               published_info = ""

     

       788
        
                               if entry.published:

     

       789
        
                                   published_info = f" • {entry.published.strftime('%Y-%m-%d')}"

     

       790
       +
       

     

       791
        
                               mention_info = f"@**{display_name}** posted{author_info}{published_info}:\n\n"

     

       792
       +
       

     

       793
        
                   # If no Zulip user found, use consistent format without @mention

     

       794
        
                   if not mention_info:

     

       795
        
                       user = self.git_store.get_user(username) if self.git_store else None

     

       796
        
                       display_name = user.display_name if user else username

     

       797
       +
       

     

       798
        
                       author_name = entry.author and entry.author.get("name")

     

       799
        
                       if author_name and author_name.lower() != display_name.lower():

     

       800
        
                           author_info = f" (by {author_name})"

     

       801
        
                       else:

     

       802
        
                           author_info = ""

     

       803
       +
       

     

       804
        
                       published_info = ""

     

       805
        
                       if entry.published:

     

       806
        
                           published_info = f" • {entry.published.strftime('%Y-%m-%d')}"

     

       807
       +
       

     

       808
        
                       mention_info = f"**{display_name}** posted{author_info}{published_info}:\n\n"

     

       809
       +
       

     

       810
        
                   # Format the message with HTML processing

     

       811
        
                   message_lines = [

     

       812
        
                       f"**{entry.title}**",

     

       813
        
                       f"🔗 {entry.link}",

     

       814
        
                   ]

     

       815
       +
       

     

       816
        
                   if entry.summary:

     

       817
        
                       # Process HTML in summary and truncate if needed

     

       818
        
                       processed_summary = self._process_html_content(entry.summary)

     

       819
        
                       if len(processed_summary) > 400:

     

       820
        
                           processed_summary = processed_summary[:397] + "..."

     

       821
        
                       message_lines.append(f"\n{processed_summary}")

     

       822
       +
       

     

       823
        
                   message_content = mention_info + "\n".join(message_lines)

     

       824
       +
       

     

       825
        
                   # Choose destination based on mode

     

       826
        
                   if self.debug_user and self.debug_zulip_user_id:

     

       827
        
                       # Debug mode: send DM

     

       828
        
                       debug_message = f"🐛 **DEBUG:** New article from thicket user `{username}`:\n\n{message_content}"

     

       829
       +
       

     

       830
        
                       # Ensure we have the numeric user ID

     

       831
        
                       user_id_to_use = self.debug_zulip_user_id

     

       832
        
                       if not user_id_to_use.isdigit():

     
···

       838
        
                           else:

     

       839
        
                               self.logger.error(f"Could not resolve user ID for {self.debug_zulip_user_id}")

     

       840
        
                               return

     

       841
       +
       

     

       842
        
                       try:

     

       843
        
                           # For private messages, user_id needs to be an integer, not string

     

       844
        
                           user_id_int = int(user_id_to_use)

     
···

       851
        
                           # If conversion to int fails, user_id_to_use might be an email

     

       852
        
                           try:

     

       853
        
                               bot_handler.send_message({

     

       854
       +
                                   "type": "private",

     

       855
        
                                   "to": [user_id_to_use],  # Try as string (email)

     

       856
        
                                   "content": debug_message

     

       857
        
                               })

     
···

       871
        
                           "content": message_content

     

       872
        
                       })

     

       873
        
                       self.logger.info(f"Posted entry to stream: {entry.title} (user: {username})")

     

       874
       +
       

     

       875
        
               except Exception as e:

     

       876
        
                   self.logger.error(f"Error posting entry to Zulip: {e}")

     

       877
        
       

     
···

       879
        
               """Process HTML content from feeds to clean Zulip-compatible markdown."""

     

       880
        
               if not html_content:

     

       881
        
                   return ""

     

       882
       +
       

     

       883
        
               try:

     

       884
        
                   # Try to use markdownify for proper HTML to Markdown conversion

     

       885
        
                   from markdownify import markdownify as md

     

       886
       +
       

     

       887
        
                   # Convert HTML to Markdown with compact settings for summaries

     

       888
        
                   markdown = md(

     

       889
        
                       html_content,

     
···

       891
        
                       bullets="-",  # Use - for bullets

     

       892
        
                       convert=['a', 'b', 'strong', 'i', 'em', 'code', 'pre', 'p', 'br', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']

     

       893
        
                   ).strip()

     

       894
       +
       

     

       895
        
                   # Post-process to convert headings to bold for compact summaries

     

       896
        
                   import re

     

       897
        
                   # Convert markdown headers to bold with period

     

       898
        
                   markdown = re.sub(r'^#{1,6}\s*(.+)$', r'**\1.**', markdown, flags=re.MULTILINE)

     

       899
       +
       

     

       900
        
                   # Clean up excessive newlines and make more compact

     

       901
        
                   markdown = re.sub(r'\n\s*\n\s*\n+', ' ', markdown)  # Multiple newlines become space

     

       902
        
                   markdown = re.sub(r'\n\s*\n', '. ', markdown)  # Double newlines become sentence breaks

     

       903
        
                   markdown = re.sub(r'\n', ' ', markdown)  # Single newlines become spaces

     

       904
       +
       

     

       905
        
                   # Clean up double periods and excessive whitespace

     

       906
        
                   markdown = re.sub(r'\.\.+', '.', markdown)

     

       907
        
                   markdown = re.sub(r'\s+', ' ', markdown)

     

       908
        
                   return markdown.strip()

     

       909
       +
       

     

       910
        
               except ImportError:

     

       911
        
                   # Fallback: manual HTML processing

     

       912
        
                   import re

     

       913
        
                   content = html_content

     

       914
       +
       

     

       915
        
                   # Convert headings to bold with periods for compact summaries

     

       916
        
                   content = re.sub(r'<h[1-6](?:\s[^>]*)?>([^<]*)</h[1-6]>', r'**\1.** ', content, flags=re.IGNORECASE)

     

       917
       +
       

     

       918
        
                   # Convert common HTML elements to Markdown

     

       919
        
                   content = re.sub(r'<(?:strong|b)(?:\s[^>]*)?>([^<]*)</(?:strong|b)>', r'**\1**', content, flags=re.IGNORECASE)

     

       920
        
                   content = re.sub(r'<(?:em|i)(?:\s[^>]*)?>([^<]*)</(?:em|i)>', r'*\1*', content, flags=re.IGNORECASE)

     

       921
        
                   content = re.sub(r'<code(?:\s[^>]*)?>([^<]*)</code>', r'`\1`', content, flags=re.IGNORECASE)

     

       922
        
                   content = re.sub(r'<a(?:\s[^>]*?)?\s*href=["\']([^"\']*)["\'](?:\s[^>]*)?>([^<]*)</a>', r'[\2](\1)', content, flags=re.IGNORECASE)

     

       923
       +
       

     

       924
        
                   # Convert block elements to spaces instead of newlines for compactness

     

       925
        
                   content = re.sub(r'<br\s*/?>', ' ', content, flags=re.IGNORECASE)

     

       926
        
                   content = re.sub(r'</p>\s*<p>', '. ', content, flags=re.IGNORECASE)

     

       927
        
                   content = re.sub(r'</?(?:p|div)(?:\s[^>]*)?>', ' ', content, flags=re.IGNORECASE)

     

       928
       +
       

     

       929
        
                   # Remove remaining HTML tags

     

       930
        
                   content = re.sub(r'<[^>]+>', '', content)

     

       931
       +
       

     

       932
        
                   # Clean up whitespace and make compact

     

       933
        
                   content = re.sub(r'\s+', ' ', content)  # Multiple whitespace becomes single space

     

       934
        
                   content = re.sub(r'\.\.+', '.', content)  # Multiple periods become single period

     

       935
        
                   return content.strip()

     

       936
       +
       

     

       937
        
               except Exception as e:

     

       938
        
                   self.logger.error(f"Error processing HTML content: {e}")

     

       939
        
                   # Last resort: just strip HTML tags

     

       940
        
                   import re

     

       941
        
                   return re.sub(r'<[^>]+>', '', html_content).strip()

     

       942
        
       

     

       943
       +
           def _get_schedule_info(self) -> str:

     

       944
       +
               """Get schedule information string."""

     

       945
       +
               lines = []

     

       946
        
       

     

       947
       +
               if self.last_sync_time:

     

       948
       +
                   import datetime

     

       949
       +
                   last_sync = datetime.datetime.fromtimestamp(self.last_sync_time)

     

       950
       +
                   next_sync = last_sync + datetime.timedelta(seconds=self.sync_interval)

     

       951
       +
                   now = datetime.datetime.now()

     

       952
       +
       

     

       953
       +
                   # Calculate time until next sync

     

       954
       +
                   time_until_next = next_sync - now

     

       955
       +
       

     

       956
       +
                   if time_until_next.total_seconds() > 0:

     

       957
       +
                       minutes, seconds = divmod(int(time_until_next.total_seconds()), 60)

     

       958
       +
                       hours, minutes = divmod(minutes, 60)

     

       959
       +
       

     

       960
       +
                       if hours > 0:

     

       961
       +
                           time_str = f"{hours}h {minutes}m {seconds}s"

     

       962
       +
                       elif minutes > 0:

     

       963
       +
                           time_str = f"{minutes}m {seconds}s"

     

       964
       +
                       else:

     

       965
       +
                           time_str = f"{seconds}s"

     

       966
       +
       

     

       967
       +
                       lines.extend([

     

       968
       +
                           f"🕐 **Last Sync:** {last_sync.strftime('%H:%M:%S')}",

     

       969
       +
                           f"⏰ **Next Sync:** {next_sync.strftime('%H:%M:%S')} (in {time_str})",

     

       970
       +
                       ])

     

       971
       +
                   else:

     

       972
       +
                       lines.extend([

     

       973
       +
                           f"🕐 **Last Sync:** {last_sync.strftime('%H:%M:%S')}",

     

       974
       +
                           f"⏰ **Next Sync:** Due now (running every {self.sync_interval}s)",

     

       975
       +
                       ])

     

       976
       +
               else:

     

       977
       +
                   lines.append("🕐 **Last Sync:** Never (bot starting up)")

     

       978
       +
       

     

       979
       +
               # Add sync frequency info

     

       980
       +
               if self.sync_interval >= 3600:

     

       981
       +
                   frequency_str = f"{self.sync_interval // 3600}h {(self.sync_interval % 3600) // 60}m"

     

       982
       +
               elif self.sync_interval >= 60:

     

       983
       +
                   frequency_str = f"{self.sync_interval // 60}m {self.sync_interval % 60}s"

     

       984
       +
               else:

     

       985
       +
                   frequency_str = f"{self.sync_interval}s"

     

       986
       +
       

     

       987
       +
               lines.append(f"🔄 **Sync Frequency:** Every {frequency_str}")

     

       988
       +
       

     

       989
       +
               return "\n".join(lines)

     

       990
       +
       

     

       991
       +
           def _send_config_change_notification(self, bot_handler: BotHandler, changer: str, setting: str, old_value: Optional[str], new_value: str) -> None:

     

       992
       +
               """Send configuration change notification if enabled."""

     

       993
       +
               if not self.config_change_notifications or self.debug_user:

     

       994
       +
                   return

     

       995
       +
       

     

       996
       +
               # Don't send notification if stream/topic aren't configured yet

     

       997
       +
               if not self.stream_name or not self.topic_name:

     

       998
       +
                   return

     

       999
       +
       

     

       1000
       +
               try:

     

       1001
       +
                   old_display = old_value if old_value else "(not set)"

     

       1002
       +
                   notification_msg = f"⚙️ **{changer}** changed {setting}: `{old_display}` → `{new_value}`"

     

       1003
       +
       

     

       1004
       +
                   bot_handler.send_message({

     

       1005
       +
                       "type": "stream",

     

       1006
       +
                       "to": self.stream_name,

     

       1007
       +
                       "subject": self.topic_name,

     

       1008
       +
                       "content": notification_msg

     

       1009
       +
                   })

     

       1010
       +
               except Exception as e:

     

       1011
       +
                   self.logger.error(f"Failed to send config change notification: {e}")

     

       1012
       +
       

     

       1013
       +
       

     

       1014
       +
       handler_class = ThicketBotHandler

     

       1015
       +

+12 -1

src/thicket/cli/commands/__init__.py

···

       1
        
       """CLI commands for thicket."""

     

       2
        
       

     

       3
        
       # Import all commands to register them with the main app

     

       4
       -
       from . import add, bot, duplicates, info_cmd, init, list_cmd, search, sync, upload, zulip

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
        
       __all__ = ["add", "bot", "duplicates", "info_cmd", "init", "list_cmd", "search", "sync", "upload", "zulip"]

···

       1
        
       """CLI commands for thicket."""

     

       2
        
       

     

       3
        
       # Import all commands to register them with the main app

     

       4
       +
       from . import (

     

       5
       +
           add,

     

       6
       +
           bot,

     

       7
       +
           duplicates,

     

       8
       +
           info_cmd,

     

       9
       +
           init,

     

       10
       +
           list_cmd,

     

       11
       +
           search,

     

       12
       +
           sync,

     

       13
       +
           upload,

     

       14
       +
           zulip,

     

       15
       +
       )

     

       16
        
       

     

       17
        
       __all__ = ["add", "bot", "duplicates", "info_cmd", "init", "list_cmd", "search", "sync", "upload", "zulip"]

+35 -33

src/thicket/cli/commands/bot.py

···

       30
        
           daemon: bool = typer.Option(

     

       31
        
               False,

     

       32
        
               "--daemon",

     

       33
       -
               "-d", 

     

       34
        
               help="Run bot in daemon mode (background)",

     

       35
        
           ),

     

       36
        
           debug_user: str = typer.Option(

     
···

       46
        
           - test: Test bot functionality

     

       47
        
           - status: Show bot status

     

       48
        
           """

     

       49
       -
           

     

       50
        
           if action == "run":

     

       51
        
               _run_bot(config_file, thicket_config, daemon, debug_user)

     

       52
        
           elif action == "test":

     
···

       64
        
           if not config_file.exists():

     

       65
        
               print_error(f"Configuration file not found: {config_file}")

     

       66
        
               print_info(f"Copy bot-config/zuliprc.template to {config_file} and configure it")

     

       0
        
       
     

       67
        
               raise typer.Exit(1)

     

       68
       -
           

     

       69
        
           if not thicket_config.exists():

     

       70
        
               print_error(f"Thicket configuration file not found: {thicket_config}")

     

       71
        
               print_info("Run `thicket init` to create a thicket.yaml file")

     

       72
        
               raise typer.Exit(1)

     

       73
       -
               

     

       74
        
           # Parse zuliprc to extract server URL

     

       75
        
           zulip_site_url = _parse_zulip_config(config_file)

     

       76
       -
               

     

       77
        
           print_info(f"Starting Thicket Zulip bot with config: {config_file}")

     

       78
        
           print_info(f"Using thicket config: {thicket_config}")

     

       79
       -
           

     

       80
        
           if debug_user:

     

       81
        
               print_info(f"🐛 DEBUG MODE: Will send DMs to thicket user '{debug_user}' instead of posting to streams")

     

       82
       -
           

     

       83
        
           if daemon:

     

       84
        
               print_info("Running in daemon mode...")

     

       85
        
           else:

     

       86
        
               print_info("Bot will be available as @thicket in your Zulip chat")

     

       87
        
               print_info("Press Ctrl+C to stop the bot")

     

       88
       -
               

     

       89
        
           try:

     

       90
        
               # Build the command

     

       91
        
               cmd = [

     
···

       93
        
                   "src/thicket/bots/thicket_bot.py",

     

       94
        
                   "--config-file", str(config_file)

     

       95
        
               ]

     

       96
       -
               

     

       97
        
               # Add environment variables for bot configuration

     

       98
        
               import os

     

       99
        
               env = os.environ.copy()

     

       100
       -
               

     

       101
        
               # Always pass thicket config path

     

       102
        
               env["THICKET_CONFIG_PATH"] = str(thicket_config.absolute())

     

       103
       -
               

     

       104
        
               # Add debug user if specified

     

       105
        
               if debug_user:

     

       106
        
                   env["THICKET_DEBUG_USER"] = debug_user

     

       107
       -
                   

     

       108
        
               # Pass Zulip server URL to bot

     

       109
        
               if zulip_site_url:

     

       110
        
                   env["THICKET_ZULIP_SITE_URL"] = zulip_site_url

     

       111
       -
               

     

       112
        
               if daemon:

     

       113
        
                   # Run in background

     

       114
        
                   process = subprocess.Popen(

     
···

       122
        
               else:

     

       123
        
                   # Run in foreground

     

       124
        
                   subprocess.run(cmd, check=True, env=env)

     

       125
       -
                   

     

       126
        
           except subprocess.CalledProcessError as e:

     

       127
        
               print_error(f"Failed to start bot: {e}")

     

       128
        
               raise typer.Exit(1)

     
···

       134
        
           """Parse zuliprc file to extract the site URL."""

     

       135
        
           try:

     

       136
        
               import configparser

     

       137
       -
               

     

       138
        
               config = configparser.ConfigParser()

     

       139
        
               config.read(config_file)

     

       140
       -
               

     

       141
        
               if "api" in config and "site" in config["api"]:

     

       142
        
                   site_url = config["api"]["site"]

     

       143
        
                   print_info(f"Detected Zulip server: {site_url}")

     
···

       145
        
               else:

     

       146
        
                   print_error("Could not find 'site' in zuliprc [api] section")

     

       147
        
                   return ""

     

       148
       -
                   

     

       149
        
           except Exception as e:

     

       150
        
               print_error(f"Error parsing zuliprc: {e}")

     

       151
        
               return ""

     
···

       154
        
       def _test_bot() -> None:

     

       155
        
           """Test bot functionality."""

     

       156
        
           print_info("Testing Thicket Zulip bot...")

     

       157
       -
           

     

       158
        
           try:

     

       159
        
               from ...bots.test_bot import BotTester

     

       160
       -
               

     

       161
        
               # Create bot tester

     

       162
        
               tester = BotTester()

     

       163
       -
               

     

       164
        
               # Test basic functionality

     

       165
        
               console.print("✓ Testing help command...", style="green")

     

       166
        
               responses = tester.send_command("help")

     

       167
        
               assert len(responses) == 1

     

       168
        
               assert "Thicket Feed Bot" in tester.get_last_response_content()

     

       169
       -
               

     

       170
       -
               console.print("✓ Testing status command...", style="green")  

     

       171
        
               responses = tester.send_command("status")

     

       172
        
               assert len(responses) == 1

     

       173
        
               assert "Status" in tester.get_last_response_content()

     

       174
       -
               

     

       175
        
               console.print("✓ Testing config commands...", style="green")

     

       176
        
               responses = tester.send_command("config stream test-stream")

     

       177
        
               tester.assert_response_contains("Stream set to")

     

       178
       -
               

     

       179
        
               responses = tester.send_command("config topic test-topic")

     

       180
        
               tester.assert_response_contains("Topic set to")

     

       181
       -
               

     

       182
        
               responses = tester.send_command("config interval 300")

     

       183
        
               tester.assert_response_contains("Sync interval set to")

     

       184
       -
               

     

       185
        
               print_success("All bot tests passed!")

     

       186
       -
               

     

       187
        
           except Exception as e:

     

       188
        
               print_error(f"Bot test failed: {e}")

     

       189
        
               raise typer.Exit(1)

     
···

       193
        
           """Show bot status."""

     

       194
        
           console.print("Thicket Zulip Bot Status", style="bold blue")

     

       195
        
           console.print()

     

       196
       -
           

     

       197
        
           # Check config file

     

       198
        
           if config_file.exists():

     

       199
        
               console.print(f"✓ Config file: {config_file}", style="green")

     

       200
        
           else:

     

       201
        
               console.print(f"✗ Config file not found: {config_file}", style="red")

     

       202
        
               console.print("  Copy bot-config/zuliprc.template and configure it", style="yellow")

     

       203
       -
               

     

       0
        
       
     

       204
        
           # Check dependencies

     

       205
        
           try:

     

       206
        
               import zulip_bots

     
···

       208
        
               console.print(f"✓ zulip-bots version: {version}", style="green")

     

       209
        
           except ImportError:

     

       210
        
               console.print("✗ zulip-bots not installed", style="red")

     

       211
       -
               

     

       212
        
           try:

     

       213
        
               from ...bots.thicket_bot import ThicketBotHandler

     

       214
        
               console.print("✓ ThicketBotHandler available", style="green")

     

       215
        
           except ImportError as e:

     

       216
        
               console.print(f"✗ Bot handler not available: {e}", style="red")

     

       217
       -
               

     

       218
        
           # Check bot file

     

       219
        
           bot_file = Path("src/thicket/bots/thicket_bot.py")

     

       220
        
           if bot_file.exists():

     

       221
        
               console.print(f"✓ Bot file: {bot_file}", style="green")

     

       222
        
           else:

     

       223
        
               console.print(f"✗ Bot file not found: {bot_file}", style="red")

     

       224
       -
               

     

       225
        
           console.print()

     

       226
        
           console.print("To run the bot:", style="bold")

     

       227
        
           console.print(f"  thicket bot run --config {config_file}")

     

       228
        
           console.print()

     

       229
       -
           console.print("For help setting up the bot, see: docs/ZULIP_BOT.md", style="dim")

···

       30
        
           daemon: bool = typer.Option(

     

       31
        
               False,

     

       32
        
               "--daemon",

     

       33
       +
               "-d",

     

       34
        
               help="Run bot in daemon mode (background)",

     

       35
        
           ),

     

       36
        
           debug_user: str = typer.Option(

     
···

       46
        
           - test: Test bot functionality

     

       47
        
           - status: Show bot status

     

       48
        
           """

     

       49
       +
       

     

       50
        
           if action == "run":

     

       51
        
               _run_bot(config_file, thicket_config, daemon, debug_user)

     

       52
        
           elif action == "test":

     
···

       64
        
           if not config_file.exists():

     

       65
        
               print_error(f"Configuration file not found: {config_file}")

     

       66
        
               print_info(f"Copy bot-config/zuliprc.template to {config_file} and configure it")

     

       67
       +
               print_info("See bot-config/README.md for setup instructions")

     

       68
        
               raise typer.Exit(1)

     

       69
       +
       

     

       70
        
           if not thicket_config.exists():

     

       71
        
               print_error(f"Thicket configuration file not found: {thicket_config}")

     

       72
        
               print_info("Run `thicket init` to create a thicket.yaml file")

     

       73
        
               raise typer.Exit(1)

     

       74
       +
       

     

       75
        
           # Parse zuliprc to extract server URL

     

       76
        
           zulip_site_url = _parse_zulip_config(config_file)

     

       77
       +
       

     

       78
        
           print_info(f"Starting Thicket Zulip bot with config: {config_file}")

     

       79
        
           print_info(f"Using thicket config: {thicket_config}")

     

       80
       +
       

     

       81
        
           if debug_user:

     

       82
        
               print_info(f"🐛 DEBUG MODE: Will send DMs to thicket user '{debug_user}' instead of posting to streams")

     

       83
       +
       

     

       84
        
           if daemon:

     

       85
        
               print_info("Running in daemon mode...")

     

       86
        
           else:

     

       87
        
               print_info("Bot will be available as @thicket in your Zulip chat")

     

       88
        
               print_info("Press Ctrl+C to stop the bot")

     

       89
       +
       

     

       90
        
           try:

     

       91
        
               # Build the command

     

       92
        
               cmd = [

     
···

       94
        
                   "src/thicket/bots/thicket_bot.py",

     

       95
        
                   "--config-file", str(config_file)

     

       96
        
               ]

     

       97
       +
       

     

       98
        
               # Add environment variables for bot configuration

     

       99
        
               import os

     

       100
        
               env = os.environ.copy()

     

       101
       +
       

     

       102
        
               # Always pass thicket config path

     

       103
        
               env["THICKET_CONFIG_PATH"] = str(thicket_config.absolute())

     

       104
       +
       

     

       105
        
               # Add debug user if specified

     

       106
        
               if debug_user:

     

       107
        
                   env["THICKET_DEBUG_USER"] = debug_user

     

       108
       +
       

     

       109
        
               # Pass Zulip server URL to bot

     

       110
        
               if zulip_site_url:

     

       111
        
                   env["THICKET_ZULIP_SITE_URL"] = zulip_site_url

     

       112
       +
       

     

       113
        
               if daemon:

     

       114
        
                   # Run in background

     

       115
        
                   process = subprocess.Popen(

     
···

       123
        
               else:

     

       124
        
                   # Run in foreground

     

       125
        
                   subprocess.run(cmd, check=True, env=env)

     

       126
       +
       

     

       127
        
           except subprocess.CalledProcessError as e:

     

       128
        
               print_error(f"Failed to start bot: {e}")

     

       129
        
               raise typer.Exit(1)

     
···

       135
        
           """Parse zuliprc file to extract the site URL."""

     

       136
        
           try:

     

       137
        
               import configparser

     

       138
       +
       

     

       139
        
               config = configparser.ConfigParser()

     

       140
        
               config.read(config_file)

     

       141
       +
       

     

       142
        
               if "api" in config and "site" in config["api"]:

     

       143
        
                   site_url = config["api"]["site"]

     

       144
        
                   print_info(f"Detected Zulip server: {site_url}")

     
···

       146
        
               else:

     

       147
        
                   print_error("Could not find 'site' in zuliprc [api] section")

     

       148
        
                   return ""

     

       149
       +
       

     

       150
        
           except Exception as e:

     

       151
        
               print_error(f"Error parsing zuliprc: {e}")

     

       152
        
               return ""

     
···

       155
        
       def _test_bot() -> None:

     

       156
        
           """Test bot functionality."""

     

       157
        
           print_info("Testing Thicket Zulip bot...")

     

       158
       +
       

     

       159
        
           try:

     

       160
        
               from ...bots.test_bot import BotTester

     

       161
       +
       

     

       162
        
               # Create bot tester

     

       163
        
               tester = BotTester()

     

       164
       +
       

     

       165
        
               # Test basic functionality

     

       166
        
               console.print("✓ Testing help command...", style="green")

     

       167
        
               responses = tester.send_command("help")

     

       168
        
               assert len(responses) == 1

     

       169
        
               assert "Thicket Feed Bot" in tester.get_last_response_content()

     

       170
       +
       

     

       171
       +
               console.print("✓ Testing status command...", style="green")

     

       172
        
               responses = tester.send_command("status")

     

       173
        
               assert len(responses) == 1

     

       174
        
               assert "Status" in tester.get_last_response_content()

     

       175
       +
       

     

       176
        
               console.print("✓ Testing config commands...", style="green")

     

       177
        
               responses = tester.send_command("config stream test-stream")

     

       178
        
               tester.assert_response_contains("Stream set to")

     

       179
       +
       

     

       180
        
               responses = tester.send_command("config topic test-topic")

     

       181
        
               tester.assert_response_contains("Topic set to")

     

       182
       +
       

     

       183
        
               responses = tester.send_command("config interval 300")

     

       184
        
               tester.assert_response_contains("Sync interval set to")

     

       185
       +
       

     

       186
        
               print_success("All bot tests passed!")

     

       187
       +
       

     

       188
        
           except Exception as e:

     

       189
        
               print_error(f"Bot test failed: {e}")

     

       190
        
               raise typer.Exit(1)

     
···

       194
        
           """Show bot status."""

     

       195
        
           console.print("Thicket Zulip Bot Status", style="bold blue")

     

       196
        
           console.print()

     

       197
       +
       

     

       198
        
           # Check config file

     

       199
        
           if config_file.exists():

     

       200
        
               console.print(f"✓ Config file: {config_file}", style="green")

     

       201
        
           else:

     

       202
        
               console.print(f"✗ Config file not found: {config_file}", style="red")

     

       203
        
               console.print("  Copy bot-config/zuliprc.template and configure it", style="yellow")

     

       204
       +
               console.print("  See bot-config/README.md for setup instructions", style="yellow")

     

       205
       +
       

     

       206
        
           # Check dependencies

     

       207
        
           try:

     

       208
        
               import zulip_bots

     
···

       210
        
               console.print(f"✓ zulip-bots version: {version}", style="green")

     

       211
        
           except ImportError:

     

       212
        
               console.print("✗ zulip-bots not installed", style="red")

     

       213
       +
       

     

       214
        
           try:

     

       215
        
               from ...bots.thicket_bot import ThicketBotHandler

     

       216
        
               console.print("✓ ThicketBotHandler available", style="green")

     

       217
        
           except ImportError as e:

     

       218
        
               console.print(f"✗ Bot handler not available: {e}", style="red")

     

       219
       +
       

     

       220
        
           # Check bot file

     

       221
        
           bot_file = Path("src/thicket/bots/thicket_bot.py")

     

       222
        
           if bot_file.exists():

     

       223
        
               console.print(f"✓ Bot file: {bot_file}", style="green")

     

       224
        
           else:

     

       225
        
               console.print(f"✗ Bot file not found: {bot_file}", style="red")

     

       226
       +
       

     

       227
        
           console.print()

     

       228
        
           console.print("To run the bot:", style="bold")

     

       229
        
           console.print(f"  thicket bot run --config {config_file}")

     

       230
        
           console.print()

     

       231
       +
           console.print("For help setting up the bot, see: docs/ZULIP_BOT.md", style="dim")

+18 -20

src/thicket/cli/commands/search.py

···

       7
        
       import typer

     

       8
        
       from rich.console import Console

     

       9
        
       from rich.table import Table

     

       10
       -
       from rich.text import Text

     

       11
        
       

     

       12
        
       from ...core.typesense_client import TypesenseClient, TypesenseConfig

     

       13
        
       from ..main import app

     

       14
       -
       from ..utils import load_config

     

       15
        
       

     

       16
        
       console = Console()

     

       17
        
       logger = logging.getLogger(__name__)

     
···

       139
        
               )

     

       140
        
               typesense_config.connection_timeout = timeout

     

       141
        
       

     

       142
       -
               console.print(f"[bold blue]Searching thicket entries[/bold blue]")

     

       143
        
               console.print(f"Query: [cyan]{query}[/cyan]")

     

       144
        
               if user:

     

       145
        
                   console.print(f"User filter: [yellow]{user}[/yellow]")

     
···

       159
        
               # Perform search

     

       160
        
               try:

     

       161
        
                   results = typesense_client.search(query, search_params)

     

       162
       -
                   

     

       163
        
                   if raw:

     

       164
        
                       import json

     

       165
        
                       console.print(json.dumps(results, indent=2))

     
···

       189
        
               return

     

       190
        
       

     

       191
        
           console.print(f"\n[green]Found {found} results in {search_time}ms[/green]")

     

       192
       -
           

     

       193
        
           table = Table(title=f"Search Results for '{query}'", show_lines=True)

     

       194
        
           table.add_column("Score", style="green", width=8, no_wrap=True)

     

       195
        
           table.add_column("User", style="cyan", width=15, no_wrap=True)

     
···

       199
        
       

     

       200
        
           for hit in hits:

     

       201
        
               doc = hit['document']

     

       202
       -
               

     

       203
        
               # Format score

     

       204
        
               score = f"{hit.get('text_match', 0):.2f}"

     

       205
       -
               

     

       206
        
               # Format user

     

       207
        
               user_display = doc.get('user_display_name', doc.get('username', 'Unknown'))

     

       208
        
               if len(user_display) > 12:

     

       209
        
                   user_display = user_display[:9] + "..."

     

       210
       -
                   

     

       211
        
               # Format title

     

       212
        
               title = doc.get('title', 'Untitled')

     

       213
        
               if len(title) > 40:

     

       214
        
                   title = title[:37] + "..."

     

       215
       -
                   

     

       216
        
               # Format date

     

       217
        
               updated_timestamp = doc.get('updated', 0)

     

       218
        
               if updated_timestamp:

     
···

       221
        
                   updated_str = updated_date.strftime("%Y-%m-%d")

     

       222
        
               else:

     

       223
        
                   updated_str = "Unknown"

     

       224
       -
                   

     

       225
        
               # Format summary

     

       226
        
               summary = doc.get('summary') or doc.get('content', '')

     

       227
        
               if summary:

     
···

       243
        
               )

     

       244
        
       

     

       245
        
           console.print(table)

     

       246
       -
           

     

       247
        
           # Show additional info

     

       248
        
           console.print(f"\n[dim]Showing {len(hits)} of {found} results[/dim]")

     

       249
        
           if len(hits) < found:

     
···

       254
        
           """Display search results in a compact format."""

     

       255
        
           hits = results.get('hits', [])

     

       256
        
           found = results.get('found', 0)

     

       257
       -
           

     

       258
        
           if not hits:

     

       259
        
               console.print("\n[yellow]No results found.[/yellow]")

     

       260
        
               return

     

       261
        
       

     

       262
        
           console.print(f"\n[green]Found {found} results[/green]\n")

     

       263
       -
           

     

       264
        
           for i, hit in enumerate(hits, 1):

     

       265
        
               doc = hit['document']

     

       266
        
               score = hit.get('text_match', 0)

     

       267
       -
               

     

       268
        
               # Header with score and user

     

       269
        
               user = doc.get('user_display_name', doc.get('username', 'Unknown'))

     

       270
        
               console.print(f"[green]{i:2d}.[/green] [cyan]{user}[/cyan] [dim](score: {score:.2f})[/dim]")

     

       271
       -
               

     

       272
        
               # Title

     

       273
        
               title = doc.get('title', 'Untitled')

     

       274
        
               console.print(f"    [bold]{title}[/bold]")

     

       275
       -
               

     

       276
        
               # Date and link

     

       277
        
               updated_timestamp = doc.get('updated', 0)

     

       278
        
               if updated_timestamp:

     
···

       281
        
                   updated_str = updated_date.strftime("%Y-%m-%d %H:%M")

     

       282
        
               else:

     

       283
        
                   updated_str = "Unknown date"

     

       284
       -
                   

     

       285
        
               link = doc.get('link', '')

     

       286
        
               console.print(f"    [blue]{updated_str}[/blue] - [link={link}]{link}[/link]")

     

       287
       -
               

     

       288
        
               # Summary

     

       289
        
               summary = doc.get('summary') or doc.get('content', '')

     

       290
        
               if summary:

     
···

       294
        
                   if len(summary) > 150:

     

       295
        
                       summary = summary[:147] + "..."

     

       296
        
                   console.print(f"    [dim]{summary}[/dim]")

     

       297
       -
               

     

       298
       -
               console.print()  # Empty line between results

···

       7
        
       import typer

     

       8
        
       from rich.console import Console

     

       9
        
       from rich.table import Table

     

       0
        
       
     

       10
        
       

     

       11
        
       from ...core.typesense_client import TypesenseClient, TypesenseConfig

     

       12
        
       from ..main import app

     

       0
        
       
     

       13
        
       

     

       14
        
       console = Console()

     

       15
        
       logger = logging.getLogger(__name__)

     
···

       137
        
               )

     

       138
        
               typesense_config.connection_timeout = timeout

     

       139
        
       

     

       140
       +
               console.print("[bold blue]Searching thicket entries[/bold blue]")

     

       141
        
               console.print(f"Query: [cyan]{query}[/cyan]")

     

       142
        
               if user:

     

       143
        
                   console.print(f"User filter: [yellow]{user}[/yellow]")

     
···

       157
        
               # Perform search

     

       158
        
               try:

     

       159
        
                   results = typesense_client.search(query, search_params)

     

       160
       +
       

     

       161
        
                   if raw:

     

       162
        
                       import json

     

       163
        
                       console.print(json.dumps(results, indent=2))

     
···

       187
        
               return

     

       188
        
       

     

       189
        
           console.print(f"\n[green]Found {found} results in {search_time}ms[/green]")

     

       190
       +
       

     

       191
        
           table = Table(title=f"Search Results for '{query}'", show_lines=True)

     

       192
        
           table.add_column("Score", style="green", width=8, no_wrap=True)

     

       193
        
           table.add_column("User", style="cyan", width=15, no_wrap=True)

     
···

       197
        
       

     

       198
        
           for hit in hits:

     

       199
        
               doc = hit['document']

     

       200
       +
       

     

       201
        
               # Format score

     

       202
        
               score = f"{hit.get('text_match', 0):.2f}"

     

       203
       +
       

     

       204
        
               # Format user

     

       205
        
               user_display = doc.get('user_display_name', doc.get('username', 'Unknown'))

     

       206
        
               if len(user_display) > 12:

     

       207
        
                   user_display = user_display[:9] + "..."

     

       208
       +
       

     

       209
        
               # Format title

     

       210
        
               title = doc.get('title', 'Untitled')

     

       211
        
               if len(title) > 40:

     

       212
        
                   title = title[:37] + "..."

     

       213
       +
       

     

       214
        
               # Format date

     

       215
        
               updated_timestamp = doc.get('updated', 0)

     

       216
        
               if updated_timestamp:

     
···

       219
        
                   updated_str = updated_date.strftime("%Y-%m-%d")

     

       220
        
               else:

     

       221
        
                   updated_str = "Unknown"

     

       222
       +
       

     

       223
        
               # Format summary

     

       224
        
               summary = doc.get('summary') or doc.get('content', '')

     

       225
        
               if summary:

     
···

       241
        
               )

     

       242
        
       

     

       243
        
           console.print(table)

     

       244
       +
       

     

       245
        
           # Show additional info

     

       246
        
           console.print(f"\n[dim]Showing {len(hits)} of {found} results[/dim]")

     

       247
        
           if len(hits) < found:

     
···

       252
        
           """Display search results in a compact format."""

     

       253
        
           hits = results.get('hits', [])

     

       254
        
           found = results.get('found', 0)

     

       255
       +
       

     

       256
        
           if not hits:

     

       257
        
               console.print("\n[yellow]No results found.[/yellow]")

     

       258
        
               return

     

       259
        
       

     

       260
        
           console.print(f"\n[green]Found {found} results[/green]\n")

     

       261
       +
       

     

       262
        
           for i, hit in enumerate(hits, 1):

     

       263
        
               doc = hit['document']

     

       264
        
               score = hit.get('text_match', 0)

     

       265
       +
       

     

       266
        
               # Header with score and user

     

       267
        
               user = doc.get('user_display_name', doc.get('username', 'Unknown'))

     

       268
        
               console.print(f"[green]{i:2d}.[/green] [cyan]{user}[/cyan] [dim](score: {score:.2f})[/dim]")

     

       269
       +
       

     

       270
        
               # Title

     

       271
        
               title = doc.get('title', 'Untitled')

     

       272
        
               console.print(f"    [bold]{title}[/bold]")

     

       273
       +
       

     

       274
        
               # Date and link

     

       275
        
               updated_timestamp = doc.get('updated', 0)

     

       276
        
               if updated_timestamp:

     
···

       279
        
                   updated_str = updated_date.strftime("%Y-%m-%d %H:%M")

     

       280
        
               else:

     

       281
        
                   updated_str = "Unknown date"

     

       282
       +
       

     

       283
        
               link = doc.get('link', '')

     

       284
        
               console.print(f"    [blue]{updated_str}[/blue] - [link={link}]{link}[/link]")

     

       285
       +
       

     

       286
        
               # Summary

     

       287
        
               summary = doc.get('summary') or doc.get('content', '')

     

       288
        
               if summary:

     
···

       292
        
                   if len(summary) > 150:

     

       293
        
                       summary = summary[:147] + "..."

     

       294
        
                   console.print(f"    [dim]{summary}[/dim]")

     

       295
       +
       

     

       296
       +
               console.print()  # Empty line between results

+30 -30

src/thicket/cli/commands/zulip.py

···

       37
        
           try:

     

       38
        
               config = load_config(config_file)

     

       39
        
               git_store = GitStore(config.git_store)

     

       40
       -
               

     

       41
        
               # Check if user exists

     

       42
        
               user = git_store.get_user(username)

     

       43
        
               if not user:

     

       44
        
                   print_error(f"User '{username}' not found")

     

       45
        
                   raise typer.Exit(1)

     

       46
       -
               

     

       47
        
               # Add association

     

       48
        
               if git_store.add_zulip_association(username, server, user_id):

     

       49
        
                   print_success(f"Added Zulip association for {username}: {user_id}@{server}")

     

       50
        
                   git_store.commit_changes(f"Add Zulip association for {username}")

     

       51
        
               else:

     

       52
        
                   print_info(f"Association already exists for {username}: {user_id}@{server}")

     

       53
       -
                   

     

       54
        
           except Exception as e:

     

       55
        
               print_error(f"Failed to add Zulip association: {e}")

     

       56
        
               raise typer.Exit(1)

     
···

       76
        
           try:

     

       77
        
               config = load_config(config_file)

     

       78
        
               git_store = GitStore(config.git_store)

     

       79
       -
               

     

       80
        
               # Check if user exists

     

       81
        
               user = git_store.get_user(username)

     

       82
        
               if not user:

     

       83
        
                   print_error(f"User '{username}' not found")

     

       84
        
                   raise typer.Exit(1)

     

       85
       -
               

     

       86
        
               # Remove association

     

       87
        
               if git_store.remove_zulip_association(username, server, user_id):

     

       88
        
                   print_success(f"Removed Zulip association for {username}: {user_id}@{server}")

     
···

       90
        
               else:

     

       91
        
                   print_error(f"Association not found for {username}: {user_id}@{server}")

     

       92
        
                   raise typer.Exit(1)

     

       93
       -
                   

     

       94
        
           except Exception as e:

     

       95
        
               print_error(f"Failed to remove Zulip association: {e}")

     

       96
        
               raise typer.Exit(1)

     
···

       117
        
           try:

     

       118
        
               config = load_config(config_file)

     

       119
        
               git_store = GitStore(config.git_store)

     

       120
       -
               

     

       121
        
               # Create table

     

       122
        
               table = Table(title="Zulip Associations")

     

       123
        
               table.add_column("Username", style="cyan")

     

       124
        
               table.add_column("Server", style="green")

     

       125
        
               table.add_column("User ID", style="yellow")

     

       126
       -
               

     

       127
        
               if username:

     

       128
        
                   # List for specific user

     

       129
        
                   user = git_store.get_user(username)

     

       130
        
                   if not user:

     

       131
        
                       print_error(f"User '{username}' not found")

     

       132
        
                       raise typer.Exit(1)

     

       133
       -
                       

     

       134
        
                   if not user.zulip_associations:

     

       135
        
                       print_info(f"No Zulip associations for {username}")

     

       136
        
                       return

     

       137
       -
                       

     

       138
        
                   for assoc in user.zulip_associations:

     

       139
        
                       table.add_row(username, assoc.server, assoc.user_id)

     

       140
        
               else:

     

       141
        
                   # List for all users

     

       142
        
                   index = git_store._load_index()

     

       143
        
                   has_associations = False

     

       144
       -
                   

     

       145
        
                   for username, user in index.users.items():

     

       146
        
                       for assoc in user.zulip_associations:

     

       147
        
                           table.add_row(username, assoc.server, assoc.user_id)

     

       148
        
                           has_associations = True

     

       149
       -
                   

     

       150
        
                   if not has_associations:

     

       151
        
                       print_info("No Zulip associations found")

     

       152
        
                       return

     

       153
       -
               

     

       154
        
               console.print(table)

     

       155
       -
               

     

       156
        
           except Exception as e:

     

       157
        
               print_error(f"Failed to list Zulip associations: {e}")

     

       158
        
               raise typer.Exit(1)

     
···

       184
        
               thicket zulip-import associations.csv

     

       185
        
           """

     

       186
        
           import csv

     

       187
       -
           

     

       188
        
           try:

     

       189
        
               config = load_config(config_file)

     

       190
        
               git_store = GitStore(config.git_store)

     

       191
       -
               

     

       192
        
               if not csv_file.exists():

     

       193
        
                   print_error(f"CSV file not found: {csv_file}")

     

       194
        
                   raise typer.Exit(1)

     

       195
       -
               

     

       196
        
               added = 0

     

       197
        
               skipped = 0

     

       198
        
               errors = 0

     

       199
       -
               

     

       200
       -
               with open(csv_file, 'r') as f:

     

       201
        
                   reader = csv.reader(f)

     

       202
        
                   for row_num, row in enumerate(reader, 1):

     

       203
        
                       if len(row) != 3:

     

       204
        
                           print_error(f"Line {row_num}: Invalid format (expected 3 columns)")

     

       205
        
                           errors += 1

     

       206
        
                           continue

     

       207
       -
                       

     

       208
        
                       username, server, user_id = [col.strip() for col in row]

     

       209
       -
                       

     

       210
        
                       # Skip empty lines

     

       211
        
                       if not username:

     

       212
        
                           continue

     

       213
       -
                       

     

       214
        
                       # Check if user exists

     

       215
        
                       user = git_store.get_user(username)

     

       216
        
                       if not user:

     

       217
        
                           print_error(f"Line {row_num}: User '{username}' not found")

     

       218
        
                           errors += 1

     

       219
        
                           continue

     

       220
       -
                       

     

       221
        
                       if dry_run:

     

       222
        
                           # Check if association would be added

     

       223
        
                           exists = any(

     

       224
       -
                               a.server == server and a.user_id == user_id 

     

       225
        
                               for a in user.zulip_associations

     

       226
        
                           )

     

       227
        
                           if exists:

     
···

       238
        
                           else:

     

       239
        
                               print_info(f"Skipped existing: {username} -> {user_id}@{server}")

     

       240
        
                               skipped += 1

     

       241
       -
               

     

       242
        
               # Summary

     

       243
        
               console.print()

     

       244
        
               if dry_run:

     

       245
       -
                   console.print(f"[bold]Dry run summary:[/bold]")

     

       246
        
                   console.print(f"  Would add: {added}")

     

       247
        
               else:

     

       248
       -
                   console.print(f"[bold]Import summary:[/bold]")

     

       249
        
                   console.print(f"  Added: {added}")

     

       250
        
                   if not dry_run and added > 0:

     

       251
        
                       git_store.commit_changes(f"Import {added} Zulip associations from CSV")

     

       252
       -
                       

     

       253
        
               console.print(f"  Skipped: {skipped}")

     

       254
        
               console.print(f"  Errors: {errors}")

     

       255
       -
               

     

       256
        
           except Exception as e:

     

       257
        
               print_error(f"Failed to import Zulip associations: {e}")

     

       258
       -
               raise typer.Exit(1)

···

       37
        
           try:

     

       38
        
               config = load_config(config_file)

     

       39
        
               git_store = GitStore(config.git_store)

     

       40
       +
       

     

       41
        
               # Check if user exists

     

       42
        
               user = git_store.get_user(username)

     

       43
        
               if not user:

     

       44
        
                   print_error(f"User '{username}' not found")

     

       45
        
                   raise typer.Exit(1)

     

       46
       +
       

     

       47
        
               # Add association

     

       48
        
               if git_store.add_zulip_association(username, server, user_id):

     

       49
        
                   print_success(f"Added Zulip association for {username}: {user_id}@{server}")

     

       50
        
                   git_store.commit_changes(f"Add Zulip association for {username}")

     

       51
        
               else:

     

       52
        
                   print_info(f"Association already exists for {username}: {user_id}@{server}")

     

       53
       +
       

     

       54
        
           except Exception as e:

     

       55
        
               print_error(f"Failed to add Zulip association: {e}")

     

       56
        
               raise typer.Exit(1)

     
···

       76
        
           try:

     

       77
        
               config = load_config(config_file)

     

       78
        
               git_store = GitStore(config.git_store)

     

       79
       +
       

     

       80
        
               # Check if user exists

     

       81
        
               user = git_store.get_user(username)

     

       82
        
               if not user:

     

       83
        
                   print_error(f"User '{username}' not found")

     

       84
        
                   raise typer.Exit(1)

     

       85
       +
       

     

       86
        
               # Remove association

     

       87
        
               if git_store.remove_zulip_association(username, server, user_id):

     

       88
        
                   print_success(f"Removed Zulip association for {username}: {user_id}@{server}")

     
···

       90
        
               else:

     

       91
        
                   print_error(f"Association not found for {username}: {user_id}@{server}")

     

       92
        
                   raise typer.Exit(1)

     

       93
       +
       

     

       94
        
           except Exception as e:

     

       95
        
               print_error(f"Failed to remove Zulip association: {e}")

     

       96
        
               raise typer.Exit(1)

     
···

       117
        
           try:

     

       118
        
               config = load_config(config_file)

     

       119
        
               git_store = GitStore(config.git_store)

     

       120
       +
       

     

       121
        
               # Create table

     

       122
        
               table = Table(title="Zulip Associations")

     

       123
        
               table.add_column("Username", style="cyan")

     

       124
        
               table.add_column("Server", style="green")

     

       125
        
               table.add_column("User ID", style="yellow")

     

       126
       +
       

     

       127
        
               if username:

     

       128
        
                   # List for specific user

     

       129
        
                   user = git_store.get_user(username)

     

       130
        
                   if not user:

     

       131
        
                       print_error(f"User '{username}' not found")

     

       132
        
                       raise typer.Exit(1)

     

       133
       +
       

     

       134
        
                   if not user.zulip_associations:

     

       135
        
                       print_info(f"No Zulip associations for {username}")

     

       136
        
                       return

     

       137
       +
       

     

       138
        
                   for assoc in user.zulip_associations:

     

       139
        
                       table.add_row(username, assoc.server, assoc.user_id)

     

       140
        
               else:

     

       141
        
                   # List for all users

     

       142
        
                   index = git_store._load_index()

     

       143
        
                   has_associations = False

     

       144
       +
       

     

       145
        
                   for username, user in index.users.items():

     

       146
        
                       for assoc in user.zulip_associations:

     

       147
        
                           table.add_row(username, assoc.server, assoc.user_id)

     

       148
        
                           has_associations = True

     

       149
       +
       

     

       150
        
                   if not has_associations:

     

       151
        
                       print_info("No Zulip associations found")

     

       152
        
                       return

     

       153
       +
       

     

       154
        
               console.print(table)

     

       155
       +
       

     

       156
        
           except Exception as e:

     

       157
        
               print_error(f"Failed to list Zulip associations: {e}")

     

       158
        
               raise typer.Exit(1)

     
···

       184
        
               thicket zulip-import associations.csv

     

       185
        
           """

     

       186
        
           import csv

     

       187
       +
       

     

       188
        
           try:

     

       189
        
               config = load_config(config_file)

     

       190
        
               git_store = GitStore(config.git_store)

     

       191
       +
       

     

       192
        
               if not csv_file.exists():

     

       193
        
                   print_error(f"CSV file not found: {csv_file}")

     

       194
        
                   raise typer.Exit(1)

     

       195
       +
       

     

       196
        
               added = 0

     

       197
        
               skipped = 0

     

       198
        
               errors = 0

     

       199
       +
       

     

       200
       +
               with open(csv_file) as f:

     

       201
        
                   reader = csv.reader(f)

     

       202
        
                   for row_num, row in enumerate(reader, 1):

     

       203
        
                       if len(row) != 3:

     

       204
        
                           print_error(f"Line {row_num}: Invalid format (expected 3 columns)")

     

       205
        
                           errors += 1

     

       206
        
                           continue

     

       207
       +
       

     

       208
        
                       username, server, user_id = [col.strip() for col in row]

     

       209
       +
       

     

       210
        
                       # Skip empty lines

     

       211
        
                       if not username:

     

       212
        
                           continue

     

       213
       +
       

     

       214
        
                       # Check if user exists

     

       215
        
                       user = git_store.get_user(username)

     

       216
        
                       if not user:

     

       217
        
                           print_error(f"Line {row_num}: User '{username}' not found")

     

       218
        
                           errors += 1

     

       219
        
                           continue

     

       220
       +
       

     

       221
        
                       if dry_run:

     

       222
        
                           # Check if association would be added

     

       223
        
                           exists = any(

     

       224
       +
                               a.server == server and a.user_id == user_id

     

       225
        
                               for a in user.zulip_associations

     

       226
        
                           )

     

       227
        
                           if exists:

     
···

       238
        
                           else:

     

       239
        
                               print_info(f"Skipped existing: {username} -> {user_id}@{server}")

     

       240
        
                               skipped += 1

     

       241
       +
       

     

       242
        
               # Summary

     

       243
        
               console.print()

     

       244
        
               if dry_run:

     

       245
       +
                   console.print("[bold]Dry run summary:[/bold]")

     

       246
        
                   console.print(f"  Would add: {added}")

     

       247
        
               else:

     

       248
       +
                   console.print("[bold]Import summary:[/bold]")

     

       249
        
                   console.print(f"  Added: {added}")

     

       250
        
                   if not dry_run and added > 0:

     

       251
        
                       git_store.commit_changes(f"Import {added} Zulip associations from CSV")

     

       252
       +
       

     

       253
        
               console.print(f"  Skipped: {skipped}")

     

       254
        
               console.print(f"  Errors: {errors}")

     

       255
       +
       

     

       256
        
           except Exception as e:

     

       257
        
               print_error(f"Failed to import Zulip associations: {e}")

     

       258
       +
               raise typer.Exit(1)

+9 -1

src/thicket/cli/main.py

···

       47
        
       

     

       48
        
       

     

       49
        
       # Import commands to register them

     

       50
       -
       from .commands import add, duplicates, info_cmd, init, list_cmd, sync, upload  # noqa: F401

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
       

     

       52
        
       if __name__ == "__main__":

     

       53
        
           app()

···

       47
        
       

     

       48
        
       

     

       49
        
       # Import commands to register them

     

       50
       +
       from .commands import (  # noqa: F401

     

       51
       +
           add,

     

       52
       +
           duplicates,

     

       53
       +
           info_cmd,

     

       54
       +
           init,

     

       55
       +
           list_cmd,

     

       56
       +
           sync,

     

       57
       +
           upload,

     

       58
       +
       )

     

       59
        
       

     

       60
        
       if __name__ == "__main__":

     

       61
        
           app()

+10 -10

src/thicket/core/git_store.py

···

       151
        
               self._save_index(index)

     

       152
        
       

     

       153
        
               return True

     

       154
       -
           

     

       155
        
           def add_zulip_association(self, username: str, server: str, user_id: str) -> bool:

     

       156
        
               """Add a Zulip association to a user."""

     

       157
        
               index = self._load_index()

     

       158
        
               user = index.get_user(username)

     

       159
       -
               

     

       160
        
               if not user:

     

       161
        
                   return False

     

       162
       -
               

     

       163
        
               result = user.add_zulip_association(server, user_id)

     

       164
        
               if result:

     

       165
        
                   index.add_user(user)

     

       166
        
                   self._save_index(index)

     

       167
       -
               

     

       168
        
               return result

     

       169
       -
           

     

       170
        
           def remove_zulip_association(self, username: str, server: str, user_id: str) -> bool:

     

       171
        
               """Remove a Zulip association from a user."""

     

       172
        
               index = self._load_index()

     

       173
        
               user = index.get_user(username)

     

       174
       -
               

     

       175
        
               if not user:

     

       176
        
                   return False

     

       177
       -
               

     

       178
        
               result = user.remove_zulip_association(server, user_id)

     

       179
        
               if result:

     

       180
        
                   index.add_user(user)

     

       181
        
                   self._save_index(index)

     

       182
       -
               

     

       183
        
               return result

     

       184
       -
           

     

       185
        
           def get_zulip_associations(self, username: str) -> list:

     

       186
        
               """Get all Zulip associations for a user."""

     

       187
        
               user = self.get_user(username)

     
···

       383
        
               user = self.get_user(username)

     

       384
        
               if not user:

     

       385
        
                   return []

     

       386
       -
               

     

       387
        
               # Feed URLs are stored in the user metadata

     

       388
        
               return user.feeds

     

       389

···

       151
        
               self._save_index(index)

     

       152
        
       

     

       153
        
               return True

     

       154
       +
       

     

       155
        
           def add_zulip_association(self, username: str, server: str, user_id: str) -> bool:

     

       156
        
               """Add a Zulip association to a user."""

     

       157
        
               index = self._load_index()

     

       158
        
               user = index.get_user(username)

     

       159
       +
       

     

       160
        
               if not user:

     

       161
        
                   return False

     

       162
       +
       

     

       163
        
               result = user.add_zulip_association(server, user_id)

     

       164
        
               if result:

     

       165
        
                   index.add_user(user)

     

       166
        
                   self._save_index(index)

     

       167
       +
       

     

       168
        
               return result

     

       169
       +
       

     

       170
        
           def remove_zulip_association(self, username: str, server: str, user_id: str) -> bool:

     

       171
        
               """Remove a Zulip association from a user."""

     

       172
        
               index = self._load_index()

     

       173
        
               user = index.get_user(username)

     

       174
       +
       

     

       175
        
               if not user:

     

       176
        
                   return False

     

       177
       +
       

     

       178
        
               result = user.remove_zulip_association(server, user_id)

     

       179
        
               if result:

     

       180
        
                   index.add_user(user)

     

       181
        
                   self._save_index(index)

     

       182
       +
       

     

       183
        
               return result

     

       184
       +
       

     

       185
        
           def get_zulip_associations(self, username: str) -> list:

     

       186
        
               """Get all Zulip associations for a user."""

     

       187
        
               user = self.get_user(username)

     
···

       383
        
               user = self.get_user(username)

     

       384
        
               if not user:

     

       385
        
                   return []

     

       386
       +
       

     

       387
        
               # Feed URLs are stored in the user metadata

     

       388
        
               return user.feeds

     

       389

+5 -5

src/thicket/models/user.py

···

       8
        
       

     

       9
        
       class ZulipAssociation(BaseModel):

     

       10
        
           """Association between a user and their Zulip identity."""

     

       11
       -
           

     

       12
        
           server: str  # Zulip server URL (e.g., "yourorg.zulipchat.com")

     

       13
        
           user_id: str  # Zulip user ID or email for @mentions

     

       14
       -
           

     

       15
        
           def __hash__(self) -> int:

     

       16
        
               """Make hashable for use in sets."""

     

       17
        
               return hash((self.server, self.user_id))

     
···

       45
        
               """Increment the entry count by the given amount."""

     

       46
        
               self.entry_count += count

     

       47
        
               self.update_timestamp()

     

       48
       -
           

     

       49
        
           def add_zulip_association(self, server: str, user_id: str) -> bool:

     

       50
        
               """Add a Zulip association if it doesn't exist. Returns True if added."""

     

       51
        
               association = ZulipAssociation(server=server, user_id=user_id)

     
···

       54
        
                   self.update_timestamp()

     

       55
        
                   return True

     

       56
        
               return False

     

       57
       -
           

     

       58
        
           def remove_zulip_association(self, server: str, user_id: str) -> bool:

     

       59
        
               """Remove a Zulip association. Returns True if removed."""

     

       60
        
               association = ZulipAssociation(server=server, user_id=user_id)

     
···

       63
        
                   self.update_timestamp()

     

       64
        
                   return True

     

       65
        
               return False

     

       66
       -
           

     

       67
        
           def get_zulip_mention(self, server: str) -> Optional[str]:

     

       68
        
               """Get the Zulip user_id for @mentions on a specific server."""

     

       69
        
               for association in self.zulip_associations:

···

       8
        
       

     

       9
        
       class ZulipAssociation(BaseModel):

     

       10
        
           """Association between a user and their Zulip identity."""

     

       11
       +
       

     

       12
        
           server: str  # Zulip server URL (e.g., "yourorg.zulipchat.com")

     

       13
        
           user_id: str  # Zulip user ID or email for @mentions

     

       14
       +
       

     

       15
        
           def __hash__(self) -> int:

     

       16
        
               """Make hashable for use in sets."""

     

       17
        
               return hash((self.server, self.user_id))

     
···

       45
        
               """Increment the entry count by the given amount."""

     

       46
        
               self.entry_count += count

     

       47
        
               self.update_timestamp()

     

       48
       +
       

     

       49
        
           def add_zulip_association(self, server: str, user_id: str) -> bool:

     

       50
        
               """Add a Zulip association if it doesn't exist. Returns True if added."""

     

       51
        
               association = ZulipAssociation(server=server, user_id=user_id)

     
···

       54
        
                   self.update_timestamp()

     

       55
        
                   return True

     

       56
        
               return False

     

       57
       +
       

     

       58
        
           def remove_zulip_association(self, server: str, user_id: str) -> bool:

     

       59
        
               """Remove a Zulip association. Returns True if removed."""

     

       60
        
               association = ZulipAssociation(server=server, user_id=user_id)

     
···

       63
        
                   self.update_timestamp()

     

       64
        
                   return True

     

       65
        
               return False

     

       66
       +
       

     

       67
        
           def get_zulip_mention(self, server: str) -> Optional[str]:

     

       68
        
               """Get the Zulip user_id for @mentions on a specific server."""

     

       69
        
               for association in self.zulip_associations:

+50 -50

tests/test_bot.py

···

       1
        
       """Tests for the Thicket Zulip bot."""

     

       2
        
       

     

       3
       -
       import json

     

       4
       -
       import tempfile

     

       5
       -
       from pathlib import Path

     

       6
       -
       from unittest.mock import patch

     

       7
        
       

     

       8
        
       import pytest

     

       9
        
       

     

       10
       -
       from thicket.bots.test_bot import BotTester, MockBotHandler, create_test_message, create_test_entry

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       from thicket.bots.thicket_bot import ThicketBotHandler

     

       12
        
       

     

       13
        
       

     
···

       30
        
               """Test help command response."""

     

       31
        
               message = create_test_message("@thicket help")

     

       32
        
               self.bot.handle_message(message, self.handler)

     

       33
       -
               

     

       34
        
               assert len(self.handler.sent_messages) == 1

     

       35
        
               response = self.handler.sent_messages[0]["content"]

     

       36
        
               assert "Thicket Feed Bot" in response

     
···

       39
        
               """Test status command when bot is not configured."""

     

       40
        
               message = create_test_message("@thicket status")

     

       41
        
               self.bot.handle_message(message, self.handler)

     

       42
       -
               

     

       43
        
               assert len(self.handler.sent_messages) == 1

     

       44
        
               response = self.handler.sent_messages[0]["content"]

     

       45
        
               assert "Not configured" in response

     
···

       50
        
               """Test setting stream configuration."""

     

       51
        
               message = create_test_message("@thicket config stream general")

     

       52
        
               self.bot.handle_message(message, self.handler)

     

       53
       -
               

     

       54
        
               assert len(self.handler.sent_messages) == 1

     

       55
        
               response = self.handler.sent_messages[0]["content"]

     

       56
        
               assert "Stream set to: **general**" in response

     
···

       60
        
               """Test setting topic configuration."""

     

       61
        
               message = create_test_message("@thicket config topic 'Feed Updates'")

     

       62
        
               self.bot.handle_message(message, self.handler)

     

       63
       -
               

     

       64
        
               assert len(self.handler.sent_messages) == 1

     

       65
        
               response = self.handler.sent_messages[0]["content"]

     

       66
        
               assert "Topic set to:" in response and "Feed Updates" in response

     
···

       70
        
               """Test setting sync interval."""

     

       71
        
               message = create_test_message("@thicket config interval 600")

     

       72
        
               self.bot.handle_message(message, self.handler)

     

       73
       -
               

     

       74
        
               assert len(self.handler.sent_messages) == 1

     

       75
        
               response = self.handler.sent_messages[0]["content"]

     

       76
        
               assert "Sync interval set to: **600s**" in response

     
···

       80
        
               """Test setting sync interval that's too small."""

     

       81
        
               message = create_test_message("@thicket config interval 30")

     

       82
        
               self.bot.handle_message(message, self.handler)

     

       83
       -
               

     

       84
        
               assert len(self.handler.sent_messages) == 1

     

       85
        
               response = self.handler.sent_messages[0]["content"]

     

       86
        
               assert "must be at least 60 seconds" in response

     
···

       90
        
               """Test setting config path that doesn't exist."""

     

       91
        
               message = create_test_message("@thicket config path /nonexistent/config.yaml")

     

       92
        
               self.bot.handle_message(message, self.handler)

     

       93
       -
               

     

       94
        
               assert len(self.handler.sent_messages) == 1

     

       95
        
               response = self.handler.sent_messages[0]["content"]

     

       96
        
               assert "Config file not found" in response

     
···

       99
        
               """Test unknown command handling."""

     

       100
        
               message = create_test_message("@thicket unknown")

     

       101
        
               self.bot.handle_message(message, self.handler)

     

       102
       -
               

     

       103
        
               assert len(self.handler.sent_messages) == 1

     

       104
        
               response = self.handler.sent_messages[0]["content"]

     

       105
        
               assert "Unknown command: unknown" in response

     
···

       110
        
               self.bot.stream_name = "test-stream"

     

       111
        
               self.bot.topic_name = "test-topic"

     

       112
        
               self.bot.sync_interval = 600

     

       113
       -
               

     

       114
        
               # Save config

     

       115
        
               self.bot._save_bot_config(self.handler)

     

       116
       -
               

     

       117
        
               # Create new bot instance

     

       118
        
               new_bot = ThicketBotHandler()

     

       119
        
               new_bot._load_bot_config(self.handler)

     

       120
       -
               

     

       121
        
               # Check config was loaded

     

       122
        
               assert new_bot.stream_name == "test-stream"

     

       123
        
               assert new_bot.topic_name == "test-topic"

     
···

       127
        
               """Test that posted entries are persisted."""

     

       128
        
               # Add some entries

     

       129
        
               self.bot.posted_entries = {"user1:entry1", "user2:entry2"}

     

       130
       -
               

     

       131
        
               # Save entries

     

       132
        
               self.bot._save_posted_entries(self.handler)

     

       133
       -
               

     

       134
        
               # Create new bot instance

     

       135
        
               new_bot = ThicketBotHandler()

     

       136
        
               new_bot._load_posted_entries(self.handler)

     

       137
       -
               

     

       138
        
               # Check entries were loaded

     

       139
        
               assert new_bot.posted_entries == {"user1:entry1", "user2:entry2"}

     

       140
        
       

     
···

       148
        
               """Test cleaning mentions from messages."""

     

       149
        
               cleaned = self.bot._clean_mention("@Thicket Bot status", self.handler)

     

       150
        
               assert cleaned == "status"

     

       151
       -
               

     

       152
        
               cleaned = self.bot._clean_mention("@thicket help", self.handler)

     

       153
        
               assert cleaned == "help"

     

       154
        
       

     
···

       156
        
               """Test sync now command when not initialized."""

     

       157
        
               message = create_test_message("@thicket sync now")

     

       158
        
               self.bot.handle_message(message, self.handler)

     

       159
       -
               

     

       160
        
               assert len(self.handler.sent_messages) == 1

     

       161
        
               response = self.handler.sent_messages[0]["content"]

     

       162
        
               assert "not initialized" in response.lower()

     

       163
       -
           

     

       164
        
           def test_debug_mode_initialization(self) -> None:

     

       165
        
               """Test debug mode initialization."""

     

       166
        
               import os

     

       167
       -
               

     

       168
        
               # Mock environment variable

     

       169
        
               os.environ["THICKET_DEBUG_USER"] = "testuser"

     

       170
       -
               

     

       171
        
               try:

     

       172
        
                   bot = ThicketBotHandler()

     

       173
        
                   # Simulate initialize call

     

       174
        
                   bot.debug_user = os.getenv("THICKET_DEBUG_USER")

     

       175
       -
                   

     

       176
        
                   assert bot.debug_user == "testuser"

     

       177
        
                   assert bot.debug_zulip_user_id is None  # Not validated yet

     

       178
        
               finally:

     

       179
        
                   # Clean up

     

       180
        
                   if "THICKET_DEBUG_USER" in os.environ:

     

       181
        
                       del os.environ["THICKET_DEBUG_USER"]

     

       182
       -
           

     

       183
        
           def test_debug_mode_status(self) -> None:

     

       184
        
               """Test status command in debug mode."""

     

       185
        
               self.bot.debug_user = "testuser"

     

       186
        
               self.bot.debug_zulip_user_id = "test.user"

     

       187
       -
               

     

       188
        
               message = create_test_message("@thicket status")

     

       189
        
               self.bot.handle_message(message, self.handler)

     

       190
       -
               

     

       191
        
               assert len(self.handler.sent_messages) == 1

     

       192
        
               response = self.handler.sent_messages[0]["content"]

     

       193
        
               assert "**Debug Mode:** ENABLED" in response

     

       194
        
               assert "**Debug User:** testuser" in response

     

       195
        
               assert "**Debug Zulip ID:** test.user" in response

     

       196
       -
           

     

       197
        
           def test_debug_mode_check_initialization(self) -> None:

     

       198
        
               """Test initialization check in debug mode."""

     

       199
        
               from unittest.mock import Mock

     

       200
       -
               

     

       201
        
               # Setup mock git store and config

     

       202
        
               self.bot.git_store = Mock()

     

       203
        
               self.bot.config = Mock()

     

       204
        
               self.bot.debug_user = "testuser"

     

       205
        
               self.bot.debug_zulip_user_id = "test.user"

     

       206
       -
               

     

       207
        
               message = create_test_message("@thicket sync now")

     

       208
       -
               

     

       209
        
               # Should pass with debug mode properly set up

     

       210
        
               result = self.bot._check_initialization(message, self.handler)

     

       211
        
               assert result is True

     

       212
       -
               

     

       213
        
               # Should fail if debug_zulip_user_id is missing

     

       214
        
               self.bot.debug_zulip_user_id = None

     

       215
        
               result = self.bot._check_initialization(message, self.handler)

     

       216
        
               assert result is False

     

       217
        
               assert len(self.handler.sent_messages) == 1

     

       218
        
               assert "Debug mode validation failed" in self.handler.sent_messages[0]["content"]

     

       219
       -
           

     

       220
        
           def test_debug_mode_dm_posting(self) -> None:

     

       221
        
               """Test that debug mode posts DMs instead of stream messages."""

     

       222
        
               from unittest.mock import Mock

     

       223
       -
               from datetime import datetime

     

       224
       -
               from pydantic import HttpUrl

     

       225
       -
               

     

       226
        
               # Setup bot in debug mode

     

       227
        
               self.bot.debug_user = "testuser"

     

       228
        
               self.bot.debug_zulip_user_id = "test.user@example.com"

     

       229
        
               self.bot.git_store = Mock()

     

       230
       -
               

     

       231
        
               # Create a test entry

     

       232
        
               entry = create_test_entry()

     

       233
       -
               

     

       234
        
               # Mock the handler config

     

       235
        
               self.handler.config_info = {

     

       236
        
                   "full_name": "Thicket Bot",

     

       237
        
                   "email": "thicket-bot@example.com",

     

       238
        
                   "site": "https://example.zulipchat.com"

     

       239
        
               }

     

       240
       -
               

     

       241
        
               # Mock git store user

     

       242
        
               mock_user = Mock()

     

       243
        
               mock_user.get_zulip_mention.return_value = "author.user"

     

       244
        
               self.bot.git_store.get_user.return_value = mock_user

     

       245
       -
               

     

       246
        
               # Post entry

     

       247
        
               self.bot._post_entry_to_zulip(entry, self.handler, "testauthor")

     

       248
       -
               

     

       249
        
               # Check that a DM was sent

     

       250
        
               assert len(self.handler.sent_messages) == 1

     

       251
        
               message = self.handler.sent_messages[0]

     

       252
       -
               

     

       253
        
               # Verify it's a DM

     

       254
        
               assert message["type"] == "private"

     

       255
        
               assert message["to"] == ["test.user@example.com"]

     
···

       264
        
           def test_bot_tester_basic(self) -> None:

     

       265
        
               """Test basic bot tester functionality."""

     

       266
        
               tester = BotTester()

     

       267
       -
               

     

       268
        
               # Test help command

     

       269
        
               responses = tester.send_command("help")

     

       270
        
               assert len(responses) == 1

     
···

       273
        
           def test_bot_tester_config(self) -> None:

     

       274
        
               """Test bot tester configuration."""

     

       275
        
               tester = BotTester()

     

       276
       -
               

     

       277
        
               # Configure stream

     

       278
        
               responses = tester.send_command("config stream general")

     

       279
        
               tester.assert_response_contains("Stream set to")

     

       280
       -
               

     

       281
        
               # Configure topic

     

       282
        
               responses = tester.send_command("config topic test")

     

       283
        
               tester.assert_response_contains("Topic set to")

     
···

       285
        
           def test_assert_response_contains(self) -> None:

     

       286
        
               """Test response assertion helper."""

     

       287
        
               tester = BotTester()

     

       288
       -
               

     

       289
        
               # Send command

     

       290
        
               tester.send_command("help")

     

       291
       -
               

     

       292
        
               # This should pass

     

       293
        
               tester.assert_response_contains("Thicket Feed Bot")

     

       294
       -
               

     

       295
        
               # This should fail

     

       296
        
               with pytest.raises(AssertionError):

     

       297
       -
                   tester.assert_response_contains("nonexistent text")

···

       1
        
       """Tests for the Thicket Zulip bot."""

     

       2
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
       

     

       4
        
       import pytest

     

       5
        
       

     

       6
       +
       from thicket.bots.test_bot import (

     

       7
       +
           BotTester,

     

       8
       +
           MockBotHandler,

     

       9
       +
           create_test_entry,

     

       10
       +
           create_test_message,

     

       11
       +
       )

     

       12
        
       from thicket.bots.thicket_bot import ThicketBotHandler

     

       13
        
       

     

       14
        
       

     
···

       31
        
               """Test help command response."""

     

       32
        
               message = create_test_message("@thicket help")

     

       33
        
               self.bot.handle_message(message, self.handler)

     

       34
       +
       

     

       35
        
               assert len(self.handler.sent_messages) == 1

     

       36
        
               response = self.handler.sent_messages[0]["content"]

     

       37
        
               assert "Thicket Feed Bot" in response

     
···

       40
        
               """Test status command when bot is not configured."""

     

       41
        
               message = create_test_message("@thicket status")

     

       42
        
               self.bot.handle_message(message, self.handler)

     

       43
       +
       

     

       44
        
               assert len(self.handler.sent_messages) == 1

     

       45
        
               response = self.handler.sent_messages[0]["content"]

     

       46
        
               assert "Not configured" in response

     
···

       51
        
               """Test setting stream configuration."""

     

       52
        
               message = create_test_message("@thicket config stream general")

     

       53
        
               self.bot.handle_message(message, self.handler)

     

       54
       +
       

     

       55
        
               assert len(self.handler.sent_messages) == 1

     

       56
        
               response = self.handler.sent_messages[0]["content"]

     

       57
        
               assert "Stream set to: **general**" in response

     
···

       61
        
               """Test setting topic configuration."""

     

       62
        
               message = create_test_message("@thicket config topic 'Feed Updates'")

     

       63
        
               self.bot.handle_message(message, self.handler)

     

       64
       +
       

     

       65
        
               assert len(self.handler.sent_messages) == 1

     

       66
        
               response = self.handler.sent_messages[0]["content"]

     

       67
        
               assert "Topic set to:" in response and "Feed Updates" in response

     
···

       71
        
               """Test setting sync interval."""

     

       72
        
               message = create_test_message("@thicket config interval 600")

     

       73
        
               self.bot.handle_message(message, self.handler)

     

       74
       +
       

     

       75
        
               assert len(self.handler.sent_messages) == 1

     

       76
        
               response = self.handler.sent_messages[0]["content"]

     

       77
        
               assert "Sync interval set to: **600s**" in response

     
···

       81
        
               """Test setting sync interval that's too small."""

     

       82
        
               message = create_test_message("@thicket config interval 30")

     

       83
        
               self.bot.handle_message(message, self.handler)

     

       84
       +
       

     

       85
        
               assert len(self.handler.sent_messages) == 1

     

       86
        
               response = self.handler.sent_messages[0]["content"]

     

       87
        
               assert "must be at least 60 seconds" in response

     
···

       91
        
               """Test setting config path that doesn't exist."""

     

       92
        
               message = create_test_message("@thicket config path /nonexistent/config.yaml")

     

       93
        
               self.bot.handle_message(message, self.handler)

     

       94
       +
       

     

       95
        
               assert len(self.handler.sent_messages) == 1

     

       96
        
               response = self.handler.sent_messages[0]["content"]

     

       97
        
               assert "Config file not found" in response

     
···

       100
        
               """Test unknown command handling."""

     

       101
        
               message = create_test_message("@thicket unknown")

     

       102
        
               self.bot.handle_message(message, self.handler)

     

       103
       +
       

     

       104
        
               assert len(self.handler.sent_messages) == 1

     

       105
        
               response = self.handler.sent_messages[0]["content"]

     

       106
        
               assert "Unknown command: unknown" in response

     
···

       111
        
               self.bot.stream_name = "test-stream"

     

       112
        
               self.bot.topic_name = "test-topic"

     

       113
        
               self.bot.sync_interval = 600

     

       114
       +
       

     

       115
        
               # Save config

     

       116
        
               self.bot._save_bot_config(self.handler)

     

       117
       +
       

     

       118
        
               # Create new bot instance

     

       119
        
               new_bot = ThicketBotHandler()

     

       120
        
               new_bot._load_bot_config(self.handler)

     

       121
       +
       

     

       122
        
               # Check config was loaded

     

       123
        
               assert new_bot.stream_name == "test-stream"

     

       124
        
               assert new_bot.topic_name == "test-topic"

     
···

       128
        
               """Test that posted entries are persisted."""

     

       129
        
               # Add some entries

     

       130
        
               self.bot.posted_entries = {"user1:entry1", "user2:entry2"}

     

       131
       +
       

     

       132
        
               # Save entries

     

       133
        
               self.bot._save_posted_entries(self.handler)

     

       134
       +
       

     

       135
        
               # Create new bot instance

     

       136
        
               new_bot = ThicketBotHandler()

     

       137
        
               new_bot._load_posted_entries(self.handler)

     

       138
       +
       

     

       139
        
               # Check entries were loaded

     

       140
        
               assert new_bot.posted_entries == {"user1:entry1", "user2:entry2"}

     

       141
        
       

     
···

       149
        
               """Test cleaning mentions from messages."""

     

       150
        
               cleaned = self.bot._clean_mention("@Thicket Bot status", self.handler)

     

       151
        
               assert cleaned == "status"

     

       152
       +
       

     

       153
        
               cleaned = self.bot._clean_mention("@thicket help", self.handler)

     

       154
        
               assert cleaned == "help"

     

       155
        
       

     
···

       157
        
               """Test sync now command when not initialized."""

     

       158
        
               message = create_test_message("@thicket sync now")

     

       159
        
               self.bot.handle_message(message, self.handler)

     

       160
       +
       

     

       161
        
               assert len(self.handler.sent_messages) == 1

     

       162
        
               response = self.handler.sent_messages[0]["content"]

     

       163
        
               assert "not initialized" in response.lower()

     

       164
       +
       

     

       165
        
           def test_debug_mode_initialization(self) -> None:

     

       166
        
               """Test debug mode initialization."""

     

       167
        
               import os

     

       168
       +
       

     

       169
        
               # Mock environment variable

     

       170
        
               os.environ["THICKET_DEBUG_USER"] = "testuser"

     

       171
       +
       

     

       172
        
               try:

     

       173
        
                   bot = ThicketBotHandler()

     

       174
        
                   # Simulate initialize call

     

       175
        
                   bot.debug_user = os.getenv("THICKET_DEBUG_USER")

     

       176
       +
       

     

       177
        
                   assert bot.debug_user == "testuser"

     

       178
        
                   assert bot.debug_zulip_user_id is None  # Not validated yet

     

       179
        
               finally:

     

       180
        
                   # Clean up

     

       181
        
                   if "THICKET_DEBUG_USER" in os.environ:

     

       182
        
                       del os.environ["THICKET_DEBUG_USER"]

     

       183
       +
       

     

       184
        
           def test_debug_mode_status(self) -> None:

     

       185
        
               """Test status command in debug mode."""

     

       186
        
               self.bot.debug_user = "testuser"

     

       187
        
               self.bot.debug_zulip_user_id = "test.user"

     

       188
       +
       

     

       189
        
               message = create_test_message("@thicket status")

     

       190
        
               self.bot.handle_message(message, self.handler)

     

       191
       +
       

     

       192
        
               assert len(self.handler.sent_messages) == 1

     

       193
        
               response = self.handler.sent_messages[0]["content"]

     

       194
        
               assert "**Debug Mode:** ENABLED" in response

     

       195
        
               assert "**Debug User:** testuser" in response

     

       196
        
               assert "**Debug Zulip ID:** test.user" in response

     

       197
       +
       

     

       198
        
           def test_debug_mode_check_initialization(self) -> None:

     

       199
        
               """Test initialization check in debug mode."""

     

       200
        
               from unittest.mock import Mock

     

       201
       +
       

     

       202
        
               # Setup mock git store and config

     

       203
        
               self.bot.git_store = Mock()

     

       204
        
               self.bot.config = Mock()

     

       205
        
               self.bot.debug_user = "testuser"

     

       206
        
               self.bot.debug_zulip_user_id = "test.user"

     

       207
       +
       

     

       208
        
               message = create_test_message("@thicket sync now")

     

       209
       +
       

     

       210
        
               # Should pass with debug mode properly set up

     

       211
        
               result = self.bot._check_initialization(message, self.handler)

     

       212
        
               assert result is True

     

       213
       +
       

     

       214
        
               # Should fail if debug_zulip_user_id is missing

     

       215
        
               self.bot.debug_zulip_user_id = None

     

       216
        
               result = self.bot._check_initialization(message, self.handler)

     

       217
        
               assert result is False

     

       218
        
               assert len(self.handler.sent_messages) == 1

     

       219
        
               assert "Debug mode validation failed" in self.handler.sent_messages[0]["content"]

     

       220
       +
       

     

       221
        
           def test_debug_mode_dm_posting(self) -> None:

     

       222
        
               """Test that debug mode posts DMs instead of stream messages."""

     

       223
        
               from unittest.mock import Mock

     

       224
       +
       

     

       225
       +
       

     

       0
        
       
     

       226
        
               # Setup bot in debug mode

     

       227
        
               self.bot.debug_user = "testuser"

     

       228
        
               self.bot.debug_zulip_user_id = "test.user@example.com"

     

       229
        
               self.bot.git_store = Mock()

     

       230
       +
       

     

       231
        
               # Create a test entry

     

       232
        
               entry = create_test_entry()

     

       233
       +
       

     

       234
        
               # Mock the handler config

     

       235
        
               self.handler.config_info = {

     

       236
        
                   "full_name": "Thicket Bot",

     

       237
        
                   "email": "thicket-bot@example.com",

     

       238
        
                   "site": "https://example.zulipchat.com"

     

       239
        
               }

     

       240
       +
       

     

       241
        
               # Mock git store user

     

       242
        
               mock_user = Mock()

     

       243
        
               mock_user.get_zulip_mention.return_value = "author.user"

     

       244
        
               self.bot.git_store.get_user.return_value = mock_user

     

       245
       +
       

     

       246
        
               # Post entry

     

       247
        
               self.bot._post_entry_to_zulip(entry, self.handler, "testauthor")

     

       248
       +
       

     

       249
        
               # Check that a DM was sent

     

       250
        
               assert len(self.handler.sent_messages) == 1

     

       251
        
               message = self.handler.sent_messages[0]

     

       252
       +
       

     

       253
        
               # Verify it's a DM

     

       254
        
               assert message["type"] == "private"

     

       255
        
               assert message["to"] == ["test.user@example.com"]

     
···

       264
        
           def test_bot_tester_basic(self) -> None:

     

       265
        
               """Test basic bot tester functionality."""

     

       266
        
               tester = BotTester()

     

       267
       +
       

     

       268
        
               # Test help command

     

       269
        
               responses = tester.send_command("help")

     

       270
        
               assert len(responses) == 1

     
···

       273
        
           def test_bot_tester_config(self) -> None:

     

       274
        
               """Test bot tester configuration."""

     

       275
        
               tester = BotTester()

     

       276
       +
       

     

       277
        
               # Configure stream

     

       278
        
               responses = tester.send_command("config stream general")

     

       279
        
               tester.assert_response_contains("Stream set to")

     

       280
       +
       

     

       281
        
               # Configure topic

     

       282
        
               responses = tester.send_command("config topic test")

     

       283
        
               tester.assert_response_contains("Topic set to")

     
···

       285
        
           def test_assert_response_contains(self) -> None:

     

       286
        
               """Test response assertion helper."""

     

       287
        
               tester = BotTester()

     

       288
       +
       

     

       289
        
               # Send command

     

       290
        
               tester.send_command("help")

     

       291
       +
       

     

       292
        
               # This should pass

     

       293
        
               tester.assert_response_contains("Thicket Feed Bot")

     

       294
       +
       

     

       295
        
               # This should fail

     

       296
        
               with pytest.raises(AssertionError):

     

       297
       +
                   tester.assert_response_contains("nonexistent text")

+15 -16

tests/test_models.py

···

       9
        
           AtomEntry,

     

       10
        
           DuplicateMap,

     

       11
        
           FeedMetadata,

     

       12
       -
           GitStoreIndex,

     

       13
        
           ThicketConfig,

     

       14
        
           UserConfig,

     

       15
        
           UserMetadata,

     
···

       352
        
       

     

       353
        
               assert metadata.entry_count == original_count + 3

     

       354
        
               assert metadata.last_updated > original_time

     

       355
       -
           

     

       356
        
           def test_zulip_associations(self):

     

       357
        
               """Test Zulip association methods."""

     

       358
        
               metadata = UserMetadata(

     
···

       361
        
                   created=datetime.now(),

     

       362
        
                   last_updated=datetime.now(),

     

       363
        
               )

     

       364
       -
               

     

       365
        
               # Test adding association

     

       366
        
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       367
        
               assert result is True

     

       368
        
               assert len(metadata.zulip_associations) == 1

     

       369
        
               assert metadata.zulip_associations[0].server == "example.zulipchat.com"

     

       370
        
               assert metadata.zulip_associations[0].user_id == "alice"

     

       371
       -
               

     

       372
        
               # Test adding duplicate association

     

       373
        
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       374
        
               assert result is False

     

       375
        
               assert len(metadata.zulip_associations) == 1

     

       376
       -
               

     

       377
        
               # Test adding different association

     

       378
        
               result = metadata.add_zulip_association("other.zulipchat.com", "alice")

     

       379
        
               assert result is True

     

       380
        
               assert len(metadata.zulip_associations) == 2

     

       381
       -
               

     

       382
        
               # Test get_zulip_mention

     

       383
        
               mention = metadata.get_zulip_mention("example.zulipchat.com")

     

       384
        
               assert mention == "alice"

     

       385
       -
               

     

       386
        
               mention = metadata.get_zulip_mention("other.zulipchat.com")

     

       387
        
               assert mention == "alice"

     

       388
       -
               

     

       389
        
               mention = metadata.get_zulip_mention("nonexistent.zulipchat.com")

     

       390
        
               assert mention is None

     

       391
       -
               

     

       392
        
               # Test removing association

     

       393
        
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       394
        
               assert result is True

     

       395
        
               assert len(metadata.zulip_associations) == 1

     

       396
       -
               

     

       397
        
               # Test removing non-existent association

     

       398
        
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       399
        
               assert result is False

     
···

       402
        
       

     

       403
        
       class TestZulipAssociation:

     

       404
        
           """Test ZulipAssociation model."""

     

       405
       -
           

     

       406
        
           def test_valid_association(self):

     

       407
        
               """Test creating valid Zulip association."""

     

       408
        
               assoc = ZulipAssociation(

     

       409
        
                   server="example.zulipchat.com",

     

       410
        
                   user_id="alice@example.com"

     

       411
        
               )

     

       412
       -
               

     

       413
        
               assert assoc.server == "example.zulipchat.com"

     

       414
        
               assert assoc.user_id == "alice@example.com"

     

       415
       -
           

     

       416
        
           def test_association_hash(self):

     

       417
        
               """Test that associations are hashable."""

     

       418
        
               assoc1 = ZulipAssociation(

     
···

       427
        
                   server="other.zulipchat.com",

     

       428
        
                   user_id="alice"

     

       429
        
               )

     

       430
       -
               

     

       431
        
               # Same associations should have same hash

     

       432
        
               assert hash(assoc1) == hash(assoc2)

     

       433
       -
               

     

       434
        
               # Different associations should have different hash

     

       435
        
               assert hash(assoc1) != hash(assoc3)

     

       436
       -
               

     

       437
        
               # Can be used in sets

     

       438
        
               assoc_set = {assoc1, assoc2, assoc3}

     

       439
        
               assert len(assoc_set) == 2  # assoc1 and assoc2 are considered the same

···

       9
        
           AtomEntry,

     

       10
        
           DuplicateMap,

     

       11
        
           FeedMetadata,

     

       0
        
       
     

       12
        
           ThicketConfig,

     

       13
        
           UserConfig,

     

       14
        
           UserMetadata,

     
···

       351
        
       

     

       352
        
               assert metadata.entry_count == original_count + 3

     

       353
        
               assert metadata.last_updated > original_time

     

       354
       +
       

     

       355
        
           def test_zulip_associations(self):

     

       356
        
               """Test Zulip association methods."""

     

       357
        
               metadata = UserMetadata(

     
···

       360
        
                   created=datetime.now(),

     

       361
        
                   last_updated=datetime.now(),

     

       362
        
               )

     

       363
       +
       

     

       364
        
               # Test adding association

     

       365
        
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       366
        
               assert result is True

     

       367
        
               assert len(metadata.zulip_associations) == 1

     

       368
        
               assert metadata.zulip_associations[0].server == "example.zulipchat.com"

     

       369
        
               assert metadata.zulip_associations[0].user_id == "alice"

     

       370
       +
       

     

       371
        
               # Test adding duplicate association

     

       372
        
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       373
        
               assert result is False

     

       374
        
               assert len(metadata.zulip_associations) == 1

     

       375
       +
       

     

       376
        
               # Test adding different association

     

       377
        
               result = metadata.add_zulip_association("other.zulipchat.com", "alice")

     

       378
        
               assert result is True

     

       379
        
               assert len(metadata.zulip_associations) == 2

     

       380
       +
       

     

       381
        
               # Test get_zulip_mention

     

       382
        
               mention = metadata.get_zulip_mention("example.zulipchat.com")

     

       383
        
               assert mention == "alice"

     

       384
       +
       

     

       385
        
               mention = metadata.get_zulip_mention("other.zulipchat.com")

     

       386
        
               assert mention == "alice"

     

       387
       +
       

     

       388
        
               mention = metadata.get_zulip_mention("nonexistent.zulipchat.com")

     

       389
        
               assert mention is None

     

       390
       +
       

     

       391
        
               # Test removing association

     

       392
        
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       393
        
               assert result is True

     

       394
        
               assert len(metadata.zulip_associations) == 1

     

       395
       +
       

     

       396
        
               # Test removing non-existent association

     

       397
        
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       398
        
               assert result is False

     
···

       401
        
       

     

       402
        
       class TestZulipAssociation:

     

       403
        
           """Test ZulipAssociation model."""

     

       404
       +
       

     

       405
        
           def test_valid_association(self):

     

       406
        
               """Test creating valid Zulip association."""

     

       407
        
               assoc = ZulipAssociation(

     

       408
        
                   server="example.zulipchat.com",

     

       409
        
                   user_id="alice@example.com"

     

       410
        
               )

     

       411
       +
       

     

       412
        
               assert assoc.server == "example.zulipchat.com"

     

       413
        
               assert assoc.user_id == "alice@example.com"

     

       414
       +
       

     

       415
        
           def test_association_hash(self):

     

       416
        
               """Test that associations are hashable."""

     

       417
        
               assoc1 = ZulipAssociation(

     
···

       426
        
                   server="other.zulipchat.com",

     

       427
        
                   user_id="alice"

     

       428
        
               )

     

       429
       +
       

     

       430
        
               # Same associations should have same hash

     

       431
        
               assert hash(assoc1) == hash(assoc2)

     

       432
       +
       

     

       433
        
               # Different associations should have different hash

     

       434
        
               assert hash(assoc1) != hash(assoc3)

     

       435
       +
       

     

       436
        
               # Can be used in sets

     

       437
        
               assoc_set = {assoc1, assoc2, assoc3}

     

       438
        
               assert len(assoc_set) == 2  # assoc1 and assoc2 are considered the same