comparing b4fed7139ef257995f19fd035dfb358eab3075f9 and main on anil.recoil.org/thicket

.gitignore

···

       203
        
       .streamlit/secrets.toml

     

       204
        
       

     

       205
        
       thicket.yaml

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       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

+26

README.md

···

       9
        
       - **Duplicate Management**: Manual curation of duplicate entries across feeds

     

       10
        
       - **Modern CLI**: Built with Typer and Rich for beautiful terminal output

     

       11
        
       - **Comprehensive Parsing**: Supports RSS 0.9x, RSS 1.0, RSS 2.0, and Atom feeds

     

       0
        
       
     

       12
        
       - **Cron-Friendly**: Designed for scheduled execution

     

       13
        
       

     

       14
        
       ## Installation

     
···

       109
        
       # Remove duplicate mapping

     

       110
        
       thicket duplicates remove "https://example.com/dup"

     

       111
        
       ```

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       112
        
       

     

       113
        
       ## Configuration

     

       114

···

       9
        
       - **Duplicate Management**: Manual curation of duplicate entries across feeds

     

       10
        
       - **Modern CLI**: Built with Typer and Rich for beautiful terminal output

     

       11
        
       - **Comprehensive Parsing**: Supports RSS 0.9x, RSS 1.0, RSS 2.0, and Atom feeds

     

       12
       +
       - **Zulip Bot Integration**: Automatically post new feed articles to Zulip chat

     

       13
        
       - **Cron-Friendly**: Designed for scheduled execution

     

       14
        
       

     

       15
        
       ## Installation

     
···

       110
        
       # Remove duplicate mapping

     

       111
        
       thicket duplicates remove "https://example.com/dup"

     

       112
        
       ```

     

       113
       +
       

     

       114
       +
       ### Zulip Bot Integration

     

       115
       +
       ```bash

     

       116
       +
       # Test bot functionality

     

       117
       +
       thicket bot test

     

       118
       +
       

     

       119
       +
       # Show bot status 

     

       120
       +
       thicket bot status

     

       121
       +
       

     

       122
       +
       # Run bot (requires configuration)

     

       123
       +
       thicket bot run --config bot-config/zuliprc

     

       124
       +
       ```

     

       125
       +
       

     

       126
       +
       **Bot Setup:**

     

       127
       +
       1. Create a Zulip bot in your organization

     

       128
       +
       2. Copy `bot-config/zuliprc.template` to `bot-config/zuliprc`

     

       129
       +
       3. Configure with your bot's credentials

     

       130
       +
       4. Run the bot and configure via Zulip chat:

     

       131
       +
          ```

     

       132
       +
          @thicket config path /path/to/thicket.yaml

     

       133
       +
          @thicket config stream general

     

       134
       +
          @thicket config topic "Feed Updates"

     

       135
       +
          ```

     

       136
       +
       

     

       137
       +
       See [docs/ZULIP_BOT.md](docs/ZULIP_BOT.md) for detailed setup instructions.

     

       138
        
       

     

       139
        
       ## Configuration

     

       140

+400

SPEC.md

···

       1
       +
       # Thicket Git Store Specification

     

       2
       +
       

     

       3
       +
       This document comprehensively defines the JSON format and structure of the Thicket Git repository, enabling third-party clients to read and write to the store while leveraging Thicket's existing Python classes for data validation and business logic.

     

       4
       +
       

     

       5
       +
       ## Overview

     

       6
       +
       

     

       7
       +
       The Thicket Git store is a structured repository that persists Atom/RSS feed entries in JSON format. The store is designed to be both human-readable and machine-parseable, with a clear directory structure and standardized JSON schemas.

     

       8
       +
       

     

       9
       +
       ## Repository Structure

     

       10
       +
       

     

       11
       +
       ```

     

       12
       +
       <git_store>/

     

       13
       +
       ├── index.json              # Main index of all users and metadata

     

       14
       +
       ├── duplicates.json         # Maps duplicate entry IDs to canonical IDs

     

       15
       +
       ├── index.opml             # OPML export of all feeds (generated)

     

       16
       +
       ├── <username1>/           # User directory (sanitized username)

     

       17
       +
       │   ├── <entry_id1>.json   # Individual feed entry

     

       18
       +
       │   ├── <entry_id2>.json   # Individual feed entry

     

       19
       +
       │   └── ...

     

       20
       +
       ├── <username2>/

     

       21
       +
       │   ├── <entry_id3>.json

     

       22
       +
       │   └── ...

     

       23
       +
       └── ...

     

       24
       +
       ```

     

       25
       +
       

     

       26
       +
       ## JSON Schemas

     

       27
       +
       

     

       28
       +
       ### 1. Index File (`index.json`)

     

       29
       +
       

     

       30
       +
       The main index tracks all users, their metadata, and repository statistics.

     

       31
       +
       

     

       32
       +
       **Schema:**

     

       33
       +
       ```json

     

       34
       +
       {

     

       35
       +
         "users": {

     

       36
       +
           "<username>": {

     

       37
       +
             "username": "string",

     

       38
       +
             "display_name": "string | null",

     

       39
       +
             "email": "string | null", 

     

       40
       +
             "homepage": "string (URL) | null",

     

       41
       +
             "icon": "string (URL) | null",

     

       42
       +
             "feeds": ["string (URL)", ...],

     

       43
       +
             "zulip_associations": [

     

       44
       +
               {

     

       45
       +
                 "server": "string",

     

       46
       +
                 "user_id": "string"

     

       47
       +
               },

     

       48
       +
               ...

     

       49
       +
             ],

     

       50
       +
             "directory": "string",

     

       51
       +
             "created": "string (ISO 8601 datetime)",

     

       52
       +
             "last_updated": "string (ISO 8601 datetime)",

     

       53
       +
             "entry_count": "integer"

     

       54
       +
           }

     

       55
       +
         },

     

       56
       +
         "created": "string (ISO 8601 datetime)",

     

       57
       +
         "last_updated": "string (ISO 8601 datetime)", 

     

       58
       +
         "total_entries": "integer"

     

       59
       +
       }

     

       60
       +
       ```

     

       61
       +
       

     

       62
       +
       **Example:**

     

       63
       +
       ```json

     

       64
       +
       {

     

       65
       +
         "users": {

     

       66
       +
           "johndoe": {

     

       67
       +
             "username": "johndoe",

     

       68
       +
             "display_name": "John Doe",

     

       69
       +
             "email": "john@example.com",

     

       70
       +
             "homepage": "https://johndoe.blog",

     

       71
       +
             "icon": "https://johndoe.blog/avatar.png",

     

       72
       +
             "feeds": [

     

       73
       +
               "https://johndoe.blog/feed.xml",

     

       74
       +
               "https://johndoe.blog/categories/tech/feed.xml"

     

       75
       +
             ],

     

       76
       +
             "zulip_associations": [

     

       77
       +
               {

     

       78
       +
                 "server": "myorg.zulipchat.com",

     

       79
       +
                 "user_id": "john.doe"

     

       80
       +
               },

     

       81
       +
               {

     

       82
       +
                 "server": "community.zulipchat.com",

     

       83
       +
                 "user_id": "johndoe@example.com"

     

       84
       +
               }

     

       85
       +
             ],

     

       86
       +
             "directory": "johndoe",

     

       87
       +
             "created": "2024-01-15T10:30:00",

     

       88
       +
             "last_updated": "2024-01-20T14:22:00",

     

       89
       +
             "entry_count": 42

     

       90
       +
           }

     

       91
       +
         },

     

       92
       +
         "created": "2024-01-15T10:30:00",

     

       93
       +
         "last_updated": "2024-01-20T14:22:00",

     

       94
       +
         "total_entries": 42

     

       95
       +
       }

     

       96
       +
       ```

     

       97
       +
       

     

       98
       +
       ### 2. Duplicates File (`duplicates.json`)

     

       99
       +
       

     

       100
       +
       Maps duplicate entry IDs to their canonical representations to handle feed entries that appear with different IDs but identical content.

     

       101
       +
       

     

       102
       +
       **Schema:**

     

       103
       +
       ```json

     

       104
       +
       {

     

       105
       +
         "duplicates": {

     

       106
       +
           "<duplicate_id>": "<canonical_id>"

     

       107
       +
         },

     

       108
       +
         "comment": "Entry IDs that map to the same canonical content"

     

       109
       +
       }

     

       110
       +
       ```

     

       111
       +
       

     

       112
       +
       **Example:**

     

       113
       +
       ```json

     

       114
       +
       {

     

       115
       +
         "duplicates": {

     

       116
       +
           "https://example.com/posts/123?utm_source=rss": "https://example.com/posts/123",

     

       117
       +
           "https://example.com/feed/item-duplicate": "https://example.com/feed/item-original"

     

       118
       +
         },

     

       119
       +
         "comment": "Entry IDs that map to the same canonical content"

     

       120
       +
       }

     

       121
       +
       ```

     

       122
       +
       

     

       123
       +
       ### 3. Feed Entry Files (`<username>/<entry_id>.json`)

     

       124
       +
       

     

       125
       +
       Individual feed entries are stored as normalized Atom entries, regardless of their original format (RSS/Atom).

     

       126
       +
       

     

       127
       +
       **Schema:**

     

       128
       +
       ```json

     

       129
       +
       {

     

       130
       +
         "id": "string",

     

       131
       +
         "title": "string", 

     

       132
       +
         "link": "string (URL)",

     

       133
       +
         "updated": "string (ISO 8601 datetime)",

     

       134
       +
         "published": "string (ISO 8601 datetime) | null",

     

       135
       +
         "summary": "string | null",

     

       136
       +
         "content": "string | null",

     

       137
       +
         "content_type": "html | text | xhtml",

     

       138
       +
         "author": {

     

       139
       +
           "name": "string | null",

     

       140
       +
           "email": "string | null", 

     

       141
       +
           "uri": "string (URL) | null"

     

       142
       +
         } | null,

     

       143
       +
         "categories": ["string", ...],

     

       144
       +
         "rights": "string | null",

     

       145
       +
         "source": "string (URL) | null"

     

       146
       +
       }

     

       147
       +
       ```

     

       148
       +
       

     

       149
       +
       **Example:**

     

       150
       +
       ```json

     

       151
       +
       {

     

       152
       +
         "id": "https://johndoe.blog/posts/my-first-post",

     

       153
       +
         "title": "My First Blog Post",

     

       154
       +
         "link": "https://johndoe.blog/posts/my-first-post",

     

       155
       +
         "updated": "2024-01-20T14:22:00",

     

       156
       +
         "published": "2024-01-20T09:00:00", 

     

       157
       +
         "summary": "This is a summary of my first blog post.",

     

       158
       +
         "content": "<p>This is the full content of my <strong>first</strong> blog post with HTML formatting.</p>",

     

       159
       +
         "content_type": "html",

     

       160
       +
         "author": {

     

       161
       +
           "name": "John Doe",

     

       162
       +
           "email": "john@example.com",

     

       163
       +
           "uri": "https://johndoe.blog"

     

       164
       +
         },

     

       165
       +
         "categories": ["blogging", "personal"],

     

       166
       +
         "rights": "Copyright 2024 John Doe",

     

       167
       +
         "source": "https://johndoe.blog/feed.xml"

     

       168
       +
       }

     

       169
       +
       ```

     

       170
       +
       

     

       171
       +
       ## Python Class Integration

     

       172
       +
       

     

       173
       +
       To leverage Thicket's existing validation and business logic, third-party clients should use the following Python classes from the `thicket.models` package:

     

       174
       +
       

     

       175
       +
       ### Core Data Models

     

       176
       +
       

     

       177
       +
       ```python

     

       178
       +
       from thicket.models import (

     

       179
       +
           AtomEntry,           # Feed entry representation

     

       180
       +
           GitStoreIndex,       # Repository index

     

       181
       +
           UserMetadata,        # User information  

     

       182
       +
           DuplicateMap,        # Duplicate ID mappings

     

       183
       +
           FeedMetadata,        # Feed-level metadata

     

       184
       +
           ThicketConfig,       # Configuration

     

       185
       +
           UserConfig,          # User configuration

     

       186
       +
           ZulipAssociation     # Zulip server/user_id pairs

     

       187
       +
       )

     

       188
       +
       ```

     

       189
       +
       

     

       190
       +
       ### Repository Operations

     

       191
       +
       

     

       192
       +
       ```python

     

       193
       +
       from thicket.core.git_store import GitStore

     

       194
       +
       from thicket.core.feed_parser import FeedParser

     

       195
       +
       

     

       196
       +
       # Initialize git store

     

       197
       +
       store = GitStore(Path("/path/to/git/store"))

     

       198
       +
       

     

       199
       +
       # Read data

     

       200
       +
       index = store._load_index()          # Load index.json

     

       201
       +
       user = store.get_user("username")    # Get user metadata

     

       202
       +
       entries = store.list_entries("username", limit=10)

     

       203
       +
       entry = store.get_entry("username", "entry_id")

     

       204
       +
       duplicates = store.get_duplicates()  # Load duplicates.json

     

       205
       +
       

     

       206
       +
       # Write data  

     

       207
       +
       store.add_user("username", display_name="Display Name")

     

       208
       +
       store.store_entry("username", atom_entry)

     

       209
       +
       store.add_duplicate("duplicate_id", "canonical_id") 

     

       210
       +
       store.commit_changes("Commit message")

     

       211
       +
       

     

       212
       +
       # Zulip associations

     

       213
       +
       store.add_zulip_association("username", "myorg.zulipchat.com", "user@example.com")

     

       214
       +
       store.remove_zulip_association("username", "myorg.zulipchat.com", "user@example.com")

     

       215
       +
       associations = store.get_zulip_associations("username")

     

       216
       +
       

     

       217
       +
       # Search and statistics

     

       218
       +
       results = store.search_entries("query", username="optional")

     

       219
       +
       stats = store.get_stats()

     

       220
       +
       ```

     

       221
       +
       

     

       222
       +
       ### Feed Processing

     

       223
       +
       

     

       224
       +
       ```python

     

       225
       +
       from thicket.core.feed_parser import FeedParser

     

       226
       +
       from pydantic import HttpUrl

     

       227
       +
       

     

       228
       +
       parser = FeedParser()

     

       229
       +
       

     

       230
       +
       # Fetch and parse feeds

     

       231
       +
       content = await parser.fetch_feed(HttpUrl("https://example.com/feed.xml"))

     

       232
       +
       feed_metadata, entries = parser.parse_feed(content, source_url)

     

       233
       +
       

     

       234
       +
       # Entry ID sanitization for filenames

     

       235
       +
       safe_filename = parser.sanitize_entry_id(entry.id)

     

       236
       +
       ```

     

       237
       +
       

     

       238
       +
       ## File Naming and ID Sanitization

     

       239
       +
       

     

       240
       +
       Entry IDs from feeds are sanitized to create safe filenames using `FeedParser.sanitize_entry_id()`:

     

       241
       +
       

     

       242
       +
       - URLs are parsed and the path component is used as the base

     

       243
       +
       - Characters are limited to alphanumeric, hyphens, underscores, and periods

     

       244
       +
       - Other characters are replaced with underscores

     

       245
       +
       - Maximum length is 200 characters

     

       246
       +
       - Empty results default to "entry"

     

       247
       +
       

     

       248
       +
       **Examples:**

     

       249
       +
       - `https://example.com/posts/my-post` → `posts_my-post.json`

     

       250
       +
       - `https://blog.com/2024/01/title?utm=source` → `2024_01_title.json`

     

       251
       +
       

     

       252
       +
       ## Data Validation

     

       253
       +
       

     

       254
       +
       All JSON data should be validated using Pydantic models before writing to the store:

     

       255
       +
       

     

       256
       +
       ```python

     

       257
       +
       from thicket.models import AtomEntry

     

       258
       +
       from pydantic import ValidationError

     

       259
       +
       

     

       260
       +
       try:

     

       261
       +
           entry = AtomEntry(**json_data)

     

       262
       +
           # Data is valid, safe to store

     

       263
       +
           store.store_entry(username, entry)

     

       264
       +
       except ValidationError as e:

     

       265
       +
           # Handle validation errors

     

       266
       +
           print(f"Invalid entry data: {e}")

     

       267
       +
       ```

     

       268
       +
       

     

       269
       +
       ## Timestamps

     

       270
       +
       

     

       271
       +
       All timestamps use ISO 8601 format in UTC:

     

       272
       +
       - `created`: When the record was first created

     

       273
       +
       - `last_updated`: When the record was last modified  

     

       274
       +
       - `updated`: When the feed entry was last updated (from feed)

     

       275
       +
       - `published`: When the feed entry was originally published (from feed)

     

       276
       +
       

     

       277
       +
       ## Content Sanitization

     

       278
       +
       

     

       279
       +
       HTML content in entries is sanitized using the `FeedParser._sanitize_html()` method to prevent XSS attacks. Allowed tags and attributes are strictly controlled.

     

       280
       +
       

     

       281
       +
       **Allowed HTML tags:**

     

       282
       +
       `a`, `abbr`, `acronym`, `b`, `blockquote`, `br`, `code`, `em`, `i`, `li`, `ol`, `p`, `pre`, `strong`, `ul`, `h1`-`h6`, `img`, `div`, `span`

     

       283
       +
       

     

       284
       +
       **Allowed attributes:**

     

       285
       +
       - `a`: `href`, `title`

     

       286
       +
       - `img`: `src`, `alt`, `title`, `width`, `height` 

     

       287
       +
       - `blockquote`: `cite`

     

       288
       +
       - `abbr`/`acronym`: `title`

     

       289
       +
       

     

       290
       +
       ## Error Handling and Robustness

     

       291
       +
       

     

       292
       +
       The store is designed to be fault-tolerant:

     

       293
       +
       

     

       294
       +
       - Invalid entries are skipped during processing with error logging

     

       295
       +
       - Malformed JSON files are ignored in listings

     

       296
       +
       - Missing files return `None` rather than raising exceptions

     

       297
       +
       - Git operations are atomic where possible

     

       298
       +
       

     

       299
       +
       ## Example Usage

     

       300
       +
       

     

       301
       +
       ### Reading the Store

     

       302
       +
       

     

       303
       +
       ```python

     

       304
       +
       from pathlib import Path

     

       305
       +
       from thicket.core.git_store import GitStore

     

       306
       +
       

     

       307
       +
       # Initialize

     

       308
       +
       store = GitStore(Path("/path/to/thicket/store"))

     

       309
       +
       

     

       310
       +
       # Get all users

     

       311
       +
       index = store._load_index()

     

       312
       +
       for username, user_metadata in index.users.items():

     

       313
       +
           print(f"User: {user_metadata.display_name} ({username})")

     

       314
       +
           print(f"  Feeds: {user_metadata.feeds}")

     

       315
       +
           print(f"  Entries: {user_metadata.entry_count}")

     

       316
       +
       

     

       317
       +
       # Get recent entries for a user

     

       318
       +
       entries = store.list_entries("johndoe", limit=5)

     

       319
       +
       for entry in entries:

     

       320
       +
           print(f"  - {entry.title} ({entry.updated})")

     

       321
       +
       ```

     

       322
       +
       

     

       323
       +
       ### Adding Data

     

       324
       +
       

     

       325
       +
       ```python

     

       326
       +
       from thicket.models import AtomEntry

     

       327
       +
       from datetime import datetime

     

       328
       +
       from pydantic import HttpUrl

     

       329
       +
       

     

       330
       +
       # Create entry

     

       331
       +
       entry = AtomEntry(

     

       332
       +
           id="https://example.com/new-post",

     

       333
       +
           title="New Post",

     

       334
       +
           link=HttpUrl("https://example.com/new-post"),

     

       335
       +
           updated=datetime.now(),

     

       336
       +
           content="<p>Post content</p>",

     

       337
       +
           content_type="html"

     

       338
       +
       )

     

       339
       +
       

     

       340
       +
       # Store entry

     

       341
       +
       store.store_entry("johndoe", entry)

     

       342
       +
       store.commit_changes("Add new blog post")

     

       343
       +
       ```

     

       344
       +
       

     

       345
       +
       ## Zulip Integration

     

       346
       +
       

     

       347
       +
       The Thicket Git store supports Zulip bot integration for automatic feed posting with user mentions.

     

       348
       +
       

     

       349
       +
       ### Zulip Associations

     

       350
       +
       

     

       351
       +
       Users can be associated with their Zulip identities to enable @mentions:

     

       352
       +
       

     

       353
       +
       ```python

     

       354
       +
       # UserMetadata includes zulip_associations field

     

       355
       +
       user.zulip_associations = [

     

       356
       +
           ZulipAssociation(server="myorg.zulipchat.com", user_id="alice"),

     

       357
       +
           ZulipAssociation(server="other.zulipchat.com", user_id="alice@example.com")

     

       358
       +
       ]

     

       359
       +
       

     

       360
       +
       # Methods for managing associations

     

       361
       +
       user.add_zulip_association("myorg.zulipchat.com", "alice")

     

       362
       +
       user.get_zulip_mention("myorg.zulipchat.com")  # Returns "alice"

     

       363
       +
       user.remove_zulip_association("myorg.zulipchat.com", "alice")

     

       364
       +
       ```

     

       365
       +
       

     

       366
       +
       ### CLI Management

     

       367
       +
       

     

       368
       +
       ```bash

     

       369
       +
       # Add association

     

       370
       +
       thicket zulip-add alice myorg.zulipchat.com alice@example.com

     

       371
       +
       

     

       372
       +
       # Remove association  

     

       373
       +
       thicket zulip-remove alice myorg.zulipchat.com alice@example.com

     

       374
       +
       

     

       375
       +
       # List associations

     

       376
       +
       thicket zulip-list           # All users

     

       377
       +
       thicket zulip-list alice     # Specific user

     

       378
       +
       

     

       379
       +
       # Bulk import from CSV

     

       380
       +
       thicket zulip-import associations.csv

     

       381
       +
       ```

     

       382
       +
       

     

       383
       +
       ### Bot Behavior

     

       384
       +
       

     

       385
       +
       When the Thicket Zulip bot posts articles:

     

       386
       +
       

     

       387
       +
       1. It checks for Zulip associations matching the current server

     

       388
       +
       2. If found, adds @mention to the post: `@**alice** posted:`

     

       389
       +
       3. The mentioned user receives a notification in Zulip

     

       390
       +
       

     

       391
       +
       This enables automatic notifications when someone's blog post is shared.

     

       392
       +
       

     

       393
       +
       ## Versioning and Compatibility

     

       394
       +
       

     

       395
       +
       This specification describes version 1.1 of the Thicket Git store format. Changes from 1.0:

     

       396
       +
       - Added `zulip_associations` field to UserMetadata (backwards compatible - defaults to empty list)

     

       397
       +
       

     

       398
       +
       Future versions will maintain backward compatibility where possible, with migration tools provided for breaking changes.

     

       399
       +
       

     

       400
       +
       To check the store format version, examine the repository structure and JSON schemas. Stores created by Thicket 0.1.0+ follow this specification.

+97

bot-config/README.md

···

       1
       +
       # Thicket Bot Configuration

     

       2
       +
       

     

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

     

       4
       +
       

     

       5
       +
       ## Setup Instructions

     

       6
       +
       

     

       7
       +
       ### 1. Zulip Bot Configuration

     

       8
       +
       

     

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

     

       10
       +
          ```bash

     

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

     

       12
       +
          ```

     

       13
       +
       

     

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

     

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

     

       16
       +
          - Choose "Generic bot" type

     

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

     

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

     

       19
       +
       

     

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

     

       21
       +
          ```ini

     

       22
       +
          [api]

     

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

     

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

     

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

     

       26
       +
          ```

     

       27
       +
       

     

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

     

       29
       +
       

     

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

     

       31
       +
          ```bash

     

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

     

       33
       +
          ```

     

       34
       +
       

     

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

     

       36
       +
          - Sync intervals and batch sizes

     

       37
       +
          - Default stream/topic settings

     

       38
       +
          - Rate limiting parameters

     

       39
       +
          - Notification preferences

     

       40
       +
       

     

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

     

       42
       +
       

     

       43
       +
       ## File Descriptions

     

       44
       +
       

     

       45
       +
       ### `zuliprc` (Required)

     

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

     

       47
       +
       

     

       48
       +
       ### `botrc` (Optional)

     

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

     

       50
       +
       

     

       51
       +
       ### Template Files

     

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

     

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

     

       54
       +
       

     

       55
       +
       ## Running the Bot

     

       56
       +
       

     

       57
       +
       Once configured, run the bot with:

     

       58
       +
       

     

       59
       +
       ```bash

     

       60
       +
       # Run in foreground

     

       61
       +
       thicket bot run

     

       62
       +
       

     

       63
       +
       # Run in background (daemon mode)

     

       64
       +
       thicket bot run --daemon

     

       65
       +
       

     

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

     

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

     

       68
       +
       

     

       69
       +
       # Custom config paths

     

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

     

       71
       +
       ```

     

       72
       +
       

     

       73
       +
       ## Bot Commands

     

       74
       +
       

     

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

     

       76
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       83
       +
       

     

       84
       +
       ## Security Notes

     

       85
       +
       

     

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

     

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

     

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

     

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

     

       90
       +
       

     

       91
       +
       ## Troubleshooting

     

       92
       +
       

     

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

     

       94
       +
       - View bot logs when running in foreground mode

     

       95
       +
       - Verify Zulip credentials are correct

     

       96
       +
       - Ensure thicket.yaml configuration exists

     

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

+28

bot-config/botrc

···

       1
       +
       [bot]

     

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

     

       3
       +
       sync_interval = 300

     

       4
       +
       

     

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

     

       6
       +
       max_entries_per_sync = 10

     

       7
       +
       

     

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

     

       9
       +
       # Leave empty to require configuration via chat

     

       10
       +
       default_stream = 

     

       11
       +
       default_topic = 

     

       12
       +
       

     

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

     

       14
       +
       rate_limit_delay = 5

     

       15
       +
       

     

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

     

       17
       +
       posts_per_batch = 5

     

       18
       +
       

     

       19
       +
       [catchup]

     

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

     

       21
       +
       catchup_entries = 5

     

       22
       +
       

     

       23
       +
       [notifications]

     

       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       +
       config_change_notifications = true

     

       26
       +
       

     

       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       +
       username_claim_notifications = true

+34

bot-config/botrc.template

···

       1
       +
       [bot]

     

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

     

       3
       +
       sync_interval = 300

     

       4
       +
       

     

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

     

       6
       +
       max_entries_per_sync = 10

     

       7
       +
       

     

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

     

       9
       +
       # Leave empty to require configuration via chat

     

       10
       +
       default_stream = 

     

       11
       +
       default_topic = 

     

       12
       +
       

     

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

     

       14
       +
       rate_limit_delay = 5

     

       15
       +
       

     

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

     

       17
       +
       posts_per_batch = 5

     

       18
       +
       

     

       19
       +
       [catchup]

     

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

     

       21
       +
       catchup_entries = 5

     

       22
       +
       

     

       23
       +
       [notifications]

     

       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       +
       config_change_notifications = true

     

       26
       +
       

     

       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       +
       username_claim_notifications = true

     

       29
       +
       

     

       30
       +
       # Instructions:

     

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

     

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

     

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

     

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

+16

bot-config/zuliprc.template

···

       1
       +
       [api]

     

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

     

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

     

       4
       +
       

     

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

     

       6
       +
       key=YOUR_BOT_API_KEY_HERE

     

       7
       +
       

     

       8
       +
       # Your Zulip server URL

     

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

     

       10
       +
       

     

       11
       +
       # Instructions:

     

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

     

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

     

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

     

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

     

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

pyproject.toml

···

       41
        
           "pyyaml>=6.0.0",

     

       42
        
           "email_validator",

     

       43
        
           "typesense>=1.1.1",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       44
        
       ]

     

       45
        
       

     

       46
        
       [project.optional-dependencies]

···

       41
        
           "pyyaml>=6.0.0",

     

       42
        
           "email_validator",

     

       43
        
           "typesense>=1.1.1",

     

       44
       +
           "zulip>=0.9.0",

     

       45
       +
           "zulip-bots>=0.9.0",

     

       46
       +
           "importlib-metadata>=8.7.0",

     

       47
       +
           "markdownify>=1.2.0",

     

       48
        
       ]

     

       49
        
       

     

       50
        
       [project.optional-dependencies]

src/thicket/bots/__init__.py

···

       1
       +
       """Zulip bot integration for thicket."""

     

       2
       +
       

     

       3
       +
       from .thicket_bot import ThicketBotHandler

     

       4
       +
       

     

       5
       +
       __all__ = ["ThicketBotHandler"]

src/thicket/bots/requirements.txt

···

       1
       +
       # Requirements for Thicket Zulip bot

     

       2
       +
       # These are already included in the main thicket package

     

       3
       +
       pydantic>=2.11.0

     

       4
       +
       GitPython>=3.1.40

     

       5
       +
       feedparser>=6.0.11

     

       6
       +
       httpx>=0.28.0

     

       7
       +
       pyyaml>=6.0.0

+201

src/thicket/bots/test_bot.py

···

       1
       +
       """Test utilities for the Thicket Zulip bot."""

     

       2
       +
       

     

       3
       +
       import json

     

       4
       +
       from pathlib import Path

     

       5
       +
       from typing import Any, Optional

     

       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,

     

       84
       +
               "sender_full_name": sender,

     

       85
       +
               "sender_id": sender_id,

     

       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,

     

       106
       +
               link=HttpUrl(link),

     

       107
       +
               updated=datetime(2024, 1, 20, 12, 0, 0),

     

       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"

     

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

     

       174
       +
               assert content is not None, "No response received"

     

       175
       +
               assert text in content, f"Response does not contain '{text}': {content}"

     

       176
       +
       

     

       177
       +
       

     

       178
       +
       # Example usage for testing

     

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

+1257

src/thicket/bots/thicket_bot.py

···

       1
       +
       """Zulip bot for automatically posting thicket feed updates."""

     

       2
       +
       

     

       3
       +
       import asyncio

     

       4
       +
       import json

     

       5
       +
       import logging

     

       6
       +
       import os

     

       7
       +
       import time

     

       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

     

       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

     

       29
       +
       

     

       30
       +
       

     

       31
       +
       class ThicketBotHandler:

     

       32
       +
           """Zulip bot that monitors thicket feeds and posts new articles."""

     

       33
       +
       

     

       34
       +
           def __init__(self) -> None:

     

       35
       +
               """Initialize the thicket bot."""

     

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

     

       164
       +
       

     

       165
       +
           def _is_mentioned(self, content: str, bot_handler: BotHandler) -> bool:

     

       166
       +
               """Check if the bot is mentioned in the message."""

     

       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
       +
       

     

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

     

       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:

     

       515
       +
               """Load bot configuration from persistent storage."""

     

       516
       +
               try:

     

       517
       +
                   config_data = bot_handler.storage.get("bot_config")

     

       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
       +
       

     

       529
       +
           def _save_bot_config(self, bot_handler: BotHandler) -> None:

     

       530
       +
               """Save bot configuration to persistent storage."""

     

       531
       +
               try:

     

       532
       +
                   config_data = {

     

       533
       +
                       "stream_name": self.stream_name,

     

       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

     

       746
       +
       

     

       747
       +
           def _load_posted_entries(self, bot_handler: BotHandler) -> None:

     

       748
       +
               """Load the set of already posted entries."""

     

       749
       +
               try:

     

       750
       +
                   posted_data = bot_handler.storage.get("posted_entries")

     

       751
       +
                   if posted_data:

     

       752
       +
                       self.posted_entries = set(json.loads(posted_data))

     

       753
       +
               except Exception:

     

       754
       +
                   # Empty set on first run is expected

     

       755
       +
                   self.posted_entries = set()

     

       756
       +
       

     

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

     

       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:

     

       828
       +
                       try:

     

       829
       +
                           # Run async sync function

     

       830
       +
                           loop = asyncio.new_event_loop()

     

       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:

     

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

     

       913
       +
                       if user:

     

       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
       +
       

     

       1044
       +
           def _process_html_content(self, html_content: str) -> str:

     

       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, duplicates, info_cmd, init, list_cmd, search, sync, upload

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       

     

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

     

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

+247

src/thicket/cli/commands/bot.py

···

       1
       +
       """Bot management commands for thicket."""

     

       2
       +
       

     

       3
       +
       import subprocess

     

       4
       +
       import sys

     

       5
       +
       from pathlib import Path

     

       6
       +
       

     

       7
       +
       import typer

     

       8
       +
       from rich.console import Console

     

       9
       +
       

     

       10
       +
       from ..main import app

     

       11
       +
       from ..utils import print_error, print_info, print_success

     

       12
       +
       

     

       13
       +
       console = Console()

     

       14
       +
       

     

       15
       +
       

     

       16
       +
       @app.command()

     

       17
       +
       def bot(

     

       18
       +
           action: str = typer.Argument(..., help="Action: run, test, or status"),

     

       19
       +
           config_file: Path = typer.Option(

     

       20
       +
               Path("bot-config/zuliprc"),

     

       21
       +
               "--config",

     

       22
       +
               "-c",

     

       23
       +
               help="Zulip bot configuration file",

     

       24
       +
           ),

     

       25
       +
           thicket_config: Path = typer.Option(

     

       26
       +
               Path("thicket.yaml"),

     

       27
       +
               "--thicket-config",

     

       28
       +
               help="Path to thicket configuration file",

     

       29
       +
           ),

     

       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(

     

       37
       +
               None,

     

       38
       +
               "--debug-user",

     

       39
       +
               help="Debug mode: send DMs to this thicket username instead of posting to streams",

     

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

     

       53
       +
               _test_bot()

     

       54
       +
           elif action == "status":

     

       55
       +
               _bot_status(config_file)

     

       56
       +
           else:

     

       57
       +
               print_error(f"Unknown action: {action}")

     

       58
       +
               print_info("Available actions: run, test, status")

     

       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(

     

       126
       +
                       cmd,

     

       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
       +
       

     

       143
       +
       

     

       144
       +
       def _parse_zulip_config(config_file: Path) -> str:

     

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

     

       155
       +
                   return 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 ""

     

       163
       +
       

     

       164
       +
       

     

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

+268

src/thicket/cli/commands/zulip.py

···

       1
       +
       """Zulip association management commands for thicket."""

     

       2
       +
       

     

       3
       +
       from pathlib import Path

     

       4
       +
       from typing import Optional

     

       5
       +
       

     

       6
       +
       import typer

     

       7
       +
       from rich.console import Console

     

       8
       +
       from rich.table import Table

     

       9
       +
       

     

       10
       +
       from ...core.git_store import GitStore

     

       11
       +
       from ..main import app

     

       12
       +
       from ..utils import load_config, print_error, print_info, print_success

     

       13
       +
       

     

       14
       +
       console = Console()

     

       15
       +
       

     

       16
       +
       

     

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

     

       26
       +
               "--config",

     

       27
       +
               "-c",

     

       28
       +
               help="Path to thicket configuration file",

     

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

     

       62
       +
       def zulip_remove(

     

       63
       +
           username: str = typer.Argument(..., help="Username to remove association from"),

     

       64
       +
           server: str = typer.Argument(..., help="Zulip server"),

     

       65
       +
           user_id: str = typer.Argument(..., help="Zulip user ID or email"),

     

       66
       +
           config_file: Path = typer.Option(

     

       67
       +
               Path("thicket.yaml"),

     

       68
       +
               "--config",

     

       69
       +
               "-c",

     

       70
       +
               help="Path to thicket configuration file",

     

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

     

       111
       +
               "-c",

     

       112
       +
               help="Path to thicket configuration file",

     

       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

     

       122
       +
           """

     

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

     

       168
       +
       def zulip_import(

     

       169
       +
           csv_file: Path = typer.Argument(..., help="CSV file with username,server,user_id"),

     

       170
       +
           config_file: Path = typer.Option(

     

       171
       +
               Path("thicket.yaml"),

     

       172
       +
               "--config",

     

       173
       +
               "-c",

     

       174
       +
               help="Path to thicket configuration file",

     

       175
       +
           ),

     

       176
       +
           dry_run: bool = typer.Option(

     

       177
       +
               False,

     

       178
       +
               "--dry-run",

     

       179
       +
               help="Show what would be imported without making changes",

     

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

     

       240
       +
                               added += 1

     

       241
       +
                       else:

     

       242
       +
                           # Actually add association

     

       243
       +
                           if git_store.add_zulip_association(username, server, user_id):

     

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

+62

src/thicket/core/git_store.py

···

       152
        
       

     

       153
        
               return True

     

       154
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       155
        
           def store_entry(self, username: str, entry: AtomEntry) -> bool:

     

       156
        
               """Store an entry in the user's directory."""

     

       157
        
               user = self.get_user(username)

     
···

       335
        
               results.sort(key=lambda x: x[1].updated, reverse=True)

     

       336
        
       

     

       337
        
               return results[:limit] if limit else results

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       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)

     

       190
       +
               if user:

     

       191
       +
                   return user.zulip_associations

     

       192
       +
               return []

     

       193
       +
       

     

       194
        
           def store_entry(self, username: str, entry: AtomEntry) -> bool:

     

       195
        
               """Store an entry in the user's directory."""

     

       196
        
               user = self.get_user(username)

     
···

       374
        
               results.sort(key=lambda x: x[1].updated, reverse=True)

     

       375
        
       

     

       376
        
               return results[:limit] if limit else results

     

       377
       +
       

     

       378
       +
           def list_users(self) -> list[str]:

     

       379
       +
               """Get list of all usernames in the git store."""

     

       380
       +
               index = self._load_index()

     

       381
       +
               return list(index.users.keys())

     

       382
       +
       

     

       383
       +
           def get_user_feeds(self, username: str) -> list[str]:

     

       384
       +
               """Get list of feed URLs for a specific user from their metadata."""

     

       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
       +
       

     

       392
       +
           def list_all_users_with_feeds(self) -> list[tuple[str, list[str]]]:

     

       393
       +
               """Get all users and their feed URLs."""

     

       394
       +
               result = []

     

       395
       +
               for username in self.list_users():

     

       396
       +
                   feeds = self.get_user_feeds(username)

     

       397
       +
                   if feeds:  # Only include users that have feeds configured

     

       398
       +
                       result.append((username, feeds))

     

       399
       +
               return result

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

+2 -1

src/thicket/models/__init__.py

···

       2
        
       

     

       3
        
       from .config import ThicketConfig, UserConfig

     

       4
        
       from .feed import AtomEntry, DuplicateMap, FeedMetadata

     

       5
       -
       from .user import GitStoreIndex, UserMetadata

     

       6
        
       

     

       7
        
       __all__ = [

     

       8
        
           "ThicketConfig",

     
···

       12
        
           "FeedMetadata",

     

       13
        
           "GitStoreIndex",

     

       14
        
           "UserMetadata",

     

       0
        
       
     

       15
        
       ]

···

       2
        
       

     

       3
        
       from .config import ThicketConfig, UserConfig

     

       4
        
       from .feed import AtomEntry, DuplicateMap, FeedMetadata

     

       5
       +
       from .user import GitStoreIndex, UserMetadata, ZulipAssociation

     

       6
        
       

     

       7
        
       __all__ = [

     

       8
        
           "ThicketConfig",

     
···

       12
        
           "FeedMetadata",

     

       13
        
           "GitStoreIndex",

     

       14
        
           "UserMetadata",

     

       15
       +
           "ZulipAssociation",

     

       16
        
       ]

+40 -1

src/thicket/models/user.py

···

       3
        
       from datetime import datetime

     

       4
        
       from typing import Optional

     

       5
        
       

     

       6
       -
       from pydantic import BaseModel, ConfigDict

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
       

     

       8
        
       

     

       9
        
       class UserMetadata(BaseModel):

     
···

       20
        
           homepage: Optional[str] = None

     

       21
        
           icon: Optional[str] = None

     

       22
        
           feeds: list[str] = []

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
           directory: str  # Directory name in Git store

     

       24
        
           created: datetime

     

       25
        
           last_updated: datetime

     
···

       33
        
               """Increment the entry count by the given amount."""

     

       34
        
               self.entry_count += count

     

       35
        
               self.update_timestamp()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36
        
       

     

       37
        
       

     

       38
        
       class GitStoreIndex(BaseModel):

···

       3
        
       from datetime import datetime

     

       4
        
       from typing import Optional

     

       5
        
       

     

       6
       +
       from pydantic import BaseModel, ConfigDict, Field

     

       7
       +
       

     

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

     

       18
        
       

     

       19
        
       

     

       20
        
       class UserMetadata(BaseModel):

     
···

       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)

     

       54
       +
               if association not in self.zulip_associations:

     

       55
       +
                   self.zulip_associations.append(association)

     

       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)

     

       63
       +
               if association in self.zulip_associations:

     

       64
       +
                   self.zulip_associations.remove(association)

     

       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:

     

       72
       +
                   if association.server == server:

     

       73
       +
                       return association.user_id

     

       74
       +
               return None

     

       75
        
       

     

       76
        
       

     

       77
        
       class GitStoreIndex(BaseModel):

+297

tests/test_bot.py

···

       1
       +
       """Tests for the Thicket Zulip bot."""

     

       2
       +
       

     

       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
       +
       

     

       14
       +
       class TestThicketBot:

     

       15
       +
           """Test suite for ThicketBotHandler."""

     

       16
       +
       

     

       17
       +
           def setup_method(self) -> None:

     

       18
       +
               """Set up test environment."""

     

       19
       +
               self.bot = ThicketBotHandler()

     

       20
       +
               self.handler = MockBotHandler()

     

       21
       +
       

     

       22
       +
           def test_usage(self) -> None:

     

       23
       +
               """Test bot usage message."""

     

       24
       +
               usage = self.bot.usage()

     

       25
       +
               assert "Thicket Feed Bot" in usage

     

       26
       +
               assert "@thicket status" in usage

     

       27
       +
               assert "@thicket config" in usage

     

       28
       +
       

     

       29
       +
           def test_help_command(self) -> None:

     

       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

     

       37
       +
       

     

       38
       +
           def test_status_command_unconfigured(self) -> None:

     

       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

     

       46
       +
               assert "Stream:" in response

     

       47
       +
               assert "Topic:" in response

     

       48
       +
       

     

       49
       +
           def test_config_stream_command(self) -> None:

     

       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

     

       57
       +
               assert self.bot.stream_name == "general"

     

       58
       +
       

     

       59
       +
           def test_config_topic_command(self) -> None:

     

       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

     

       67
       +
               assert self.bot.topic_name == "'Feed Updates'"

     

       68
       +
       

     

       69
       +
           def test_config_interval_command(self) -> None:

     

       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

     

       77
       +
               assert self.bot.sync_interval == 600

     

       78
       +
       

     

       79
       +
           def test_config_interval_too_small(self) -> None:

     

       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

     

       87
       +
               assert self.bot.sync_interval != 30

     

       88
       +
       

     

       89
       +
           def test_config_path_nonexistent(self) -> None:

     

       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

     

       97
       +
       

     

       98
       +
           def test_unknown_command(self) -> None:

     

       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

     

       106
       +
       

     

       107
       +
           def test_config_persistence(self) -> None:

     

       108
       +
               """Test that configuration is persisted."""

     

       109
       +
               # Set some config

     

       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"

     

       124
       +
               assert new_bot.sync_interval == 600

     

       125
       +
       

     

       126
       +
           def test_posted_entries_persistence(self) -> None:

     

       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
       +
       

     

       141
       +
           def test_mention_detection(self) -> None:

     

       142
       +
               """Test bot mention detection."""

     

       143
       +
               assert self.bot._is_mentioned("@Thicket Bot help", self.handler)

     

       144
       +
               assert self.bot._is_mentioned("@thicket status", self.handler)

     

       145
       +
               assert not self.bot._is_mentioned("regular message", self.handler)

     

       146
       +
       

     

       147
       +
           def test_mention_cleaning(self) -> None:

     

       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
       +
       

     

       155
       +
           def test_sync_now_uninitialized(self) -> None:

     

       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
       +
       

     

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

     

       256
       +
               assert "DEBUG:" in message["content"]

     

       257
       +
               assert entry.title in message["content"]

     

       258
       +
               assert "@**author.user** posted:" in message["content"]

     

       259
       +
       

     

       260
       +
       

     

       261
       +
       class TestBotTester:

     

       262
       +
           """Test the bot testing utilities."""

     

       263
       +
       

     

       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

     

       271
       +
               assert "Thicket Feed Bot" in tester.get_last_response_content()

     

       272
       +
       

     

       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
        
                   )

+88 -4

tests/test_models.py

···

       12
        
           ThicketConfig,

     

       13
        
           UserConfig,

     

       14
        
           UserMetadata,

     

       0
        
       
     

       15
        
       )

     

       16
        
       

     

       17
        
       

     
···

       126
        
                   git_store=temp_dir / "git_store",

     

       127
        
                   cache_dir=temp_dir / "cache",

     

       128
        
                   users=[

     

       129
       -
                       UserConfig(username="testuser", feeds=["https://example.com/feed1.xml"]),

     

       0
        
       
     

       0
        
       
     

       130
        
                   ],

     

       131
        
               )

     

       132
        
       

     

       133
       -
               result = config.add_feed_to_user("testuser", HttpUrl("https://example.com/feed2.xml"))

     

       0
        
       
     

       0
        
       
     

       134
        
               assert result is True

     

       135
        
       

     

       136
        
               user = config.find_user("testuser")

     
···

       138
        
               assert HttpUrl("https://example.com/feed2.xml") in user.feeds

     

       139
        
       

     

       140
        
               # Test adding to non-existent user

     

       141
       -
               result = config.add_feed_to_user("nonexistent", HttpUrl("https://example.com/feed.xml"))

     

       0
        
       
     

       0
        
       
     

       142
        
               assert result is False

     

       143
        
       

     

       144
        
       

     
···

       293
        
               user_config = metadata.to_user_config("testuser", feed_url)

     

       294
        
       

     

       295
        
               assert user_config.display_name == "Test Feed"  # Falls back to title

     

       296
       -
               assert user_config.homepage == HttpUrl("https://example.com")  # Falls back to link

     

       0
        
       
     

       0
        
       
     

       297
        
               assert user_config.icon == HttpUrl("https://example.com/icon.png")

     

       298
        
               assert user_config.email is None

     

       299
        
       

     
···

       350
        
       

     

       351
        
               assert metadata.entry_count == original_count + 3

     

       352
        
               assert metadata.last_updated > original_time

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       12
        
           ThicketConfig,

     

       13
        
           UserConfig,

     

       14
        
           UserMetadata,

     

       15
       +
           ZulipAssociation,

     

       16
        
       )

     

       17
        
       

     

       18
        
       

     
···

       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(

     

       366
       +
                   username="testuser",

     

       367
       +
                   directory="testuser",

     

       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

     

       407
       +
               assert len(metadata.zulip_associations) == 1

     

       408
       +
       

     

       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"

     

       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
       +
       

     

       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

+219

uv.lock

···

       31
        
       ]

     

       32
        
       

     

       33
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
       name = "black"

     

       35
        
       version = "25.1.0"

     

       36
        
       source = { registry = "https://pypi.org/simple" }

     
···

       284
        
       ]

     

       285
        
       

     

       286
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       287
        
       name = "dnspython"

     

       288
        
       version = "2.7.0"

     

       289
        
       source = { registry = "https://pypi.org/simple" }

     
···

       363
        
       ]

     

       364
        
       

     

       365
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       366
        
       name = "httpcore"

     

       367
        
       version = "1.0.9"

     

       368
        
       source = { registry = "https://pypi.org/simple" }

     
···

       400
        
       ]

     

       401
        
       

     

       402
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       403
        
       name = "iniconfig"

     

       404
        
       version = "2.1.0"

     

       405
        
       source = { registry = "https://pypi.org/simple" }

     
···

       409
        
       ]

     

       410
        
       

     

       411
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       412
        
       name = "markdown-it-py"

     

       413
        
       version = "3.0.0"

     

       414
        
       source = { registry = "https://pypi.org/simple" }

     
···

       418
        
       sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }

     

       419
        
       wheels = [

     

       420
        
           { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       421
        
       ]

     

       422
        
       

     

       423
        
       [[package]]

     
···

       574
        
           { url = "https://files.pythonhosted.org/packages/0b/c7/d3654a790129684d0e8dc04707cb6d75633d7b102a962c6dc0f862c64c25/pendulum-3.1.0-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e4cbd933a40c915ed5c41b083115cca15c7afa8179363b2a61db167c64fa0670", size = 526685, upload-time = "2025-04-19T14:02:31.523Z" },

     

       575
        
           { url = "https://files.pythonhosted.org/packages/50/d9/4a166256386b7973e36ff44135e8d009f4afb25d6c72df5380ccfd6fbb89/pendulum-3.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3363a470b5d67dbf8d9fd1bf77dcdbf720788bc3be4a10bdcd28ae5d7dbd26c4", size = 261170, upload-time = "2025-04-19T14:02:33.099Z" },

     

       576
        
           { url = "https://files.pythonhosted.org/packages/6e/23/e98758924d1b3aac11a626268eabf7f3cf177e7837c28d47bf84c64532d0/pendulum-3.1.0-py3-none-any.whl", hash = "sha256:f9178c2a8e291758ade1e8dd6371b1d26d08371b4c7730a6e9a3ef8b16ebae0f", size = 111799, upload-time = "2025-04-19T14:02:34.739Z" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       577
        
       ]

     

       578
        
       

     

       579
        
       [[package]]

     
···

       957
        
       ]

     

       958
        
       

     

       959
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       960
        
       name = "thicket"

     

       961
        
       source = { editable = "." }

     

       962
        
       dependencies = [

     
···

       965
        
           { name = "feedparser" },

     

       966
        
           { name = "gitpython" },

     

       967
        
           { name = "httpx" },

     

       0
        
       
     

       0
        
       
     

       968
        
           { name = "pendulum" },

     

       969
        
           { name = "platformdirs" },

     

       970
        
           { name = "pydantic" },

     
···

       973
        
           { name = "rich" },

     

       974
        
           { name = "typer" },

     

       975
        
           { name = "typesense" },

     

       0
        
       
     

       0
        
       
     

       976
        
       ]

     

       977
        
       

     

       978
        
       [package.optional-dependencies]

     
···

       1000
        
           { name = "feedparser", specifier = ">=6.0.11" },

     

       1001
        
           { name = "gitpython", specifier = ">=3.1.40" },

     

       1002
        
           { name = "httpx", specifier = ">=0.28.0" },

     

       0
        
       
     

       0
        
       
     

       1003
        
           { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13.0" },

     

       1004
        
           { name = "pendulum", specifier = ">=3.0.0" },

     

       1005
        
           { name = "platformdirs", specifier = ">=4.0.0" },

     
···

       1014
        
           { name = "typer", specifier = ">=0.15.0" },

     

       1015
        
           { name = "types-pyyaml", marker = "extra == 'dev'", specifier = ">=6.0.0" },

     

       1016
        
           { name = "typesense", specifier = ">=1.1.1" },

     

       0
        
       
     

       0
        
       
     

       1017
        
       ]

     

       1018
        
       provides-extras = ["dev"]

     

       1019
        
       

     
···

       1146
        
       wheels = [

     

       1147
        
           { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" },

     

       1148
        
       ]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       31
        
       ]

     

       32
        
       

     

       33
        
       [[package]]

     

       34
       +
       name = "beautifulsoup4"

     

       35
       +
       version = "4.13.4"

     

       36
       +
       source = { registry = "https://pypi.org/simple" }

     

       37
       +
       dependencies = [

     

       38
       +
           { name = "soupsieve" },

     

       39
       +
           { name = "typing-extensions" },

     

       40
       +
       ]

     

       41
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d8/e4/0c4c39e18fd76d6a628d4dd8da40543d136ce2d1752bd6eeeab0791f4d6b/beautifulsoup4-4.13.4.tar.gz", hash = "sha256:dbb3c4e1ceae6aefebdaf2423247260cd062430a410e38c66f2baa50a8437195", size = 621067, upload-time = "2025-04-15T17:05:13.836Z" }

     

       42
       +
       wheels = [

     

       43
       +
           { url = "https://files.pythonhosted.org/packages/50/cd/30110dc0ffcf3b131156077b90e9f60ed75711223f306da4db08eff8403b/beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b", size = 187285, upload-time = "2025-04-15T17:05:12.221Z" },

     

       44
       +
       ]

     

       45
       +
       

     

       46
       +
       [[package]]

     

       47
        
       name = "black"

     

       48
        
       version = "25.1.0"

     

       49
        
       source = { registry = "https://pypi.org/simple" }

     
···

       297
        
       ]

     

       298
        
       

     

       299
        
       [[package]]

     

       300
       +
       name = "distro"

     

       301
       +
       version = "1.9.0"

     

       302
       +
       source = { registry = "https://pypi.org/simple" }

     

       303
       +
       sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }

     

       304
       +
       wheels = [

     

       305
       +
           { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },

     

       306
       +
       ]

     

       307
       +
       

     

       308
       +
       [[package]]

     

       309
        
       name = "dnspython"

     

       310
        
       version = "2.7.0"

     

       311
        
       source = { registry = "https://pypi.org/simple" }

     
···

       385
        
       ]

     

       386
        
       

     

       387
        
       [[package]]

     

       388
       +
       name = "html2text"

     

       389
       +
       version = "2025.4.15"

     

       390
       +
       source = { registry = "https://pypi.org/simple" }

     

       391
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f8/27/e158d86ba1e82967cc2f790b0cb02030d4a8bef58e0c79a8590e9678107f/html2text-2025.4.15.tar.gz", hash = "sha256:948a645f8f0bc3abe7fd587019a2197a12436cd73d0d4908af95bfc8da337588", size = 64316, upload-time = "2025-04-15T04:02:30.045Z" }

     

       392
       +
       wheels = [

     

       393
       +
           { url = "https://files.pythonhosted.org/packages/1d/84/1a0f9555fd5f2b1c924ff932d99b40a0f8a6b12f6dd625e2a47f415b00ea/html2text-2025.4.15-py3-none-any.whl", hash = "sha256:00569167ffdab3d7767a4cdf589b7f57e777a5ed28d12907d8c58769ec734acc", size = 34656, upload-time = "2025-04-15T04:02:28.44Z" },

     

       394
       +
       ]

     

       395
       +
       

     

       396
       +
       [[package]]

     

       397
        
       name = "httpcore"

     

       398
        
       version = "1.0.9"

     

       399
        
       source = { registry = "https://pypi.org/simple" }

     
···

       431
        
       ]

     

       432
        
       

     

       433
        
       [[package]]

     

       434
       +
       name = "importlib-metadata"

     

       435
       +
       version = "8.7.0"

     

       436
       +
       source = { registry = "https://pypi.org/simple" }

     

       437
       +
       dependencies = [

     

       438
       +
           { name = "zipp" },

     

       439
       +
       ]

     

       440
       +
       sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }

     

       441
       +
       wheels = [

     

       442
       +
           { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },

     

       443
       +
       ]

     

       444
       +
       

     

       445
       +
       [[package]]

     

       446
        
       name = "iniconfig"

     

       447
        
       version = "2.1.0"

     

       448
        
       source = { registry = "https://pypi.org/simple" }

     
···

       452
        
       ]

     

       453
        
       

     

       454
        
       [[package]]

     

       455
       +
       name = "lxml"

     

       456
       +
       version = "6.0.0"

     

       457
       +
       source = { registry = "https://pypi.org/simple" }

     

       458
       +
       sdist = { url = "https://files.pythonhosted.org/packages/c5/ed/60eb6fa2923602fba988d9ca7c5cdbd7cf25faa795162ed538b527a35411/lxml-6.0.0.tar.gz", hash = "sha256:032e65120339d44cdc3efc326c9f660f5f7205f3a535c1fdbf898b29ea01fb72", size = 4096938, upload-time = "2025-06-26T16:28:19.373Z" }

     

       459
       +
       wheels = [

     

       460
       +
           { url = "https://files.pythonhosted.org/packages/4b/e9/9c3ca02fbbb7585116c2e274b354a2d92b5c70561687dd733ec7b2018490/lxml-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:35bc626eec405f745199200ccb5c6b36f202675d204aa29bb52e27ba2b71dea8", size = 8399057, upload-time = "2025-06-26T16:25:02.169Z" },

     

       461
       +
           { url = "https://files.pythonhosted.org/packages/86/25/10a6e9001191854bf283515020f3633b1b1f96fd1b39aa30bf8fff7aa666/lxml-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:246b40f8a4aec341cbbf52617cad8ab7c888d944bfe12a6abd2b1f6cfb6f6082", size = 4569676, upload-time = "2025-06-26T16:25:05.431Z" },

     

       462
       +
           { url = "https://files.pythonhosted.org/packages/f5/a5/378033415ff61d9175c81de23e7ad20a3ffb614df4ffc2ffc86bc6746ffd/lxml-6.0.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2793a627e95d119e9f1e19720730472f5543a6d84c50ea33313ce328d870f2dd", size = 5291361, upload-time = "2025-06-26T16:25:07.901Z" },

     

       463
       +
           { url = "https://files.pythonhosted.org/packages/5a/a6/19c87c4f3b9362b08dc5452a3c3bce528130ac9105fc8fff97ce895ce62e/lxml-6.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:46b9ed911f36bfeb6338e0b482e7fe7c27d362c52fde29f221fddbc9ee2227e7", size = 5008290, upload-time = "2025-06-28T18:47:13.196Z" },

     

       464
       +
           { url = "https://files.pythonhosted.org/packages/09/d1/e9b7ad4b4164d359c4d87ed8c49cb69b443225cb495777e75be0478da5d5/lxml-6.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b4790b558bee331a933e08883c423f65bbcd07e278f91b2272489e31ab1e2b4", size = 5163192, upload-time = "2025-06-28T18:47:17.279Z" },

     

       465
       +
           { url = "https://files.pythonhosted.org/packages/56/d6/b3eba234dc1584744b0b374a7f6c26ceee5dc2147369a7e7526e25a72332/lxml-6.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2030956cf4886b10be9a0285c6802e078ec2391e1dd7ff3eb509c2c95a69b76", size = 5076973, upload-time = "2025-06-26T16:25:10.936Z" },

     

       466
       +
           { url = "https://files.pythonhosted.org/packages/8e/47/897142dd9385dcc1925acec0c4afe14cc16d310ce02c41fcd9010ac5d15d/lxml-6.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d23854ecf381ab1facc8f353dcd9adeddef3652268ee75297c1164c987c11dc", size = 5297795, upload-time = "2025-06-26T16:25:14.282Z" },

     

       467
       +
           { url = "https://files.pythonhosted.org/packages/fb/db/551ad84515c6f415cea70193a0ff11d70210174dc0563219f4ce711655c6/lxml-6.0.0-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:43fe5af2d590bf4691531b1d9a2495d7aab2090547eaacd224a3afec95706d76", size = 4776547, upload-time = "2025-06-26T16:25:17.123Z" },

     

       468
       +
           { url = "https://files.pythonhosted.org/packages/e0/14/c4a77ab4f89aaf35037a03c472f1ccc54147191888626079bd05babd6808/lxml-6.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74e748012f8c19b47f7d6321ac929a9a94ee92ef12bc4298c47e8b7219b26541", size = 5124904, upload-time = "2025-06-26T16:25:19.485Z" },

     

       469
       +
           { url = "https://files.pythonhosted.org/packages/70/b4/12ae6a51b8da106adec6a2e9c60f532350a24ce954622367f39269e509b1/lxml-6.0.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:43cfbb7db02b30ad3926e8fceaef260ba2fb7df787e38fa2df890c1ca7966c3b", size = 4805804, upload-time = "2025-06-26T16:25:21.949Z" },

     

       470
       +
           { url = "https://files.pythonhosted.org/packages/a9/b6/2e82d34d49f6219cdcb6e3e03837ca5fb8b7f86c2f35106fb8610ac7f5b8/lxml-6.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34190a1ec4f1e84af256495436b2d196529c3f2094f0af80202947567fdbf2e7", size = 5323477, upload-time = "2025-06-26T16:25:24.475Z" },

     

       471
       +
           { url = "https://files.pythonhosted.org/packages/a1/e6/b83ddc903b05cd08a5723fefd528eee84b0edd07bdf87f6c53a1fda841fd/lxml-6.0.0-cp310-cp310-win32.whl", hash = "sha256:5967fe415b1920a3877a4195e9a2b779249630ee49ece22021c690320ff07452", size = 3613840, upload-time = "2025-06-26T16:25:27.345Z" },

     

       472
       +
           { url = "https://files.pythonhosted.org/packages/40/af/874fb368dd0c663c030acb92612341005e52e281a102b72a4c96f42942e1/lxml-6.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:f3389924581d9a770c6caa4df4e74b606180869043b9073e2cec324bad6e306e", size = 3993584, upload-time = "2025-06-26T16:25:29.391Z" },

     

       473
       +
           { url = "https://files.pythonhosted.org/packages/4a/f4/d296bc22c17d5607653008f6dd7b46afdfda12efd31021705b507df652bb/lxml-6.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:522fe7abb41309e9543b0d9b8b434f2b630c5fdaf6482bee642b34c8c70079c8", size = 3681400, upload-time = "2025-06-26T16:25:31.421Z" },

     

       474
       +
           { url = "https://files.pythonhosted.org/packages/7c/23/828d4cc7da96c611ec0ce6147bbcea2fdbde023dc995a165afa512399bbf/lxml-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4ee56288d0df919e4aac43b539dd0e34bb55d6a12a6562038e8d6f3ed07f9e36", size = 8438217, upload-time = "2025-06-26T16:25:34.349Z" },

     

       475
       +
           { url = "https://files.pythonhosted.org/packages/f1/33/5ac521212c5bcb097d573145d54b2b4a3c9766cda88af5a0e91f66037c6e/lxml-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b8dd6dd0e9c1992613ccda2bcb74fc9d49159dbe0f0ca4753f37527749885c25", size = 4590317, upload-time = "2025-06-26T16:25:38.103Z" },

     

       476
       +
           { url = "https://files.pythonhosted.org/packages/2b/2e/45b7ca8bee304c07f54933c37afe7dd4d39ff61ba2757f519dcc71bc5d44/lxml-6.0.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:d7ae472f74afcc47320238b5dbfd363aba111a525943c8a34a1b657c6be934c3", size = 5221628, upload-time = "2025-06-26T16:25:40.878Z" },

     

       477
       +
           { url = "https://files.pythonhosted.org/packages/32/23/526d19f7eb2b85da1f62cffb2556f647b049ebe2a5aa8d4d41b1fb2c7d36/lxml-6.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5592401cdf3dc682194727c1ddaa8aa0f3ddc57ca64fd03226a430b955eab6f6", size = 4949429, upload-time = "2025-06-28T18:47:20.046Z" },

     

       478
       +
           { url = "https://files.pythonhosted.org/packages/ac/cc/f6be27a5c656a43a5344e064d9ae004d4dcb1d3c9d4f323c8189ddfe4d13/lxml-6.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58ffd35bd5425c3c3b9692d078bf7ab851441434531a7e517c4984d5634cd65b", size = 5087909, upload-time = "2025-06-28T18:47:22.834Z" },

     

       479
       +
           { url = "https://files.pythonhosted.org/packages/3b/e6/8ec91b5bfbe6972458bc105aeb42088e50e4b23777170404aab5dfb0c62d/lxml-6.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f720a14aa102a38907c6d5030e3d66b3b680c3e6f6bc95473931ea3c00c59967", size = 5031713, upload-time = "2025-06-26T16:25:43.226Z" },

     

       480
       +
           { url = "https://files.pythonhosted.org/packages/33/cf/05e78e613840a40e5be3e40d892c48ad3e475804db23d4bad751b8cadb9b/lxml-6.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c2a5e8d207311a0170aca0eb6b160af91adc29ec121832e4ac151a57743a1e1e", size = 5232417, upload-time = "2025-06-26T16:25:46.111Z" },

     

       481
       +
           { url = "https://files.pythonhosted.org/packages/ac/8c/6b306b3e35c59d5f0b32e3b9b6b3b0739b32c0dc42a295415ba111e76495/lxml-6.0.0-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:2dd1cc3ea7e60bfb31ff32cafe07e24839df573a5e7c2d33304082a5019bcd58", size = 4681443, upload-time = "2025-06-26T16:25:48.837Z" },

     

       482
       +
           { url = "https://files.pythonhosted.org/packages/59/43/0bd96bece5f7eea14b7220476835a60d2b27f8e9ca99c175f37c085cb154/lxml-6.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cfcf84f1defed7e5798ef4f88aa25fcc52d279be731ce904789aa7ccfb7e8d2", size = 5074542, upload-time = "2025-06-26T16:25:51.65Z" },

     

       483
       +
           { url = "https://files.pythonhosted.org/packages/e2/3d/32103036287a8ca012d8518071f8852c68f2b3bfe048cef2a0202eb05910/lxml-6.0.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:a52a4704811e2623b0324a18d41ad4b9fabf43ce5ff99b14e40a520e2190c851", size = 4729471, upload-time = "2025-06-26T16:25:54.571Z" },

     

       484
       +
           { url = "https://files.pythonhosted.org/packages/ca/a8/7be5d17df12d637d81854bd8648cd329f29640a61e9a72a3f77add4a311b/lxml-6.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c16304bba98f48a28ae10e32a8e75c349dd742c45156f297e16eeb1ba9287a1f", size = 5256285, upload-time = "2025-06-26T16:25:56.997Z" },

     

       485
       +
           { url = "https://files.pythonhosted.org/packages/cd/d0/6cb96174c25e0d749932557c8d51d60c6e292c877b46fae616afa23ed31a/lxml-6.0.0-cp311-cp311-win32.whl", hash = "sha256:f8d19565ae3eb956d84da3ef367aa7def14a2735d05bd275cd54c0301f0d0d6c", size = 3612004, upload-time = "2025-06-26T16:25:59.11Z" },

     

       486
       +
           { url = "https://files.pythonhosted.org/packages/ca/77/6ad43b165dfc6dead001410adeb45e88597b25185f4479b7ca3b16a5808f/lxml-6.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b2d71cdefda9424adff9a3607ba5bbfc60ee972d73c21c7e3c19e71037574816", size = 4003470, upload-time = "2025-06-26T16:26:01.655Z" },

     

       487
       +
           { url = "https://files.pythonhosted.org/packages/a0/bc/4c50ec0eb14f932a18efc34fc86ee936a66c0eb5f2fe065744a2da8a68b2/lxml-6.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:8a2e76efbf8772add72d002d67a4c3d0958638696f541734304c7f28217a9cab", size = 3682477, upload-time = "2025-06-26T16:26:03.808Z" },

     

       488
       +
           { url = "https://files.pythonhosted.org/packages/89/c3/d01d735c298d7e0ddcedf6f028bf556577e5ab4f4da45175ecd909c79378/lxml-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78718d8454a6e928470d511bf8ac93f469283a45c354995f7d19e77292f26108", size = 8429515, upload-time = "2025-06-26T16:26:06.776Z" },

     

       489
       +
           { url = "https://files.pythonhosted.org/packages/06/37/0e3eae3043d366b73da55a86274a590bae76dc45aa004b7042e6f97803b1/lxml-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:84ef591495ffd3f9dcabffd6391db7bb70d7230b5c35ef5148354a134f56f2be", size = 4601387, upload-time = "2025-06-26T16:26:09.511Z" },

     

       490
       +
           { url = "https://files.pythonhosted.org/packages/a3/28/e1a9a881e6d6e29dda13d633885d13acb0058f65e95da67841c8dd02b4a8/lxml-6.0.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2930aa001a3776c3e2601cb8e0a15d21b8270528d89cc308be4843ade546b9ab", size = 5228928, upload-time = "2025-06-26T16:26:12.337Z" },

     

       491
       +
           { url = "https://files.pythonhosted.org/packages/9a/55/2cb24ea48aa30c99f805921c1c7860c1f45c0e811e44ee4e6a155668de06/lxml-6.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:219e0431ea8006e15005767f0351e3f7f9143e793e58519dc97fe9e07fae5563", size = 4952289, upload-time = "2025-06-28T18:47:25.602Z" },

     

       492
       +
           { url = "https://files.pythonhosted.org/packages/31/c0/b25d9528df296b9a3306ba21ff982fc5b698c45ab78b94d18c2d6ae71fd9/lxml-6.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bd5913b4972681ffc9718bc2d4c53cde39ef81415e1671ff93e9aa30b46595e7", size = 5111310, upload-time = "2025-06-28T18:47:28.136Z" },

     

       493
       +
           { url = "https://files.pythonhosted.org/packages/e9/af/681a8b3e4f668bea6e6514cbcb297beb6de2b641e70f09d3d78655f4f44c/lxml-6.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:390240baeb9f415a82eefc2e13285016f9c8b5ad71ec80574ae8fa9605093cd7", size = 5025457, upload-time = "2025-06-26T16:26:15.068Z" },

     

       494
       +
           { url = "https://files.pythonhosted.org/packages/99/b6/3a7971aa05b7be7dfebc7ab57262ec527775c2c3c5b2f43675cac0458cad/lxml-6.0.0-cp312-cp312-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d6e200909a119626744dd81bae409fc44134389e03fbf1d68ed2a55a2fb10991", size = 5657016, upload-time = "2025-07-03T19:19:06.008Z" },

     

       495
       +
           { url = "https://files.pythonhosted.org/packages/69/f8/693b1a10a891197143c0673fcce5b75fc69132afa81a36e4568c12c8faba/lxml-6.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca50bd612438258a91b5b3788c6621c1f05c8c478e7951899f492be42defc0da", size = 5257565, upload-time = "2025-06-26T16:26:17.906Z" },

     

       496
       +
           { url = "https://files.pythonhosted.org/packages/a8/96/e08ff98f2c6426c98c8964513c5dab8d6eb81dadcd0af6f0c538ada78d33/lxml-6.0.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:c24b8efd9c0f62bad0439283c2c795ef916c5a6b75f03c17799775c7ae3c0c9e", size = 4713390, upload-time = "2025-06-26T16:26:20.292Z" },

     

       497
       +
           { url = "https://files.pythonhosted.org/packages/a8/83/6184aba6cc94d7413959f6f8f54807dc318fdcd4985c347fe3ea6937f772/lxml-6.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afd27d8629ae94c5d863e32ab0e1d5590371d296b87dae0a751fb22bf3685741", size = 5066103, upload-time = "2025-06-26T16:26:22.765Z" },

     

       498
       +
           { url = "https://files.pythonhosted.org/packages/ee/01/8bf1f4035852d0ff2e36a4d9aacdbcc57e93a6cd35a54e05fa984cdf73ab/lxml-6.0.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:54c4855eabd9fc29707d30141be99e5cd1102e7d2258d2892314cf4c110726c3", size = 4791428, upload-time = "2025-06-26T16:26:26.461Z" },

     

       499
       +
           { url = "https://files.pythonhosted.org/packages/29/31/c0267d03b16954a85ed6b065116b621d37f559553d9339c7dcc4943a76f1/lxml-6.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c907516d49f77f6cd8ead1322198bdfd902003c3c330c77a1c5f3cc32a0e4d16", size = 5678523, upload-time = "2025-07-03T19:19:09.837Z" },

     

       500
       +
           { url = "https://files.pythonhosted.org/packages/5c/f7/5495829a864bc5f8b0798d2b52a807c89966523140f3d6fa3a58ab6720ea/lxml-6.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36531f81c8214e293097cd2b7873f178997dae33d3667caaae8bdfb9666b76c0", size = 5281290, upload-time = "2025-06-26T16:26:29.406Z" },

     

       501
       +
           { url = "https://files.pythonhosted.org/packages/79/56/6b8edb79d9ed294ccc4e881f4db1023af56ba451909b9ce79f2a2cd7c532/lxml-6.0.0-cp312-cp312-win32.whl", hash = "sha256:690b20e3388a7ec98e899fd54c924e50ba6693874aa65ef9cb53de7f7de9d64a", size = 3613495, upload-time = "2025-06-26T16:26:31.588Z" },

     

       502
       +
           { url = "https://files.pythonhosted.org/packages/0b/1e/cc32034b40ad6af80b6fd9b66301fc0f180f300002e5c3eb5a6110a93317/lxml-6.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:310b719b695b3dd442cdfbbe64936b2f2e231bb91d998e99e6f0daf991a3eba3", size = 4014711, upload-time = "2025-06-26T16:26:33.723Z" },

     

       503
       +
           { url = "https://files.pythonhosted.org/packages/55/10/dc8e5290ae4c94bdc1a4c55865be7e1f31dfd857a88b21cbba68b5fea61b/lxml-6.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:8cb26f51c82d77483cdcd2b4a53cda55bbee29b3c2f3ddeb47182a2a9064e4eb", size = 3674431, upload-time = "2025-06-26T16:26:35.959Z" },

     

       504
       +
           { url = "https://files.pythonhosted.org/packages/79/21/6e7c060822a3c954ff085e5e1b94b4a25757c06529eac91e550f3f5cd8b8/lxml-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6da7cd4f405fd7db56e51e96bff0865b9853ae70df0e6720624049da76bde2da", size = 8414372, upload-time = "2025-06-26T16:26:39.079Z" },

     

       505
       +
           { url = "https://files.pythonhosted.org/packages/a4/f6/051b1607a459db670fc3a244fa4f06f101a8adf86cda263d1a56b3a4f9d5/lxml-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b34339898bb556a2351a1830f88f751679f343eabf9cf05841c95b165152c9e7", size = 4593940, upload-time = "2025-06-26T16:26:41.891Z" },

     

       506
       +
           { url = "https://files.pythonhosted.org/packages/8e/74/dd595d92a40bda3c687d70d4487b2c7eff93fd63b568acd64fedd2ba00fe/lxml-6.0.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:51a5e4c61a4541bd1cd3ba74766d0c9b6c12d6a1a4964ef60026832aac8e79b3", size = 5214329, upload-time = "2025-06-26T16:26:44.669Z" },

     

       507
       +
           { url = "https://files.pythonhosted.org/packages/52/46/3572761efc1bd45fcafb44a63b3b0feeb5b3f0066886821e94b0254f9253/lxml-6.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d18a25b19ca7307045581b18b3ec9ead2b1db5ccd8719c291f0cd0a5cec6cb81", size = 4947559, upload-time = "2025-06-28T18:47:31.091Z" },

     

       508
       +
           { url = "https://files.pythonhosted.org/packages/94/8a/5e40de920e67c4f2eef9151097deb9b52d86c95762d8ee238134aff2125d/lxml-6.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d4f0c66df4386b75d2ab1e20a489f30dc7fd9a06a896d64980541506086be1f1", size = 5102143, upload-time = "2025-06-28T18:47:33.612Z" },

     

       509
       +
           { url = "https://files.pythonhosted.org/packages/7c/4b/20555bdd75d57945bdabfbc45fdb1a36a1a0ff9eae4653e951b2b79c9209/lxml-6.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f4b481b6cc3a897adb4279216695150bbe7a44c03daba3c894f49d2037e0a24", size = 5021931, upload-time = "2025-06-26T16:26:47.503Z" },

     

       510
       +
           { url = "https://files.pythonhosted.org/packages/b6/6e/cf03b412f3763d4ca23b25e70c96a74cfece64cec3addf1c4ec639586b13/lxml-6.0.0-cp313-cp313-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a78d6c9168f5bcb20971bf3329c2b83078611fbe1f807baadc64afc70523b3a", size = 5645469, upload-time = "2025-07-03T19:19:13.32Z" },

     

       511
       +
           { url = "https://files.pythonhosted.org/packages/d4/dd/39c8507c16db6031f8c1ddf70ed95dbb0a6d466a40002a3522c128aba472/lxml-6.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae06fbab4f1bb7db4f7c8ca9897dc8db4447d1a2b9bee78474ad403437bcc29", size = 5247467, upload-time = "2025-06-26T16:26:49.998Z" },

     

       512
       +
           { url = "https://files.pythonhosted.org/packages/4d/56/732d49def0631ad633844cfb2664563c830173a98d5efd9b172e89a4800d/lxml-6.0.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:1fa377b827ca2023244a06554c6e7dc6828a10aaf74ca41965c5d8a4925aebb4", size = 4720601, upload-time = "2025-06-26T16:26:52.564Z" },

     

       513
       +
           { url = "https://files.pythonhosted.org/packages/8f/7f/6b956fab95fa73462bca25d1ea7fc8274ddf68fb8e60b78d56c03b65278e/lxml-6.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1676b56d48048a62ef77a250428d1f31f610763636e0784ba67a9740823988ca", size = 5060227, upload-time = "2025-06-26T16:26:55.054Z" },

     

       514
       +
           { url = "https://files.pythonhosted.org/packages/97/06/e851ac2924447e8b15a294855caf3d543424364a143c001014d22c8ca94c/lxml-6.0.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:0e32698462aacc5c1cf6bdfebc9c781821b7e74c79f13e5ffc8bfe27c42b1abf", size = 4790637, upload-time = "2025-06-26T16:26:57.384Z" },

     

       515
       +
           { url = "https://files.pythonhosted.org/packages/06/d4/fd216f3cd6625022c25b336c7570d11f4a43adbaf0a56106d3d496f727a7/lxml-6.0.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4d6036c3a296707357efb375cfc24bb64cd955b9ec731abf11ebb1e40063949f", size = 5662049, upload-time = "2025-07-03T19:19:16.409Z" },

     

       516
       +
           { url = "https://files.pythonhosted.org/packages/52/03/0e764ce00b95e008d76b99d432f1807f3574fb2945b496a17807a1645dbd/lxml-6.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7488a43033c958637b1a08cddc9188eb06d3ad36582cebc7d4815980b47e27ef", size = 5272430, upload-time = "2025-06-26T16:27:00.031Z" },

     

       517
       +
           { url = "https://files.pythonhosted.org/packages/5f/01/d48cc141bc47bc1644d20fe97bbd5e8afb30415ec94f146f2f76d0d9d098/lxml-6.0.0-cp313-cp313-win32.whl", hash = "sha256:5fcd7d3b1d8ecb91445bd71b9c88bdbeae528fefee4f379895becfc72298d181", size = 3612896, upload-time = "2025-06-26T16:27:04.251Z" },

     

       518
       +
           { url = "https://files.pythonhosted.org/packages/f4/87/6456b9541d186ee7d4cb53bf1b9a0d7f3b1068532676940fdd594ac90865/lxml-6.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:2f34687222b78fff795feeb799a7d44eca2477c3d9d3a46ce17d51a4f383e32e", size = 4013132, upload-time = "2025-06-26T16:27:06.415Z" },

     

       519
       +
           { url = "https://files.pythonhosted.org/packages/b7/42/85b3aa8f06ca0d24962f8100f001828e1f1f1a38c954c16e71154ed7d53a/lxml-6.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:21db1ec5525780fd07251636eb5f7acb84003e9382c72c18c542a87c416ade03", size = 3672642, upload-time = "2025-06-26T16:27:09.888Z" },

     

       520
       +
           { url = "https://files.pythonhosted.org/packages/dc/04/a53941fb0d7c60eed08301942c70aa63650a59308d15e05eb823acbce41d/lxml-6.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:85b14a4689d5cff426c12eefe750738648706ea2753b20c2f973b2a000d3d261", size = 8407699, upload-time = "2025-06-26T16:27:28.167Z" },

     

       521
       +
           { url = "https://files.pythonhosted.org/packages/44/d2/e1d4526e903afebe147f858322f1c0b36e44969d5c87e5d243c23f81987f/lxml-6.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f64ccf593916e93b8d36ed55401bb7fe9c7d5de3180ce2e10b08f82a8f397316", size = 4574678, upload-time = "2025-06-26T16:27:30.888Z" },

     

       522
       +
           { url = "https://files.pythonhosted.org/packages/61/aa/b0a8ee233c00f2f437dbb6e7bd2df115a996d8211b7d03f4ab029b8e3378/lxml-6.0.0-cp39-cp39-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:b372d10d17a701b0945f67be58fae4664fd056b85e0ff0fbc1e6c951cdbc0512", size = 5292694, upload-time = "2025-06-26T16:27:34.037Z" },

     

       523
       +
           { url = "https://files.pythonhosted.org/packages/53/7f/e6f377489b2ac4289418b879c34ed664e5a1174b2a91590936ec4174e773/lxml-6.0.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a674c0948789e9136d69065cc28009c1b1874c6ea340253db58be7622ce6398f", size = 5009177, upload-time = "2025-06-28T18:47:39.377Z" },

     

       524
       +
           { url = "https://files.pythonhosted.org/packages/c6/05/ae239e997374680741b768044545251a29abc21ada42248638dbed749a0a/lxml-6.0.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:edf6e4c8fe14dfe316939711e3ece3f9a20760aabf686051b537a7562f4da91a", size = 5163787, upload-time = "2025-06-28T18:47:42.452Z" },

     

       525
       +
           { url = "https://files.pythonhosted.org/packages/2a/da/4f27222570d008fd2386e19d6923af6e64c317ee6116bbb2b98247f98f31/lxml-6.0.0-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:048a930eb4572829604982e39a0c7289ab5dc8abc7fc9f5aabd6fbc08c154e93", size = 5075755, upload-time = "2025-06-26T16:27:36.611Z" },

     

       526
       +
           { url = "https://files.pythonhosted.org/packages/1f/65/12552caf7b3e3b9b9aba12349370dc53a36d4058e4ed482811f1d262deee/lxml-6.0.0-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0b5fa5eda84057a4f1bbb4bb77a8c28ff20ae7ce211588d698ae453e13c6281", size = 5297070, upload-time = "2025-06-26T16:27:39.232Z" },

     

       527
       +
           { url = "https://files.pythonhosted.org/packages/3e/6a/f053a8369fdf4e3b8127a6ffb079c519167e684e956a1281392c5c3679b6/lxml-6.0.0-cp39-cp39-manylinux_2_31_armv7l.whl", hash = "sha256:c352fc8f36f7e9727db17adbf93f82499457b3d7e5511368569b4c5bd155a922", size = 4779864, upload-time = "2025-06-26T16:27:41.713Z" },

     

       528
       +
           { url = "https://files.pythonhosted.org/packages/df/7b/b2a392ad34ce37a17d1cf3aec303e15125768061cf0e355a92d292d20d37/lxml-6.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8db5dc617cb937ae17ff3403c3a70a7de9df4852a046f93e71edaec678f721d0", size = 5122039, upload-time = "2025-06-26T16:27:44.252Z" },

     

       529
       +
           { url = "https://files.pythonhosted.org/packages/80/0e/6459ff8ae7d87188e1f99f11691d0f32831caa6429599c3b289de9f08b21/lxml-6.0.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:2181e4b1d07dde53986023482673c0f1fba5178ef800f9ab95ad791e8bdded6a", size = 4805117, upload-time = "2025-06-26T16:27:46.769Z" },

     

       530
       +
           { url = "https://files.pythonhosted.org/packages/ca/78/4186f573805ff623d28a8736788a3b29eeaf589afdcf0233de2c9bb9fc50/lxml-6.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b3c98d5b24c6095e89e03d65d5c574705be3d49c0d8ca10c17a8a4b5201b72f5", size = 5322300, upload-time = "2025-06-26T16:27:49.278Z" },

     

       531
       +
           { url = "https://files.pythonhosted.org/packages/e8/97/352e07992901473529c8e19dbfdba6430ba6a37f6b46a4d0fa93321f8fee/lxml-6.0.0-cp39-cp39-win32.whl", hash = "sha256:04d67ceee6db4bcb92987ccb16e53bef6b42ced872509f333c04fb58a3315256", size = 3615832, upload-time = "2025-06-26T16:27:51.728Z" },

     

       532
       +
           { url = "https://files.pythonhosted.org/packages/71/93/8f3b880e2618e548fb0ca157349abb526d81cb4f01ef5ea3a0f22bd4d0df/lxml-6.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:e0b1520ef900e9ef62e392dd3d7ae4f5fa224d1dd62897a792cf353eb20b6cae", size = 4038551, upload-time = "2025-06-26T16:27:54.193Z" },

     

       533
       +
           { url = "https://files.pythonhosted.org/packages/e7/8a/046cbf5b262dd2858c6e65833339100fd5f1c017b37b26bc47c92d4584d7/lxml-6.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:e35e8aaaf3981489f42884b59726693de32dabfc438ac10ef4eb3409961fd402", size = 3684237, upload-time = "2025-06-26T16:27:57.117Z" },

     

       534
       +
           { url = "https://files.pythonhosted.org/packages/66/e1/2c22a3cff9e16e1d717014a1e6ec2bf671bf56ea8716bb64466fcf820247/lxml-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:dbdd7679a6f4f08152818043dbb39491d1af3332128b3752c3ec5cebc0011a72", size = 3898804, upload-time = "2025-06-26T16:27:59.751Z" },

     

       535
       +
           { url = "https://files.pythonhosted.org/packages/2b/3a/d68cbcb4393a2a0a867528741fafb7ce92dac5c9f4a1680df98e5e53e8f5/lxml-6.0.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:40442e2a4456e9910875ac12951476d36c0870dcb38a68719f8c4686609897c4", size = 4216406, upload-time = "2025-06-28T18:47:45.518Z" },

     

       536
       +
           { url = "https://files.pythonhosted.org/packages/15/8f/d9bfb13dff715ee3b2a1ec2f4a021347ea3caf9aba93dea0cfe54c01969b/lxml-6.0.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db0efd6bae1c4730b9c863fc4f5f3c0fa3e8f05cae2c44ae141cb9dfc7d091dc", size = 4326455, upload-time = "2025-06-28T18:47:48.411Z" },

     

       537
       +
           { url = "https://files.pythonhosted.org/packages/01/8b/fde194529ee8a27e6f5966d7eef05fa16f0567e4a8e8abc3b855ef6b3400/lxml-6.0.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ab542c91f5a47aaa58abdd8ea84b498e8e49fe4b883d67800017757a3eb78e8", size = 4268788, upload-time = "2025-06-26T16:28:02.776Z" },

     

       538
       +
           { url = "https://files.pythonhosted.org/packages/99/a8/3b8e2581b4f8370fc9e8dc343af4abdfadd9b9229970fc71e67bd31c7df1/lxml-6.0.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:013090383863b72c62a702d07678b658fa2567aa58d373d963cca245b017e065", size = 4411394, upload-time = "2025-06-26T16:28:05.179Z" },

     

       539
       +
           { url = "https://files.pythonhosted.org/packages/e7/a5/899a4719e02ff4383f3f96e5d1878f882f734377f10dfb69e73b5f223e44/lxml-6.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c86df1c9af35d903d2b52d22ea3e66db8058d21dc0f59842ca5deb0595921141", size = 3517946, upload-time = "2025-06-26T16:28:07.665Z" },

     

       540
       +
           { url = "https://files.pythonhosted.org/packages/93/e3/ef14f1d23aea1dec1eccbe2c07a93b6d0be693fd9d5f248a47155e436701/lxml-6.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4337e4aec93b7c011f7ee2e357b0d30562edd1955620fdd4aeab6aacd90d43c5", size = 3892325, upload-time = "2025-06-26T16:28:10.024Z" },

     

       541
       +
           { url = "https://files.pythonhosted.org/packages/09/8a/1410b9e1ec43f606f9aac0661d09892509d86032e229711798906e1b5e7a/lxml-6.0.0-pp39-pypy39_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ae74f7c762270196d2dda56f8dd7309411f08a4084ff2dfcc0b095a218df2e06", size = 4210839, upload-time = "2025-06-28T18:47:50.768Z" },

     

       542
       +
           { url = "https://files.pythonhosted.org/packages/79/cb/6696ce0d1712c5ae94b18bdf225086a5fb04b23938ac4d2011b323b3860b/lxml-6.0.0-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:059c4cbf3973a621b62ea3132934ae737da2c132a788e6cfb9b08d63a0ef73f9", size = 4321235, upload-time = "2025-06-28T18:47:53.338Z" },

     

       543
       +
           { url = "https://files.pythonhosted.org/packages/f3/98/04997f61d720cf320a0daee66b3096e3a3b57453e15549c14b87058c2acd/lxml-6.0.0-pp39-pypy39_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:17f090a9bc0ce8da51a5632092f98a7e7f84bca26f33d161a98b57f7fb0004ca", size = 4265071, upload-time = "2025-06-26T16:28:12.367Z" },

     

       544
       +
           { url = "https://files.pythonhosted.org/packages/e6/86/e5f6fa80154a5f5bf2c1e89d6265892299942edeb115081ca72afe7c7199/lxml-6.0.0-pp39-pypy39_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9da022c14baeec36edfcc8daf0e281e2f55b950249a455776f0d1adeeada4734", size = 4406816, upload-time = "2025-06-26T16:28:14.744Z" },

     

       545
       +
           { url = "https://files.pythonhosted.org/packages/18/a6/ae69e0e6f5fb6293eb8cbfbf8a259e37d71608bbae3658a768dd26b69f3e/lxml-6.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a55da151d0b0c6ab176b4e761670ac0e2667817a1e0dadd04a01d0561a219349", size = 3515499, upload-time = "2025-06-26T16:28:17.035Z" },

     

       546
       +
       ]

     

       547
       +
       

     

       548
       +
       [[package]]

     

       549
        
       name = "markdown-it-py"

     

       550
        
       version = "3.0.0"

     

       551
        
       source = { registry = "https://pypi.org/simple" }

     
···

       555
        
       sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }

     

       556
        
       wheels = [

     

       557
        
           { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },

     

       558
       +
       ]

     

       559
       +
       

     

       560
       +
       [[package]]

     

       561
       +
       name = "markdownify"

     

       562
       +
       version = "1.2.0"

     

       563
       +
       source = { registry = "https://pypi.org/simple" }

     

       564
       +
       dependencies = [

     

       565
       +
           { name = "beautifulsoup4" },

     

       566
       +
           { name = "six" },

     

       567
       +
       ]

     

       568
       +
       sdist = { url = "https://files.pythonhosted.org/packages/83/1b/6f2697b51eaca81f08852fd2734745af15718fea10222a1d40f8a239c4ea/markdownify-1.2.0.tar.gz", hash = "sha256:f6c367c54eb24ee953921804dfe6d6575c5e5b42c643955e7242034435de634c", size = 18771, upload-time = "2025-08-09T17:44:15.302Z" }

     

       569
       +
       wheels = [

     

       570
       +
           { url = "https://files.pythonhosted.org/packages/6a/e2/7af643acb4cae0741dffffaa7f3f7c9e7ab4046724543ba1777c401d821c/markdownify-1.2.0-py3-none-any.whl", hash = "sha256:48e150a1c4993d4d50f282f725c0111bd9eb25645d41fa2f543708fd44161351", size = 15561, upload-time = "2025-08-09T17:44:14.074Z" },

     

       571
        
       ]

     

       572
        
       

     

       573
        
       [[package]]

     
···

       724
        
           { url = "https://files.pythonhosted.org/packages/0b/c7/d3654a790129684d0e8dc04707cb6d75633d7b102a962c6dc0f862c64c25/pendulum-3.1.0-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e4cbd933a40c915ed5c41b083115cca15c7afa8179363b2a61db167c64fa0670", size = 526685, upload-time = "2025-04-19T14:02:31.523Z" },

     

       725
        
           { url = "https://files.pythonhosted.org/packages/50/d9/4a166256386b7973e36ff44135e8d009f4afb25d6c72df5380ccfd6fbb89/pendulum-3.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3363a470b5d67dbf8d9fd1bf77dcdbf720788bc3be4a10bdcd28ae5d7dbd26c4", size = 261170, upload-time = "2025-04-19T14:02:33.099Z" },

     

       726
        
           { url = "https://files.pythonhosted.org/packages/6e/23/e98758924d1b3aac11a626268eabf7f3cf177e7837c28d47bf84c64532d0/pendulum-3.1.0-py3-none-any.whl", hash = "sha256:f9178c2a8e291758ade1e8dd6371b1d26d08371b4c7730a6e9a3ef8b16ebae0f", size = 111799, upload-time = "2025-04-19T14:02:34.739Z" },

     

       727
       +
       ]

     

       728
       +
       

     

       729
       +
       [[package]]

     

       730
       +
       name = "pip"

     

       731
       +
       version = "25.2"

     

       732
       +
       source = { registry = "https://pypi.org/simple" }

     

       733
       +
       sdist = { url = "https://files.pythonhosted.org/packages/20/16/650289cd3f43d5a2fadfd98c68bd1e1e7f2550a1a5326768cddfbcedb2c5/pip-25.2.tar.gz", hash = "sha256:578283f006390f85bb6282dffb876454593d637f5d1be494b5202ce4877e71f2", size = 1840021, upload-time = "2025-07-30T21:50:15.401Z" }

     

       734
       +
       wheels = [

     

       735
       +
           { url = "https://files.pythonhosted.org/packages/b7/3f/945ef7ab14dc4f9d7f40288d2df998d1837ee0888ec3659c813487572faa/pip-25.2-py3-none-any.whl", hash = "sha256:6d67a2b4e7f14d8b31b8b52648866fa717f45a1eb70e83002f4331d07e953717", size = 1752557, upload-time = "2025-07-30T21:50:13.323Z" },

     

       736
        
       ]

     

       737
        
       

     

       738
        
       [[package]]

     
···

       1116
        
       ]

     

       1117
        
       

     

       1118
        
       [[package]]

     

       1119
       +
       name = "soupsieve"

     

       1120
       +
       version = "2.7"

     

       1121
       +
       source = { registry = "https://pypi.org/simple" }

     

       1122
       +
       sdist = { url = "https://files.pythonhosted.org/packages/3f/f4/4a80cd6ef364b2e8b65b15816a843c0980f7a5a2b4dc701fc574952aa19f/soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a", size = 103418, upload-time = "2025-04-20T18:50:08.518Z" }

     

       1123
       +
       wheels = [

     

       1124
       +
           { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" },

     

       1125
       +
       ]

     

       1126
       +
       

     

       1127
       +
       [[package]]

     

       1128
        
       name = "thicket"

     

       1129
        
       source = { editable = "." }

     

       1130
        
       dependencies = [

     
···

       1133
        
           { name = "feedparser" },

     

       1134
        
           { name = "gitpython" },

     

       1135
        
           { name = "httpx" },

     

       1136
       +
           { name = "importlib-metadata" },

     

       1137
       +
           { name = "markdownify" },

     

       1138
        
           { name = "pendulum" },

     

       1139
        
           { name = "platformdirs" },

     

       1140
        
           { name = "pydantic" },

     
···

       1143
        
           { name = "rich" },

     

       1144
        
           { name = "typer" },

     

       1145
        
           { name = "typesense" },

     

       1146
       +
           { name = "zulip" },

     

       1147
       +
           { name = "zulip-bots" },

     

       1148
        
       ]

     

       1149
        
       

     

       1150
        
       [package.optional-dependencies]

     
···

       1172
        
           { name = "feedparser", specifier = ">=6.0.11" },

     

       1173
        
           { name = "gitpython", specifier = ">=3.1.40" },

     

       1174
        
           { name = "httpx", specifier = ">=0.28.0" },

     

       1175
       +
           { name = "importlib-metadata", specifier = ">=8.7.0" },

     

       1176
       +
           { name = "markdownify", specifier = ">=1.2.0" },

     

       1177
        
           { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13.0" },

     

       1178
        
           { name = "pendulum", specifier = ">=3.0.0" },

     

       1179
        
           { name = "platformdirs", specifier = ">=4.0.0" },

     
···

       1188
        
           { name = "typer", specifier = ">=0.15.0" },

     

       1189
        
           { name = "types-pyyaml", marker = "extra == 'dev'", specifier = ">=6.0.0" },

     

       1190
        
           { name = "typesense", specifier = ">=1.1.1" },

     

       1191
       +
           { name = "zulip", specifier = ">=0.9.0" },

     

       1192
       +
           { name = "zulip-bots", specifier = ">=0.9.0" },

     

       1193
        
       ]

     

       1194
        
       provides-extras = ["dev"]

     

       1195
        
       

     
···

       1322
        
       wheels = [

     

       1323
        
           { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" },

     

       1324
        
       ]

     

       1325
       +
       

     

       1326
       +
       [[package]]

     

       1327
       +
       name = "zipp"

     

       1328
       +
       version = "3.23.0"

     

       1329
       +
       source = { registry = "https://pypi.org/simple" }

     

       1330
       +
       sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }

     

       1331
       +
       wheels = [

     

       1332
       +
           { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },

     

       1333
       +
       ]

     

       1334
       +
       

     

       1335
       +
       [[package]]

     

       1336
       +
       name = "zulip"

     

       1337
       +
       version = "0.9.0"

     

       1338
       +
       source = { registry = "https://pypi.org/simple" }

     

       1339
       +
       dependencies = [

     

       1340
       +
           { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },

     

       1341
       +
           { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },

     

       1342
       +
           { name = "distro" },

     

       1343
       +
           { name = "requests" },

     

       1344
       +
           { name = "typing-extensions" },

     

       1345
       +
       ]

     

       1346
       +
       sdist = { url = "https://files.pythonhosted.org/packages/7e/85/754c025bf7e5ff2622b89c555ff3e1ecc3dd501874745a7ec2c3b59fc743/zulip-0.9.0.tar.gz", hash = "sha256:7a14149e5d9e3fcc53b13e998719fd1f6ccb8289bc60fccbaa1aafcd0a9d0843", size = 134624, upload-time = "2023-11-15T00:28:39.338Z" }

     

       1347
       +
       wheels = [

     

       1348
       +
           { url = "https://files.pythonhosted.org/packages/db/ed/81e42dbfe0dd538f60514d0e4849b872d949a1caa7a2c80bbe6aa4c1bae9/zulip-0.9.0-py3-none-any.whl", hash = "sha256:a315db3e990c6b94aef323540b7f386485e8fc359dbd26af526c20dbe9068217", size = 289297, upload-time = "2023-11-15T00:28:33.172Z" },

     

       1349
       +
       ]

     

       1350
       +
       

     

       1351
       +
       [[package]]

     

       1352
       +
       name = "zulip-bots"

     

       1353
       +
       version = "0.9.0"

     

       1354
       +
       source = { registry = "https://pypi.org/simple" }

     

       1355
       +
       dependencies = [

     

       1356
       +
           { name = "beautifulsoup4" },

     

       1357
       +
           { name = "html2text" },

     

       1358
       +
           { name = "importlib-metadata", marker = "python_full_version < '3.10'" },

     

       1359
       +
           { name = "lxml" },

     

       1360
       +
           { name = "pip" },

     

       1361
       +
           { name = "typing-extensions" },

     

       1362
       +
           { name = "zulip" },

     

       1363
       +
       ]

     

       1364
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a5/39/6e60bea336fbfd4ad55dbdbb5fbd6d62dc32b08ad240688f119d145a29b3/zulip_bots-0.9.0.tar.gz", hash = "sha256:94925a4bd7c3558bf0e0cc3e83021d6a2f2139824745081abaa605a3d012e37a", size = 2268775, upload-time = "2023-11-15T00:28:36.507Z" }

     

       1365
       +
       wheels = [

     

       1366
       +
           { url = "https://files.pythonhosted.org/packages/e6/c9/c242abc63de86d1a20b02e5d8e507c38d4889b9c01f663a5b80eb050effd/zulip_bots-0.9.0-py3-none-any.whl", hash = "sha256:1c46b011002fdf375f27fbf0c17394149e77ea36b33aa762b58368db14229e37", size = 2317628, upload-time = "2023-11-15T00:28:26.312Z" },

     

       1367
       +
       ]

Compare changes