comparing 4f61c1b819969ecd7e834e1c2aeb9a733b06c969 and main on 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

-30

bot-config/run-bot.sh

···

       1
       -
       #!/bin/bash

     

       2
       -
       

     

       3
       -
       # Script to run the Thicket Zulip bot

     

       4
       -
       # Usage: ./run-bot.sh [config-file]

     

       5
       -
       

     

       6
       -
       set -e

     

       7
       -
       

     

       8
       -
       # Default configuration file

     

       9
       -
       CONFIG_FILE="${1:-./zuliprc}"

     

       10
       -
       

     

       11
       -
       # Check if config file exists

     

       12
       -
       if [ ! -f "$CONFIG_FILE" ]; then

     

       13
       -
           echo "Error: Configuration file '$CONFIG_FILE' not found."

     

       14
       -
           echo "Please copy zuliprc.template to zuliprc and fill in your bot credentials."

     

       15
       -
           exit 1

     

       16
       -
       fi

     

       17
       -
       

     

       18
       -
       # Check if we're in the right directory

     

       19
       -
       if [ ! -f "pyproject.toml" ]; then

     

       20
       -
           echo "Error: Please run this script from the thicket project root directory."

     

       21
       -
           exit 1

     

       22
       -
       fi

     

       23
       -
       

     

       24
       -
       echo "Starting Thicket Zulip bot with config: $CONFIG_FILE"

     

       25
       -
       echo "Bot will be available as @thicket in your Zulip chat."

     

       26
       -
       echo "Type Ctrl+C to stop the bot."

     

       27
       -
       echo ""

     

       28
       -
       

     

       29
       -
       # Run the bot using zulip-run-bot

     

       30
       -
       uv run zulip-run-bot src/thicket/bots/thicket_bot.py --config-file "$CONFIG_FILE"

+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"]

+57 -58

src/thicket/bots/test_bot.py

···

       2
        
       

     

       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] = {}

     

       18
       -
               self.sent_messages: list[Dict[str, Any]] = []

     

       19
        
               self.config_info = {

     

       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 = {

     

       31
        
                   "type": "reply",

     

       32
        
                   "to": message.get("sender_id"),

     

       33
        
                   "content": content,

     

       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."""

     

       45
        
               return MockStorage(self.storage_data)

     

       46
        
       

     

       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"

     

       81
       -
       ) -> Dict[str, Any]:

     

       82
        
           """Create a test message for bot testing."""

     

       83
        
           return {

     

       84
        
               "content": content,

     
···

       87
        
               "type": message_type,

     

       88
        
               "timestamp": 1642694400,  # 2022-01-20 12:00:00 UTC

     

       89
        
               "stream_id": 1,

     

       90
       -
               "subject": "test topic"

     

       91
        
           }

     

       92
        
       

     

       93
        
       

     

       94
        
       def create_test_entry(

     

       95
        
           entry_id: str = "test-entry-1",

     

       96
        
           title: str = "Test Article",

     

       97
       -
           link: str = "https://example.com/test-article"

     

       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,

     
···

       108
        
               published=datetime(2024, 1, 20, 10, 0, 0),

     

       109
        
               summary="This is a test article summary",

     

       110
        
               content="<p>This is test article content</p>",

     

       111
       -
               author={"name": "Test Author", "email": "author@example.com"}

     

       112
        
           )

     

       113
        
       

     

       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]]:

     

       0
        
       
     

       0
        
       
     

       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!")

···

       2
        
       

     

       3
        
       import json

     

       4
        
       from pathlib import Path

     

       5
       +
       from typing import Any, 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] = {}

     

       17
       +
               self.sent_messages: list[dict[str, Any]] = []

     

       18
        
               self.config_info = {

     

       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 = {

     

       30
        
                   "type": "reply",

     

       31
        
                   "to": message.get("sender_id"),

     

       32
        
                   "content": content,

     

       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."""

     

       44
        
               return MockStorage(self.storage_data)

     

       45
        
       

     

       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",

     

       80
       +
       ) -> dict[str, Any]:

     

       81
        
           """Create a test message for bot testing."""

     

       82
        
           return {

     

       83
        
               "content": content,

     
···

       86
        
               "type": message_type,

     

       87
        
               "timestamp": 1642694400,  # 2022-01-20 12:00:00 UTC

     

       88
        
               "stream_id": 1,

     

       89
       +
               "subject": "test topic",

     

       90
        
           }

     

       91
        
       

     

       92
        
       

     

       93
        
       def create_test_entry(

     

       94
        
           entry_id: str = "test-entry-1",

     

       95
        
           title: str = "Test Article",

     

       96
       +
           link: str = "https://example.com/test-article",

     

       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,

     
···

       108
        
               published=datetime(2024, 1, 20, 10, 0, 0),

     

       109
        
               summary="This is a test article summary",

     

       110
        
               content="<p>This is test article content</p>",

     

       111
       +
               author={"name": "Test Author", "email": "author@example.com"},

     

       112
        
           )

     

       113
        
       

     

       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, config_path: Path, stream: str = "test-stream", topic: str = "test-topic"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       129
        
           ) -> None:

     

       130
        
               """Configure the bot for testing."""

     

       131
        
               # Set bot configuration

     

       132
        
               config_data = {

     

       133
        
                   "stream_name": stream,

     

       134
       +
                   "topic_name": topic,

     

       135
        
                   "sync_interval": 300,

     

       136
        
                   "max_entries_per_sync": 10,

     

       137
       +
                   "config_path": str(config_path),

     

       138
        
               }

     

       139
       +
       

     

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

     

       141
       +
       

     

       142
        
               # Initialize bot

     

       143
        
               self.bot._load_bot_config(self.handler)

     

       144
       +
       

     

       145
       +
           def send_command(

     

       146
       +
               self, command: str, sender: str = "Test User"

     

       147
       +
           ) -> list[dict[str, Any]]:

     

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

     

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

     

       150
       +
       

     

       151
        
               # Clear previous messages

     

       152
        
               self.handler.sent_messages.clear()

     

       153
       +
       

     

       154
        
               # Send command

     

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

     

       156
       +
       

     

       157
        
               return self.handler.sent_messages.copy()

     

       158
       +
       

     

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

     

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

     

       161
        
               if self.handler.sent_messages:

     

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

     

       163
        
               return None

     

       164
       +
       

     

       165
       +
           def get_last_message(self) -> Optional[dict[str, Any]]:

     

       166
        
               """Get the last sent message."""

     

       167
        
               if self.handler.sent_messages:

     

       168
        
                   return self.handler.sent_messages[-1]

     

       169
        
               return None

     

       170
       +
       

     

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

     

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

     

       173
        
               content = self.get_last_response_content()

     
···

       179
        
       if __name__ == "__main__":

     

       180
        
           # Create a test config file

     

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

     

       182
       +
       

     

       183
        
           # Create bot tester

     

       184
        
           tester = BotTester()

     

       185
       +
       

     

       186
        
           # Test help command

     

       187
        
           responses = tester.send_command("help")

     

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

     

       189
       +
       

     

       190
        
           # Test status command

     

       191
        
           responses = tester.send_command("status")

     

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

     

       193
       +
       

     

       194
        
           # Test configuration

     

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

     

       196
        
           tester.assert_response_contains("Stream set to")

     

       197
       +
       

     

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

     

       199
        
           tester.assert_response_contains("Topic set to")

     

       200
       +
       

     

       201
       +
           print("All tests passed!")

+755 -252

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

     

       0
        
       
     

       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)

     

       121
        
                   elif command == "status":

     

       122
        
                       self._send_status(message, bot_handler, sender)

     

       123
       -
                   elif command == "sync" and len(command_parts) > 1 and command_parts[1] == "now":

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       124
        
                       self._handle_force_sync(message, bot_handler, sender)

     

       125
        
                   elif command == "reset":

     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       129
        
                   else:

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       131
        
               except Exception as e:

     

       132
        
                   self.logger.error(f"Error handling command '{command}': {e}")

     

       133
        
                   bot_handler.send_reply(message, f"Error processing command: {str(e)}")

     
···

       137
        
               try:

     

       138
        
                   # Get bot's actual name from Zulip

     

       139
        
                   bot_info = bot_handler._client.get_profile()

     

       140
       -
                   if bot_info.get('result') == 'success':

     

       141
       -
                       bot_name = bot_info.get('full_name', '').lower()

     

       142
        
                       if bot_name:

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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()

     

       157
       -
                   if bot_info.get('result') == 'success':

     

       158
       -
                       bot_name = bot_info.get('full_name', '')

     

       159
        
                       if bot_name:

     

       160
        
                           # Remove @bot_name or @**bot_name**

     

       161
        
                           escaped_name = re.escape(bot_name)

     

       162
       -
                           content = re.sub(rf'@(?:\*\*)?{escaped_name}(?:\*\*)?', '', content, flags=re.IGNORECASE).strip()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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()

     

       0
        
       
     

       0
        
       
     

       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:

     

       0
        
       
     

       0
        
       
     

       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
       -
                   ])

     

       0
        
       
     

       0
        
       
     

       189
        
               else:

     

       190
       -
                   status_lines.extend([

     

       191
       -
                       f"📍 **Stream:** {self.stream_name or 'Not configured'}",

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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}",

     

       199
       -
                   f"📁 **Config Path:** {self.config_path or 'Not configured'}",

     

       200
       -
                   "",

     

       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'}",

     

       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:

     

       0
        
       
     

       0
        
       
     

       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
       -
               

     

       0
        
       
     

       0
        
       
     

       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:

     

       0
        
       
     

       0
        
       
     

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

     

       227
        
               try:

     

       228
        
                   self.posted_entries.clear()

     

       229
        
                   self._save_posted_entries(bot_handler)

     

       230
        
                   bot_handler.send_reply(

     

       231
        
                       message,

     

       232
       -
                       f"✅ Posting history reset! Recent entries will be posted on next sync. (requested by {sender})"

     

       233
        
                   )

     

       234
        
                   self.logger.info(f"Posted entries tracking reset by {sender}")

     

       235
        
               except Exception as e:

     

       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
        
       
     

       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>`")

     

       0
        
       
     

       0
        
       
     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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")

     

       0
        
       
     

       0
        
       
     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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
        
       
     

       0
        
       
     

       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
        
       
     

       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

     

       0
        
       
     

       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
       -
               

     

       0
        
       
     

       0
        
       
     

       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)

     

       350
        
               if actual_user_id and actual_user_id != zulip_user_id:

     

       351
        
                   # Successfully resolved to numeric ID

     

       352
        
                   self.debug_zulip_user_id = actual_user_id

     

       353
       -
                   self.logger.info(f"Debug mode enabled: Will send DMs to {self.debug_user} (email: {zulip_user_id}, user_id: {actual_user_id}) on {server_url}")

     

       0
        
       
     

       0
        
       
     

       354
        
               else:

     

       355
        
                   # Keep the email address, will resolve later when sending

     

       356
        
                   self.debug_zulip_user_id = zulip_user_id

     

       357
       -
                   self.logger.info(f"Debug mode enabled: Will send DMs to {self.debug_user} ({zulip_user_id}) on {server_url} (will resolve user ID when sending)")

     

       0
        
       
     

       0
        
       
     

       358
        
       

     

       359
       -
           def _lookup_zulip_user_id(self, bot_handler: BotHandler, email_or_id: str) -> Optional[str]:

     

       0
        
       
     

       0
        
       
     

       360
        
               """Look up Zulip user ID from email address or return the ID if it's already numeric."""

     

       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)

     

       374
       -
                       if user_result.get('result') == 'success':

     

       375
       -
                           user_data = user_result.get('user', {})

     

       376
       -
                           user_id = user_data.get('user_id')

     

       377
        
                           if user_id:

     

       378
       -
                               self.logger.info(f"Found user ID {user_id} for '{email_or_id}' via get_user_by_email API")

     

       0
        
       
     

       0
        
       
     

       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')

     

       0
        
       
     

       0
        
       
     

       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.")

     

       0
        
       
     

       0
        
       
     

       397
        
                       return None

     

       398
        
                   else:

     

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

     

       0
        
       
     

       0
        
       
     

       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]]:

     

       0
        
       
     

       0
        
       
     

       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)

     

       419
       -
                       if user_result.get('result') == 'success':

     

       420
       -
                           user_data = user_result.get('user', {})

     

       421
       -
                           user_id = user_data.get('user_id')

     

       422
       -
                           full_name = user_data.get('full_name', '')

     

       423
        
                           if user_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
       -
                               

     

       0
        
       
     

       0
        
       
     

       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

     
···

       452
        
           def _save_posted_entries(self, bot_handler: BotHandler) -> None:

     

       453
        
               """Save the set of posted entries."""

     

       454
        
               try:

     

       455
       -
                   bot_handler.storage.put("posted_entries", json.dumps(list(self.posted_entries)))

     

       0
        
       
     

       0
        
       
     

       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:

     

       0
        
       
     

       0
        
       
     

       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:

     

       482
        
               """Schedule periodic sync operations."""

     

       0
        
       
     

       483
        
               def sync_loop():

     

       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

     

       0
        
       
     

       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:

     
···

       521
        
                           asyncio.set_event_loop(loop)

     

       522
        
                           try:

     

       523
        
                               new_count, _ = loop.run_until_complete(

     

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

     

       0
        
       
     

       0
        
       
     

       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
       -
                               

     

       0
        
       
     

       0
        
       
     

       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
       -
                               

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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
       -
                           

     

       0
        
       
     

       0
        
       
     

       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
       -
                           

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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:

     

       0
        
       
     

       0
        
       
     

       573
        
               """Post a single entry to the configured Zulip stream/topic or debug user DM."""

     

       574
        
               try:

     

       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:

     
···

       584
        
                           zulip_user_id = user.get_zulip_mention(server_url)

     

       585
        
                           if zulip_user_id:

     

       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)

     

       0
        
       
     

       0
        
       
     

       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
       -
                               

     

       0
        
       
     

       0
        
       
     

       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
       -
                   

     

       0
        
       
     

       0
        
       
     

       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():

     

       643
        
                           # Need to look up the numeric ID

     

       644
       -
                           resolved_id = self._lookup_zulip_user_id(bot_handler, user_id_to_use)

     

       0
        
       
     

       0
        
       
     

       645
        
                           if resolved_id:

     

       646
        
                               user_id_to_use = resolved_id

     

       647
       -
                               self.logger.debug(f"Resolved {self.debug_zulip_user_id} to user ID {user_id_to_use}")

     

       0
        
       
     

       0
        
       
     

       648
        
                           else:

     

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

     

       0
        
       
     

       0
        
       
     

       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)

     

       655
       -
                           bot_handler.send_message({

     

       656
       -
                               "type": "private",

     

       657
       -
                               "to": [user_id_int],  # Use integer user ID

     

       658
       -
                               "content": debug_message

     

       659
       -
                           })

     

       0
        
       
     

       0
        
       
     

       660
        
                       except ValueError:

     

       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
       -
                               })

     

       0
        
       
     

       0
        
       
     

       668
        
                           except Exception as e2:

     

       669
       -
                               self.logger.error(f"Failed to send DM to {self.debug_user} (tried both int and string): {e2}")

     

       0
        
       
     

       0
        
       
     

       670
        
                               return

     

       671
        
                       except Exception as e:

     

       672
       -
                           self.logger.error(f"Failed to send DM to {self.debug_user} ({user_id_to_use}): {e}")

     

       0
        
       
     

       0
        
       
     

       673
        
                           return

     

       674
       -
                       self.logger.info(f"Posted entry to debug user {self.debug_user}: {entry.title}")

     

       0
        
       
     

       0
        
       
     

       675
        
                   else:

     

       676
        
                       # Normal mode: send to stream/topic

     

       677
       -
                       bot_handler.send_message({

     

       678
       -
                           "type": "stream",

     

       679
       -
                           "to": self.stream_name,

     

       680
       -
                           "subject": self.topic_name,

     

       681
       -
                           "content": message_content

     

       682
       -
                       })

     

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

     

       684
       -
                   

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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,

     

       700
        
                       heading_style="ATX",  # Use # for headings (but we'll post-process these)

     

       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']

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       703
        
                   ).strip()

     

       704
       -
                   

     

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

     

       706
        
                   import re

     

       0
        
       
     

       707
        
                   # Convert markdown headers to bold with period

     

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

     

       709
       -
                   

     

       0
        
       
     

       0
        
       
     

       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
       -
                   

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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

     

       0
        
       
     

       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
       -
                   

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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
       -
                   

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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
       -
                   

     

       0
        
       
     

       0
        
       
     

       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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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()

     

       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
        
       
     

       752
        
       

     

       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

···

       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
       +
       

     

       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
       +
       

     

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

     

       27
        
           from thicket.core.git_store import GitStore

     

       28
        
           from thicket.models import AtomEntry, ThicketConfig

     

       0
        
       
     

       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
       +
       

     

       48
       +
               # Bot behavior settings (loaded from botrc)

     

       49
       +
               self.rate_limit_delay: int = 5

     

       50
       +
               self.posts_per_batch: int = 5

     

       51
       +
               self.catchup_entries: int = 5

     

       52
       +
               self.config_change_notifications: bool = True

     

       53
       +
               self.username_claim_notifications: bool = True

     

       54
       +
       

     

       55
       +
               # Track last sync time for schedule queries

     

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

     

       57
       +
       

     

       58
        
               # Debug mode configuration

     

       59
        
               self.debug_user: Optional[str] = None

     

       60
        
               self.debug_zulip_user_id: Optional[str] = None

     

       61
       +
       

     

       62
        
           def usage(self) -> str:

     

       63
        
               """Return bot usage instructions."""

     

       64
        
               return """

     

       65
        
               **Thicket Feed Bot**

     

       66
       +
       

     

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

     

       68
       +
       

     

       69
        
               Commands:

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       79
        
               """

     

       80
        
       

     

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

     

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

     

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

     

       84
       +
       

     

       85
        
               # Get configuration from environment (set by CLI)

     

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

     

       87
        
               config_path_env = os.getenv("THICKET_CONFIG_PATH")

     

       88
        
               if config_path_env:

     

       89
        
                   self.config_path = Path(config_path_env)

     

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

     

       91
       +
       

     

       92
       +
               # Load default configuration from botrc file

     

       93
       +
               self._load_botrc_defaults()

     

       94
       +
       

     

       95
        
               # Load bot configuration from persistent storage

     

       96
        
               self._load_bot_config(bot_handler)

     

       97
       +
       

     

       98
        
               # Initialize thicket components

     

       99
        
               if self.config_path:

     

       100
        
                   try:

     

       101
        
                       self._initialize_thicket()

     

       102
        
                       self._load_posted_entries(bot_handler)

     

       103
       +
       

     

       104
        
                       # Validate debug mode if enabled

     

       105
        
                       if self.debug_user:

     

       106
        
                           self._validate_debug_mode(bot_handler)

     

       107
       +
       

     

       108
        
                   except Exception as e:

     

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

     

       110
       +
       

     

       111
        
               # Start background sync loop

     

       112
        
               self._schedule_sync(bot_handler)

     

       113
        
       

     

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

     

       115
        
               """Handle incoming Zulip messages."""

     

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

     

       117
        
               sender = message["sender_full_name"]

     

       118
       +
       

     

       119
        
               # Only respond to mentions

     

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

     

       121
        
                   return

     

       122
       +
       

     

       123
        
               # Parse command

     

       124
        
               cleaned_content = self._clean_mention(content, bot_handler)

     

       125
        
               command_parts = cleaned_content.split()

     

       126
       +
       

     

       127
        
               if not command_parts:

     

       128
        
                   self._send_help(message, bot_handler)

     

       129
        
                   return

     

       130
       +
       

     

       131
        
               command = command_parts[0].lower()

     

       132
       +
       

     

       133
        
               try:

     

       134
        
                   if command == "help":

     

       135
        
                       self._send_help(message, bot_handler)

     

       136
        
                   elif command == "status":

     

       137
        
                       self._send_status(message, bot_handler, sender)

     

       138
       +
                   elif (

     

       139
       +
                       command == "sync"

     

       140
       +
                       and len(command_parts) > 1

     

       141
       +
                       and command_parts[1] == "now"

     

       142
       +
                   ):

     

       143
        
                       self._handle_force_sync(message, bot_handler, sender)

     

       144
        
                   elif command == "reset":

     

       145
        
                       self._handle_reset_command(message, bot_handler, sender)

     

       146
        
                   elif command == "config":

     

       147
       +
                       self._handle_config_command(

     

       148
       +
                           message, bot_handler, command_parts[1:], sender

     

       149
       +
                       )

     

       150
       +
                   elif command == "schedule":

     

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

     

       152
       +
                   elif command == "claim":

     

       153
       +
                       self._handle_claim_command(

     

       154
       +
                           message, bot_handler, command_parts[1:], sender

     

       155
       +
                       )

     

       156
        
                   else:

     

       157
       +
                       bot_handler.send_reply(

     

       158
       +
                           message,

     

       159
       +
                           f"Unknown command: {command}. Type `@mention help` for usage.",

     

       160
       +
                       )

     

       161
        
               except Exception as e:

     

       162
        
                   self.logger.error(f"Error handling command '{command}': {e}")

     

       163
        
                   bot_handler.send_reply(message, f"Error processing command: {str(e)}")

     
···

       167
        
               try:

     

       168
        
                   # Get bot's actual name from Zulip

     

       169
        
                   bot_info = bot_handler._client.get_profile()

     

       170
       +
                   if bot_info.get("result") == "success":

     

       171
       +
                       bot_name = bot_info.get("full_name", "").lower()

     

       172
        
                       if bot_name:

     

       173
       +
                           return (

     

       174
       +
                               f"@{bot_name}" in content.lower()

     

       175
       +
                               or f"@**{bot_name}**" in content.lower()

     

       176
       +
                           )

     

       177
        
               except Exception as e:

     

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

     

       179
       +
       

     

       180
        
               # Fallback to generic check

     

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

     

       182
       +
       

     

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

     

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

     

       185
        
               import re

     

       186
       +
       

     

       187
        
               try:

     

       188
        
                   # Get bot's actual name from Zulip

     

       189
        
                   bot_info = bot_handler._client.get_profile()

     

       190
       +
                   if bot_info.get("result") == "success":

     

       191
       +
                       bot_name = bot_info.get("full_name", "")

     

       192
        
                       if bot_name:

     

       193
        
                           # Remove @bot_name or @**bot_name**

     

       194
        
                           escaped_name = re.escape(bot_name)

     

       195
       +
                           content = re.sub(

     

       196
       +
                               rf"@(?:\*\*)?{escaped_name}(?:\*\*)?",

     

       197
       +
                               "",

     

       198
       +
                               content,

     

       199
       +
                               flags=re.IGNORECASE,

     

       200
       +
                           ).strip()

     

       201
        
                           return content

     

       202
        
               except Exception as e:

     

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

     

       204
       +
       

     

       205
        
               # Fallback to removing @thicket

     

       206
       +
               content = re.sub(

     

       207
       +
                   r"@(?:\*\*)?thicket(?:\*\*)?", "", content, flags=re.IGNORECASE

     

       208
       +
               ).strip()

     

       209
        
               return content

     

       210
        
       

     

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

     

       212
        
               """Send help message."""

     

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

     

       214
        
       

     

       215
       +
           def _send_status(

     

       216
       +
               self, message: dict[str, Any], bot_handler: BotHandler, sender: str

     

       217
       +
           ) -> None:

     

       218
        
               """Send bot status information."""

     

       219
        
               status_lines = [

     

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

     

       221
        
                   "",

     

       222
        
               ]

     

       223
       +
       

     

       224
        
               # Debug mode status

     

       225
        
               if self.debug_user:

     

       226
       +
                   status_lines.extend(

     

       227
       +
                       [

     

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

     

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

     

       230
       +
                           "",

     

       231
       +
                       ]

     

       232
       +
                   )

     

       233
        
               else:

     

       234
       +
                   status_lines.extend(

     

       235
       +
                       [

     

       236
       +
                           f"📍 **Stream:** {self.stream_name or 'Not configured'}",

     

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

     

       238
       +
                           "",

     

       239
       +
                       ]

     

       240
       +
                   )

     

       241
       +
       

     

       242
       +
               status_lines.extend(

     

       243
       +
                   [

     

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

     

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

     

       246
       +
                       f"📁 **Config Path:** {self.config_path or 'Not configured'}",

     

       247
       +
                       "",

     

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

     

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

     

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

     

       251
        
                       "",

     

       252
       +
                       self._get_schedule_info(),

     

       253
       +
                   ]

     

       254
       +
               )

     

       255
       +
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       257
        
       

     

       258
       +
           def _handle_force_sync(

     

       259
       +
               self, message: dict[str, Any], bot_handler: BotHandler, sender: str

     

       260
       +
           ) -> None:

     

       261
        
               """Handle immediate sync request."""

     

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

     

       263
        
                   return

     

       264
       +
       

     

       265
       +
               bot_handler.send_reply(

     

       266
       +
                   message, f"🔄 Starting immediate sync... (requested by {sender})"

     

       267
       +
               )

     

       268
       +
       

     

       269
        
               try:

     

       270
        
                   new_entries = self._perform_sync(bot_handler)

     

       271
        
                   bot_handler.send_reply(

     

       272
       +
                       message, f"✅ Sync completed! Found {len(new_entries)} new entries."

     

       0
        
       
     

       273
        
                   )

     

       274
        
               except Exception as e:

     

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

     

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

     

       277
        
       

     

       278
       +
           def _handle_reset_command(

     

       279
       +
               self, message: dict[str, Any], bot_handler: BotHandler, sender: str

     

       280
       +
           ) -> None:

     

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

     

       282
        
               try:

     

       283
        
                   self.posted_entries.clear()

     

       284
        
                   self._save_posted_entries(bot_handler)

     

       285
        
                   bot_handler.send_reply(

     

       286
        
                       message,

     

       287
       +
                       f"✅ Posting history reset! Recent entries will be posted on next sync. (requested by {sender})",

     

       288
        
                   )

     

       289
        
                   self.logger.info(f"Posted entries tracking reset by {sender}")

     

       290
        
               except Exception as e:

     

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

     

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

     

       293
        
       

     

       294
       +
           def _handle_schedule_command(

     

       295
       +
               self, message: dict[str, Any], bot_handler: BotHandler, sender: str

     

       296
       +
           ) -> None:

     

       297
       +
               """Handle schedule query command."""

     

       298
       +
               schedule_info = self._get_schedule_info()

     

       299
       +
               bot_handler.send_reply(

     

       300
       +
                   message,

     

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

     

       302
       +
               )

     

       303
       +
       

     

       304
       +
           def _handle_claim_command(

     

       305
       +
               self,

     

       306
       +
               message: dict[str, Any],

     

       307
       +
               bot_handler: BotHandler,

     

       308
       +
               args: list[str],

     

       309
       +
               sender: str,

     

       310
       +
           ) -> None:

     

       311
       +
               """Handle username claiming command."""

     

       312
       +
               if not args:

     

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

     

       314
       +
                   return

     

       315
       +
       

     

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

     

       317
       +
                   return

     

       318
       +
       

     

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

     

       320
       +
       

     

       321
       +
               # Get sender's Zulip user info

     

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

     

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

     

       324
       +
       

     

       325
       +
               if not sender_user_id or not sender_email:

     

       326
       +
                   bot_handler.send_reply(

     

       327
       +
                       message, "❌ Could not determine your Zulip user information."

     

       328
       +
                   )

     

       329
       +
                   return

     

       330
       +
       

     

       331
       +
               try:

     

       332
       +
                   # Get current Zulip server from environment

     

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

     

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

     

       335
       +
       

     

       336
       +
                   if not server_url:

     

       337
       +
                       bot_handler.send_reply(

     

       338
       +
                           message, "❌ Could not determine Zulip server URL."

     

       339
       +
                       )

     

       340
       +
                       return

     

       341
       +
       

     

       342
       +
                   # Check if username exists in thicket

     

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

     

       344
       +
                   if not user:

     

       345
       +
                       bot_handler.send_reply(

     

       346
       +
                           message,

     

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

     

       348
       +
                       )

     

       349
       +
                       return

     

       350
       +
       

     

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

     

       352
       +
                   existing_zulip_id = user.get_zulip_mention(server_url)

     

       353
       +
                   if existing_zulip_id:

     

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

     

       355
       +
                       if existing_zulip_id == sender_email or str(existing_zulip_id) == str(

     

       356
       +
                           sender_user_id

     

       357
       +
                       ):

     

       358
       +
                           bot_handler.send_reply(

     

       359
       +
                               message,

     

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

     

       361
       +
                           )

     

       362
       +
                       else:

     

       363
       +
                           bot_handler.send_reply(

     

       364
       +
                               message,

     

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

     

       366
       +
                           )

     

       367
       +
                       return

     

       368
       +
       

     

       369
       +
                   # Claim the username - prefer email for consistency

     

       370
       +
                   success = self.git_store.add_zulip_association(

     

       371
       +
                       username, server_url, sender_email

     

       372
       +
                   )

     

       373
       +
       

     

       374
       +
                   if success:

     

       375
       +
                       reply_msg = (

     

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

     

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

     

       378
       +
                       )

     

       379
       +
                       bot_handler.send_reply(message, reply_msg)

     

       380
       +
       

     

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

     

       382
       +
                       if (

     

       383
       +
                           self.username_claim_notifications

     

       384
       +
                           and not self.debug_user

     

       385
       +
                           and self.stream_name

     

       386
       +
                           and self.topic_name

     

       387
       +
                       ):

     

       388
       +
                           try:

     

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

     

       390
       +
                               bot_handler.send_message(

     

       391
       +
                                   {

     

       392
       +
                                       "type": "stream",

     

       393
       +
                                       "to": self.stream_name,

     

       394
       +
                                       "subject": self.topic_name,

     

       395
       +
                                       "content": notification_msg,

     

       396
       +
                                   }

     

       397
       +
                               )

     

       398
       +
                           except Exception as e:

     

       399
       +
                               self.logger.error(

     

       400
       +
                                   f"Failed to send username claim notification: {e}"

     

       401
       +
                               )

     

       402
       +
       

     

       403
       +
                       self.logger.info(

     

       404
       +
                           f"User {sender} ({sender_email}) claimed username {username} on {server_url}"

     

       405
       +
                       )

     

       406
       +
                   else:

     

       407
       +
                       bot_handler.send_reply(

     

       408
       +
                           message,

     

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

     

       410
       +
                       )

     

       411
       +
       

     

       412
       +
               except Exception as e:

     

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

     

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

     

       415
       +
       

     

       416
        
           def _handle_config_command(

     

       417
       +
               self,

     

       418
       +
               message: dict[str, Any],

     

       419
       +
               bot_handler: BotHandler,

     

       420
       +
               args: list[str],

     

       421
       +
               sender: str,

     

       422
        
           ) -> None:

     

       423
        
               """Handle configuration commands."""

     

       424
        
               if len(args) < 2:

     

       425
       +
                   bot_handler.send_reply(

     

       426
       +
                       message, "Usage: `@mention config <setting> <value>`"

     

       427
       +
                   )

     

       428
        
                   return

     

       429
       +
       

     

       430
        
               setting = args[0].lower()

     

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

     

       432
       +
       

     

       433
        
               if setting == "stream":

     

       434
       +
                   old_value = self.stream_name

     

       435
        
                   self.stream_name = value

     

       436
        
                   self._save_bot_config(bot_handler)

     

       437
       +
                   bot_handler.send_reply(

     

       438
       +
                       message, f"✅ Stream set to: **{value}** (by {sender})"

     

       439
       +
                   )

     

       440
       +
                   self._send_config_change_notification(

     

       441
       +
                       bot_handler, sender, "stream", old_value, value

     

       442
       +
                   )

     

       443
       +
       

     

       444
        
               elif setting == "topic":

     

       445
       +
                   old_value = self.topic_name

     

       446
        
                   self.topic_name = value

     

       447
        
                   self._save_bot_config(bot_handler)

     

       448
       +
                   bot_handler.send_reply(

     

       449
       +
                       message, f"✅ Topic set to: **{value}** (by {sender})"

     

       450
       +
                   )

     

       451
       +
                   self._send_config_change_notification(

     

       452
       +
                       bot_handler, sender, "topic", old_value, value

     

       453
       +
                   )

     

       454
       +
       

     

       455
        
               elif setting == "interval":

     

       456
        
                   try:

     

       457
        
                       interval = int(value)

     

       458
        
                       if interval < 60:

     

       459
       +
                           bot_handler.send_reply(

     

       460
       +
                               message, "❌ Interval must be at least 60 seconds"

     

       461
       +
                           )

     

       462
        
                           return

     

       463
       +
                       old_value = self.sync_interval

     

       464
        
                       self.sync_interval = interval

     

       465
        
                       self._save_bot_config(bot_handler)

     

       466
       +
                       bot_handler.send_reply(

     

       467
       +
                           message, f"✅ Sync interval set to: **{interval}s** (by {sender})"

     

       468
       +
                       )

     

       469
       +
                       self._send_config_change_notification(

     

       470
       +
                           bot_handler,

     

       471
       +
                           sender,

     

       472
       +
                           "sync interval",

     

       473
       +
                           f"{old_value}s",

     

       474
       +
                           f"{interval}s",

     

       475
       +
                       )

     

       476
        
                   except ValueError:

     

       477
       +
                       bot_handler.send_reply(

     

       478
       +
                           message, "❌ Invalid interval value. Must be a number of seconds."

     

       479
       +
                       )

     

       480
       +
       

     

       481
       +
               elif setting == "max_entries":

     

       482
       +
                   try:

     

       483
       +
                       max_entries = int(value)

     

       484
       +
                       if max_entries < 1 or max_entries > 50:

     

       485
       +
                           bot_handler.send_reply(

     

       486
       +
                               message, "❌ Max entries must be between 1 and 50"

     

       487
       +
                           )

     

       488
       +
                           return

     

       489
       +
                       old_value = self.max_entries_per_sync

     

       490
       +
                       self.max_entries_per_sync = max_entries

     

       491
       +
                       self._save_bot_config(bot_handler)

     

       492
       +
                       bot_handler.send_reply(

     

       493
       +
                           message,

     

       494
       +
                           f"✅ Max entries per sync set to: **{max_entries}** (by {sender})",

     

       495
       +
                       )

     

       496
       +
                       self._send_config_change_notification(

     

       497
       +
                           bot_handler,

     

       498
       +
                           sender,

     

       499
       +
                           "max entries per sync",

     

       500
       +
                           str(old_value),

     

       501
       +
                           str(max_entries),

     

       502
       +
                       )

     

       503
       +
                   except ValueError:

     

       504
       +
                       bot_handler.send_reply(

     

       505
       +
                           message, "❌ Invalid max entries value. Must be a number."

     

       506
       +
                       )

     

       507
       +
       

     

       508
        
               else:

     

       509
        
                   bot_handler.send_reply(

     

       510
       +
                       message,

     

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

     

       512
        
                   )

     

       513
        
       

     

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

     
···

       518
        
                   if config_data:

     

       519
        
                       config = json.loads(config_data)

     

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

     

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

     

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

     

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

     

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

     

       525
       +
               except Exception:

     

       526
        
                   # Bot config not found on first run is expected

     

       527
        
                   pass

     

       528
        
       

     
···

       534
        
                       "topic_name": self.topic_name,

     

       535
        
                       "sync_interval": self.sync_interval,

     

       536
        
                       "max_entries_per_sync": self.max_entries_per_sync,

     

       537
       +
                       "last_sync_time": self.last_sync_time,

     

       538
        
                   }

     

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

     

       540
        
               except Exception as e:

     

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

     

       542
        
       

     

       543
       +
           def _load_botrc_defaults(self) -> None:

     

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

     

       545
       +
               try:

     

       546
       +
                   import configparser

     

       547
       +
                   from pathlib import Path

     

       548
       +
       

     

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

     

       550
       +
                   if not botrc_path.exists():

     

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

     

       552
       +
                       return

     

       553
       +
       

     

       554
       +
                   config = configparser.ConfigParser()

     

       555
       +
                   config.read(botrc_path)

     

       556
       +
       

     

       557
       +
                   if "bot" in config:

     

       558
       +
                       bot_section = config["bot"]

     

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

     

       560
       +
                       self.max_entries_per_sync = bot_section.getint(

     

       561
       +
                           "max_entries_per_sync", 10

     

       562
       +
                       )

     

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

     

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

     

       565
       +
       

     

       566
       +
                       # Set defaults only if not already configured

     

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

     

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

     

       569
       +
                       if default_stream:

     

       570
       +
                           self.stream_name = default_stream

     

       571
       +
                       if default_topic:

     

       572
       +
                           self.topic_name = default_topic

     

       573
       +
       

     

       574
       +
                   if "catchup" in config:

     

       575
       +
                       catchup_section = config["catchup"]

     

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

     

       577
       +
       

     

       578
       +
                   if "notifications" in config:

     

       579
       +
                       notifications_section = config["notifications"]

     

       580
       +
                       self.config_change_notifications = notifications_section.getboolean(

     

       581
       +
                           "config_change_notifications", True

     

       582
       +
                       )

     

       583
       +
                       self.username_claim_notifications = notifications_section.getboolean(

     

       584
       +
                           "username_claim_notifications", True

     

       585
       +
                       )

     

       586
       +
       

     

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

     

       588
       +
       

     

       589
       +
               except Exception as e:

     

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

     

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

     

       592
       +
       

     

       593
        
           def _initialize_thicket(self) -> None:

     

       594
        
               """Initialize thicket components."""

     

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

     

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

     

       597
       +
       

     

       598
        
               # Load thicket configuration

     

       599
        
               import yaml

     

       600
       +
       

     

       601
        
               with open(self.config_path) as f:

     

       602
        
                   config_data = yaml.safe_load(f)

     

       603
        
               self.config = ThicketConfig(**config_data)

     

       604
       +
       

     

       605
        
               # Initialize git store

     

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

     

       607
       +
       

     

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

     

       609
       +
       

     

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

     

       611
        
               """Validate debug mode configuration."""

     

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

     

       613
        
                   return

     

       614
       +
       

     

       615
        
               # Get current Zulip server from environment

     

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

     

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

     

       618
       +
       

     

       619
        
               # Check if debug user exists in thicket

     

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

     

       621
        
               if not user:

     

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

     

       623
       +
       

     

       624
        
               # Check if user has Zulip association for this server

     

       625
        
               if not server_url:

     

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

     

       627
       +
       

     

       628
        
               zulip_user_id = user.get_zulip_mention(server_url)

     

       629
        
               if not zulip_user_id:

     

       630
       +
                   raise ValueError(

     

       631
       +
                       f"User '{self.debug_user}' has no Zulip association for server '{server_url}'"

     

       632
       +
                   )

     

       633
       +
       

     

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

     

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

     

       636
        
               actual_user_id = self._lookup_zulip_user_id(bot_handler, zulip_user_id)

     

       637
        
               if actual_user_id and actual_user_id != zulip_user_id:

     

       638
        
                   # Successfully resolved to numeric ID

     

       639
        
                   self.debug_zulip_user_id = actual_user_id

     

       640
       +
                   self.logger.info(

     

       641
       +
                       f"Debug mode enabled: Will send DMs to {self.debug_user} (email: {zulip_user_id}, user_id: {actual_user_id}) on {server_url}"

     

       642
       +
                   )

     

       643
        
               else:

     

       644
        
                   # Keep the email address, will resolve later when sending

     

       645
        
                   self.debug_zulip_user_id = zulip_user_id

     

       646
       +
                   self.logger.info(

     

       647
       +
                       f"Debug mode enabled: Will send DMs to {self.debug_user} ({zulip_user_id}) on {server_url} (will resolve user ID when sending)"

     

       648
       +
                   )

     

       649
        
       

     

       650
       +
           def _lookup_zulip_user_id(

     

       651
       +
               self, bot_handler: BotHandler, email_or_id: str

     

       652
       +
           ) -> Optional[str]:

     

       653
        
               """Look up Zulip user ID from email address or return the ID if it's already numeric."""

     

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

     

       655
        
               if email_or_id.isdigit():

     

       656
        
                   return email_or_id

     

       657
       +
       

     

       658
        
               try:

     

       659
        
                   client = bot_handler._client

     

       660
        
                   if not client:

     

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

     

       662
        
                       return None

     

       663
       +
       

     

       664
        
                   # First try the get_user_by_email API if available

     

       665
        
                   try:

     

       666
        
                       user_result = client.get_user_by_email(email_or_id)

     

       667
       +
                       if user_result.get("result") == "success":

     

       668
       +
                           user_data = user_result.get("user", {})

     

       669
       +
                           user_id = user_data.get("user_id")

     

       670
        
                           if user_id:

     

       671
       +
                               self.logger.info(

     

       672
       +
                                   f"Found user ID {user_id} for '{email_or_id}' via get_user_by_email API"

     

       673
       +
                               )

     

       674
        
                               return str(user_id)

     

       675
        
                   except (AttributeError, Exception):

     

       676
        
                       pass

     

       677
       +
       

     

       678
        
                   # Fallback: Get all users and search through them

     

       679
        
                   users_result = client.get_users()

     

       680
       +
                   if users_result.get("result") == "success":

     

       681
       +
                       for user in users_result["members"]:

     

       682
       +
                           user_email = user.get("email", "")

     

       683
       +
                           delivery_email = user.get("delivery_email", "")

     

       684
       +
       

     

       685
       +
                           if (

     

       686
       +
                               user_email == email_or_id

     

       687
       +
                               or delivery_email == email_or_id

     

       688
       +
                               or str(user.get("user_id")) == email_or_id

     

       689
       +
                           ):

     

       690
       +
                               user_id = user.get("user_id")

     

       691
        
                               return str(user_id)

     

       692
       +
       

     

       693
       +
                       self.logger.error(

     

       694
       +
                           f"No user found with identifier '{email_or_id}'. Searched {len(users_result['members'])} users."

     

       695
       +
                       )

     

       696
        
                       return None

     

       697
        
                   else:

     

       698
       +
                       self.logger.error(

     

       699
       +
                           f"Failed to get users: {users_result.get('msg', 'Unknown error')}"

     

       700
       +
                       )

     

       701
        
                       return None

     

       702
       +
       

     

       703
        
               except Exception as e:

     

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

     

       705
        
                   return None

     

       706
        
       

     

       707
       +
           def _lookup_zulip_user_info(

     

       708
       +
               self, bot_handler: BotHandler, email_or_id: str

     

       709
       +
           ) -> tuple[Optional[str], Optional[str]]:

     

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

     

       711
        
               if email_or_id.isdigit():

     

       712
        
                   return email_or_id, None

     

       713
       +
       

     

       714
        
               try:

     

       715
        
                   client = bot_handler._client

     

       716
        
                   if not client:

     

       717
        
                       return None, None

     

       718
       +
       

     

       719
        
                   # Try get_user_by_email API first

     

       720
        
                   try:

     

       721
        
                       user_result = client.get_user_by_email(email_or_id)

     

       722
       +
                       if user_result.get("result") == "success":

     

       723
       +
                           user_data = user_result.get("user", {})

     

       724
       +
                           user_id = user_data.get("user_id")

     

       725
       +
                           full_name = user_data.get("full_name", "")

     

       726
        
                           if user_id:

     

       727
        
                               return str(user_id), full_name

     

       728
        
                   except AttributeError:

     

       729
        
                       pass

     

       730
       +
       

     

       731
        
                   # Fallback: search all users

     

       732
        
                   users_result = client.get_users()

     

       733
       +
                   if users_result.get("result") == "success":

     

       734
       +
                       for user in users_result["members"]:

     

       735
       +
                           if (

     

       736
       +
                               user.get("email") == email_or_id

     

       737
       +
                               or user.get("delivery_email") == email_or_id

     

       738
       +
                           ):

     

       739
       +
                               return str(user.get("user_id")), user.get("full_name", "")

     

       740
       +
       

     

       741
        
                   return None, None

     

       742
       +
       

     

       743
        
               except Exception as e:

     

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

     

       745
        
                   return None, None

     
···

       757
        
           def _save_posted_entries(self, bot_handler: BotHandler) -> None:

     

       758
        
               """Save the set of posted entries."""

     

       759
        
               try:

     

       760
       +
                   bot_handler.storage.put(

     

       761
       +
                       "posted_entries", json.dumps(list(self.posted_entries))

     

       762
       +
                   )

     

       763
        
               except Exception as e:

     

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

     

       765
        
       

     

       766
       +
           def _check_initialization(

     

       767
       +
               self, message: dict[str, Any], bot_handler: BotHandler

     

       768
       +
           ) -> bool:

     

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

     

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

     

       771
        
                   bot_handler.send_reply(

     

       772
       +
                       message, "❌ Thicket not initialized. Please check configuration."

     

       0
        
       
     

       773
        
                   )

     

       774
        
                   return False

     

       775
       +
       

     

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

     

       777
        
               if self.debug_user:

     

       778
        
                   return True

     

       779
       +
       

     

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

     

       781
        
                   bot_handler.send_reply(

     

       782
        
                       message,

     

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

     

       784
        
                   )

     

       785
        
                   return False

     

       786
       +
       

     

       787
        
               return True

     

       788
        
       

     

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

     

       790
        
               """Schedule periodic sync operations."""

     

       791
       +
       

     

       792
        
               def sync_loop():

     

       793
        
                   while True:

     

       794
        
                       try:

     

       795
        
                           # Check if we can sync

     

       796
       +
                           can_sync = self.git_store and (

     

       797
       +
                               (self.stream_name and self.topic_name) or self.debug_user

     

       798
       +
                           )

     

       799
       +
       

     

       800
        
                           if can_sync:

     

       801
        
                               self._perform_sync(bot_handler)

     

       802
       +
       

     

       803
        
                           time.sleep(self.sync_interval)

     

       804
        
                       except Exception as e:

     

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

     

       806
        
                           time.sleep(60)  # Wait before retrying

     

       807
       +
       

     

       808
        
               # Start background thread

     

       809
        
               import threading

     

       810
       +
       

     

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

     

       812
        
               sync_thread.start()

     

       813
        
       

     

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

     

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

     

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

     

       817
        
                   return []

     

       818
       +
       

     

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

     

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

     

       821
       +
       

     

       822
        
               # Get all users and their feeds from git store

     

       823
        
               users_with_feeds = self.git_store.list_all_users_with_feeds()

     

       824
       +
       

     

       825
        
               # Sync each user's feeds

     

       826
        
               for username, feed_urls in users_with_feeds:

     

       827
        
                   for feed_url in feed_urls:

     
···

       831
        
                           asyncio.set_event_loop(loop)

     

       832
        
                           try:

     

       833
        
                               new_count, _ = loop.run_until_complete(

     

       834
       +
                                   sync_feed(

     

       835
       +
                                       self.git_store, username, str(feed_url), dry_run=False

     

       836
       +
                                   )

     

       837
        
                               )

     

       838
       +
       

     

       839
        
                               entries_to_check = []

     

       840
       +
       

     

       841
        
                               if new_count > 0:

     

       842
        
                                   # Get the newly added entries

     

       843
       +
                                   entries_to_check = self.git_store.list_entries(

     

       844
       +
                                       username, limit=new_count

     

       845
       +
                                   )

     

       846
       +
       

     

       847
        
                               # Always check for catchup mode on first run

     

       848
        
                               if is_first_run:

     

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

     

       850
       +
                                   catchup_entries = self.git_store.list_entries(

     

       851
       +
                                       username, limit=self.catchup_entries

     

       852
       +
                                   )

     

       853
       +
                                   entries_to_check = (

     

       854
       +
                                       catchup_entries

     

       855
       +
                                       if not entries_to_check

     

       856
       +
                                       else entries_to_check

     

       857
       +
                                   )

     

       858
       +
       

     

       859
        
                               for entry in entries_to_check:

     

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

     

       861
        
                                   if entry_key not in self.posted_entries:

     

       862
        
                                       new_entries.append((entry, username))

     

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

     

       864
        
                                           break

     

       865
       +
       

     

       866
        
                           finally:

     

       867
        
                               loop.close()

     

       868
       +
       

     

       869
        
                       except Exception as e:

     

       870
       +
                           self.logger.error(

     

       871
       +
                               f"Error syncing feed {feed_url} for user {username}: {e}"

     

       872
       +
                           )

     

       873
       +
       

     

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

     

       875
        
                           break

     

       876
       +
       

     

       877
        
               # Post new entries to Zulip with rate limiting

     

       878
        
               if new_entries:

     

       879
        
                   posted_count = 0

     

       880
       +
       

     

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

     

       882
        
                       self._post_entry_to_zulip(entry, bot_handler, username)

     

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

     

       884
        
                       posted_count += 1

     

       885
       +
       

     

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

     

       887
       +
                       if (

     

       888
       +
                           posted_count % self.posts_per_batch == 0

     

       889
       +
                           and i < len(new_entries) - 1

     

       890
       +
                       ):

     

       891
       +
                           time.sleep(self.rate_limit_delay)

     

       892
       +
       

     

       893
        
                   self._save_posted_entries(bot_handler)

     

       894
       +
       

     

       895
       +
               # Update last sync time

     

       896
       +
               self.last_sync_time = time.time()

     

       897
       +
       

     

       898
        
               return [entry for entry, _ in new_entries]

     

       899
        
       

     

       900
       +
           def _post_entry_to_zulip(

     

       901
       +
               self, entry: AtomEntry, bot_handler: BotHandler, username: str

     

       902
       +
           ) -> None:

     

       903
        
               """Post a single entry to the configured Zulip stream/topic or debug user DM."""

     

       904
        
               try:

     

       905
        
                   # Get current Zulip server from environment

     

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

     

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

     

       908
       +
       

     

       909
        
                   # Build author/date info consistently

     

       910
        
                   mention_info = ""

     

       911
        
                   if server_url and self.git_store:

     
···

       914
        
                           zulip_user_id = user.get_zulip_mention(server_url)

     

       915
        
                           if zulip_user_id:

     

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

     

       917
       +
                               _, zulip_full_name = self._lookup_zulip_user_info(

     

       918
       +
                                   bot_handler, zulip_user_id

     

       919
       +
                               )

     

       920
        
                               display_name = zulip_full_name or user.display_name or username

     

       921
       +
       

     

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

     

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

     

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

     

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

     

       926
        
                               else:

     

       927
        
                                   author_info = ""

     

       928
       +
       

     

       929
        
                               published_info = ""

     

       930
        
                               if entry.published:

     

       931
       +
                                   published_info = (

     

       932
       +
                                       f" • {entry.published.strftime('%Y-%m-%d')}"

     

       933
       +
                                   )

     

       934
       +
       

     

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

     

       936
       +
       

     

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

     

       938
        
                   if not mention_info:

     

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

     

       940
        
                       display_name = user.display_name if user else username

     

       941
       +
       

     

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

     

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

     

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

     

       945
        
                       else:

     

       946
        
                           author_info = ""

     

       947
       +
       

     

       948
        
                       published_info = ""

     

       949
        
                       if entry.published:

     

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

     

       951
       +
       

     

       952
       +
                       mention_info = (

     

       953
       +
                           f"**{display_name}** posted{author_info}{published_info}:\n\n"

     

       954
       +
                       )

     

       955
       +
       

     

       956
        
                   # Format the message with HTML processing

     

       957
        
                   message_lines = [

     

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

     

       959
        
                       f"🔗 {entry.link}",

     

       960
        
                   ]

     

       961
       +
       

     

       962
        
                   if entry.summary:

     

       963
        
                       # Process HTML in summary and truncate if needed

     

       964
        
                       processed_summary = self._process_html_content(entry.summary)

     

       965
        
                       if len(processed_summary) > 400:

     

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

     

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

     

       968
       +
       

     

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

     

       970
       +
       

     

       971
        
                   # Choose destination based on mode

     

       972
        
                   if self.debug_user and self.debug_zulip_user_id:

     

       973
        
                       # Debug mode: send DM

     

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

     

       975
       +
       

     

       976
        
                       # Ensure we have the numeric user ID

     

       977
        
                       user_id_to_use = self.debug_zulip_user_id

     

       978
        
                       if not user_id_to_use.isdigit():

     

       979
        
                           # Need to look up the numeric ID

     

       980
       +
                           resolved_id = self._lookup_zulip_user_id(

     

       981
       +
                               bot_handler, user_id_to_use

     

       982
       +
                           )

     

       983
        
                           if resolved_id:

     

       984
        
                               user_id_to_use = resolved_id

     

       985
       +
                               self.logger.debug(

     

       986
       +
                                   f"Resolved {self.debug_zulip_user_id} to user ID {user_id_to_use}"

     

       987
       +
                               )

     

       988
        
                           else:

     

       989
       +
                               self.logger.error(

     

       990
       +
                                   f"Could not resolve user ID for {self.debug_zulip_user_id}"

     

       991
       +
                               )

     

       992
        
                               return

     

       993
       +
       

     

       994
        
                       try:

     

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

     

       996
        
                           user_id_int = int(user_id_to_use)

     

       997
       +
                           bot_handler.send_message(

     

       998
       +
                               {

     

       999
       +
                                   "type": "private",

     

       1000
       +
                                   "to": [user_id_int],  # Use integer user ID

     

       1001
       +
                                   "content": debug_message,

     

       1002
       +
                               }

     

       1003
       +
                           )

     

       1004
        
                       except ValueError:

     

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

     

       1006
        
                           try:

     

       1007
       +
                               bot_handler.send_message(

     

       1008
       +
                                   {

     

       1009
       +
                                       "type": "private",

     

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

     

       1011
       +
                                       "content": debug_message,

     

       1012
       +
                                   }

     

       1013
       +
                               )

     

       1014
        
                           except Exception as e2:

     

       1015
       +
                               self.logger.error(

     

       1016
       +
                                   f"Failed to send DM to {self.debug_user} (tried both int and string): {e2}"

     

       1017
       +
                               )

     

       1018
        
                               return

     

       1019
        
                       except Exception as e:

     

       1020
       +
                           self.logger.error(

     

       1021
       +
                               f"Failed to send DM to {self.debug_user} ({user_id_to_use}): {e}"

     

       1022
       +
                           )

     

       1023
        
                           return

     

       1024
       +
                       self.logger.info(

     

       1025
       +
                           f"Posted entry to debug user {self.debug_user}: {entry.title}"

     

       1026
       +
                       )

     

       1027
        
                   else:

     

       1028
        
                       # Normal mode: send to stream/topic

     

       1029
       +
                       bot_handler.send_message(

     

       1030
       +
                           {

     

       1031
       +
                               "type": "stream",

     

       1032
       +
                               "to": self.stream_name,

     

       1033
       +
                               "subject": self.topic_name,

     

       1034
       +
                               "content": message_content,

     

       1035
       +
                           }

     

       1036
       +
                       )

     

       1037
       +
                       self.logger.info(

     

       1038
       +
                           f"Posted entry to stream: {entry.title} (user: {username})"

     

       1039
       +
                       )

     

       1040
       +
       

     

       1041
        
               except Exception as e:

     

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

     

       1043
        
       

     
···

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

     

       1046
        
               if not html_content:

     

       1047
        
                   return ""

     

       1048
       +
       

     

       1049
        
               try:

     

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

     

       1051
        
                   from markdownify import markdownify as md

     

       1052
       +
       

     

       1053
        
                   # Convert HTML to Markdown with compact settings for summaries

     

       1054
        
                   markdown = md(

     

       1055
        
                       html_content,

     

       1056
        
                       heading_style="ATX",  # Use # for headings (but we'll post-process these)

     

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

     

       1058
       +
                       convert=[

     

       1059
       +
                           "a",

     

       1060
       +
                           "b",

     

       1061
       +
                           "strong",

     

       1062
       +
                           "i",

     

       1063
       +
                           "em",

     

       1064
       +
                           "code",

     

       1065
       +
                           "pre",

     

       1066
       +
                           "p",

     

       1067
       +
                           "br",

     

       1068
       +
                           "ul",

     

       1069
       +
                           "ol",

     

       1070
       +
                           "li",

     

       1071
       +
                           "h1",

     

       1072
       +
                           "h2",

     

       1073
       +
                           "h3",

     

       1074
       +
                           "h4",

     

       1075
       +
                           "h5",

     

       1076
       +
                           "h6",

     

       1077
       +
                       ],

     

       1078
        
                   ).strip()

     

       1079
       +
       

     

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

     

       1081
        
                   import re

     

       1082
       +
       

     

       1083
        
                   # Convert markdown headers to bold with period

     

       1084
       +
                   markdown = re.sub(

     

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

     

       1086
       +
                   )

     

       1087
       +
       

     

       1088
        
                   # Clean up excessive newlines and make more compact

     

       1089
       +
                   markdown = re.sub(

     

       1090
       +
                       r"\n\s*\n\s*\n+", " ", markdown

     

       1091
       +
                   )  # Multiple newlines become space

     

       1092
       +
                   markdown = re.sub(

     

       1093
       +
                       r"\n\s*\n", ". ", markdown

     

       1094
       +
                   )  # Double newlines become sentence breaks

     

       1095
       +
                   markdown = re.sub(r"\n", " ", markdown)  # Single newlines become spaces

     

       1096
       +
       

     

       1097
        
                   # Clean up double periods and excessive whitespace

     

       1098
       +
                   markdown = re.sub(r"\.\.+", ".", markdown)

     

       1099
       +
                   markdown = re.sub(r"\s+", " ", markdown)

     

       1100
        
                   return markdown.strip()

     

       1101
       +
       

     

       1102
        
               except ImportError:

     

       1103
        
                   # Fallback: manual HTML processing

     

       1104
        
                   import re

     

       1105
       +
       

     

       1106
        
                   content = html_content

     

       1107
       +
       

     

       1108
        
                   # Convert headings to bold with periods for compact summaries

     

       1109
       +
                   content = re.sub(

     

       1110
       +
                       r"<h[1-6](?:\s[^>]*)?>([^<]*)</h[1-6]>",

     

       1111
       +
                       r"**\1.** ",

     

       1112
       +
                       content,

     

       1113
       +
                       flags=re.IGNORECASE,

     

       1114
       +
                   )

     

       1115
       +
       

     

       1116
        
                   # Convert common HTML elements to Markdown

     

       1117
       +
                   content = re.sub(

     

       1118
       +
                       r"<(?:strong|b)(?:\s[^>]*)?>([^<]*)</(?:strong|b)>",

     

       1119
       +
                       r"**\1**",

     

       1120
       +
                       content,

     

       1121
       +
                       flags=re.IGNORECASE,

     

       1122
       +
                   )

     

       1123
       +
                   content = re.sub(

     

       1124
       +
                       r"<(?:em|i)(?:\s[^>]*)?>([^<]*)</(?:em|i)>",

     

       1125
       +
                       r"*\1*",

     

       1126
       +
                       content,

     

       1127
       +
                       flags=re.IGNORECASE,

     

       1128
       +
                   )

     

       1129
       +
                   content = re.sub(

     

       1130
       +
                       r"<code(?:\s[^>]*)?>([^<]*)</code>",

     

       1131
       +
                       r"`\1`",

     

       1132
       +
                       content,

     

       1133
       +
                       flags=re.IGNORECASE,

     

       1134
       +
                   )

     

       1135
       +
                   content = re.sub(

     

       1136
       +
                       r'<a(?:\s[^>]*?)?\s*href=["\']([^"\']*)["\'](?:\s[^>]*)?>([^<]*)</a>',

     

       1137
       +
                       r"[\2](\1)",

     

       1138
       +
                       content,

     

       1139
       +
                       flags=re.IGNORECASE,

     

       1140
       +
                   )

     

       1141
       +
       

     

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

     

       1143
       +
                   content = re.sub(r"<br\s*/?>", " ", content, flags=re.IGNORECASE)

     

       1144
       +
                   content = re.sub(r"</p>\s*<p>", ". ", content, flags=re.IGNORECASE)

     

       1145
       +
                   content = re.sub(

     

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

     

       1147
       +
                   )

     

       1148
       +
       

     

       1149
        
                   # Remove remaining HTML tags

     

       1150
       +
                   content = re.sub(r"<[^>]+>", "", content)

     

       1151
       +
       

     

       1152
        
                   # Clean up whitespace and make compact

     

       1153
       +
                   content = re.sub(

     

       1154
       +
                       r"\s+", " ", content

     

       1155
       +
                   )  # Multiple whitespace becomes single space

     

       1156
       +
                   content = re.sub(

     

       1157
       +
                       r"\.\.+", ".", content

     

       1158
       +
                   )  # Multiple periods become single period

     

       1159
        
                   return content.strip()

     

       1160
       +
       

     

       1161
        
               except Exception as e:

     

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

     

       1163
        
                   # Last resort: just strip HTML tags

     

       1164
        
                   import re

     

       1165
       +
       

     

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

     

       1167
       +
       

     

       1168
       +
           def _get_schedule_info(self) -> str:

     

       1169
       +
               """Get schedule information string."""

     

       1170
       +
               lines = []

     

       1171
       +
       

     

       1172
       +
               if self.last_sync_time:

     

       1173
       +
                   import datetime

     

       1174
       +
       

     

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

     

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

     

       1177
       +
                   now = datetime.datetime.now()

     

       1178
       +
       

     

       1179
       +
                   # Calculate time until next sync

     

       1180
       +
                   time_until_next = next_sync - now

     

       1181
       +
       

     

       1182
       +
                   if time_until_next.total_seconds() > 0:

     

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

     

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

     

       1185
       +
       

     

       1186
       +
                       if hours > 0:

     

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

     

       1188
       +
                       elif minutes > 0:

     

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

     

       1190
       +
                       else:

     

       1191
       +
                           time_str = f"{seconds}s"

     

       1192
       +
       

     

       1193
       +
                       lines.extend(

     

       1194
       +
                           [

     

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

     

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

     

       1197
       +
                           ]

     

       1198
       +
                       )

     

       1199
       +
                   else:

     

       1200
       +
                       lines.extend(

     

       1201
       +
                           [

     

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

     

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

     

       1204
       +
                           ]

     

       1205
       +
                       )

     

       1206
       +
               else:

     

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

     

       1208
       +
       

     

       1209
       +
               # Add sync frequency info

     

       1210
       +
               if self.sync_interval >= 3600:

     

       1211
       +
                   frequency_str = (

     

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

     

       1213
       +
                   )

     

       1214
       +
               elif self.sync_interval >= 60:

     

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

     

       1216
       +
               else:

     

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

     

       1218
       +
       

     

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

     

       1220
        
       

     

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

     

       1222
        
       

     

       1223
       +
           def _send_config_change_notification(

     

       1224
       +
               self,

     

       1225
       +
               bot_handler: BotHandler,

     

       1226
       +
               changer: str,

     

       1227
       +
               setting: str,

     

       1228
       +
               old_value: Optional[str],

     

       1229
       +
               new_value: str,

     

       1230
       +
           ) -> None:

     

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

     

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

     

       1233
       +
                   return

     

       1234
       +
       

     

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

     

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

     

       1237
       +
                   return

     

       1238
       +
       

     

       1239
       +
               try:

     

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

     

       1241
       +
                   notification_msg = (

     

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

     

       1243
       +
                   )

     

       1244
       +
       

     

       1245
       +
                   bot_handler.send_message(

     

       1246
       +
                       {

     

       1247
       +
                           "type": "stream",

     

       1248
       +
                           "to": self.stream_name,

     

       1249
       +
                           "subject": self.topic_name,

     

       1250
       +
                           "content": notification_msg,

     

       1251
       +
                       }

     

       1252
       +
                   )

     

       1253
       +
               except Exception as e:

     

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

     

       1255
       +
       

     

       1256
       +
       

     

       1257
       +
       handler_class = ThicketBotHandler

+24 -2

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"]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       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__ = [

     

       18
       +
           "add",

     

       19
       +
           "bot",

     

       20
       +
           "duplicates",

     

       21
       +
           "info_cmd",

     

       22
       +
           "init",

     

       23
       +
           "list_cmd",

     

       24
       +
           "search",

     

       25
       +
           "sync",

     

       26
       +
           "upload",

     

       27
       +
           "zulip",

     

       28
       +
       ]

+63 -45

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(

     
···

       40
        
           ),

     

       41
        
       ) -> None:

     

       42
        
           """Manage the Thicket Zulip bot.

     

       43
       -
           

     

       44
        
           Actions:

     

       45
        
           - run: Start the Zulip bot

     

       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":

     
···

       59
        
               raise typer.Exit(1)

     

       60
        
       

     

       61
        
       

     

       62
       -
       def _run_bot(config_file: Path, thicket_config: Path, daemon: bool, debug_user: str = None) -> None:

     

       0
        
       
     

       0
        
       
     

       63
        
           """Run the Zulip bot."""

     

       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
        
       
     

       0
        
       
     

       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
       -
           

     

       0
        
       
     

       0
        
       
     

       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 = [

     

       92
       -
                   sys.executable, "-m", "zulip_bots.run",

     

       0
        
       
     

       0
        
       
     

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

     

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

     

       0
        
       
     

       95
        
               ]

     

       96
       -
               

     

       97
        
               # Add environment variables for bot configuration

     

       98
        
               import os

     

       0
        
       
     

       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(

     
···

       116
        
                       stdout=subprocess.DEVNULL,

     

       117
        
                       stderr=subprocess.DEVNULL,

     

       118
        
                       start_new_session=True,

     

       119
       -
                       env=env

     

       120
        
                   )

     

       121
        
                   print_success(f"Bot started in background with PID {process.pid}")

     

       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)

     

       129
        
           except KeyboardInterrupt:

     

       130
        
               print_info("Bot stopped by user")

     

       131
        
       

     
···

       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)

     

       190
        
       

     

       191
        
       

     

       192
        
       def _bot_status(config_file: Path) -> None:

     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       204
        
           # Check dependencies

     

       205
        
           try:

     

       206
        
               import zulip_bots

     

       207
       -
               version = getattr(zulip_bots, '__version__', 'unknown')

     

       0
        
       
     

       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

     

       0
        
       
     

       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(

     
···

       40
        
           ),

     

       41
        
       ) -> None:

     

       42
        
           """Manage the Thicket Zulip bot.

     

       43
       +
       

     

       44
        
           Actions:

     

       45
        
           - run: Start the Zulip bot

     

       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":

     
···

       59
        
               raise typer.Exit(1)

     

       60
        
       

     

       61
        
       

     

       62
       +
       def _run_bot(

     

       63
       +
           config_file: Path, thicket_config: Path, daemon: bool, debug_user: str = None

     

       64
       +
       ) -> None:

     

       65
        
           """Run the Zulip bot."""

     

       66
        
           if not config_file.exists():

     

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

     

       68
       +
               print_info(

     

       69
       +
                   f"Copy bot-config/zuliprc.template to {config_file} and configure it"

     

       70
       +
               )

     

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

     

       72
        
               raise typer.Exit(1)

     

       73
       +
       

     

       74
        
           if not thicket_config.exists():

     

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

     

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

     

       77
        
               raise typer.Exit(1)

     

       78
       +
       

     

       79
        
           # Parse zuliprc to extract server URL

     

       80
        
           zulip_site_url = _parse_zulip_config(config_file)

     

       81
       +
       

     

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

     

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

     

       84
       +
       

     

       85
        
           if debug_user:

     

       86
       +
               print_info(

     

       87
       +
                   f"🐛 DEBUG MODE: Will send DMs to thicket user '{debug_user}' instead of posting to streams"

     

       88
       +
               )

     

       89
       +
       

     

       90
        
           if daemon:

     

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

     

       92
        
           else:

     

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

     

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

     

       95
       +
       

     

       96
        
           try:

     

       97
        
               # Build the command

     

       98
        
               cmd = [

     

       99
       +
                   sys.executable,

     

       100
       +
                   "-m",

     

       101
       +
                   "zulip_bots.run",

     

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

     

       103
       +
                   "--config-file",

     

       104
       +
                   str(config_file),

     

       105
        
               ]

     

       106
       +
       

     

       107
        
               # Add environment variables for bot configuration

     

       108
        
               import os

     

       109
       +
       

     

       110
        
               env = os.environ.copy()

     

       111
       +
       

     

       112
        
               # Always pass thicket config path

     

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

     

       114
       +
       

     

       115
        
               # Add debug user if specified

     

       116
        
               if debug_user:

     

       117
        
                   env["THICKET_DEBUG_USER"] = debug_user

     

       118
       +
       

     

       119
        
               # Pass Zulip server URL to bot

     

       120
        
               if zulip_site_url:

     

       121
        
                   env["THICKET_ZULIP_SITE_URL"] = zulip_site_url

     

       122
       +
       

     

       123
        
               if daemon:

     

       124
        
                   # Run in background

     

       125
        
                   process = subprocess.Popen(

     
···

       127
        
                       stdout=subprocess.DEVNULL,

     

       128
        
                       stderr=subprocess.DEVNULL,

     

       129
        
                       start_new_session=True,

     

       130
       +
                       env=env,

     

       131
        
                   )

     

       132
        
                   print_success(f"Bot started in background with PID {process.pid}")

     

       133
        
               else:

     

       134
        
                   # Run in foreground

     

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

     

       136
       +
       

     

       137
        
           except subprocess.CalledProcessError as e:

     

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

     

       139
       +
               raise typer.Exit(1) from e

     

       140
        
           except KeyboardInterrupt:

     

       141
        
               print_info("Bot stopped by user")

     

       142
        
       

     
···

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

     

       146
        
           try:

     

       147
        
               import configparser

     

       148
       +
       

     

       149
        
               config = configparser.ConfigParser()

     

       150
        
               config.read(config_file)

     

       151
       +
       

     

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

     

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

     

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

     
···

       156
        
               else:

     

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

     

       158
        
                   return ""

     

       159
       +
       

     

       160
        
           except Exception as e:

     

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

     

       162
        
               return ""

     
···

       165
        
       def _test_bot() -> None:

     

       166
        
           """Test bot functionality."""

     

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

     

       168
       +
       

     

       169
        
           try:

     

       170
        
               from ...bots.test_bot import BotTester

     

       171
       +
       

     

       172
        
               # Create bot tester

     

       173
        
               tester = BotTester()

     

       174
       +
       

     

       175
        
               # Test basic functionality

     

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

     

       177
        
               responses = tester.send_command("help")

     

       178
        
               assert len(responses) == 1

     

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

     

       180
       +
       

     

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

     

       182
        
               responses = tester.send_command("status")

     

       183
        
               assert len(responses) == 1

     

       184
        
               assert "Status" in tester.get_last_response_content()

     

       185
       +
       

     

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

     

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

     

       188
        
               tester.assert_response_contains("Stream set to")

     

       189
       +
       

     

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

     

       191
        
               tester.assert_response_contains("Topic set to")

     

       192
       +
       

     

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

     

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

     

       195
       +
       

     

       196
        
               print_success("All bot tests passed!")

     

       197
       +
       

     

       198
        
           except Exception as e:

     

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

     

       200
       +
               raise typer.Exit(1) from e

     

       201
        
       

     

       202
        
       

     

       203
        
       def _bot_status(config_file: Path) -> None:

     

       204
        
           """Show bot status."""

     

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

     

       206
        
           console.print()

     

       207
       +
       

     

       208
        
           # Check config file

     

       209
        
           if config_file.exists():

     

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

     

       211
        
           else:

     

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

     

       213
       +
               console.print(

     

       214
       +
                   "  Copy bot-config/zuliprc.template and configure it", style="yellow"

     

       215
       +
               )

     

       216
       +
               console.print(

     

       217
       +
                   "  See bot-config/README.md for setup instructions", style="yellow"

     

       218
       +
               )

     

       219
       +
       

     

       220
        
           # Check dependencies

     

       221
        
           try:

     

       222
        
               import zulip_bots

     

       223
       +
       

     

       224
       +
               version = getattr(zulip_bots, "__version__", "unknown")

     

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

     

       226
        
           except ImportError:

     

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

     

       228
       +
       

     

       229
        
           try:

     

       230
       +
               from ...bots.thicket_bot import ThicketBotHandler  # noqa: F401

     

       231
       +
       

     

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

     

       233
        
           except ImportError as e:

     

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

     

       235
       +
       

     

       236
        
           # Check bot file

     

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

     

       238
        
           if bot_file.exists():

     

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

     

       240
        
           else:

     

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

     

       242
       +
       

     

       243
        
           console.print()

     

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

     

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

     

       246
        
           console.print()

     

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

+1 -1

src/thicket/cli/commands/info_cmd.py

···

       118
        
       

     

       119
        
           except Exception as e:

     

       120
        
               console.print(f"[red]Error displaying entry info: {e}[/red]")

     

       121
       -
               raise typer.Exit(1)

     

       122
        
       

     

       123
        
       

     

       124
        
       def _display_entry_info(entry, username: str) -> None:

···

       118
        
       

     

       119
        
           except Exception as e:

     

       120
        
               console.print(f"[red]Error displaying entry info: {e}[/red]")

     

       121
       +
               raise typer.Exit(1) from e

     

       122
        
       

     

       123
        
       

     

       124
        
       def _display_entry_info(entry, username: str) -> None:

+58 -55

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__)

     
···

       123
        
               # Check that we have required configuration

     

       124
        
               if not final_url:

     

       125
        
                   console.print("[red]Error: Typesense URL is required[/red]")

     

       126
       -
                   console.print("Either provide --typesense-url or create ~/.typesense/url file")

     

       0
        
       
     

       0
        
       
     

       127
        
                   raise typer.Exit(1)

     

       128
        
       

     

       129
        
               if not final_api_key:

     

       130
        
                   console.print("[red]Error: Typesense API key is required[/red]")

     

       131
       -
                   console.print("Either provide --api-key or create ~/.typesense/api_key file")

     

       0
        
       
     

       0
        
       
     

       132
        
                   raise typer.Exit(1)

     

       133
        
       

     

       134
        
               # Create Typesense configuration

     

       135
        
               typesense_config = TypesenseConfig.from_url(

     

       136
       -
                   final_url,

     

       137
       -
                   final_api_key,

     

       138
       -
                   collection_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]")

     
···

       149
        
       

     

       150
        
               # Prepare search parameters

     

       151
        
               search_params = {

     

       152
       -
                   'per_page': limit,

     

       153
        
               }

     

       154
        
       

     

       155
        
               # Add user filter if specified

     

       156
        
               if user:

     

       157
       -
                   search_params['filter_by'] = f'username:{user}'

     

       158
        
       

     

       159
        
               # Perform search

     

       160
        
               try:

     

       161
        
                   results = typesense_client.search(query, search_params)

     

       162
       -
                   

     

       163
        
                   if raw:

     

       164
        
                       import json

     

       0
        
       
     

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

     

       166
        
                       return

     

       167
        
       

     
···

       180
        
       

     

       181
        
       def _display_search_results(results: dict, query: str) -> None:

     

       182
        
           """Display search results in a formatted table."""

     

       183
       -
           hits = results.get('hits', [])

     

       184
       -
           found = results.get('found', 0)

     

       185
       -
           search_time = results.get('search_time_ms', 0)

     

       186
        
       

     

       187
        
           if not hits:

     

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

     

       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)

     
···

       198
        
           table.add_column("Summary", style="dim", width=50)

     

       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:

     

       219
        
                   from datetime import datetime

     

       0
        
       
     

       220
        
                   updated_date = datetime.fromtimestamp(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:

     

       228
        
                   # Remove HTML tags and truncate

     

       229
        
                   import re

     

       230
       -
                   summary = re.sub(r'<[^>]+>', '', summary)

     

       0
        
       
     

       231
        
                   summary = summary.strip()

     

       232
        
                   if len(summary) > 60:

     

       233
        
                       summary = summary[:57] + "..."

     

       234
        
               else:

     

       235
        
                   summary = ""

     

       236
        
       

     

       237
       -
               table.add_row(

     

       238
       -
                   score,

     

       239
       -
                   user_display,

     

       240
       -
                   title,

     

       241
       -
                   updated_str,

     

       242
       -
                   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:

     

       250
       -
               console.print(f"[dim]Use --limit to see more results (current limit: {len(hits)})[/dim]")

     

       0
        
       
     

       0
        
       
     

       251
        
       

     

       252
        
       

     

       253
        
       def _display_compact_results(results: dict, query: str) -> None:

     

       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
       -
               

     

       0
        
       
     

       0
        
       
     

       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:

     

       279
        
                   from datetime import datetime

     

       0
        
       
     

       280
        
                   updated_date = datetime.fromtimestamp(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:

     

       291
        
                   import re

     

       292
       -
                   summary = re.sub(r'<[^>]+>', '', summary)

     

       0
        
       
     

       293
        
                   summary = summary.strip()

     

       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__)

     
···

       121
        
               # Check that we have required configuration

     

       122
        
               if not final_url:

     

       123
        
                   console.print("[red]Error: Typesense URL is required[/red]")

     

       124
       +
                   console.print(

     

       125
       +
                       "Either provide --typesense-url or create ~/.typesense/url file"

     

       126
       +
                   )

     

       127
        
                   raise typer.Exit(1)

     

       128
        
       

     

       129
        
               if not final_api_key:

     

       130
        
                   console.print("[red]Error: Typesense API key is required[/red]")

     

       131
       +
                   console.print(

     

       132
       +
                       "Either provide --api-key or create ~/.typesense/api_key file"

     

       133
       +
                   )

     

       134
        
                   raise typer.Exit(1)

     

       135
        
       

     

       136
        
               # Create Typesense configuration

     

       137
        
               typesense_config = TypesenseConfig.from_url(

     

       138
       +
                   final_url, final_api_key, collection_name

     

       0
        
       
     

       0
        
       
     

       139
        
               )

     

       140
        
               typesense_config.connection_timeout = timeout

     

       141
        
       

     

       142
       +
               console.print("[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]")

     
···

       149
        
       

     

       150
        
               # Prepare search parameters

     

       151
        
               search_params = {

     

       152
       +
                   "per_page": limit,

     

       153
        
               }

     

       154
        
       

     

       155
        
               # Add user filter if specified

     

       156
        
               if user:

     

       157
       +
                   search_params["filter_by"] = f"username:{user}"

     

       158
        
       

     

       159
        
               # Perform search

     

       160
        
               try:

     

       161
        
                   results = typesense_client.search(query, search_params)

     

       162
       +
       

     

       163
        
                   if raw:

     

       164
        
                       import json

     

       165
       +
       

     

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

     

       167
        
                       return

     

       168
        
       

     
···

       181
        
       

     

       182
        
       def _display_search_results(results: dict, query: str) -> None:

     

       183
        
           """Display search results in a formatted table."""

     

       184
       +
           hits = results.get("hits", [])

     

       185
       +
           found = results.get("found", 0)

     

       186
       +
           search_time = results.get("search_time_ms", 0)

     

       187
        
       

     

       188
        
           if not hits:

     

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

     

       190
        
               return

     

       191
        
       

     

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

     

       193
       +
       

     

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

     

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

     

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

     
···

       199
        
           table.add_column("Summary", style="dim", width=50)

     

       200
        
       

     

       201
        
           for hit in hits:

     

       202
       +
               doc = hit["document"]

     

       203
       +
       

     

       204
        
               # Format score

     

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

     

       206
       +
       

     

       207
        
               # Format user

     

       208
       +
               user_display = doc.get("user_display_name", doc.get("username", "Unknown"))

     

       209
        
               if len(user_display) > 12:

     

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

     

       211
       +
       

     

       212
        
               # Format title

     

       213
       +
               title = doc.get("title", "Untitled")

     

       214
        
               if len(title) > 40:

     

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

     

       216
       +
       

     

       217
        
               # Format date

     

       218
       +
               updated_timestamp = doc.get("updated", 0)

     

       219
        
               if updated_timestamp:

     

       220
        
                   from datetime import datetime

     

       221
       +
       

     

       222
        
                   updated_date = datetime.fromtimestamp(updated_timestamp)

     

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

     

       224
        
               else:

     

       225
        
                   updated_str = "Unknown"

     

       226
       +
       

     

       227
        
               # Format summary

     

       228
       +
               summary = doc.get("summary") or doc.get("content", "")

     

       229
        
               if summary:

     

       230
        
                   # Remove HTML tags and truncate

     

       231
        
                   import re

     

       232
       +
       

     

       233
       +
                   summary = re.sub(r"<[^>]+>", "", summary)

     

       234
        
                   summary = summary.strip()

     

       235
        
                   if len(summary) > 60:

     

       236
        
                       summary = summary[:57] + "..."

     

       237
        
               else:

     

       238
        
                   summary = ""

     

       239
        
       

     

       240
       +
               table.add_row(score, user_display, title, updated_str, summary)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       241
        
       

     

       242
        
           console.print(table)

     

       243
       +
       

     

       244
        
           # Show additional info

     

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

     

       246
        
           if len(hits) < found:

     

       247
       +
               console.print(

     

       248
       +
                   f"[dim]Use --limit to see more results (current limit: {len(hits)})[/dim]"

     

       249
       +
               )

     

       250
        
       

     

       251
        
       

     

       252
        
       def _display_compact_results(results: dict, query: str) -> None:

     

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

     

       254
       +
           hits = results.get("hits", [])

     

       255
       +
           found = results.get("found", 0)

     

       256
       +
       

     

       257
        
           if not hits:

     

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

     

       259
        
               return

     

       260
        
       

     

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

     

       262
       +
       

     

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

     

       264
       +
               doc = hit["document"]

     

       265
       +
               score = hit.get("text_match", 0)

     

       266
       +
       

     

       267
        
               # Header with score and user

     

       268
       +
               user = doc.get("user_display_name", doc.get("username", "Unknown"))

     

       269
       +
               console.print(

     

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

     

       271
       +
               )

     

       272
       +
       

     

       273
        
               # Title

     

       274
       +
               title = doc.get("title", "Untitled")

     

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

     

       276
       +
       

     

       277
        
               # Date and link

     

       278
       +
               updated_timestamp = doc.get("updated", 0)

     

       279
        
               if updated_timestamp:

     

       280
        
                   from datetime import datetime

     

       281
       +
       

     

       282
        
                   updated_date = datetime.fromtimestamp(updated_timestamp)

     

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

     

       284
        
               else:

     

       285
        
                   updated_str = "Unknown date"

     

       286
       +
       

     

       287
       +
               link = doc.get("link", "")

     

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

     

       289
       +
       

     

       290
        
               # Summary

     

       291
       +
               summary = doc.get("summary") or doc.get("content", "")

     

       292
        
               if summary:

     

       293
        
                   import re

     

       294
       +
       

     

       295
       +
                   summary = re.sub(r"<[^>]+>", "", summary)

     

       296
        
                   summary = summary.strip()

     

       297
        
                   if len(summary) > 150:

     

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

     

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

     

       300
       +
       

     

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

+44 -20

src/thicket/cli/commands/upload.py

···

       42
        
           return url, api_key

     

       43
        
       

     

       44
        
       

     

       45
       -
       def _save_typesense_config(url: Optional[str] = None, api_key: Optional[str] = None) -> None:

     

       0
        
       
     

       0
        
       
     

       46
        
           """Save Typesense URL and API key to ~/.typesense directory."""

     

       47
        
           typesense_dir = Path.home() / ".typesense"

     

       48
        
           typesense_dir.mkdir(exist_ok=True, mode=0o700)  # Secure permissions

     
···

       139
        
               # Check that we have required configuration

     

       140
        
               if not final_url:

     

       141
        
                   console.print("[red]Error: Typesense URL is required[/red]")

     

       142
       -
                   console.print("Either provide --typesense-url or create ~/.typesense/url file")

     

       0
        
       
     

       0
        
       
     

       143
        
                   raise typer.Exit(1)

     

       144
        
       

     

       145
        
               if not final_api_key:

     

       146
        
                   console.print("[red]Error: Typesense API key is required[/red]")

     

       147
       -
                   console.print("Either provide --api-key or create ~/.typesense/api_key file")

     

       0
        
       
     

       0
        
       
     

       148
        
                   raise typer.Exit(1)

     

       149
        
       

     

       150
        
               # Save configuration if provided via command line (for future use)

     
···

       183
        
       

     

       184
        
               # Create Typesense configuration

     

       185
        
               typesense_config = TypesenseConfig.from_url(

     

       186
       -
                   final_url,

     

       187
       -
                   final_api_key,

     

       188
       -
                   collection_name

     

       189
        
               )

     

       190
        
               typesense_config.connection_timeout = timeout

     

       191
        
       

     
···

       200
        
               raise typer.Exit(1) from e

     

       201
        
       

     

       202
        
       

     

       203
       -
       def _dry_run_upload(git_store: GitStore, config: ThicketConfig, typesense_config: TypesenseConfig) -> None:

     

       0
        
       
     

       0
        
       
     

       204
        
           """Perform a dry run showing what would be uploaded."""

     

       205
        
           console.print("\n[bold]Dry run analysis:[/bold]")

     

       206
        
       

     
···

       216
        
       

     

       217
        
                   entry_files = list(user_dir.glob("*.json"))

     

       218
        
                   total_entries += len(entry_files)

     

       219
       -
                   console.print(f"  ✅ User {username}: {len(entry_files)} entries would be uploaded")

     

       0
        
       
     

       0
        
       
     

       220
        
               except Exception as e:

     

       221
        
                   console.print(f"  ❌ User {username}: Error loading entries - {e}")

     

       222
        
       

     
···

       224
        
           console.print(f"  • Total users: {len(index.users)}")

     

       225
        
           console.print(f"  • Total entries to upload: {total_entries}")

     

       226
        
           console.print(f"  • Target collection: {typesense_config.collection_name}")

     

       227
       -
           console.print(f"  • Typesense server: {typesense_config.protocol}://{typesense_config.host}:{typesense_config.port}")

     

       0
        
       
     

       0
        
       
     

       228
        
       

     

       229
        
           if total_entries > 0:

     

       230
        
               console.print("\n[green]Ready to upload! Remove --dry-run to proceed.[/green]")

     
···

       232
        
               console.print("\n[yellow]No entries found to upload.[/yellow]")

     

       233
        
       

     

       234
        
       

     

       235
       -
       def _perform_upload(git_store: GitStore, config: ThicketConfig, typesense_config: TypesenseConfig) -> None:

     

       0
        
       
     

       0
        
       
     

       236
        
           """Perform the actual upload to Typesense."""

     

       237
        
           with Progress(

     

       238
        
               SpinnerColumn(),

     

       239
        
               TextColumn("[progress.description]{task.description}"),

     

       240
        
               console=console,

     

       241
        
           ) as progress:

     

       242
       -
       

     

       243
        
               # Test connection

     

       244
        
               progress.add_task("Testing Typesense connection...", total=None)

     

       245
        
       

     
···

       260
        
                   TextColumn("[progress.description]{task.description}"),

     

       261
        
                   console=console,

     

       262
        
               ) as upload_progress:

     

       263
       -
       

     

       264
        
                   upload_progress.add_task("Uploading entries to Typesense...", total=None)

     

       265
        
       

     

       266
        
                   try:

     
···

       273
        
                               # Batch import results

     

       274
        
                               success_count = sum(1 for r in result if r.get("success"))

     

       275
        
                               total_count = len(result)

     

       276
       -
                               console.print(f"[green]✅ Upload completed: {success_count}/{total_count} documents uploaded successfully[/green]")

     

       0
        
       
     

       0
        
       
     

       277
        
       

     

       278
        
                               # Show any errors

     

       279
        
                               errors = [r for r in result if not r.get("success")]

     

       280
        
                               if errors:

     

       281
       -
                                   console.print(f"[yellow]⚠️  {len(errors)} documents had errors[/yellow]")

     

       282
       -
                                   for i, error in enumerate(errors[:5]):  # Show first 5 errors

     

       283
       -
                                       console.print(f"  Error {i+1}: {error}")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       284
        
                                   if len(errors) > 5:

     

       285
       -
                                       console.print(f"  ... and {len(errors) - 5} more errors")

     

       0
        
       
     

       0
        
       
     

       286
        
                           else:

     

       287
        
                               console.print("[green]✅ Upload completed successfully[/green]")

     

       288
        
                       else:

     

       289
       -
                           console.print("[yellow]⚠️  Upload completed but no result data available[/yellow]")

     

       0
        
       
     

       0
        
       
     

       290
        
       

     

       291
        
                       console.print("\n[bold]Collection information:[/bold]")

     

       292
       -
                       console.print(f"  • Server: {typesense_config.protocol}://{typesense_config.host}:{typesense_config.port}")

     

       0
        
       
     

       0
        
       
     

       293
        
                       console.print(f"  • Collection: {typesense_config.collection_name}")

     

       294
       -
                       console.print("\n[dim]You can now search your entries using the Typesense API or dashboard.[/dim]")

     

       0
        
       
     

       0
        
       
     

       295
        
       

     

       296
        
                   except Exception as e:

     

       297
        
                       upload_progress.stop()

···

       42
        
           return url, api_key

     

       43
        
       

     

       44
        
       

     

       45
       +
       def _save_typesense_config(

     

       46
       +
           url: Optional[str] = None, api_key: Optional[str] = None

     

       47
       +
       ) -> None:

     

       48
        
           """Save Typesense URL and API key to ~/.typesense directory."""

     

       49
        
           typesense_dir = Path.home() / ".typesense"

     

       50
        
           typesense_dir.mkdir(exist_ok=True, mode=0o700)  # Secure permissions

     
···

       141
        
               # Check that we have required configuration

     

       142
        
               if not final_url:

     

       143
        
                   console.print("[red]Error: Typesense URL is required[/red]")

     

       144
       +
                   console.print(

     

       145
       +
                       "Either provide --typesense-url or create ~/.typesense/url file"

     

       146
       +
                   )

     

       147
        
                   raise typer.Exit(1)

     

       148
        
       

     

       149
        
               if not final_api_key:

     

       150
        
                   console.print("[red]Error: Typesense API key is required[/red]")

     

       151
       +
                   console.print(

     

       152
       +
                       "Either provide --api-key or create ~/.typesense/api_key file"

     

       153
       +
                   )

     

       154
        
                   raise typer.Exit(1)

     

       155
        
       

     

       156
        
               # Save configuration if provided via command line (for future use)

     
···

       189
        
       

     

       190
        
               # Create Typesense configuration

     

       191
        
               typesense_config = TypesenseConfig.from_url(

     

       192
       +
                   final_url, final_api_key, collection_name

     

       0
        
       
     

       0
        
       
     

       193
        
               )

     

       194
        
               typesense_config.connection_timeout = timeout

     

       195
        
       

     
···

       204
        
               raise typer.Exit(1) from e

     

       205
        
       

     

       206
        
       

     

       207
       +
       def _dry_run_upload(

     

       208
       +
           git_store: GitStore, config: ThicketConfig, typesense_config: TypesenseConfig

     

       209
       +
       ) -> None:

     

       210
        
           """Perform a dry run showing what would be uploaded."""

     

       211
        
           console.print("\n[bold]Dry run analysis:[/bold]")

     

       212
        
       

     
···

       222
        
       

     

       223
        
                   entry_files = list(user_dir.glob("*.json"))

     

       224
        
                   total_entries += len(entry_files)

     

       225
       +
                   console.print(

     

       226
       +
                       f"  ✅ User {username}: {len(entry_files)} entries would be uploaded"

     

       227
       +
                   )

     

       228
        
               except Exception as e:

     

       229
        
                   console.print(f"  ❌ User {username}: Error loading entries - {e}")

     

       230
        
       

     
···

       232
        
           console.print(f"  • Total users: {len(index.users)}")

     

       233
        
           console.print(f"  • Total entries to upload: {total_entries}")

     

       234
        
           console.print(f"  • Target collection: {typesense_config.collection_name}")

     

       235
       +
           console.print(

     

       236
       +
               f"  • Typesense server: {typesense_config.protocol}://{typesense_config.host}:{typesense_config.port}"

     

       237
       +
           )

     

       238
        
       

     

       239
        
           if total_entries > 0:

     

       240
        
               console.print("\n[green]Ready to upload! Remove --dry-run to proceed.[/green]")

     
···

       242
        
               console.print("\n[yellow]No entries found to upload.[/yellow]")

     

       243
        
       

     

       244
        
       

     

       245
       +
       def _perform_upload(

     

       246
       +
           git_store: GitStore, config: ThicketConfig, typesense_config: TypesenseConfig

     

       247
       +
       ) -> None:

     

       248
        
           """Perform the actual upload to Typesense."""

     

       249
        
           with Progress(

     

       250
        
               SpinnerColumn(),

     

       251
        
               TextColumn("[progress.description]{task.description}"),

     

       252
        
               console=console,

     

       253
        
           ) as progress:

     

       0
        
       
     

       254
        
               # Test connection

     

       255
        
               progress.add_task("Testing Typesense connection...", total=None)

     

       256
        
       

     
···

       271
        
                   TextColumn("[progress.description]{task.description}"),

     

       272
        
                   console=console,

     

       273
        
               ) as upload_progress:

     

       0
        
       
     

       274
        
                   upload_progress.add_task("Uploading entries to Typesense...", total=None)

     

       275
        
       

     

       276
        
                   try:

     
···

       283
        
                               # Batch import results

     

       284
        
                               success_count = sum(1 for r in result if r.get("success"))

     

       285
        
                               total_count = len(result)

     

       286
       +
                               console.print(

     

       287
       +
                                   f"[green]✅ Upload completed: {success_count}/{total_count} documents uploaded successfully[/green]"

     

       288
       +
                               )

     

       289
        
       

     

       290
        
                               # Show any errors

     

       291
        
                               errors = [r for r in result if not r.get("success")]

     

       292
        
                               if errors:

     

       293
       +
                                   console.print(

     

       294
       +
                                       f"[yellow]⚠️  {len(errors)} documents had errors[/yellow]"

     

       295
       +
                                   )

     

       296
       +
                                   for i, error in enumerate(

     

       297
       +
                                       errors[:5]

     

       298
       +
                                   ):  # Show first 5 errors

     

       299
       +
                                       console.print(f"  Error {i + 1}: {error}")

     

       300
        
                                   if len(errors) > 5:

     

       301
       +
                                       console.print(

     

       302
       +
                                           f"  ... and {len(errors) - 5} more errors"

     

       303
       +
                                       )

     

       304
        
                           else:

     

       305
        
                               console.print("[green]✅ Upload completed successfully[/green]")

     

       306
        
                       else:

     

       307
       +
                           console.print(

     

       308
       +
                               "[yellow]⚠️  Upload completed but no result data available[/yellow]"

     

       309
       +
                           )

     

       310
        
       

     

       311
        
                       console.print("\n[bold]Collection information:[/bold]")

     

       312
       +
                       console.print(

     

       313
       +
                           f"  • Server: {typesense_config.protocol}://{typesense_config.host}:{typesense_config.port}"

     

       314
       +
                       )

     

       315
        
                       console.print(f"  • Collection: {typesense_config.collection_name}")

     

       316
       +
                       console.print(

     

       317
       +
                           "\n[dim]You can now search your entries using the Typesense API or dashboard.[/dim]"

     

       318
       +
                       )

     

       319
        
       

     

       320
        
                   except Exception as e:

     

       321
        
                       upload_progress.stop()

+55 -45

src/thicket/cli/commands/zulip.py

···

       17
        
       @app.command()

     

       18
        
       def zulip_add(

     

       19
        
           username: str = typer.Argument(..., help="Username to associate with Zulip"),

     

       20
       -
           server: str = typer.Argument(..., help="Zulip server (e.g., yourorg.zulipchat.com)"),

     

       0
        
       
     

       0
        
       
     

       21
        
           user_id: str = typer.Argument(..., help="Zulip user ID or email for @mentions"),

     

       22
        
           config_file: Path = typer.Option(

     

       23
        
               Path("thicket.yaml"),

     
···

       27
        
           ),

     

       28
        
       ) -> None:

     

       29
        
           """Add a Zulip association for a user.

     

       30
       -
           

     

       31
        
           This associates a thicket user with their Zulip identity, enabling

     

       32
        
           @mentions when the bot posts their articles.

     

       33
       -
           

     

       34
        
           Example:

     

       35
        
               thicket zulip-add alice myorg.zulipchat.com alice@example.com

     

       36
        
           """

     

       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)

     

       57
        
       

     

       58
        
       

     

       59
        
       @app.command()

     
···

       69
        
           ),

     

       70
        
       ) -> None:

     

       71
        
           """Remove a Zulip association from a user.

     

       72
       -
           

     

       73
        
           Example:

     

       74
        
               thicket zulip-remove alice myorg.zulipchat.com alice@example.com

     

       75
        
           """

     

       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}")

     

       0
        
       
     

       0
        
       
     

       89
        
                   git_store.commit_changes(f"Remove Zulip association for {username}")

     

       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)

     

       97
        
       

     

       98
        
       

     

       99
        
       @app.command()

     

       100
        
       def zulip_list(

     

       101
       -
           username: Optional[str] = typer.Argument(None, help="Username to list associations for"),

     

       0
        
       
     

       0
        
       
     

       102
        
           config_file: Path = typer.Option(

     

       103
        
               Path("thicket.yaml"),

     

       104
        
               "--config",

     
···

       107
        
           ),

     

       108
        
       ) -> None:

     

       109
        
           """List Zulip associations for users.

     

       110
       -
           

     

       111
        
           If no username is provided, lists associations for all users.

     

       112
       -
           

     

       113
        
           Examples:

     

       114
        
               thicket zulip-list          # List all associations

     

       115
        
               thicket zulip-list alice    # List associations for alice

     
···

       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)

     

       159
        
       

     

       160
        
       

     

       161
        
       @app.command()

     
···

       174
        
           ),

     

       175
        
       ) -> None:

     

       176
        
           """Import Zulip associations from a CSV file.

     

       177
       -
           

     

       178
        
           CSV format (no header):

     

       179
        
               username,server,user_id

     

       180
        
               alice,myorg.zulipchat.com,alice@example.com

     

       181
        
               bob,myorg.zulipchat.com,bob.smith

     

       182
       -
           

     

       183
        
           Example:

     

       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:

     

       228
       -
                               print_info(f"Would skip existing: {username} -> {user_id}@{server}")

     

       0
        
       
     

       0
        
       
     

       229
        
                               skipped += 1

     

       230
        
                           else:

     

       231
        
                               print_info(f"Would add: {username} -> {user_id}@{server}")

     
···

       236
        
                               print_success(f"Added: {username} -> {user_id}@{server}")

     

       237
        
                               added += 1

     

       238
        
                           else:

     

       239
       -
                               print_info(f"Skipped existing: {username} -> {user_id}@{server}")

     

       0
        
       
     

       0
        
       
     

       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)

···

       17
        
       @app.command()

     

       18
        
       def zulip_add(

     

       19
        
           username: str = typer.Argument(..., help="Username to associate with Zulip"),

     

       20
       +
           server: str = typer.Argument(

     

       21
       +
               ..., help="Zulip server (e.g., yourorg.zulipchat.com)"

     

       22
       +
           ),

     

       23
        
           user_id: str = typer.Argument(..., help="Zulip user ID or email for @mentions"),

     

       24
        
           config_file: Path = typer.Option(

     

       25
        
               Path("thicket.yaml"),

     
···

       29
        
           ),

     

       30
        
       ) -> None:

     

       31
        
           """Add a Zulip association for a user.

     

       32
       +
       

     

       33
        
           This associates a thicket user with their Zulip identity, enabling

     

       34
        
           @mentions when the bot posts their articles.

     

       35
       +
       

     

       36
        
           Example:

     

       37
        
               thicket zulip-add alice myorg.zulipchat.com alice@example.com

     

       38
        
           """

     

       39
        
           try:

     

       40
        
               config = load_config(config_file)

     

       41
        
               git_store = GitStore(config.git_store)

     

       42
       +
       

     

       43
        
               # Check if user exists

     

       44
        
               user = git_store.get_user(username)

     

       45
        
               if not user:

     

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

     

       47
        
                   raise typer.Exit(1)

     

       48
       +
       

     

       49
        
               # Add association

     

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

     

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

     

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

     

       53
        
               else:

     

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

     

       55
       +
       

     

       56
        
           except Exception as e:

     

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

     

       58
       +
               raise typer.Exit(1) from e

     

       59
        
       

     

       60
        
       

     

       61
        
       @app.command()

     
···

       71
        
           ),

     

       72
        
       ) -> None:

     

       73
        
           """Remove a Zulip association from a user.

     

       74
       +
       

     

       75
        
           Example:

     

       76
        
               thicket zulip-remove alice myorg.zulipchat.com alice@example.com

     

       77
        
           """

     

       78
        
           try:

     

       79
        
               config = load_config(config_file)

     

       80
        
               git_store = GitStore(config.git_store)

     

       81
       +
       

     

       82
        
               # Check if user exists

     

       83
        
               user = git_store.get_user(username)

     

       84
        
               if not user:

     

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

     

       86
        
                   raise typer.Exit(1)

     

       87
       +
       

     

       88
        
               # Remove association

     

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

     

       90
       +
                   print_success(

     

       91
       +
                       f"Removed Zulip association for {username}: {user_id}@{server}"

     

       92
       +
                   )

     

       93
        
                   git_store.commit_changes(f"Remove Zulip association for {username}")

     

       94
        
               else:

     

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

     

       96
        
                   raise typer.Exit(1)

     

       97
       +
       

     

       98
        
           except Exception as e:

     

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

     

       100
       +
               raise typer.Exit(1) from e

     

       101
        
       

     

       102
        
       

     

       103
        
       @app.command()

     

       104
        
       def zulip_list(

     

       105
       +
           username: Optional[str] = typer.Argument(

     

       106
       +
               None, help="Username to list associations for"

     

       107
       +
           ),

     

       108
        
           config_file: Path = typer.Option(

     

       109
        
               Path("thicket.yaml"),

     

       110
        
               "--config",

     
···

       113
        
           ),

     

       114
        
       ) -> None:

     

       115
        
           """List Zulip associations for users.

     

       116
       +
       

     

       117
        
           If no username is provided, lists associations for all users.

     

       118
       +
       

     

       119
        
           Examples:

     

       120
        
               thicket zulip-list          # List all associations

     

       121
        
               thicket zulip-list alice    # List associations for alice

     
···

       123
        
           try:

     

       124
        
               config = load_config(config_file)

     

       125
        
               git_store = GitStore(config.git_store)

     

       126
       +
       

     

       127
        
               # Create table

     

       128
        
               table = Table(title="Zulip Associations")

     

       129
        
               table.add_column("Username", style="cyan")

     

       130
        
               table.add_column("Server", style="green")

     

       131
        
               table.add_column("User ID", style="yellow")

     

       132
       +
       

     

       133
        
               if username:

     

       134
        
                   # List for specific user

     

       135
        
                   user = git_store.get_user(username)

     

       136
        
                   if not user:

     

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

     

       138
        
                       raise typer.Exit(1)

     

       139
       +
       

     

       140
        
                   if not user.zulip_associations:

     

       141
        
                       print_info(f"No Zulip associations for {username}")

     

       142
        
                       return

     

       143
       +
       

     

       144
        
                   for assoc in user.zulip_associations:

     

       145
        
                       table.add_row(username, assoc.server, assoc.user_id)

     

       146
        
               else:

     

       147
        
                   # List for all users

     

       148
        
                   index = git_store._load_index()

     

       149
        
                   has_associations = False

     

       150
       +
       

     

       151
        
                   for username, user in index.users.items():

     

       152
        
                       for assoc in user.zulip_associations:

     

       153
        
                           table.add_row(username, assoc.server, assoc.user_id)

     

       154
        
                           has_associations = True

     

       155
       +
       

     

       156
        
                   if not has_associations:

     

       157
        
                       print_info("No Zulip associations found")

     

       158
        
                       return

     

       159
       +
       

     

       160
        
               console.print(table)

     

       161
       +
       

     

       162
        
           except Exception as e:

     

       163
        
               print_error(f"Failed to list Zulip associations: {e}")

     

       164
       +
               raise typer.Exit(1) from e

     

       165
        
       

     

       166
        
       

     

       167
        
       @app.command()

     
···

       180
        
           ),

     

       181
        
       ) -> None:

     

       182
        
           """Import Zulip associations from a CSV file.

     

       183
       +
       

     

       184
        
           CSV format (no header):

     

       185
        
               username,server,user_id

     

       186
        
               alice,myorg.zulipchat.com,alice@example.com

     

       187
        
               bob,myorg.zulipchat.com,bob.smith

     

       188
       +
       

     

       189
        
           Example:

     

       190
        
               thicket zulip-import associations.csv

     

       191
        
           """

     

       192
        
           import csv

     

       193
       +
       

     

       194
        
           try:

     

       195
        
               config = load_config(config_file)

     

       196
        
               git_store = GitStore(config.git_store)

     

       197
       +
       

     

       198
        
               if not csv_file.exists():

     

       199
        
                   print_error(f"CSV file not found: {csv_file}")

     

       200
        
                   raise typer.Exit(1)

     

       201
       +
       

     

       202
        
               added = 0

     

       203
        
               skipped = 0

     

       204
        
               errors = 0

     

       205
       +
       

     

       206
       +
               with open(csv_file) as f:

     

       207
        
                   reader = csv.reader(f)

     

       208
        
                   for row_num, row in enumerate(reader, 1):

     

       209
        
                       if len(row) != 3:

     

       210
        
                           print_error(f"Line {row_num}: Invalid format (expected 3 columns)")

     

       211
        
                           errors += 1

     

       212
        
                           continue

     

       213
       +
       

     

       214
        
                       username, server, user_id = [col.strip() for col in row]

     

       215
       +
       

     

       216
        
                       # Skip empty lines

     

       217
        
                       if not username:

     

       218
        
                           continue

     

       219
       +
       

     

       220
        
                       # Check if user exists

     

       221
        
                       user = git_store.get_user(username)

     

       222
        
                       if not user:

     

       223
        
                           print_error(f"Line {row_num}: User '{username}' not found")

     

       224
        
                           errors += 1

     

       225
        
                           continue

     

       226
       +
       

     

       227
        
                       if dry_run:

     

       228
        
                           # Check if association would be added

     

       229
        
                           exists = any(

     

       230
       +
                               a.server == server and a.user_id == user_id

     

       231
        
                               for a in user.zulip_associations

     

       232
        
                           )

     

       233
        
                           if exists:

     

       234
       +
                               print_info(

     

       235
       +
                                   f"Would skip existing: {username} -> {user_id}@{server}"

     

       236
       +
                               )

     

       237
        
                               skipped += 1

     

       238
        
                           else:

     

       239
        
                               print_info(f"Would add: {username} -> {user_id}@{server}")

     
···

       244
        
                               print_success(f"Added: {username} -> {user_id}@{server}")

     

       245
        
                               added += 1

     

       246
        
                           else:

     

       247
       +
                               print_info(

     

       248
       +
                                   f"Skipped existing: {username} -> {user_id}@{server}"

     

       249
       +
                               )

     

       250
        
                               skipped += 1

     

       251
       +
       

     

       252
        
               # Summary

     

       253
        
               console.print()

     

       254
        
               if dry_run:

     

       255
       +
                   console.print("[bold]Dry run summary:[/bold]")

     

       256
        
                   console.print(f"  Would add: {added}")

     

       257
        
               else:

     

       258
       +
                   console.print("[bold]Import summary:[/bold]")

     

       259
        
                   console.print(f"  Added: {added}")

     

       260
        
                   if not dry_run and added > 0:

     

       261
        
                       git_store.commit_changes(f"Import {added} Zulip associations from CSV")

     

       262
       +
       

     

       263
        
               console.print(f"  Skipped: {skipped}")

     

       264
        
               console.print(f"  Errors: {errors}")

     

       265
       +
       

     

       266
        
           except Exception as e:

     

       267
        
               print_error(f"Failed to import Zulip associations: {e}")

     

       268
       +
               raise typer.Exit(1) from e

+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, E402

     

       51
       +
           add,

     

       52
       +
           duplicates,

     

       53
       +
           info_cmd,

     

       54
       +
           init,

     

       55
       +
           list_cmd,

     

       56
       +
           sync,

     

       57
       +
           upload,

     

       58
       +
       )

     

       59
        
       

     

       60
        
       if __name__ == "__main__":

     

       61
        
           app()

+13 -11

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:

     

       0
        
       
     

       0
        
       
     

       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(

     

       171
       +
               self, username: str, server: str, user_id: str

     

       172
       +
           ) -> bool:

     

       173
        
               """Remove a Zulip association from a user."""

     

       174
        
               index = self._load_index()

     

       175
        
               user = index.get_user(username)

     

       176
       +
       

     

       177
        
               if not user:

     

       178
        
                   return False

     

       179
       +
       

     

       180
        
               result = user.remove_zulip_association(server, user_id)

     

       181
        
               if result:

     

       182
        
                   index.add_user(user)

     

       183
        
                   self._save_index(index)

     

       184
       +
       

     

       185
        
               return result

     

       186
       +
       

     

       187
        
           def get_zulip_associations(self, username: str) -> list:

     

       188
        
               """Get all Zulip associations for a user."""

     

       189
        
               user = self.get_user(username)

     
···

       385
        
               user = self.get_user(username)

     

       386
        
               if not user:

     

       387
        
                   return []

     

       388
       +
       

     

       389
        
               # Feed URLs are stored in the user metadata

     

       390
        
               return user.feeds

     

       391

+114 -58

src/thicket/core/typesense_client.py

···

       30
        
           collection_name: str = "thicket_entries"

     

       31
        
       

     

       32
        
           @classmethod

     

       33
       -
           def from_url(cls, url: str, api_key: str, collection_name: str = "thicket_entries") -> "TypesenseConfig":

     

       0
        
       
     

       0
        
       
     

       34
        
               """Create config from Typesense URL."""

     

       35
        
               parsed = urlparse(url)

     

       36
        
               return cls(

     
···

       207
        
           def __init__(self, config: TypesenseConfig):

     

       208
        
               """Initialize Typesense client."""

     

       209
        
               self.config = config

     

       210
       -
               self.client = typesense.Client({

     

       211
       -
                   'nodes': [{

     

       212
       -
                       'host': config.host,

     

       213
       -
                       'port': config.port,

     

       214
       -
                       'protocol': config.protocol,

     

       215
       -
                   }],

     

       216
       -
                   'api_key': config.api_key,

     

       217
       -
                   'connection_timeout_seconds': config.connection_timeout,

     

       218
       -
               })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       219
        
       

     

       220
        
           def get_collection_schema(self) -> dict[str, Any]:

     

       221
        
               """Get the Typesense collection schema for thicket entries."""

     

       222
        
               return {

     

       223
       -
                   'name': self.config.collection_name,

     

       224
       -
                   'fields': [

     

       225
        
                       # Primary identifiers

     

       226
       -
                       {'name': 'id', 'type': 'string', 'facet': False},

     

       227
       -
                       {'name': 'original_id', 'type': 'string', 'facet': False},

     

       228
       -
       

     

       229
        
                       # Content fields - optimized for search

     

       230
       -
                       {'name': 'title', 'type': 'string', 'facet': False},

     

       231
       -
                       {'name': 'summary', 'type': 'string', 'optional': True, 'facet': False},

     

       232
       -
                       {'name': 'content', 'type': 'string', 'optional': True, 'facet': False},

     

       233
       -
                       {'name': 'content_type', 'type': 'string', 'facet': True},

     

       234
       -
       

     

       235
        
                       # Searchable combined fields for embeddings/semantic search

     

       236
       -
                       {'name': 'searchable_content', 'type': 'string', 'facet': False},

     

       237
       -
                       {'name': 'searchable_metadata', 'type': 'string', 'facet': False},

     

       238
       -
       

     

       239
        
                       # Temporal fields

     

       240
       -
                       {'name': 'updated', 'type': 'int64', 'facet': False, 'sort': True},

     

       241
       -
                       {'name': 'published', 'type': 'int64', 'optional': True, 'facet': False, 'sort': True},

     

       242
       -
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       243
        
                       # Link and source

     

       244
       -
                       {'name': 'link', 'type': 'string', 'facet': False},

     

       245
       -
                       {'name': 'source', 'type': 'string', 'optional': True, 'facet': False},

     

       246
       -
       

     

       247
        
                       # Categories and classification

     

       248
       -
                       {'name': 'categories', 'type': 'string[]', 'facet': True, 'optional': True},

     

       249
       -
                       {'name': 'rights', 'type': 'string', 'optional': True, 'facet': False},

     

       250
       -
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       251
        
                       # User/feed metadata - facetable for filtering

     

       252
       -
                       {'name': 'username', 'type': 'string', 'facet': True},

     

       253
       -
                       {'name': 'user_display_name', 'type': 'string', 'optional': True, 'facet': True},

     

       254
       -
                       {'name': 'user_email', 'type': 'string', 'optional': True, 'facet': False},

     

       255
       -
                       {'name': 'user_homepage', 'type': 'string', 'optional': True, 'facet': False},

     

       256
       -
                       {'name': 'user_icon', 'type': 'string', 'optional': True, 'facet': False},

     

       257
       -
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       258
        
                       # Author information from entries

     

       259
       -
                       {'name': 'author_name', 'type': 'string', 'optional': True, 'facet': True},

     

       260
       -
                       {'name': 'author_email', 'type': 'string', 'optional': True, 'facet': False},

     

       261
       -
                       {'name': 'author_uri', 'type': 'string', 'optional': True, 'facet': False},

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       262
        
                   ],

     

       263
       -
                   'default_sorting_field': 'updated',

     

       264
        
               }

     

       265
        
       

     

       266
        
           def create_collection(self) -> dict[str, Any]:

     
···

       269
        
                   # Try to delete existing collection first

     

       270
        
                   try:

     

       271
        
                       self.client.collections[self.config.collection_name].delete()

     

       272
       -
                       logger.info(f"Deleted existing collection: {self.config.collection_name}")

     

       0
        
       
     

       0
        
       
     

       273
        
                   except typesense.exceptions.ObjectNotFound:

     

       274
       -
                       logger.info(f"Collection {self.config.collection_name} does not exist, creating new one")

     

       0
        
       
     

       0
        
       
     

       275
        
       

     

       276
        
                   # Create new collection

     

       277
        
                   schema = self.get_collection_schema()

     
···

       290
        
                   document_dicts = [doc.model_dump() for doc in documents]

     

       291
        
       

     

       292
        
                   # Use import endpoint for batch indexing

     

       293
       -
                   result = self.client.collections[self.config.collection_name].documents.import_(

     

       0
        
       
     

       0
        
       
     

       294
        
                       document_dicts,

     

       295
       -
                       {'action': 'upsert'}  # Update if exists, insert if not

     

       296
        
                   )

     

       297
        
       

     

       298
        
                   logger.info(f"Indexed {len(documents)} documents")

     
···

       302
        
                   logger.error(f"Failed to index documents: {e}")

     

       303
        
                   raise

     

       304
        
       

     

       305
       -
           def upload_from_git_store(self, git_store: GitStore, config: ThicketConfig) -> dict[str, Any]:

     

       0
        
       
     

       0
        
       
     

       306
        
               """Upload all entries from the Git store to Typesense."""

     

       307
        
               logger.info("Starting Typesense upload from Git store")

     

       308
        
       

     
···

       319
        
                   try:

     

       320
        
                       user_dir = git_store.repo_path / user_metadata.directory

     

       321
        
                       if not user_dir.exists():

     

       322
       -
                           logger.warning(f"Directory not found for user {username}: {user_dir}")

     

       0
        
       
     

       0
        
       
     

       323
        
                           continue

     

       324
        
       

     

       325
        
                       entry_files = list(user_dir.glob("*.json"))

     
···

       338
        
                               )

     

       339
        
                               documents.append(doc)

     

       340
        
                           except Exception as e:

     

       341
       -
                               logger.error(f"Failed to convert entry {entry_file} to document: {e}")

     

       0
        
       
     

       0
        
       
     

       342
        
       

     

       343
        
                   except Exception as e:

     

       344
        
                       logger.error(f"Failed to load entries for user {username}: {e}")

     
···

       353
        
                   return {}

     

       354
        
       

     

       355
        
           def search(

     

       356
       -
               self,

     

       357
       -
               query: str,

     

       358
       -
               search_parameters: Optional[dict[str, Any]] = None

     

       359
        
           ) -> dict[str, Any]:

     

       360
        
               """Search the collection."""

     

       361
        
               default_params = {

     

       362
       -
                   'q': query,

     

       363
       -
                   'query_by': 'title,searchable_content,searchable_metadata',

     

       364
       -
                   'sort_by': 'updated:desc',

     

       365
       -
                   'per_page': 20,

     

       366
        
               }

     

       367
        
       

     

       368
        
               if search_parameters:

     

       369
        
                   default_params.update(search_parameters)

     

       370
        
       

     

       371
       -
               return self.client.collections[self.config.collection_name].documents.search(default_params)

     

       372
       -
       

     

       0

···

       30
        
           collection_name: str = "thicket_entries"

     

       31
        
       

     

       32
        
           @classmethod

     

       33
       +
           def from_url(

     

       34
       +
               cls, url: str, api_key: str, collection_name: str = "thicket_entries"

     

       35
       +
           ) -> "TypesenseConfig":

     

       36
        
               """Create config from Typesense URL."""

     

       37
        
               parsed = urlparse(url)

     

       38
        
               return cls(

     
···

       209
        
           def __init__(self, config: TypesenseConfig):

     

       210
        
               """Initialize Typesense client."""

     

       211
        
               self.config = config

     

       212
       +
               self.client = typesense.Client(

     

       213
       +
                   {

     

       214
       +
                       "nodes": [

     

       215
       +
                           {

     

       216
       +
                               "host": config.host,

     

       217
       +
                               "port": config.port,

     

       218
       +
                               "protocol": config.protocol,

     

       219
       +
                           }

     

       220
       +
                       ],

     

       221
       +
                       "api_key": config.api_key,

     

       222
       +
                       "connection_timeout_seconds": config.connection_timeout,

     

       223
       +
                   }

     

       224
       +
               )

     

       225
        
       

     

       226
        
           def get_collection_schema(self) -> dict[str, Any]:

     

       227
        
               """Get the Typesense collection schema for thicket entries."""

     

       228
        
               return {

     

       229
       +
                   "name": self.config.collection_name,

     

       230
       +
                   "fields": [

     

       231
        
                       # Primary identifiers

     

       232
       +
                       {"name": "id", "type": "string", "facet": False},

     

       233
       +
                       {"name": "original_id", "type": "string", "facet": False},

     

       0
        
       
     

       234
        
                       # Content fields - optimized for search

     

       235
       +
                       {"name": "title", "type": "string", "facet": False},

     

       236
       +
                       {"name": "summary", "type": "string", "optional": True, "facet": False},

     

       237
       +
                       {"name": "content", "type": "string", "optional": True, "facet": False},

     

       238
       +
                       {"name": "content_type", "type": "string", "facet": True},

     

       0
        
       
     

       239
        
                       # Searchable combined fields for embeddings/semantic search

     

       240
       +
                       {"name": "searchable_content", "type": "string", "facet": False},

     

       241
       +
                       {"name": "searchable_metadata", "type": "string", "facet": False},

     

       0
        
       
     

       242
        
                       # Temporal fields

     

       243
       +
                       {"name": "updated", "type": "int64", "facet": False, "sort": True},

     

       244
       +
                       {

     

       245
       +
                           "name": "published",

     

       246
       +
                           "type": "int64",

     

       247
       +
                           "optional": True,

     

       248
       +
                           "facet": False,

     

       249
       +
                           "sort": True,

     

       250
       +
                       },

     

       251
        
                       # Link and source

     

       252
       +
                       {"name": "link", "type": "string", "facet": False},

     

       253
       +
                       {"name": "source", "type": "string", "optional": True, "facet": False},

     

       0
        
       
     

       254
        
                       # Categories and classification

     

       255
       +
                       {

     

       256
       +
                           "name": "categories",

     

       257
       +
                           "type": "string[]",

     

       258
       +
                           "facet": True,

     

       259
       +
                           "optional": True,

     

       260
       +
                       },

     

       261
       +
                       {"name": "rights", "type": "string", "optional": True, "facet": False},

     

       262
        
                       # User/feed metadata - facetable for filtering

     

       263
       +
                       {"name": "username", "type": "string", "facet": True},

     

       264
       +
                       {

     

       265
       +
                           "name": "user_display_name",

     

       266
       +
                           "type": "string",

     

       267
       +
                           "optional": True,

     

       268
       +
                           "facet": True,

     

       269
       +
                       },

     

       270
       +
                       {

     

       271
       +
                           "name": "user_email",

     

       272
       +
                           "type": "string",

     

       273
       +
                           "optional": True,

     

       274
       +
                           "facet": False,

     

       275
       +
                       },

     

       276
       +
                       {

     

       277
       +
                           "name": "user_homepage",

     

       278
       +
                           "type": "string",

     

       279
       +
                           "optional": True,

     

       280
       +
                           "facet": False,

     

       281
       +
                       },

     

       282
       +
                       {

     

       283
       +
                           "name": "user_icon",

     

       284
       +
                           "type": "string",

     

       285
       +
                           "optional": True,

     

       286
       +
                           "facet": False,

     

       287
       +
                       },

     

       288
        
                       # Author information from entries

     

       289
       +
                       {

     

       290
       +
                           "name": "author_name",

     

       291
       +
                           "type": "string",

     

       292
       +
                           "optional": True,

     

       293
       +
                           "facet": True,

     

       294
       +
                       },

     

       295
       +
                       {

     

       296
       +
                           "name": "author_email",

     

       297
       +
                           "type": "string",

     

       298
       +
                           "optional": True,

     

       299
       +
                           "facet": False,

     

       300
       +
                       },

     

       301
       +
                       {

     

       302
       +
                           "name": "author_uri",

     

       303
       +
                           "type": "string",

     

       304
       +
                           "optional": True,

     

       305
       +
                           "facet": False,

     

       306
       +
                       },

     

       307
        
                   ],

     

       308
       +
                   "default_sorting_field": "updated",

     

       309
        
               }

     

       310
        
       

     

       311
        
           def create_collection(self) -> dict[str, Any]:

     
···

       314
        
                   # Try to delete existing collection first

     

       315
        
                   try:

     

       316
        
                       self.client.collections[self.config.collection_name].delete()

     

       317
       +
                       logger.info(

     

       318
       +
                           f"Deleted existing collection: {self.config.collection_name}"

     

       319
       +
                       )

     

       320
        
                   except typesense.exceptions.ObjectNotFound:

     

       321
       +
                       logger.info(

     

       322
       +
                           f"Collection {self.config.collection_name} does not exist, creating new one"

     

       323
       +
                       )

     

       324
        
       

     

       325
        
                   # Create new collection

     

       326
        
                   schema = self.get_collection_schema()

     
···

       339
        
                   document_dicts = [doc.model_dump() for doc in documents]

     

       340
        
       

     

       341
        
                   # Use import endpoint for batch indexing

     

       342
       +
                   result = self.client.collections[

     

       343
       +
                       self.config.collection_name

     

       344
       +
                   ].documents.import_(

     

       345
        
                       document_dicts,

     

       346
       +
                       {"action": "upsert"},  # Update if exists, insert if not

     

       347
        
                   )

     

       348
        
       

     

       349
        
                   logger.info(f"Indexed {len(documents)} documents")

     
···

       353
        
                   logger.error(f"Failed to index documents: {e}")

     

       354
        
                   raise

     

       355
        
       

     

       356
       +
           def upload_from_git_store(

     

       357
       +
               self, git_store: GitStore, config: ThicketConfig

     

       358
       +
           ) -> dict[str, Any]:

     

       359
        
               """Upload all entries from the Git store to Typesense."""

     

       360
        
               logger.info("Starting Typesense upload from Git store")

     

       361
        
       

     
···

       372
        
                   try:

     

       373
        
                       user_dir = git_store.repo_path / user_metadata.directory

     

       374
        
                       if not user_dir.exists():

     

       375
       +
                           logger.warning(

     

       376
       +
                               f"Directory not found for user {username}: {user_dir}"

     

       377
       +
                           )

     

       378
        
                           continue

     

       379
        
       

     

       380
        
                       entry_files = list(user_dir.glob("*.json"))

     
···

       393
        
                               )

     

       394
        
                               documents.append(doc)

     

       395
        
                           except Exception as e:

     

       396
       +
                               logger.error(

     

       397
       +
                                   f"Failed to convert entry {entry_file} to document: {e}"

     

       398
       +
                               )

     

       399
        
       

     

       400
        
                   except Exception as e:

     

       401
        
                       logger.error(f"Failed to load entries for user {username}: {e}")

     
···

       410
        
                   return {}

     

       411
        
       

     

       412
        
           def search(

     

       413
       +
               self, query: str, search_parameters: Optional[dict[str, Any]] = None

     

       0
        
       
     

       0
        
       
     

       414
        
           ) -> dict[str, Any]:

     

       415
        
               """Search the collection."""

     

       416
        
               default_params = {

     

       417
       +
                   "q": query,

     

       418
       +
                   "query_by": "title,searchable_content,searchable_metadata",

     

       419
       +
                   "sort_by": "updated:desc",

     

       420
       +
                   "per_page": 20,

     

       421
        
               }

     

       422
        
       

     

       423
        
               if search_parameters:

     

       424
        
                   default_params.update(search_parameters)

     

       425
        
       

     

       426
       +
               return self.client.collections[self.config.collection_name].documents.search(

     

       427
       +
                   default_params

     

       428
       +
               )

+8 -6

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))

     
···

       31
        
           homepage: Optional[str] = None

     

       32
        
           icon: Optional[str] = None

     

       33
        
           feeds: list[str] = []

     

       34
       -
           zulip_associations: list[ZulipAssociation] = Field(default_factory=list)  # Zulip server/user pairs

     

       0
        
       
     

       0
        
       
     

       35
        
           directory: str  # Directory name in Git store

     

       36
        
           created: datetime

     

       37
        
           last_updated: datetime

     
···

       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))

     
···

       31
        
           homepage: Optional[str] = None

     

       32
        
           icon: Optional[str] = None

     

       33
        
           feeds: list[str] = []

     

       34
       +
           zulip_associations: list[ZulipAssociation] = Field(

     

       35
       +
               default_factory=list

     

       36
       +
           )  # Zulip server/user pairs

     

       37
        
           directory: str  # Directory name in Git store

     

       38
        
           created: datetime

     

       39
        
           last_updated: datetime

     
···

       47
        
               """Increment the entry count by the given amount."""

     

       48
        
               self.entry_count += count

     

       49
        
               self.update_timestamp()

     

       50
       +
       

     

       51
        
           def add_zulip_association(self, server: str, user_id: str) -> bool:

     

       52
        
               """Add a Zulip association if it doesn't exist. Returns True if added."""

     

       53
        
               association = ZulipAssociation(server=server, user_id=user_id)

     
···

       56
        
                   self.update_timestamp()

     

       57
        
                   return True

     

       58
        
               return False

     

       59
       +
       

     

       60
        
           def remove_zulip_association(self, server: str, user_id: str) -> bool:

     

       61
        
               """Remove a Zulip association. Returns True if removed."""

     

       62
        
               association = ZulipAssociation(server=server, user_id=user_id)

     
···

       65
        
                   self.update_timestamp()

     

       66
        
                   return True

     

       67
        
               return False

     

       68
       +
       

     

       69
        
           def get_zulip_mention(self, server: str) -> Optional[str]:

     

       70
        
               """Get the Zulip user_id for @mentions on a specific server."""

     

       71
        
               for association in self.zulip_associations:

+55 -55

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
       -
           

     

       0
        
       
     

       0
        
       
     

       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")

     

       284
        
       

     

       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
        
       
     

       0
        
       
     

       3
        
       import pytest

     

       4
        
       

     

       5
       +
       from thicket.bots.test_bot import (

     

       6
       +
           BotTester,

     

       7
       +
           MockBotHandler,

     

       8
       +
           create_test_entry,

     

       9
       +
           create_test_message,

     

       10
       +
       )

     

       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 (

     

       219
       +
                   "Debug mode validation failed" in self.handler.sent_messages[0]["content"]

     

       220
       +
               )

     

       221
       +
       

     

       222
        
           def test_debug_mode_dm_posting(self) -> None:

     

       223
        
               """Test that debug mode posts DMs instead of stream messages."""

     

       224
        
               from unittest.mock import Mock

     

       225
       +
       

     

       0
        
       
     

       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
       +
               tester.send_command("config stream general")

     

       279
        
               tester.assert_response_contains("Stream set to")

     

       280
       +
       

     

       281
        
               # Configure topic

     

       282
       +
               tester.send_command("config topic test")

     

       283
        
               tester.assert_response_contains("Topic set to")

     

       284
        
       

     

       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")

+2 -1

tests/test_feed_parser.py

···

       100
        
               html_with_attrs = '<a href="https://example.com" onclick="alert()">Link</a>'

     

       101
        
               sanitized = parser._sanitize_html(html_with_attrs)

     

       102
        
               assert 'href="https://example.com"' in sanitized

     

       103
       -
               assert 'onclick' not in sanitized

     

       104
        
       

     

       105
        
           def test_extract_feed_metadata(self):

     

       106
        
               """Test feed metadata extraction."""

     
···

       108
        
       

     

       109
        
               # Test with feedparser parsed data

     

       110
        
               import feedparser

     

       0
        
       
     

       111
        
               parsed = feedparser.parse("""<?xml version="1.0" encoding="utf-8"?>

     

       112
        
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       113
        
         <title>Test Feed</title>

···

       100
        
               html_with_attrs = '<a href="https://example.com" onclick="alert()">Link</a>'

     

       101
        
               sanitized = parser._sanitize_html(html_with_attrs)

     

       102
        
               assert 'href="https://example.com"' in sanitized

     

       103
       +
               assert "onclick" not in sanitized

     

       104
        
       

     

       105
        
           def test_extract_feed_metadata(self):

     

       106
        
               """Test feed metadata extraction."""

     
···

       108
        
       

     

       109
        
               # Test with feedparser parsed data

     

       110
        
               import feedparser

     

       111
       +
       

     

       112
        
               parsed = feedparser.parse("""<?xml version="1.0" encoding="utf-8"?>

     

       113
        
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       114
        
         <title>Test Feed</title>

+7 -2

tests/test_git_store.py

···

       191
        
               duplicates = store.get_duplicates()

     

       192
        
               assert len(duplicates.duplicates) == 1

     

       193
        
               assert duplicates.is_duplicate("https://example.com/dup")

     

       194
       -
               assert duplicates.get_canonical("https://example.com/dup") == "https://example.com/canonical"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       195
        
       

     

       196
        
               # Remove duplicate

     

       197
        
               result = store.remove_duplicate("https://example.com/dup")

     
···

       220
        
                   entry = AtomEntry(

     

       221
        
                       id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",

     

       222
        
                       title=title,

     

       223
       -
                       link=HttpUrl(f"https://example.com/entry/{title.lower().replace(' ', '-')}"),

     

       0
        
       
     

       0
        
       
     

       224
        
                       updated=datetime.now(),

     

       225
        
                       summary=summary,

     

       226
        
                   )

···

       191
        
               duplicates = store.get_duplicates()

     

       192
        
               assert len(duplicates.duplicates) == 1

     

       193
        
               assert duplicates.is_duplicate("https://example.com/dup")

     

       194
       +
               assert (

     

       195
       +
                   duplicates.get_canonical("https://example.com/dup")

     

       196
       +
                   == "https://example.com/canonical"

     

       197
       +
               )

     

       198
        
       

     

       199
        
               # Remove duplicate

     

       200
        
               result = store.remove_duplicate("https://example.com/dup")

     
···

       223
        
                   entry = AtomEntry(

     

       224
        
                       id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",

     

       225
        
                       title=title,

     

       226
       +
                       link=HttpUrl(

     

       227
       +
                           f"https://example.com/entry/{title.lower().replace(' ', '-')}"

     

       228
       +
                       ),

     

       229
        
                       updated=datetime.now(),

     

       230
        
                       summary=summary,

     

       231
        
                   )

+31 -34

tests/test_models.py

···

       9
        
           AtomEntry,

     

       10
        
           DuplicateMap,

     

       11
        
           FeedMetadata,

     

       12
       -
           GitStoreIndex,

     

       13
        
           ThicketConfig,

     

       14
        
           UserConfig,

     

       15
        
           UserMetadata,

     
···

       128
        
                   git_store=temp_dir / "git_store",

     

       129
        
                   cache_dir=temp_dir / "cache",

     

       130
        
                   users=[

     

       131
       -
                       UserConfig(username="testuser", feeds=["https://example.com/feed1.xml"]),

     

       0
        
       
     

       0
        
       
     

       132
        
                   ],

     

       133
        
               )

     

       134
        
       

     

       135
       -
               result = config.add_feed_to_user("testuser", HttpUrl("https://example.com/feed2.xml"))

     

       0
        
       
     

       0
        
       
     

       136
        
               assert result is True

     

       137
        
       

     

       138
        
               user = config.find_user("testuser")

     
···

       140
        
               assert HttpUrl("https://example.com/feed2.xml") in user.feeds

     

       141
        
       

     

       142
        
               # Test adding to non-existent user

     

       143
       -
               result = config.add_feed_to_user("nonexistent", HttpUrl("https://example.com/feed.xml"))

     

       0
        
       
     

       0
        
       
     

       144
        
               assert result is False

     

       145
        
       

     

       146
        
       

     
···

       295
        
               user_config = metadata.to_user_config("testuser", feed_url)

     

       296
        
       

     

       297
        
               assert user_config.display_name == "Test Feed"  # Falls back to title

     

       298
       -
               assert user_config.homepage == HttpUrl("https://example.com")  # Falls back to link

     

       0
        
       
     

       0
        
       
     

       299
        
               assert user_config.icon == HttpUrl("https://example.com/icon.png")

     

       300
        
               assert user_config.email is None

     

       301
        
       

     
···

       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(

     

       419
       -
                   server="example.zulipchat.com",

     

       420
       -
                   user_id="alice"

     

       421
       -
               )

     

       422
       -
               assoc2 = ZulipAssociation(

     

       423
       -
                   server="example.zulipchat.com",

     

       424
       -
                   user_id="alice"

     

       425
       -
               )

     

       426
       -
               assoc3 = 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,

     
···

       127
        
                   git_store=temp_dir / "git_store",

     

       128
        
                   cache_dir=temp_dir / "cache",

     

       129
        
                   users=[

     

       130
       +
                       UserConfig(

     

       131
       +
                           username="testuser", feeds=["https://example.com/feed1.xml"]

     

       132
       +
                       ),

     

       133
        
                   ],

     

       134
        
               )

     

       135
        
       

     

       136
       +
               result = config.add_feed_to_user(

     

       137
       +
                   "testuser", HttpUrl("https://example.com/feed2.xml")

     

       138
       +
               )

     

       139
        
               assert result is True

     

       140
        
       

     

       141
        
               user = config.find_user("testuser")

     
···

       143
        
               assert HttpUrl("https://example.com/feed2.xml") in user.feeds

     

       144
        
       

     

       145
        
               # Test adding to non-existent user

     

       146
       +
               result = config.add_feed_to_user(

     

       147
       +
                   "nonexistent", HttpUrl("https://example.com/feed.xml")

     

       148
       +
               )

     

       149
        
               assert result is False

     

       150
        
       

     

       151
        
       

     
···

       300
        
               user_config = metadata.to_user_config("testuser", feed_url)

     

       301
        
       

     

       302
        
               assert user_config.display_name == "Test Feed"  # Falls back to title

     

       303
       +
               assert user_config.homepage == HttpUrl(

     

       304
       +
                   "https://example.com"

     

       305
       +
               )  # Falls back to link

     

       306
        
               assert user_config.icon == HttpUrl("https://example.com/icon.png")

     

       307
        
               assert user_config.email is None

     

       308
        
       

     
···

       359
        
       

     

       360
        
               assert metadata.entry_count == original_count + 3

     

       361
        
               assert metadata.last_updated > original_time

     

       362
       +
       

     

       363
        
           def test_zulip_associations(self):

     

       364
        
               """Test Zulip association methods."""

     

       365
        
               metadata = UserMetadata(

     
···

       368
        
                   created=datetime.now(),

     

       369
        
                   last_updated=datetime.now(),

     

       370
        
               )

     

       371
       +
       

     

       372
        
               # Test adding association

     

       373
        
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       374
        
               assert result is True

     

       375
        
               assert len(metadata.zulip_associations) == 1

     

       376
        
               assert metadata.zulip_associations[0].server == "example.zulipchat.com"

     

       377
        
               assert metadata.zulip_associations[0].user_id == "alice"

     

       378
       +
       

     

       379
        
               # Test adding duplicate association

     

       380
        
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       381
        
               assert result is False

     

       382
        
               assert len(metadata.zulip_associations) == 1

     

       383
       +
       

     

       384
        
               # Test adding different association

     

       385
        
               result = metadata.add_zulip_association("other.zulipchat.com", "alice")

     

       386
        
               assert result is True

     

       387
        
               assert len(metadata.zulip_associations) == 2

     

       388
       +
       

     

       389
        
               # Test get_zulip_mention

     

       390
        
               mention = metadata.get_zulip_mention("example.zulipchat.com")

     

       391
        
               assert mention == "alice"

     

       392
       +
       

     

       393
        
               mention = metadata.get_zulip_mention("other.zulipchat.com")

     

       394
        
               assert mention == "alice"

     

       395
       +
       

     

       396
        
               mention = metadata.get_zulip_mention("nonexistent.zulipchat.com")

     

       397
        
               assert mention is None

     

       398
       +
       

     

       399
        
               # Test removing association

     

       400
        
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       401
        
               assert result is True

     

       402
        
               assert len(metadata.zulip_associations) == 1

     

       403
       +
       

     

       404
        
               # Test removing non-existent association

     

       405
        
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       406
        
               assert result is False

     
···

       409
        
       

     

       410
        
       class TestZulipAssociation:

     

       411
        
           """Test ZulipAssociation model."""

     

       412
       +
       

     

       413
        
           def test_valid_association(self):

     

       414
        
               """Test creating valid Zulip association."""

     

       415
        
               assoc = ZulipAssociation(

     

       416
       +
                   server="example.zulipchat.com", user_id="alice@example.com"

     

       0
        
       
     

       417
        
               )

     

       418
       +
       

     

       419
        
               assert assoc.server == "example.zulipchat.com"

     

       420
        
               assert assoc.user_id == "alice@example.com"

     

       421
       +
       

     

       422
        
           def test_association_hash(self):

     

       423
        
               """Test that associations are hashable."""

     

       424
       +
               assoc1 = ZulipAssociation(server="example.zulipchat.com", user_id="alice")

     

       425
       +
               assoc2 = ZulipAssociation(server="example.zulipchat.com", user_id="alice")

     

       426
       +
               assoc3 = ZulipAssociation(server="other.zulipchat.com", user_id="alice")

     

       427
       +
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       428
        
               # Same associations should have same hash

     

       429
        
               assert hash(assoc1) == hash(assoc2)

     

       430
       +
       

     

       431
        
               # Different associations should have different hash

     

       432
        
               assert hash(assoc1) != hash(assoc3)

     

       433
       +
       

     

       434
        
               # Can be used in sets

     

       435
        
               assoc_set = {assoc1, assoc2, assoc3}

     

       436
        
               assert len(assoc_set) == 2  # assoc1 and assoc2 are considered the same

Compare changes