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

.gitignore

···

       203
       203
        
       .streamlit/secrets.toml

     

       204
       204
        
       

     

       205
       205
        
       thicket.yaml

     

       206
       206
       +
       

     

       207
       207
       +
       # Bot configuration files with secrets

     

       208
       208
       +
       bot-config/zuliprc

     

       209
       209
       +
       bot-config/*.key  

     

       210
       210
       +
       bot-config/*.secret

+3 -5

ARCH.md

···

       408
       408
        
         "links": {

     

       409
       409
        
           "https://example.com/post/123": {

     

       410
       410
        
             "referencing_entries": ["https://blog.user.com/entry/456"],

     

       411
       411
       -
             "is_tracked_post": true,

     

       412
       411
        
             "target_username": "user2"

     

       413
       412
        
           },

     

       414
       413
        
           "https://external-site.com/article": {

     

       415
       415
       -
             "referencing_entries": ["https://blog.user.com/entry/789"],

     

       416
       416
       -
             "is_tracked_post": false

     

       414
       414
       +
             "referencing_entries": ["https://blog.user.com/entry/789"]

     

       417
       415
        
           }

     

       418
       416
        
         },

     

       419
       417
        
         "reverse_mapping": {

     
···

       438
       436
        
       ```

     

       439
       437
        
       

     

       440
       438
        
       This unified structure eliminates duplication by:

     

       441
       441
       -
       - Storing each URL only once with metadata flags

     

       439
       439
       +
       - Storing each URL only once with minimal metadata

     

       442
       440
        
       - Including all link data, reference data, and mappings in one file

     

       443
       443
       -
       - Using `is_tracked_post` to identify internal vs external links

     

       441
       441
       +
       - Using presence of `target_username` to identify tracked vs external links

     

       444
       442
        
       - Providing bidirectional mappings for efficient queries

     

       445
       443
        
       

     

       446
       444
        
       ### Unified Structure Benefits

+26

README.md

···

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

     

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

     

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

     

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

     

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

     

       13
       14
        
       

     

       14
       15
        
       ## Installation

     
···

       109
       110
        
       # Remove duplicate mapping

     

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

     

       111
       112
        
       ```

     

       113
       113
       +
       

     

       114
       114
       +
       ### Zulip Bot Integration

     

       115
       115
       +
       ```bash

     

       116
       116
       +
       # Test bot functionality

     

       117
       117
       +
       thicket bot test

     

       118
       118
       +
       

     

       119
       119
       +
       # Show bot status 

     

       120
       120
       +
       thicket bot status

     

       121
       121
       +
       

     

       122
       122
       +
       # Run bot (requires configuration)

     

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

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

       126
       126
       +
       **Bot Setup:**

     

       127
       127
       +
       1. Create a Zulip bot in your organization

     

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

     

       129
       129
       +
       3. Configure with your bot's credentials

     

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

     

       131
       131
       +
          ```

     

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

     

       133
       133
       +
          @thicket config stream general

     

       134
       134
       +
          @thicket config topic "Feed Updates"

     

       135
       135
       +
          ```

     

       136
       136
       +
       

     

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

     

       112
       138
        
       

     

       113
       139
        
       ## Configuration

     

       114
       140

+400

SPEC.md

···

       1
       1
       +
       # Thicket Git Store Specification

     

       2
       2
       +
       

     

       3
       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
       4
       +
       

     

       5
       5
       +
       ## Overview

     

       6
       6
       +
       

     

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

     

       9
       9
       +
       ## Repository Structure

     

       10
       10
       +
       

     

       11
       11
       +
       ```

     

       12
       12
       +
       <git_store>/

     

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

     

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

     

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

     

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

     

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

     

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

     

       19
       19
       +
       │   └── ...

     

       20
       20
       +
       ├── <username2>/

     

       21
       21
       +
       │   ├── <entry_id3>.json

     

       22
       22
       +
       │   └── ...

     

       23
       23
       +
       └── ...

     

       24
       24
       +
       ```

     

       25
       25
       +
       

     

       26
       26
       +
       ## JSON Schemas

     

       27
       27
       +
       

     

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

     

       29
       29
       +
       

     

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

     

       31
       31
       +
       

     

       32
       32
       +
       **Schema:**

     

       33
       33
       +
       ```json

     

       34
       34
       +
       {

     

       35
       35
       +
         "users": {

     

       36
       36
       +
           "<username>": {

     

       37
       37
       +
             "username": "string",

     

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

     

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

     

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

     

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

     

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

     

       43
       43
       +
             "zulip_associations": [

     

       44
       44
       +
               {

     

       45
       45
       +
                 "server": "string",

     

       46
       46
       +
                 "user_id": "string"

     

       47
       47
       +
               },

     

       48
       48
       +
               ...

     

       49
       49
       +
             ],

     

       50
       50
       +
             "directory": "string",

     

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

     

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

     

       53
       53
       +
             "entry_count": "integer"

     

       54
       54
       +
           }

     

       55
       55
       +
         },

     

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

     

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

     

       58
       58
       +
         "total_entries": "integer"

     

       59
       59
       +
       }

     

       60
       60
       +
       ```

     

       61
       61
       +
       

     

       62
       62
       +
       **Example:**

     

       63
       63
       +
       ```json

     

       64
       64
       +
       {

     

       65
       65
       +
         "users": {

     

       66
       66
       +
           "johndoe": {

     

       67
       67
       +
             "username": "johndoe",

     

       68
       68
       +
             "display_name": "John Doe",

     

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

     

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

     

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

     

       72
       72
       +
             "feeds": [

     

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

     

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

     

       75
       75
       +
             ],

     

       76
       76
       +
             "zulip_associations": [

     

       77
       77
       +
               {

     

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

     

       79
       79
       +
                 "user_id": "john.doe"

     

       80
       80
       +
               },

     

       81
       81
       +
               {

     

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

     

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

     

       84
       84
       +
               }

     

       85
       85
       +
             ],

     

       86
       86
       +
             "directory": "johndoe",

     

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

     

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

     

       89
       89
       +
             "entry_count": 42

     

       90
       90
       +
           }

     

       91
       91
       +
         },

     

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

     

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

     

       94
       94
       +
         "total_entries": 42

     

       95
       95
       +
       }

     

       96
       96
       +
       ```

     

       97
       97
       +
       

     

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

     

       99
       99
       +
       

     

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

     

       101
       101
       +
       

     

       102
       102
       +
       **Schema:**

     

       103
       103
       +
       ```json

     

       104
       104
       +
       {

     

       105
       105
       +
         "duplicates": {

     

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

     

       107
       107
       +
         },

     

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

     

       109
       109
       +
       }

     

       110
       110
       +
       ```

     

       111
       111
       +
       

     

       112
       112
       +
       **Example:**

     

       113
       113
       +
       ```json

     

       114
       114
       +
       {

     

       115
       115
       +
         "duplicates": {

     

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

     

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

     

       118
       118
       +
         },

     

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

     

       120
       120
       +
       }

     

       121
       121
       +
       ```

     

       122
       122
       +
       

     

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

     

       124
       124
       +
       

     

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

     

       126
       126
       +
       

     

       127
       127
       +
       **Schema:**

     

       128
       128
       +
       ```json

     

       129
       129
       +
       {

     

       130
       130
       +
         "id": "string",

     

       131
       131
       +
         "title": "string", 

     

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

     

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

     

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

     

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

     

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

     

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

     

       138
       138
       +
         "author": {

     

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

     

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

     

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

     

       142
       142
       +
         } | null,

     

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

     

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

     

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

     

       146
       146
       +
       }

     

       147
       147
       +
       ```

     

       148
       148
       +
       

     

       149
       149
       +
       **Example:**

     

       150
       150
       +
       ```json

     

       151
       151
       +
       {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       159
       159
       +
         "content_type": "html",

     

       160
       160
       +
         "author": {

     

       161
       161
       +
           "name": "John Doe",

     

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

     

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

     

       164
       164
       +
         },

     

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

     

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

     

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

     

       168
       168
       +
       }

     

       169
       169
       +
       ```

     

       170
       170
       +
       

     

       171
       171
       +
       ## Python Class Integration

     

       172
       172
       +
       

     

       173
       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
       174
       +
       

     

       175
       175
       +
       ### Core Data Models

     

       176
       176
       +
       

     

       177
       177
       +
       ```python

     

       178
       178
       +
       from thicket.models import (

     

       179
       179
       +
           AtomEntry,           # Feed entry representation

     

       180
       180
       +
           GitStoreIndex,       # Repository index

     

       181
       181
       +
           UserMetadata,        # User information  

     

       182
       182
       +
           DuplicateMap,        # Duplicate ID mappings

     

       183
       183
       +
           FeedMetadata,        # Feed-level metadata

     

       184
       184
       +
           ThicketConfig,       # Configuration

     

       185
       185
       +
           UserConfig,          # User configuration

     

       186
       186
       +
           ZulipAssociation     # Zulip server/user_id pairs

     

       187
       187
       +
       )

     

       188
       188
       +
       ```

     

       189
       189
       +
       

     

       190
       190
       +
       ### Repository Operations

     

       191
       191
       +
       

     

       192
       192
       +
       ```python

     

       193
       193
       +
       from thicket.core.git_store import GitStore

     

       194
       194
       +
       from thicket.core.feed_parser import FeedParser

     

       195
       195
       +
       

     

       196
       196
       +
       # Initialize git store

     

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

     

       198
       198
       +
       

     

       199
       199
       +
       # Read data

     

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

     

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

     

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

     

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

     

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

     

       205
       205
       +
       

     

       206
       206
       +
       # Write data  

     

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

     

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

     

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

     

       210
       210
       +
       store.commit_changes("Commit message")

     

       211
       211
       +
       

     

       212
       212
       +
       # Zulip associations

     

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

     

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

     

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

     

       216
       216
       +
       

     

       217
       217
       +
       # Search and statistics

     

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

     

       219
       219
       +
       stats = store.get_stats()

     

       220
       220
       +
       ```

     

       221
       221
       +
       

     

       222
       222
       +
       ### Feed Processing

     

       223
       223
       +
       

     

       224
       224
       +
       ```python

     

       225
       225
       +
       from thicket.core.feed_parser import FeedParser

     

       226
       226
       +
       from pydantic import HttpUrl

     

       227
       227
       +
       

     

       228
       228
       +
       parser = FeedParser()

     

       229
       229
       +
       

     

       230
       230
       +
       # Fetch and parse feeds

     

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

     

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

     

       233
       233
       +
       

     

       234
       234
       +
       # Entry ID sanitization for filenames

     

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

     

       236
       236
       +
       ```

     

       237
       237
       +
       

     

       238
       238
       +
       ## File Naming and ID Sanitization

     

       239
       239
       +
       

     

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

     

       241
       241
       +
       

     

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

     

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

     

       244
       244
       +
       - Other characters are replaced with underscores

     

       245
       245
       +
       - Maximum length is 200 characters

     

       246
       246
       +
       - Empty results default to "entry"

     

       247
       247
       +
       

     

       248
       248
       +
       **Examples:**

     

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

     

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

     

       251
       251
       +
       

     

       252
       252
       +
       ## Data Validation

     

       253
       253
       +
       

     

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

     

       255
       255
       +
       

     

       256
       256
       +
       ```python

     

       257
       257
       +
       from thicket.models import AtomEntry

     

       258
       258
       +
       from pydantic import ValidationError

     

       259
       259
       +
       

     

       260
       260
       +
       try:

     

       261
       261
       +
           entry = AtomEntry(**json_data)

     

       262
       262
       +
           # Data is valid, safe to store

     

       263
       263
       +
           store.store_entry(username, entry)

     

       264
       264
       +
       except ValidationError as e:

     

       265
       265
       +
           # Handle validation errors

     

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

     

       267
       267
       +
       ```

     

       268
       268
       +
       

     

       269
       269
       +
       ## Timestamps

     

       270
       270
       +
       

     

       271
       271
       +
       All timestamps use ISO 8601 format in UTC:

     

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

     

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

     

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

     

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

     

       276
       276
       +
       

     

       277
       277
       +
       ## Content Sanitization

     

       278
       278
       +
       

     

       279
       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
       280
       +
       

     

       281
       281
       +
       **Allowed HTML tags:**

     

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

     

       283
       283
       +
       

     

       284
       284
       +
       **Allowed attributes:**

     

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

     

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

     

       287
       287
       +
       - `blockquote`: `cite`

     

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

     

       289
       289
       +
       

     

       290
       290
       +
       ## Error Handling and Robustness

     

       291
       291
       +
       

     

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

     

       293
       293
       +
       

     

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

     

       295
       295
       +
       - Malformed JSON files are ignored in listings

     

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

     

       297
       297
       +
       - Git operations are atomic where possible

     

       298
       298
       +
       

     

       299
       299
       +
       ## Example Usage

     

       300
       300
       +
       

     

       301
       301
       +
       ### Reading the Store

     

       302
       302
       +
       

     

       303
       303
       +
       ```python

     

       304
       304
       +
       from pathlib import Path

     

       305
       305
       +
       from thicket.core.git_store import GitStore

     

       306
       306
       +
       

     

       307
       307
       +
       # Initialize

     

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

     

       309
       309
       +
       

     

       310
       310
       +
       # Get all users

     

       311
       311
       +
       index = store._load_index()

     

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

     

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

     

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

     

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

     

       316
       316
       +
       

     

       317
       317
       +
       # Get recent entries for a user

     

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

     

       319
       319
       +
       for entry in entries:

     

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

     

       321
       321
       +
       ```

     

       322
       322
       +
       

     

       323
       323
       +
       ### Adding Data

     

       324
       324
       +
       

     

       325
       325
       +
       ```python

     

       326
       326
       +
       from thicket.models import AtomEntry

     

       327
       327
       +
       from datetime import datetime

     

       328
       328
       +
       from pydantic import HttpUrl

     

       329
       329
       +
       

     

       330
       330
       +
       # Create entry

     

       331
       331
       +
       entry = AtomEntry(

     

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

     

       333
       333
       +
           title="New Post",

     

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

     

       335
       335
       +
           updated=datetime.now(),

     

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

     

       337
       337
       +
           content_type="html"

     

       338
       338
       +
       )

     

       339
       339
       +
       

     

       340
       340
       +
       # Store entry

     

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

     

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

     

       343
       343
       +
       ```

     

       344
       344
       +
       

     

       345
       345
       +
       ## Zulip Integration

     

       346
       346
       +
       

     

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

     

       348
       348
       +
       

     

       349
       349
       +
       ### Zulip Associations

     

       350
       350
       +
       

     

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

     

       352
       352
       +
       

     

       353
       353
       +
       ```python

     

       354
       354
       +
       # UserMetadata includes zulip_associations field

     

       355
       355
       +
       user.zulip_associations = [

     

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

     

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

     

       358
       358
       +
       ]

     

       359
       359
       +
       

     

       360
       360
       +
       # Methods for managing associations

     

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

     

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

     

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

     

       364
       364
       +
       ```

     

       365
       365
       +
       

     

       366
       366
       +
       ### CLI Management

     

       367
       367
       +
       

     

       368
       368
       +
       ```bash

     

       369
       369
       +
       # Add association

     

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

     

       371
       371
       +
       

     

       372
       372
       +
       # Remove association  

     

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

     

       374
       374
       +
       

     

       375
       375
       +
       # List associations

     

       376
       376
       +
       thicket zulip-list           # All users

     

       377
       377
       +
       thicket zulip-list alice     # Specific user

     

       378
       378
       +
       

     

       379
       379
       +
       # Bulk import from CSV

     

       380
       380
       +
       thicket zulip-import associations.csv

     

       381
       381
       +
       ```

     

       382
       382
       +
       

     

       383
       383
       +
       ### Bot Behavior

     

       384
       384
       +
       

     

       385
       385
       +
       When the Thicket Zulip bot posts articles:

     

       386
       386
       +
       

     

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

     

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

     

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

     

       390
       390
       +
       

     

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

     

       392
       392
       +
       

     

       393
       393
       +
       ## Versioning and Compatibility

     

       394
       394
       +
       

     

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

     

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

     

       397
       397
       +
       

     

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

     

       399
       399
       +
       

     

       400
       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
       1
       +
       # Thicket Bot Configuration

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       ## Setup Instructions

     

       6
       6
       +
       

     

       7
       7
       +
       ### 1. Zulip Bot Configuration

     

       8
       8
       +
       

     

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

     

       10
       10
       +
          ```bash

     

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

     

       12
       12
       +
          ```

     

       13
       13
       +
       

     

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

     

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

     

       16
       16
       +
          - Choose "Generic bot" type

     

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

     

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

     

       19
       19
       +
       

     

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

     

       21
       21
       +
          ```ini

     

       22
       22
       +
          [api]

     

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

     

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

     

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

     

       26
       26
       +
          ```

     

       27
       27
       +
       

     

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

     

       29
       29
       +
       

     

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

     

       31
       31
       +
          ```bash

     

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

     

       33
       33
       +
          ```

     

       34
       34
       +
       

     

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

     

       36
       36
       +
          - Sync intervals and batch sizes

     

       37
       37
       +
          - Default stream/topic settings

     

       38
       38
       +
          - Rate limiting parameters

     

       39
       39
       +
          - Notification preferences

     

       40
       40
       +
       

     

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

     

       42
       42
       +
       

     

       43
       43
       +
       ## File Descriptions

     

       44
       44
       +
       

     

       45
       45
       +
       ### `zuliprc` (Required)

     

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

     

       47
       47
       +
       

     

       48
       48
       +
       ### `botrc` (Optional)

     

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

     

       50
       50
       +
       

     

       51
       51
       +
       ### Template Files

     

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

     

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

     

       54
       54
       +
       

     

       55
       55
       +
       ## Running the Bot

     

       56
       56
       +
       

     

       57
       57
       +
       Once configured, run the bot with:

     

       58
       58
       +
       

     

       59
       59
       +
       ```bash

     

       60
       60
       +
       # Run in foreground

     

       61
       61
       +
       thicket bot run

     

       62
       62
       +
       

     

       63
       63
       +
       # Run in background (daemon mode)

     

       64
       64
       +
       thicket bot run --daemon

     

       65
       65
       +
       

     

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

     

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

     

       68
       68
       +
       

     

       69
       69
       +
       # Custom config paths

     

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

     

       71
       71
       +
       ```

     

       72
       72
       +
       

     

       73
       73
       +
       ## Bot Commands

     

       74
       74
       +
       

     

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

     

       76
       76
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       83
       83
       +
       

     

       84
       84
       +
       ## Security Notes

     

       85
       85
       +
       

     

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

     

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

     

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

     

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

     

       90
       90
       +
       

     

       91
       91
       +
       ## Troubleshooting

     

       92
       92
       +
       

     

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

     

       94
       94
       +
       - View bot logs when running in foreground mode

     

       95
       95
       +
       - Verify Zulip credentials are correct

     

       96
       96
       +
       - Ensure thicket.yaml configuration exists

     

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

+28

bot-config/botrc

···

       1
       1
       +
       [bot]

     

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

     

       3
       3
       +
       sync_interval = 300

     

       4
       4
       +
       

     

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

     

       6
       6
       +
       max_entries_per_sync = 10

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       # Leave empty to require configuration via chat

     

       10
       10
       +
       default_stream = 

     

       11
       11
       +
       default_topic = 

     

       12
       12
       +
       

     

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

     

       14
       14
       +
       rate_limit_delay = 5

     

       15
       15
       +
       

     

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

     

       17
       17
       +
       posts_per_batch = 5

     

       18
       18
       +
       

     

       19
       19
       +
       [catchup]

     

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

     

       21
       21
       +
       catchup_entries = 5

     

       22
       22
       +
       

     

       23
       23
       +
       [notifications]

     

       24
       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       25
       +
       config_change_notifications = true

     

       26
       26
       +
       

     

       27
       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       28
       +
       username_claim_notifications = true

+34

bot-config/botrc.template

···

       1
       1
       +
       [bot]

     

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

     

       3
       3
       +
       sync_interval = 300

     

       4
       4
       +
       

     

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

     

       6
       6
       +
       max_entries_per_sync = 10

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       # Leave empty to require configuration via chat

     

       10
       10
       +
       default_stream = 

     

       11
       11
       +
       default_topic = 

     

       12
       12
       +
       

     

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

     

       14
       14
       +
       rate_limit_delay = 5

     

       15
       15
       +
       

     

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

     

       17
       17
       +
       posts_per_batch = 5

     

       18
       18
       +
       

     

       19
       19
       +
       [catchup]

     

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

     

       21
       21
       +
       catchup_entries = 5

     

       22
       22
       +
       

     

       23
       23
       +
       [notifications]

     

       24
       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       25
       +
       config_change_notifications = true

     

       26
       26
       +
       

     

       27
       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       28
       +
       username_claim_notifications = true

     

       29
       29
       +
       

     

       30
       30
       +
       # Instructions:

     

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

     

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

     

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

     

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

+16

bot-config/zuliprc.template

···

       1
       1
       +
       [api]

     

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

     

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

     

       4
       4
       +
       

     

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

     

       6
       6
       +
       key=YOUR_BOT_API_KEY_HERE

     

       7
       7
       +
       

     

       8
       8
       +
       # Your Zulip server URL

     

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

     

       10
       10
       +
       

     

       11
       11
       +
       # Instructions:

     

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

     

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

     

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

     

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

     

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

+12 -5

pyproject.toml

···

       39
       39
        
           "bleach>=6.0.0",

     

       40
       40
        
           "platformdirs>=4.0.0",

     

       41
       41
        
           "pyyaml>=6.0.0",

     

       42
       42
       -
           "email_validator"

     

       42
       42
       +
           "email_validator",

     

       43
       43
       +
           "typesense>=1.1.1",

     

       44
       44
       +
           "zulip>=0.9.0",

     

       45
       45
       +
           "zulip-bots>=0.9.0",

     

       46
       46
       +
           "importlib-metadata>=8.7.0",

     

       47
       47
       +
           "markdownify>=1.2.0",

     

       43
       48
        
       ]

     

       44
       49
        
       

     

       45
       50
        
       [project.optional-dependencies]

     
···

       138
       143
        
           "-ra",

     

       139
       144
        
           "--strict-markers",

     

       140
       145
        
           "--strict-config",

     

       141
       141
       -
           "--cov=src/thicket",

     

       142
       142
       -
           "--cov-report=term-missing",

     

       143
       143
       -
           "--cov-report=html",

     

       144
       144
       -
           "--cov-report=xml",

     

       145
       146
        
       ]

     

       146
       147
        
       filterwarnings = [

     

       147
       148
        
           "error",

     
···

       170
       171
        
           "class .*\\bProtocol\\):",

     

       171
       172
        
           "@(abc\\.)?abstractmethod",

     

       172
       173
        
       ]

     

       174
       174
       +
       

     

       175
       175
       +
       [dependency-groups]

     

       176
       176
       +
       dev = [

     

       177
       177
       +
           "mypy>=1.17.0",

     

       178
       178
       +
           "pytest>=8.4.1",

     

       179
       179
       +
       ]

src/thicket/bots/__init__.py

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       from .thicket_bot import ThicketBotHandler

     

       4
       4
       +
       

     

       5
       5
       +
       __all__ = ["ThicketBotHandler"]

src/thicket/bots/requirements.txt

···

       1
       1
       +
       # Requirements for Thicket Zulip bot

     

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

     

       3
       3
       +
       pydantic>=2.11.0

     

       4
       4
       +
       GitPython>=3.1.40

     

       5
       5
       +
       feedparser>=6.0.11

     

       6
       6
       +
       httpx>=0.28.0

     

       7
       7
       +
       pyyaml>=6.0.0

+201

src/thicket/bots/test_bot.py

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       from pathlib import Path

     

       5
       5
       +
       from typing import Any, Optional

     

       6
       6
       +
       

     

       7
       7
       +
       from ..models import AtomEntry

     

       8
       8
       +
       from .thicket_bot import ThicketBotHandler

     

       9
       9
       +
       

     

       10
       10
       +
       

     

       11
       11
       +
       class MockBotHandler:

     

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

     

       13
       13
       +
       

     

       14
       14
       +
           def __init__(self) -> None:

     

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

     

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

     

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

     

       18
       18
       +
               self.config_info = {

     

       19
       19
       +
                   "full_name": "Thicket Bot",

     

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

     

       21
       21
       +
               }

     

       22
       22
       +
       

     

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

     

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

     

       25
       25
       +
               return self.config_info

     

       26
       26
       +
       

     

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

     

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

     

       29
       29
       +
               reply = {

     

       30
       30
       +
                   "type": "reply",

     

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

     

       32
       32
       +
                   "content": content,

     

       33
       33
       +
                   "original_message": message,

     

       34
       34
       +
               }

     

       35
       35
       +
               self.sent_messages.append(reply)

     

       36
       36
       +
       

     

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

     

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

     

       39
       39
       +
               self.sent_messages.append(message)

     

       40
       40
       +
       

     

       41
       41
       +
           @property

     

       42
       42
       +
           def storage(self) -> "MockStorage":

     

       43
       43
       +
               """Return mock storage."""

     

       44
       44
       +
               return MockStorage(self.storage_data)

     

       45
       45
       +
       

     

       46
       46
       +
       

     

       47
       47
       +
       class MockStorage:

     

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

     

       49
       49
       +
       

     

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

     

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

     

       52
       52
       +
               self.storage_data = storage_data

     

       53
       53
       +
       

     

       54
       54
       +
           def __enter__(self) -> "MockStorage":

     

       55
       55
       +
               """Context manager entry."""

     

       56
       56
       +
               return self

     

       57
       57
       +
       

     

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

     

       59
       59
       +
               """Context manager exit."""

     

       60
       60
       +
               pass

     

       61
       61
       +
       

     

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

     

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

     

       64
       64
       +
               return self.storage_data.get(key)

     

       65
       65
       +
       

     

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

     

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

     

       68
       68
       +
               self.storage_data[key] = value

     

       69
       69
       +
       

     

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

     

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

     

       72
       72
       +
               return key in self.storage_data

     

       73
       73
       +
       

     

       74
       74
       +
       

     

       75
       75
       +
       def create_test_message(

     

       76
       76
       +
           content: str,

     

       77
       77
       +
           sender: str = "Test User",

     

       78
       78
       +
           sender_id: int = 12345,

     

       79
       79
       +
           message_type: str = "stream",

     

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

     

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

     

       82
       82
       +
           return {

     

       83
       83
       +
               "content": content,

     

       84
       84
       +
               "sender_full_name": sender,

     

       85
       85
       +
               "sender_id": sender_id,

     

       86
       86
       +
               "type": message_type,

     

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

     

       88
       88
       +
               "stream_id": 1,

     

       89
       89
       +
               "subject": "test topic",

     

       90
       90
       +
           }

     

       91
       91
       +
       

     

       92
       92
       +
       

     

       93
       93
       +
       def create_test_entry(

     

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

     

       95
       95
       +
           title: str = "Test Article",

     

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

     

       97
       97
       +
       ) -> AtomEntry:

     

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

     

       99
       99
       +
           from datetime import datetime

     

       100
       100
       +
       

     

       101
       101
       +
           from pydantic import HttpUrl

     

       102
       102
       +
       

     

       103
       103
       +
           return AtomEntry(

     

       104
       104
       +
               id=entry_id,

     

       105
       105
       +
               title=title,

     

       106
       106
       +
               link=HttpUrl(link),

     

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

     

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

     

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

     

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

     

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

     

       112
       112
       +
           )

     

       113
       113
       +
       

     

       114
       114
       +
       

     

       115
       115
       +
       class BotTester:

     

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

     

       117
       117
       +
       

     

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

     

       119
       119
       +
               """Initialize bot tester."""

     

       120
       120
       +
               self.bot = ThicketBotHandler()

     

       121
       121
       +
               self.handler = MockBotHandler()

     

       122
       122
       +
       

     

       123
       123
       +
               if config_path:

     

       124
       124
       +
                   # Configure bot with test config

     

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

     

       126
       126
       +
       

     

       127
       127
       +
           def configure_bot(

     

       128
       128
       +
               self, config_path: Path, stream: str = "test-stream", topic: str = "test-topic"

     

       129
       129
       +
           ) -> None:

     

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

     

       131
       131
       +
               # Set bot configuration

     

       132
       132
       +
               config_data = {

     

       133
       133
       +
                   "stream_name": stream,

     

       134
       134
       +
                   "topic_name": topic,

     

       135
       135
       +
                   "sync_interval": 300,

     

       136
       136
       +
                   "max_entries_per_sync": 10,

     

       137
       137
       +
                   "config_path": str(config_path),

     

       138
       138
       +
               }

     

       139
       139
       +
       

     

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

     

       141
       141
       +
       

     

       142
       142
       +
               # Initialize bot

     

       143
       143
       +
               self.bot._load_bot_config(self.handler)

     

       144
       144
       +
       

     

       145
       145
       +
           def send_command(

     

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

     

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

     

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

     

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

     

       150
       150
       +
       

     

       151
       151
       +
               # Clear previous messages

     

       152
       152
       +
               self.handler.sent_messages.clear()

     

       153
       153
       +
       

     

       154
       154
       +
               # Send command

     

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

     

       156
       156
       +
       

     

       157
       157
       +
               return self.handler.sent_messages.copy()

     

       158
       158
       +
       

     

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

     

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

     

       161
       161
       +
               if self.handler.sent_messages:

     

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

     

       163
       163
       +
               return None

     

       164
       164
       +
       

     

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

     

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

     

       167
       167
       +
               if self.handler.sent_messages:

     

       168
       168
       +
                   return self.handler.sent_messages[-1]

     

       169
       169
       +
               return None

     

       170
       170
       +
       

     

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

     

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

     

       173
       173
       +
               content = self.get_last_response_content()

     

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

     

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

     

       176
       176
       +
       

     

       177
       177
       +
       

     

       178
       178
       +
       # Example usage for testing

     

       179
       179
       +
       if __name__ == "__main__":

     

       180
       180
       +
           # Create a test config file

     

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

     

       182
       182
       +
       

     

       183
       183
       +
           # Create bot tester

     

       184
       184
       +
           tester = BotTester()

     

       185
       185
       +
       

     

       186
       186
       +
           # Test help command

     

       187
       187
       +
           responses = tester.send_command("help")

     

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

     

       189
       189
       +
       

     

       190
       190
       +
           # Test status command

     

       191
       191
       +
           responses = tester.send_command("status")

     

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

     

       193
       193
       +
       

     

       194
       194
       +
           # Test configuration

     

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

     

       196
       196
       +
           tester.assert_response_contains("Stream set to")

     

       197
       197
       +
       

     

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

     

       199
       199
       +
           tester.assert_response_contains("Topic set to")

     

       200
       200
       +
       

     

       201
       201
       +
           print("All tests passed!")

+1257

src/thicket/bots/thicket_bot.py

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       import asyncio

     

       4
       4
       +
       import json

     

       5
       5
       +
       import logging

     

       6
       6
       +
       import os

     

       7
       7
       +
       import time

     

       8
       8
       +
       from pathlib import Path

     

       9
       9
       +
       from typing import Any, Optional

     

       10
       10
       +
       

     

       11
       11
       +
       from zulip_bots.lib import BotHandler

     

       12
       12
       +
       

     

       13
       13
       +
       # Handle imports for both direct execution and package import

     

       14
       14
       +
       try:

     

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

     

       16
       16
       +
           from ..core.git_store import GitStore

     

       17
       17
       +
           from ..models import AtomEntry, ThicketConfig

     

       18
       18
       +
       except ImportError:

     

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

     

       20
       20
       +
           import sys

     

       21
       21
       +
       

     

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

     

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

     

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

     

       25
       25
       +
       

     

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

     

       27
       27
       +
           from thicket.core.git_store import GitStore

     

       28
       28
       +
           from thicket.models import AtomEntry, ThicketConfig

     

       29
       29
       +
       

     

       30
       30
       +
       

     

       31
       31
       +
       class ThicketBotHandler:

     

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

     

       33
       33
       +
       

     

       34
       34
       +
           def __init__(self) -> None:

     

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

     

       36
       36
       +
               self.logger = logging.getLogger(__name__)

     

       37
       37
       +
               self.git_store: Optional[GitStore] = None

     

       38
       38
       +
               self.config: Optional[ThicketConfig] = None

     

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

     

       40
       40
       +
       

     

       41
       41
       +
               # Bot configuration from storage

     

       42
       42
       +
               self.stream_name: Optional[str] = None

     

       43
       43
       +
               self.topic_name: Optional[str] = None

     

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

     

       45
       45
       +
               self.max_entries_per_sync: int = 10

     

       46
       46
       +
               self.config_path: Optional[Path] = None

     

       47
       47
       +
       

     

       48
       48
       +
               # Bot behavior settings (loaded from botrc)

     

       49
       49
       +
               self.rate_limit_delay: int = 5

     

       50
       50
       +
               self.posts_per_batch: int = 5

     

       51
       51
       +
               self.catchup_entries: int = 5

     

       52
       52
       +
               self.config_change_notifications: bool = True

     

       53
       53
       +
               self.username_claim_notifications: bool = True

     

       54
       54
       +
       

     

       55
       55
       +
               # Track last sync time for schedule queries

     

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

     

       57
       57
       +
       

     

       58
       58
       +
               # Debug mode configuration

     

       59
       59
       +
               self.debug_user: Optional[str] = None

     

       60
       60
       +
               self.debug_zulip_user_id: Optional[str] = None

     

       61
       61
       +
       

     

       62
       62
       +
           def usage(self) -> str:

     

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

     

       64
       64
       +
               return """

     

       65
       65
       +
               **Thicket Feed Bot**

     

       66
       66
       +
       

     

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

     

       68
       68
       +
       

     

       69
       69
       +
               Commands:

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       79
       79
       +
               """

     

       80
       80
       +
       

     

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

     

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

     

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

     

       84
       84
       +
       

     

       85
       85
       +
               # Get configuration from environment (set by CLI)

     

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

     

       87
       87
       +
               config_path_env = os.getenv("THICKET_CONFIG_PATH")

     

       88
       88
       +
               if config_path_env:

     

       89
       89
       +
                   self.config_path = Path(config_path_env)

     

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

     

       91
       91
       +
       

     

       92
       92
       +
               # Load default configuration from botrc file

     

       93
       93
       +
               self._load_botrc_defaults()

     

       94
       94
       +
       

     

       95
       95
       +
               # Load bot configuration from persistent storage

     

       96
       96
       +
               self._load_bot_config(bot_handler)

     

       97
       97
       +
       

     

       98
       98
       +
               # Initialize thicket components

     

       99
       99
       +
               if self.config_path:

     

       100
       100
       +
                   try:

     

       101
       101
       +
                       self._initialize_thicket()

     

       102
       102
       +
                       self._load_posted_entries(bot_handler)

     

       103
       103
       +
       

     

       104
       104
       +
                       # Validate debug mode if enabled

     

       105
       105
       +
                       if self.debug_user:

     

       106
       106
       +
                           self._validate_debug_mode(bot_handler)

     

       107
       107
       +
       

     

       108
       108
       +
                   except Exception as e:

     

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

     

       110
       110
       +
       

     

       111
       111
       +
               # Start background sync loop

     

       112
       112
       +
               self._schedule_sync(bot_handler)

     

       113
       113
       +
       

     

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

     

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

     

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

     

       117
       117
       +
               sender = message["sender_full_name"]

     

       118
       118
       +
       

     

       119
       119
       +
               # Only respond to mentions

     

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

     

       121
       121
       +
                   return

     

       122
       122
       +
       

     

       123
       123
       +
               # Parse command

     

       124
       124
       +
               cleaned_content = self._clean_mention(content, bot_handler)

     

       125
       125
       +
               command_parts = cleaned_content.split()

     

       126
       126
       +
       

     

       127
       127
       +
               if not command_parts:

     

       128
       128
       +
                   self._send_help(message, bot_handler)

     

       129
       129
       +
                   return

     

       130
       130
       +
       

     

       131
       131
       +
               command = command_parts[0].lower()

     

       132
       132
       +
       

     

       133
       133
       +
               try:

     

       134
       134
       +
                   if command == "help":

     

       135
       135
       +
                       self._send_help(message, bot_handler)

     

       136
       136
       +
                   elif command == "status":

     

       137
       137
       +
                       self._send_status(message, bot_handler, sender)

     

       138
       138
       +
                   elif (

     

       139
       139
       +
                       command == "sync"

     

       140
       140
       +
                       and len(command_parts) > 1

     

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

     

       142
       142
       +
                   ):

     

       143
       143
       +
                       self._handle_force_sync(message, bot_handler, sender)

     

       144
       144
       +
                   elif command == "reset":

     

       145
       145
       +
                       self._handle_reset_command(message, bot_handler, sender)

     

       146
       146
       +
                   elif command == "config":

     

       147
       147
       +
                       self._handle_config_command(

     

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

     

       149
       149
       +
                       )

     

       150
       150
       +
                   elif command == "schedule":

     

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

     

       152
       152
       +
                   elif command == "claim":

     

       153
       153
       +
                       self._handle_claim_command(

     

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

     

       155
       155
       +
                       )

     

       156
       156
       +
                   else:

     

       157
       157
       +
                       bot_handler.send_reply(

     

       158
       158
       +
                           message,

     

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

     

       160
       160
       +
                       )

     

       161
       161
       +
               except Exception as e:

     

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

     

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

     

       164
       164
       +
       

     

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

     

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

     

       167
       167
       +
               try:

     

       168
       168
       +
                   # Get bot's actual name from Zulip

     

       169
       169
       +
                   bot_info = bot_handler._client.get_profile()

     

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

     

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

     

       172
       172
       +
                       if bot_name:

     

       173
       173
       +
                           return (

     

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

     

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

     

       176
       176
       +
                           )

     

       177
       177
       +
               except Exception as e:

     

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

     

       179
       179
       +
       

     

       180
       180
       +
               # Fallback to generic check

     

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

     

       182
       182
       +
       

     

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

     

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

     

       185
       185
       +
               import re

     

       186
       186
       +
       

     

       187
       187
       +
               try:

     

       188
       188
       +
                   # Get bot's actual name from Zulip

     

       189
       189
       +
                   bot_info = bot_handler._client.get_profile()

     

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

     

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

     

       192
       192
       +
                       if bot_name:

     

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

     

       194
       194
       +
                           escaped_name = re.escape(bot_name)

     

       195
       195
       +
                           content = re.sub(

     

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

     

       197
       197
       +
                               "",

     

       198
       198
       +
                               content,

     

       199
       199
       +
                               flags=re.IGNORECASE,

     

       200
       200
       +
                           ).strip()

     

       201
       201
       +
                           return content

     

       202
       202
       +
               except Exception as e:

     

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

     

       204
       204
       +
       

     

       205
       205
       +
               # Fallback to removing @thicket

     

       206
       206
       +
               content = re.sub(

     

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

     

       208
       208
       +
               ).strip()

     

       209
       209
       +
               return content

     

       210
       210
       +
       

     

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

     

       212
       212
       +
               """Send help message."""

     

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

     

       214
       214
       +
       

     

       215
       215
       +
           def _send_status(

     

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

     

       217
       217
       +
           ) -> None:

     

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

     

       219
       219
       +
               status_lines = [

     

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

     

       221
       221
       +
                   "",

     

       222
       222
       +
               ]

     

       223
       223
       +
       

     

       224
       224
       +
               # Debug mode status

     

       225
       225
       +
               if self.debug_user:

     

       226
       226
       +
                   status_lines.extend(

     

       227
       227
       +
                       [

     

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

     

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

     

       230
       230
       +
                           "",

     

       231
       231
       +
                       ]

     

       232
       232
       +
                   )

     

       233
       233
       +
               else:

     

       234
       234
       +
                   status_lines.extend(

     

       235
       235
       +
                       [

     

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

     

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

     

       238
       238
       +
                           "",

     

       239
       239
       +
                       ]

     

       240
       240
       +
                   )

     

       241
       241
       +
       

     

       242
       242
       +
               status_lines.extend(

     

       243
       243
       +
                   [

     

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

     

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

     

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

     

       247
       247
       +
                       "",

     

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

     

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

     

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

     

       251
       251
       +
                       "",

     

       252
       252
       +
                       self._get_schedule_info(),

     

       253
       253
       +
                   ]

     

       254
       254
       +
               )

     

       255
       255
       +
       

     

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

     

       257
       257
       +
       

     

       258
       258
       +
           def _handle_force_sync(

     

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

     

       260
       260
       +
           ) -> None:

     

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

     

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

     

       263
       263
       +
                   return

     

       264
       264
       +
       

     

       265
       265
       +
               bot_handler.send_reply(

     

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

     

       267
       267
       +
               )

     

       268
       268
       +
       

     

       269
       269
       +
               try:

     

       270
       270
       +
                   new_entries = self._perform_sync(bot_handler)

     

       271
       271
       +
                   bot_handler.send_reply(

     

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

     

       273
       273
       +
                   )

     

       274
       274
       +
               except Exception as e:

     

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

     

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

     

       277
       277
       +
       

     

       278
       278
       +
           def _handle_reset_command(

     

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

     

       280
       280
       +
           ) -> None:

     

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

     

       282
       282
       +
               try:

     

       283
       283
       +
                   self.posted_entries.clear()

     

       284
       284
       +
                   self._save_posted_entries(bot_handler)

     

       285
       285
       +
                   bot_handler.send_reply(

     

       286
       286
       +
                       message,

     

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

     

       288
       288
       +
                   )

     

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

     

       290
       290
       +
               except Exception as e:

     

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

     

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

     

       293
       293
       +
       

     

       294
       294
       +
           def _handle_schedule_command(

     

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

     

       296
       296
       +
           ) -> None:

     

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

     

       298
       298
       +
               schedule_info = self._get_schedule_info()

     

       299
       299
       +
               bot_handler.send_reply(

     

       300
       300
       +
                   message,

     

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

     

       302
       302
       +
               )

     

       303
       303
       +
       

     

       304
       304
       +
           def _handle_claim_command(

     

       305
       305
       +
               self,

     

       306
       306
       +
               message: dict[str, Any],

     

       307
       307
       +
               bot_handler: BotHandler,

     

       308
       308
       +
               args: list[str],

     

       309
       309
       +
               sender: str,

     

       310
       310
       +
           ) -> None:

     

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

     

       312
       312
       +
               if not args:

     

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

     

       314
       314
       +
                   return

     

       315
       315
       +
       

     

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

     

       317
       317
       +
                   return

     

       318
       318
       +
       

     

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

     

       320
       320
       +
       

     

       321
       321
       +
               # Get sender's Zulip user info

     

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

     

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

     

       324
       324
       +
       

     

       325
       325
       +
               if not sender_user_id or not sender_email:

     

       326
       326
       +
                   bot_handler.send_reply(

     

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

     

       328
       328
       +
                   )

     

       329
       329
       +
                   return

     

       330
       330
       +
       

     

       331
       331
       +
               try:

     

       332
       332
       +
                   # Get current Zulip server from environment

     

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

     

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

     

       335
       335
       +
       

     

       336
       336
       +
                   if not server_url:

     

       337
       337
       +
                       bot_handler.send_reply(

     

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

     

       339
       339
       +
                       )

     

       340
       340
       +
                       return

     

       341
       341
       +
       

     

       342
       342
       +
                   # Check if username exists in thicket

     

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

     

       344
       344
       +
                   if not user:

     

       345
       345
       +
                       bot_handler.send_reply(

     

       346
       346
       +
                           message,

     

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

     

       348
       348
       +
                       )

     

       349
       349
       +
                       return

     

       350
       350
       +
       

     

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

     

       352
       352
       +
                   existing_zulip_id = user.get_zulip_mention(server_url)

     

       353
       353
       +
                   if existing_zulip_id:

     

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

     

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

     

       356
       356
       +
                           sender_user_id

     

       357
       357
       +
                       ):

     

       358
       358
       +
                           bot_handler.send_reply(

     

       359
       359
       +
                               message,

     

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

     

       361
       361
       +
                           )

     

       362
       362
       +
                       else:

     

       363
       363
       +
                           bot_handler.send_reply(

     

       364
       364
       +
                               message,

     

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

     

       366
       366
       +
                           )

     

       367
       367
       +
                       return

     

       368
       368
       +
       

     

       369
       369
       +
                   # Claim the username - prefer email for consistency

     

       370
       370
       +
                   success = self.git_store.add_zulip_association(

     

       371
       371
       +
                       username, server_url, sender_email

     

       372
       372
       +
                   )

     

       373
       373
       +
       

     

       374
       374
       +
                   if success:

     

       375
       375
       +
                       reply_msg = (

     

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

     

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

     

       378
       378
       +
                       )

     

       379
       379
       +
                       bot_handler.send_reply(message, reply_msg)

     

       380
       380
       +
       

     

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

     

       382
       382
       +
                       if (

     

       383
       383
       +
                           self.username_claim_notifications

     

       384
       384
       +
                           and not self.debug_user

     

       385
       385
       +
                           and self.stream_name

     

       386
       386
       +
                           and self.topic_name

     

       387
       387
       +
                       ):

     

       388
       388
       +
                           try:

     

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

     

       390
       390
       +
                               bot_handler.send_message(

     

       391
       391
       +
                                   {

     

       392
       392
       +
                                       "type": "stream",

     

       393
       393
       +
                                       "to": self.stream_name,

     

       394
       394
       +
                                       "subject": self.topic_name,

     

       395
       395
       +
                                       "content": notification_msg,

     

       396
       396
       +
                                   }

     

       397
       397
       +
                               )

     

       398
       398
       +
                           except Exception as e:

     

       399
       399
       +
                               self.logger.error(

     

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

     

       401
       401
       +
                               )

     

       402
       402
       +
       

     

       403
       403
       +
                       self.logger.info(

     

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

     

       405
       405
       +
                       )

     

       406
       406
       +
                   else:

     

       407
       407
       +
                       bot_handler.send_reply(

     

       408
       408
       +
                           message,

     

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

     

       410
       410
       +
                       )

     

       411
       411
       +
       

     

       412
       412
       +
               except Exception as e:

     

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

     

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

     

       415
       415
       +
       

     

       416
       416
       +
           def _handle_config_command(

     

       417
       417
       +
               self,

     

       418
       418
       +
               message: dict[str, Any],

     

       419
       419
       +
               bot_handler: BotHandler,

     

       420
       420
       +
               args: list[str],

     

       421
       421
       +
               sender: str,

     

       422
       422
       +
           ) -> None:

     

       423
       423
       +
               """Handle configuration commands."""

     

       424
       424
       +
               if len(args) < 2:

     

       425
       425
       +
                   bot_handler.send_reply(

     

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

     

       427
       427
       +
                   )

     

       428
       428
       +
                   return

     

       429
       429
       +
       

     

       430
       430
       +
               setting = args[0].lower()

     

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

     

       432
       432
       +
       

     

       433
       433
       +
               if setting == "stream":

     

       434
       434
       +
                   old_value = self.stream_name

     

       435
       435
       +
                   self.stream_name = value

     

       436
       436
       +
                   self._save_bot_config(bot_handler)

     

       437
       437
       +
                   bot_handler.send_reply(

     

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

     

       439
       439
       +
                   )

     

       440
       440
       +
                   self._send_config_change_notification(

     

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

     

       442
       442
       +
                   )

     

       443
       443
       +
       

     

       444
       444
       +
               elif setting == "topic":

     

       445
       445
       +
                   old_value = self.topic_name

     

       446
       446
       +
                   self.topic_name = value

     

       447
       447
       +
                   self._save_bot_config(bot_handler)

     

       448
       448
       +
                   bot_handler.send_reply(

     

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

     

       450
       450
       +
                   )

     

       451
       451
       +
                   self._send_config_change_notification(

     

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

     

       453
       453
       +
                   )

     

       454
       454
       +
       

     

       455
       455
       +
               elif setting == "interval":

     

       456
       456
       +
                   try:

     

       457
       457
       +
                       interval = int(value)

     

       458
       458
       +
                       if interval < 60:

     

       459
       459
       +
                           bot_handler.send_reply(

     

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

     

       461
       461
       +
                           )

     

       462
       462
       +
                           return

     

       463
       463
       +
                       old_value = self.sync_interval

     

       464
       464
       +
                       self.sync_interval = interval

     

       465
       465
       +
                       self._save_bot_config(bot_handler)

     

       466
       466
       +
                       bot_handler.send_reply(

     

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

     

       468
       468
       +
                       )

     

       469
       469
       +
                       self._send_config_change_notification(

     

       470
       470
       +
                           bot_handler,

     

       471
       471
       +
                           sender,

     

       472
       472
       +
                           "sync interval",

     

       473
       473
       +
                           f"{old_value}s",

     

       474
       474
       +
                           f"{interval}s",

     

       475
       475
       +
                       )

     

       476
       476
       +
                   except ValueError:

     

       477
       477
       +
                       bot_handler.send_reply(

     

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

     

       479
       479
       +
                       )

     

       480
       480
       +
       

     

       481
       481
       +
               elif setting == "max_entries":

     

       482
       482
       +
                   try:

     

       483
       483
       +
                       max_entries = int(value)

     

       484
       484
       +
                       if max_entries < 1 or max_entries > 50:

     

       485
       485
       +
                           bot_handler.send_reply(

     

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

     

       487
       487
       +
                           )

     

       488
       488
       +
                           return

     

       489
       489
       +
                       old_value = self.max_entries_per_sync

     

       490
       490
       +
                       self.max_entries_per_sync = max_entries

     

       491
       491
       +
                       self._save_bot_config(bot_handler)

     

       492
       492
       +
                       bot_handler.send_reply(

     

       493
       493
       +
                           message,

     

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

     

       495
       495
       +
                       )

     

       496
       496
       +
                       self._send_config_change_notification(

     

       497
       497
       +
                           bot_handler,

     

       498
       498
       +
                           sender,

     

       499
       499
       +
                           "max entries per sync",

     

       500
       500
       +
                           str(old_value),

     

       501
       501
       +
                           str(max_entries),

     

       502
       502
       +
                       )

     

       503
       503
       +
                   except ValueError:

     

       504
       504
       +
                       bot_handler.send_reply(

     

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

     

       506
       506
       +
                       )

     

       507
       507
       +
       

     

       508
       508
       +
               else:

     

       509
       509
       +
                   bot_handler.send_reply(

     

       510
       510
       +
                       message,

     

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

     

       512
       512
       +
                   )

     

       513
       513
       +
       

     

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

     

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

     

       516
       516
       +
               try:

     

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

     

       518
       518
       +
                   if config_data:

     

       519
       519
       +
                       config = json.loads(config_data)

     

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

     

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

     

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

     

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

     

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

     

       525
       525
       +
               except Exception:

     

       526
       526
       +
                   # Bot config not found on first run is expected

     

       527
       527
       +
                   pass

     

       528
       528
       +
       

     

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

     

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

     

       531
       531
       +
               try:

     

       532
       532
       +
                   config_data = {

     

       533
       533
       +
                       "stream_name": self.stream_name,

     

       534
       534
       +
                       "topic_name": self.topic_name,

     

       535
       535
       +
                       "sync_interval": self.sync_interval,

     

       536
       536
       +
                       "max_entries_per_sync": self.max_entries_per_sync,

     

       537
       537
       +
                       "last_sync_time": self.last_sync_time,

     

       538
       538
       +
                   }

     

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

     

       540
       540
       +
               except Exception as e:

     

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

     

       542
       542
       +
       

     

       543
       543
       +
           def _load_botrc_defaults(self) -> None:

     

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

     

       545
       545
       +
               try:

     

       546
       546
       +
                   import configparser

     

       547
       547
       +
                   from pathlib import Path

     

       548
       548
       +
       

     

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

     

       550
       550
       +
                   if not botrc_path.exists():

     

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

     

       552
       552
       +
                       return

     

       553
       553
       +
       

     

       554
       554
       +
                   config = configparser.ConfigParser()

     

       555
       555
       +
                   config.read(botrc_path)

     

       556
       556
       +
       

     

       557
       557
       +
                   if "bot" in config:

     

       558
       558
       +
                       bot_section = config["bot"]

     

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

     

       560
       560
       +
                       self.max_entries_per_sync = bot_section.getint(

     

       561
       561
       +
                           "max_entries_per_sync", 10

     

       562
       562
       +
                       )

     

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

     

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

     

       565
       565
       +
       

     

       566
       566
       +
                       # Set defaults only if not already configured

     

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

     

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

     

       569
       569
       +
                       if default_stream:

     

       570
       570
       +
                           self.stream_name = default_stream

     

       571
       571
       +
                       if default_topic:

     

       572
       572
       +
                           self.topic_name = default_topic

     

       573
       573
       +
       

     

       574
       574
       +
                   if "catchup" in config:

     

       575
       575
       +
                       catchup_section = config["catchup"]

     

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

     

       577
       577
       +
       

     

       578
       578
       +
                   if "notifications" in config:

     

       579
       579
       +
                       notifications_section = config["notifications"]

     

       580
       580
       +
                       self.config_change_notifications = notifications_section.getboolean(

     

       581
       581
       +
                           "config_change_notifications", True

     

       582
       582
       +
                       )

     

       583
       583
       +
                       self.username_claim_notifications = notifications_section.getboolean(

     

       584
       584
       +
                           "username_claim_notifications", True

     

       585
       585
       +
                       )

     

       586
       586
       +
       

     

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

     

       588
       588
       +
       

     

       589
       589
       +
               except Exception as e:

     

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

     

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

     

       592
       592
       +
       

     

       593
       593
       +
           def _initialize_thicket(self) -> None:

     

       594
       594
       +
               """Initialize thicket components."""

     

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

     

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

     

       597
       597
       +
       

     

       598
       598
       +
               # Load thicket configuration

     

       599
       599
       +
               import yaml

     

       600
       600
       +
       

     

       601
       601
       +
               with open(self.config_path) as f:

     

       602
       602
       +
                   config_data = yaml.safe_load(f)

     

       603
       603
       +
               self.config = ThicketConfig(**config_data)

     

       604
       604
       +
       

     

       605
       605
       +
               # Initialize git store

     

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

     

       607
       607
       +
       

     

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

     

       609
       609
       +
       

     

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

     

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

     

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

     

       613
       613
       +
                   return

     

       614
       614
       +
       

     

       615
       615
       +
               # Get current Zulip server from environment

     

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

     

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

     

       618
       618
       +
       

     

       619
       619
       +
               # Check if debug user exists in thicket

     

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

     

       621
       621
       +
               if not user:

     

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

     

       623
       623
       +
       

     

       624
       624
       +
               # Check if user has Zulip association for this server

     

       625
       625
       +
               if not server_url:

     

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

     

       627
       627
       +
       

     

       628
       628
       +
               zulip_user_id = user.get_zulip_mention(server_url)

     

       629
       629
       +
               if not zulip_user_id:

     

       630
       630
       +
                   raise ValueError(

     

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

     

       632
       632
       +
                   )

     

       633
       633
       +
       

     

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

     

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

     

       636
       636
       +
               actual_user_id = self._lookup_zulip_user_id(bot_handler, zulip_user_id)

     

       637
       637
       +
               if actual_user_id and actual_user_id != zulip_user_id:

     

       638
       638
       +
                   # Successfully resolved to numeric ID

     

       639
       639
       +
                   self.debug_zulip_user_id = actual_user_id

     

       640
       640
       +
                   self.logger.info(

     

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

     

       643
       643
       +
               else:

     

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

     

       645
       645
       +
                   self.debug_zulip_user_id = zulip_user_id

     

       646
       646
       +
                   self.logger.info(

     

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

     

       649
       649
       +
       

     

       650
       650
       +
           def _lookup_zulip_user_id(

     

       651
       651
       +
               self, bot_handler: BotHandler, email_or_id: str

     

       652
       652
       +
           ) -> Optional[str]:

     

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

     

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

     

       655
       655
       +
               if email_or_id.isdigit():

     

       656
       656
       +
                   return email_or_id

     

       657
       657
       +
       

     

       658
       658
       +
               try:

     

       659
       659
       +
                   client = bot_handler._client

     

       660
       660
       +
                   if not client:

     

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

     

       662
       662
       +
                       return None

     

       663
       663
       +
       

     

       664
       664
       +
                   # First try the get_user_by_email API if available

     

       665
       665
       +
                   try:

     

       666
       666
       +
                       user_result = client.get_user_by_email(email_or_id)

     

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

     

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

     

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

     

       670
       670
       +
                           if user_id:

     

       671
       671
       +
                               self.logger.info(

     

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

     

       673
       673
       +
                               )

     

       674
       674
       +
                               return str(user_id)

     

       675
       675
       +
                   except (AttributeError, Exception):

     

       676
       676
       +
                       pass

     

       677
       677
       +
       

     

       678
       678
       +
                   # Fallback: Get all users and search through them

     

       679
       679
       +
                   users_result = client.get_users()

     

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

     

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

     

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

     

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

     

       684
       684
       +
       

     

       685
       685
       +
                           if (

     

       686
       686
       +
                               user_email == email_or_id

     

       687
       687
       +
                               or delivery_email == email_or_id

     

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

     

       689
       689
       +
                           ):

     

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

     

       691
       691
       +
                               return str(user_id)

     

       692
       692
       +
       

     

       693
       693
       +
                       self.logger.error(

     

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

     

       695
       695
       +
                       )

     

       696
       696
       +
                       return None

     

       697
       697
       +
                   else:

     

       698
       698
       +
                       self.logger.error(

     

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

     

       700
       700
       +
                       )

     

       701
       701
       +
                       return None

     

       702
       702
       +
       

     

       703
       703
       +
               except Exception as e:

     

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

     

       705
       705
       +
                   return None

     

       706
       706
       +
       

     

       707
       707
       +
           def _lookup_zulip_user_info(

     

       708
       708
       +
               self, bot_handler: BotHandler, email_or_id: str

     

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

     

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

     

       711
       711
       +
               if email_or_id.isdigit():

     

       712
       712
       +
                   return email_or_id, None

     

       713
       713
       +
       

     

       714
       714
       +
               try:

     

       715
       715
       +
                   client = bot_handler._client

     

       716
       716
       +
                   if not client:

     

       717
       717
       +
                       return None, None

     

       718
       718
       +
       

     

       719
       719
       +
                   # Try get_user_by_email API first

     

       720
       720
       +
                   try:

     

       721
       721
       +
                       user_result = client.get_user_by_email(email_or_id)

     

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

     

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

     

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

     

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

     

       726
       726
       +
                           if user_id:

     

       727
       727
       +
                               return str(user_id), full_name

     

       728
       728
       +
                   except AttributeError:

     

       729
       729
       +
                       pass

     

       730
       730
       +
       

     

       731
       731
       +
                   # Fallback: search all users

     

       732
       732
       +
                   users_result = client.get_users()

     

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

     

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

     

       735
       735
       +
                           if (

     

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

     

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

     

       738
       738
       +
                           ):

     

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

     

       740
       740
       +
       

     

       741
       741
       +
                   return None, None

     

       742
       742
       +
       

     

       743
       743
       +
               except Exception as e:

     

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

     

       745
       745
       +
                   return None, None

     

       746
       746
       +
       

     

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

     

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

     

       749
       749
       +
               try:

     

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

     

       751
       751
       +
                   if posted_data:

     

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

     

       753
       753
       +
               except Exception:

     

       754
       754
       +
                   # Empty set on first run is expected

     

       755
       755
       +
                   self.posted_entries = set()

     

       756
       756
       +
       

     

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

     

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

     

       759
       759
       +
               try:

     

       760
       760
       +
                   bot_handler.storage.put(

     

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

     

       762
       762
       +
                   )

     

       763
       763
       +
               except Exception as e:

     

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

     

       765
       765
       +
       

     

       766
       766
       +
           def _check_initialization(

     

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

     

       768
       768
       +
           ) -> bool:

     

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

     

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

     

       771
       771
       +
                   bot_handler.send_reply(

     

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

     

       773
       773
       +
                   )

     

       774
       774
       +
                   return False

     

       775
       775
       +
       

     

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

     

       777
       777
       +
               if self.debug_user:

     

       778
       778
       +
                   return True

     

       779
       779
       +
       

     

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

     

       781
       781
       +
                   bot_handler.send_reply(

     

       782
       782
       +
                       message,

     

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

     

       784
       784
       +
                   )

     

       785
       785
       +
                   return False

     

       786
       786
       +
       

     

       787
       787
       +
               return True

     

       788
       788
       +
       

     

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

     

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

     

       791
       791
       +
       

     

       792
       792
       +
               def sync_loop():

     

       793
       793
       +
                   while True:

     

       794
       794
       +
                       try:

     

       795
       795
       +
                           # Check if we can sync

     

       796
       796
       +
                           can_sync = self.git_store and (

     

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

     

       798
       798
       +
                           )

     

       799
       799
       +
       

     

       800
       800
       +
                           if can_sync:

     

       801
       801
       +
                               self._perform_sync(bot_handler)

     

       802
       802
       +
       

     

       803
       803
       +
                           time.sleep(self.sync_interval)

     

       804
       804
       +
                       except Exception as e:

     

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

     

       806
       806
       +
                           time.sleep(60)  # Wait before retrying

     

       807
       807
       +
       

     

       808
       808
       +
               # Start background thread

     

       809
       809
       +
               import threading

     

       810
       810
       +
       

     

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

     

       812
       812
       +
               sync_thread.start()

     

       813
       813
       +
       

     

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

     

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

     

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

     

       817
       817
       +
                   return []

     

       818
       818
       +
       

     

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

     

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

     

       821
       821
       +
       

     

       822
       822
       +
               # Get all users and their feeds from git store

     

       823
       823
       +
               users_with_feeds = self.git_store.list_all_users_with_feeds()

     

       824
       824
       +
       

     

       825
       825
       +
               # Sync each user's feeds

     

       826
       826
       +
               for username, feed_urls in users_with_feeds:

     

       827
       827
       +
                   for feed_url in feed_urls:

     

       828
       828
       +
                       try:

     

       829
       829
       +
                           # Run async sync function

     

       830
       830
       +
                           loop = asyncio.new_event_loop()

     

       831
       831
       +
                           asyncio.set_event_loop(loop)

     

       832
       832
       +
                           try:

     

       833
       833
       +
                               new_count, _ = loop.run_until_complete(

     

       834
       834
       +
                                   sync_feed(

     

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

     

       836
       836
       +
                                   )

     

       837
       837
       +
                               )

     

       838
       838
       +
       

     

       839
       839
       +
                               entries_to_check = []

     

       840
       840
       +
       

     

       841
       841
       +
                               if new_count > 0:

     

       842
       842
       +
                                   # Get the newly added entries

     

       843
       843
       +
                                   entries_to_check = self.git_store.list_entries(

     

       844
       844
       +
                                       username, limit=new_count

     

       845
       845
       +
                                   )

     

       846
       846
       +
       

     

       847
       847
       +
                               # Always check for catchup mode on first run

     

       848
       848
       +
                               if is_first_run:

     

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

     

       850
       850
       +
                                   catchup_entries = self.git_store.list_entries(

     

       851
       851
       +
                                       username, limit=self.catchup_entries

     

       852
       852
       +
                                   )

     

       853
       853
       +
                                   entries_to_check = (

     

       854
       854
       +
                                       catchup_entries

     

       855
       855
       +
                                       if not entries_to_check

     

       856
       856
       +
                                       else entries_to_check

     

       857
       857
       +
                                   )

     

       858
       858
       +
       

     

       859
       859
       +
                               for entry in entries_to_check:

     

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

     

       861
       861
       +
                                   if entry_key not in self.posted_entries:

     

       862
       862
       +
                                       new_entries.append((entry, username))

     

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

     

       864
       864
       +
                                           break

     

       865
       865
       +
       

     

       866
       866
       +
                           finally:

     

       867
       867
       +
                               loop.close()

     

       868
       868
       +
       

     

       869
       869
       +
                       except Exception as e:

     

       870
       870
       +
                           self.logger.error(

     

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

     

       872
       872
       +
                           )

     

       873
       873
       +
       

     

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

     

       875
       875
       +
                           break

     

       876
       876
       +
       

     

       877
       877
       +
               # Post new entries to Zulip with rate limiting

     

       878
       878
       +
               if new_entries:

     

       879
       879
       +
                   posted_count = 0

     

       880
       880
       +
       

     

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

     

       882
       882
       +
                       self._post_entry_to_zulip(entry, bot_handler, username)

     

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

     

       884
       884
       +
                       posted_count += 1

     

       885
       885
       +
       

     

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

     

       887
       887
       +
                       if (

     

       888
       888
       +
                           posted_count % self.posts_per_batch == 0

     

       889
       889
       +
                           and i < len(new_entries) - 1

     

       890
       890
       +
                       ):

     

       891
       891
       +
                           time.sleep(self.rate_limit_delay)

     

       892
       892
       +
       

     

       893
       893
       +
                   self._save_posted_entries(bot_handler)

     

       894
       894
       +
       

     

       895
       895
       +
               # Update last sync time

     

       896
       896
       +
               self.last_sync_time = time.time()

     

       897
       897
       +
       

     

       898
       898
       +
               return [entry for entry, _ in new_entries]

     

       899
       899
       +
       

     

       900
       900
       +
           def _post_entry_to_zulip(

     

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

     

       902
       902
       +
           ) -> None:

     

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

     

       904
       904
       +
               try:

     

       905
       905
       +
                   # Get current Zulip server from environment

     

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

     

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

     

       908
       908
       +
       

     

       909
       909
       +
                   # Build author/date info consistently

     

       910
       910
       +
                   mention_info = ""

     

       911
       911
       +
                   if server_url and self.git_store:

     

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

     

       913
       913
       +
                       if user:

     

       914
       914
       +
                           zulip_user_id = user.get_zulip_mention(server_url)

     

       915
       915
       +
                           if zulip_user_id:

     

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

     

       917
       917
       +
                               _, zulip_full_name = self._lookup_zulip_user_info(

     

       918
       918
       +
                                   bot_handler, zulip_user_id

     

       919
       919
       +
                               )

     

       920
       920
       +
                               display_name = zulip_full_name or user.display_name or username

     

       921
       921
       +
       

     

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

     

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

     

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

     

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

     

       926
       926
       +
                               else:

     

       927
       927
       +
                                   author_info = ""

     

       928
       928
       +
       

     

       929
       929
       +
                               published_info = ""

     

       930
       930
       +
                               if entry.published:

     

       931
       931
       +
                                   published_info = (

     

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

     

       933
       933
       +
                                   )

     

       934
       934
       +
       

     

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

     

       936
       936
       +
       

     

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

     

       938
       938
       +
                   if not mention_info:

     

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

     

       940
       940
       +
                       display_name = user.display_name if user else username

     

       941
       941
       +
       

     

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

     

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

     

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

     

       945
       945
       +
                       else:

     

       946
       946
       +
                           author_info = ""

     

       947
       947
       +
       

     

       948
       948
       +
                       published_info = ""

     

       949
       949
       +
                       if entry.published:

     

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

     

       951
       951
       +
       

     

       952
       952
       +
                       mention_info = (

     

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

     

       954
       954
       +
                       )

     

       955
       955
       +
       

     

       956
       956
       +
                   # Format the message with HTML processing

     

       957
       957
       +
                   message_lines = [

     

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

     

       959
       959
       +
                       f"🔗 {entry.link}",

     

       960
       960
       +
                   ]

     

       961
       961
       +
       

     

       962
       962
       +
                   if entry.summary:

     

       963
       963
       +
                       # Process HTML in summary and truncate if needed

     

       964
       964
       +
                       processed_summary = self._process_html_content(entry.summary)

     

       965
       965
       +
                       if len(processed_summary) > 400:

     

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

     

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

     

       968
       968
       +
       

     

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

     

       970
       970
       +
       

     

       971
       971
       +
                   # Choose destination based on mode

     

       972
       972
       +
                   if self.debug_user and self.debug_zulip_user_id:

     

       973
       973
       +
                       # Debug mode: send DM

     

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

     

       975
       975
       +
       

     

       976
       976
       +
                       # Ensure we have the numeric user ID

     

       977
       977
       +
                       user_id_to_use = self.debug_zulip_user_id

     

       978
       978
       +
                       if not user_id_to_use.isdigit():

     

       979
       979
       +
                           # Need to look up the numeric ID

     

       980
       980
       +
                           resolved_id = self._lookup_zulip_user_id(

     

       981
       981
       +
                               bot_handler, user_id_to_use

     

       982
       982
       +
                           )

     

       983
       983
       +
                           if resolved_id:

     

       984
       984
       +
                               user_id_to_use = resolved_id

     

       985
       985
       +
                               self.logger.debug(

     

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

     

       987
       987
       +
                               )

     

       988
       988
       +
                           else:

     

       989
       989
       +
                               self.logger.error(

     

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

     

       991
       991
       +
                               )

     

       992
       992
       +
                               return

     

       993
       993
       +
       

     

       994
       994
       +
                       try:

     

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

     

       996
       996
       +
                           user_id_int = int(user_id_to_use)

     

       997
       997
       +
                           bot_handler.send_message(

     

       998
       998
       +
                               {

     

       999
       999
       +
                                   "type": "private",

     

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

     

       1001
       1001
       +
                                   "content": debug_message,

     

       1002
       1002
       +
                               }

     

       1003
       1003
       +
                           )

     

       1004
       1004
       +
                       except ValueError:

     

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

     

       1006
       1006
       +
                           try:

     

       1007
       1007
       +
                               bot_handler.send_message(

     

       1008
       1008
       +
                                   {

     

       1009
       1009
       +
                                       "type": "private",

     

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

     

       1011
       1011
       +
                                       "content": debug_message,

     

       1012
       1012
       +
                                   }

     

       1013
       1013
       +
                               )

     

       1014
       1014
       +
                           except Exception as e2:

     

       1015
       1015
       +
                               self.logger.error(

     

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

     

       1017
       1017
       +
                               )

     

       1018
       1018
       +
                               return

     

       1019
       1019
       +
                       except Exception as e:

     

       1020
       1020
       +
                           self.logger.error(

     

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

     

       1022
       1022
       +
                           )

     

       1023
       1023
       +
                           return

     

       1024
       1024
       +
                       self.logger.info(

     

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

     

       1026
       1026
       +
                       )

     

       1027
       1027
       +
                   else:

     

       1028
       1028
       +
                       # Normal mode: send to stream/topic

     

       1029
       1029
       +
                       bot_handler.send_message(

     

       1030
       1030
       +
                           {

     

       1031
       1031
       +
                               "type": "stream",

     

       1032
       1032
       +
                               "to": self.stream_name,

     

       1033
       1033
       +
                               "subject": self.topic_name,

     

       1034
       1034
       +
                               "content": message_content,

     

       1035
       1035
       +
                           }

     

       1036
       1036
       +
                       )

     

       1037
       1037
       +
                       self.logger.info(

     

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

     

       1039
       1039
       +
                       )

     

       1040
       1040
       +
       

     

       1041
       1041
       +
               except Exception as e:

     

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

     

       1043
       1043
       +
       

     

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

     

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

     

       1046
       1046
       +
               if not html_content:

     

       1047
       1047
       +
                   return ""

     

       1048
       1048
       +
       

     

       1049
       1049
       +
               try:

     

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

     

       1051
       1051
       +
                   from markdownify import markdownify as md

     

       1052
       1052
       +
       

     

       1053
       1053
       +
                   # Convert HTML to Markdown with compact settings for summaries

     

       1054
       1054
       +
                   markdown = md(

     

       1055
       1055
       +
                       html_content,

     

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

     

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

     

       1058
       1058
       +
                       convert=[

     

       1059
       1059
       +
                           "a",

     

       1060
       1060
       +
                           "b",

     

       1061
       1061
       +
                           "strong",

     

       1062
       1062
       +
                           "i",

     

       1063
       1063
       +
                           "em",

     

       1064
       1064
       +
                           "code",

     

       1065
       1065
       +
                           "pre",

     

       1066
       1066
       +
                           "p",

     

       1067
       1067
       +
                           "br",

     

       1068
       1068
       +
                           "ul",

     

       1069
       1069
       +
                           "ol",

     

       1070
       1070
       +
                           "li",

     

       1071
       1071
       +
                           "h1",

     

       1072
       1072
       +
                           "h2",

     

       1073
       1073
       +
                           "h3",

     

       1074
       1074
       +
                           "h4",

     

       1075
       1075
       +
                           "h5",

     

       1076
       1076
       +
                           "h6",

     

       1077
       1077
       +
                       ],

     

       1078
       1078
       +
                   ).strip()

     

       1079
       1079
       +
       

     

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

     

       1081
       1081
       +
                   import re

     

       1082
       1082
       +
       

     

       1083
       1083
       +
                   # Convert markdown headers to bold with period

     

       1084
       1084
       +
                   markdown = re.sub(

     

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

     

       1086
       1086
       +
                   )

     

       1087
       1087
       +
       

     

       1088
       1088
       +
                   # Clean up excessive newlines and make more compact

     

       1089
       1089
       +
                   markdown = re.sub(

     

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

     

       1091
       1091
       +
                   )  # Multiple newlines become space

     

       1092
       1092
       +
                   markdown = re.sub(

     

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

     

       1094
       1094
       +
                   )  # Double newlines become sentence breaks

     

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

     

       1096
       1096
       +
       

     

       1097
       1097
       +
                   # Clean up double periods and excessive whitespace

     

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

     

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

     

       1100
       1100
       +
                   return markdown.strip()

     

       1101
       1101
       +
       

     

       1102
       1102
       +
               except ImportError:

     

       1103
       1103
       +
                   # Fallback: manual HTML processing

     

       1104
       1104
       +
                   import re

     

       1105
       1105
       +
       

     

       1106
       1106
       +
                   content = html_content

     

       1107
       1107
       +
       

     

       1108
       1108
       +
                   # Convert headings to bold with periods for compact summaries

     

       1109
       1109
       +
                   content = re.sub(

     

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

     

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

     

       1112
       1112
       +
                       content,

     

       1113
       1113
       +
                       flags=re.IGNORECASE,

     

       1114
       1114
       +
                   )

     

       1115
       1115
       +
       

     

       1116
       1116
       +
                   # Convert common HTML elements to Markdown

     

       1117
       1117
       +
                   content = re.sub(

     

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

     

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

     

       1120
       1120
       +
                       content,

     

       1121
       1121
       +
                       flags=re.IGNORECASE,

     

       1122
       1122
       +
                   )

     

       1123
       1123
       +
                   content = re.sub(

     

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

     

       1125
       1125
       +
                       r"*\1*",

     

       1126
       1126
       +
                       content,

     

       1127
       1127
       +
                       flags=re.IGNORECASE,

     

       1128
       1128
       +
                   )

     

       1129
       1129
       +
                   content = re.sub(

     

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

     

       1131
       1131
       +
                       r"`\1`",

     

       1132
       1132
       +
                       content,

     

       1133
       1133
       +
                       flags=re.IGNORECASE,

     

       1134
       1134
       +
                   )

     

       1135
       1135
       +
                   content = re.sub(

     

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

     

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

     

       1138
       1138
       +
                       content,

     

       1139
       1139
       +
                       flags=re.IGNORECASE,

     

       1140
       1140
       +
                   )

     

       1141
       1141
       +
       

     

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

     

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

     

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

     

       1145
       1145
       +
                   content = re.sub(

     

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

     

       1147
       1147
       +
                   )

     

       1148
       1148
       +
       

     

       1149
       1149
       +
                   # Remove remaining HTML tags

     

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

     

       1151
       1151
       +
       

     

       1152
       1152
       +
                   # Clean up whitespace and make compact

     

       1153
       1153
       +
                   content = re.sub(

     

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

     

       1155
       1155
       +
                   )  # Multiple whitespace becomes single space

     

       1156
       1156
       +
                   content = re.sub(

     

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

     

       1158
       1158
       +
                   )  # Multiple periods become single period

     

       1159
       1159
       +
                   return content.strip()

     

       1160
       1160
       +
       

     

       1161
       1161
       +
               except Exception as e:

     

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

     

       1163
       1163
       +
                   # Last resort: just strip HTML tags

     

       1164
       1164
       +
                   import re

     

       1165
       1165
       +
       

     

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

     

       1167
       1167
       +
       

     

       1168
       1168
       +
           def _get_schedule_info(self) -> str:

     

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

     

       1170
       1170
       +
               lines = []

     

       1171
       1171
       +
       

     

       1172
       1172
       +
               if self.last_sync_time:

     

       1173
       1173
       +
                   import datetime

     

       1174
       1174
       +
       

     

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

     

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

     

       1177
       1177
       +
                   now = datetime.datetime.now()

     

       1178
       1178
       +
       

     

       1179
       1179
       +
                   # Calculate time until next sync

     

       1180
       1180
       +
                   time_until_next = next_sync - now

     

       1181
       1181
       +
       

     

       1182
       1182
       +
                   if time_until_next.total_seconds() > 0:

     

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

     

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

     

       1185
       1185
       +
       

     

       1186
       1186
       +
                       if hours > 0:

     

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

     

       1188
       1188
       +
                       elif minutes > 0:

     

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

     

       1190
       1190
       +
                       else:

     

       1191
       1191
       +
                           time_str = f"{seconds}s"

     

       1192
       1192
       +
       

     

       1193
       1193
       +
                       lines.extend(

     

       1194
       1194
       +
                           [

     

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

     

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

     

       1197
       1197
       +
                           ]

     

       1198
       1198
       +
                       )

     

       1199
       1199
       +
                   else:

     

       1200
       1200
       +
                       lines.extend(

     

       1201
       1201
       +
                           [

     

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

     

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

     

       1204
       1204
       +
                           ]

     

       1205
       1205
       +
                       )

     

       1206
       1206
       +
               else:

     

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

     

       1208
       1208
       +
       

     

       1209
       1209
       +
               # Add sync frequency info

     

       1210
       1210
       +
               if self.sync_interval >= 3600:

     

       1211
       1211
       +
                   frequency_str = (

     

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

     

       1213
       1213
       +
                   )

     

       1214
       1214
       +
               elif self.sync_interval >= 60:

     

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

     

       1216
       1216
       +
               else:

     

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

     

       1218
       1218
       +
       

     

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

     

       1220
       1220
       +
       

     

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

     

       1222
       1222
       +
       

     

       1223
       1223
       +
           def _send_config_change_notification(

     

       1224
       1224
       +
               self,

     

       1225
       1225
       +
               bot_handler: BotHandler,

     

       1226
       1226
       +
               changer: str,

     

       1227
       1227
       +
               setting: str,

     

       1228
       1228
       +
               old_value: Optional[str],

     

       1229
       1229
       +
               new_value: str,

     

       1230
       1230
       +
           ) -> None:

     

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

     

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

     

       1233
       1233
       +
                   return

     

       1234
       1234
       +
       

     

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

     

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

     

       1237
       1237
       +
                   return

     

       1238
       1238
       +
       

     

       1239
       1239
       +
               try:

     

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

     

       1241
       1241
       +
                   notification_msg = (

     

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

     

       1243
       1243
       +
                   )

     

       1244
       1244
       +
       

     

       1245
       1245
       +
                   bot_handler.send_message(

     

       1246
       1246
       +
                       {

     

       1247
       1247
       +
                           "type": "stream",

     

       1248
       1248
       +
                           "to": self.stream_name,

     

       1249
       1249
       +
                           "subject": self.topic_name,

     

       1250
       1250
       +
                           "content": notification_msg,

     

       1251
       1251
       +
                       }

     

       1252
       1252
       +
                   )

     

       1253
       1253
       +
               except Exception as e:

     

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

     

       1255
       1255
       +
       

     

       1256
       1256
       +
       

     

       1257
       1257
       +
       handler_class = ThicketBotHandler

+24 -2

src/thicket/cli/commands/__init__.py

···

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

     

       2
       2
        
       

     

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

     

       4
       4
       -
       from . import add, duplicates, index_cmd, info_cmd, init, links_cmd, list_cmd, sync

     

       4
       4
       +
       from . import (

     

       5
       5
       +
           add,

     

       6
       6
       +
           bot,

     

       7
       7
       +
           duplicates,

     

       8
       8
       +
           info_cmd,

     

       9
       9
       +
           init,

     

       10
       10
       +
           list_cmd,

     

       11
       11
       +
           search,

     

       12
       12
       +
           sync,

     

       13
       13
       +
           upload,

     

       14
       14
       +
           zulip,

     

       15
       15
       +
       )

     

       5
       16
        
       

     

       6
       6
       -
       __all__ = ["add", "duplicates", "index_cmd", "info_cmd", "init", "links_cmd", "list_cmd", "sync"]

     

       17
       17
       +
       __all__ = [

     

       18
       18
       +
           "add",

     

       19
       19
       +
           "bot",

     

       20
       20
       +
           "duplicates",

     

       21
       21
       +
           "info_cmd",

     

       22
       22
       +
           "init",

     

       23
       23
       +
           "list_cmd",

     

       24
       24
       +
           "search",

     

       25
       25
       +
           "sync",

     

       26
       26
       +
           "upload",

     

       27
       27
       +
           "zulip",

     

       28
       28
       +
       ]

+44 -9

src/thicket/cli/commands/add.py

···

       23
       23
        
       def add_command(

     

       24
       24
        
           subcommand: str = typer.Argument(..., help="Subcommand: 'user' or 'feed'"),

     

       25
       25
        
           username: str = typer.Argument(..., help="Username"),

     

       26
       26
       -
           feed_url: Optional[str] = typer.Argument(None, help="Feed URL (required for 'user' command)"),

     

       26
       26
       +
           feed_url: Optional[str] = typer.Argument(

     

       27
       27
       +
               None, help="Feed URL (required for 'user' command)"

     

       28
       28
       +
           ),

     

       27
       29
        
           email: Optional[str] = typer.Option(None, "--email", "-e", help="User email"),

     

       28
       28
       -
           homepage: Optional[str] = typer.Option(None, "--homepage", "-h", help="User homepage"),

     

       30
       30
       +
           homepage: Optional[str] = typer.Option(

     

       31
       31
       +
               None, "--homepage", "-h", help="User homepage"

     

       32
       32
       +
           ),

     

       29
       33
        
           icon: Optional[str] = typer.Option(None, "--icon", "-i", help="User icon URL"),

     

       30
       30
       -
           display_name: Optional[str] = typer.Option(None, "--display-name", "-d", help="User display name"),

     

       34
       34
       +
           display_name: Optional[str] = typer.Option(

     

       35
       35
       +
               None, "--display-name", "-d", help="User display name"

     

       36
       36
       +
           ),

     

       31
       37
        
           config_file: Optional[Path] = typer.Option(

     

       32
       38
        
               Path("thicket.yaml"), "--config", help="Configuration file path"

     

       33
       39
        
           ),

     

       34
       40
        
           auto_discover: bool = typer.Option(

     

       35
       35
       -
               True, "--auto-discover/--no-auto-discover", help="Auto-discover user metadata from feed"

     

       41
       41
       +
               True,

     

       42
       42
       +
               "--auto-discover/--no-auto-discover",

     

       43
       43
       +
               help="Auto-discover user metadata from feed",

     

       36
       44
        
           ),

     

       37
       45
        
       ) -> None:

     

       38
       46
        
           """Add a user or feed to thicket."""

     

       39
       47
        
       

     

       40
       48
        
           if subcommand == "user":

     

       41
       41
       -
               add_user(username, feed_url, email, homepage, icon, display_name, config_file, auto_discover)

     

       49
       49
       +
               add_user(

     

       50
       50
       +
                   username,

     

       51
       51
       +
                   feed_url,

     

       52
       52
       +
                   email,

     

       53
       53
       +
                   homepage,

     

       54
       54
       +
                   icon,

     

       55
       55
       +
                   display_name,

     

       56
       56
       +
                   config_file,

     

       57
       57
       +
                   auto_discover,

     

       58
       58
       +
               )

     

       42
       59
        
           elif subcommand == "feed":

     

       43
       60
        
               add_feed(username, feed_url, config_file)

     

       44
       61
        
           else:

     
···

       89
       106
        
               discovered_metadata = asyncio.run(discover_feed_metadata(validated_feed_url))

     

       90
       107
        
       

     

       91
       108
        
           # Prepare user data with manual overrides taking precedence

     

       92
       92
       -
           user_display_name = display_name or (discovered_metadata.author_name or discovered_metadata.title if discovered_metadata else None)

     

       93
       93
       -
           user_email = email or (discovered_metadata.author_email if discovered_metadata else None)

     

       94
       94
       -
           user_homepage = homepage or (str(discovered_metadata.author_uri or discovered_metadata.link) if discovered_metadata else None)

     

       95
       95
       -
           user_icon = icon or (str(discovered_metadata.logo or discovered_metadata.icon or discovered_metadata.image_url) if discovered_metadata else None)

     

       109
       109
       +
           user_display_name = display_name or (

     

       110
       110
       +
               discovered_metadata.author_name or discovered_metadata.title

     

       111
       111
       +
               if discovered_metadata

     

       112
       112
       +
               else None

     

       113
       113
       +
           )

     

       114
       114
       +
           user_email = email or (

     

       115
       115
       +
               discovered_metadata.author_email if discovered_metadata else None

     

       116
       116
       +
           )

     

       117
       117
       +
           user_homepage = homepage or (

     

       118
       118
       +
               str(discovered_metadata.author_uri or discovered_metadata.link)

     

       119
       119
       +
               if discovered_metadata

     

       120
       120
       +
               else None

     

       121
       121
       +
           )

     

       122
       122
       +
           user_icon = icon or (

     

       123
       123
       +
               str(

     

       124
       124
       +
                   discovered_metadata.logo

     

       125
       125
       +
                   or discovered_metadata.icon

     

       126
       126
       +
                   or discovered_metadata.image_url

     

       127
       127
       +
               )

     

       128
       128
       +
               if discovered_metadata

     

       129
       129
       +
               else None

     

       130
       130
       +
           )

     

       96
       131
        
       

     

       97
       132
        
           # Add user to Git store

     

       98
       133
        
           git_store.add_user(

+247

src/thicket/cli/commands/bot.py

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       import subprocess

     

       4
       4
       +
       import sys

     

       5
       5
       +
       from pathlib import Path

     

       6
       6
       +
       

     

       7
       7
       +
       import typer

     

       8
       8
       +
       from rich.console import Console

     

       9
       9
       +
       

     

       10
       10
       +
       from ..main import app

     

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

     

       12
       12
       +
       

     

       13
       13
       +
       console = Console()

     

       14
       14
       +
       

     

       15
       15
       +
       

     

       16
       16
       +
       @app.command()

     

       17
       17
       +
       def bot(

     

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

     

       19
       19
       +
           config_file: Path = typer.Option(

     

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

     

       21
       21
       +
               "--config",

     

       22
       22
       +
               "-c",

     

       23
       23
       +
               help="Zulip bot configuration file",

     

       24
       24
       +
           ),

     

       25
       25
       +
           thicket_config: Path = typer.Option(

     

       26
       26
       +
               Path("thicket.yaml"),

     

       27
       27
       +
               "--thicket-config",

     

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

     

       29
       29
       +
           ),

     

       30
       30
       +
           daemon: bool = typer.Option(

     

       31
       31
       +
               False,

     

       32
       32
       +
               "--daemon",

     

       33
       33
       +
               "-d",

     

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

     

       35
       35
       +
           ),

     

       36
       36
       +
           debug_user: str = typer.Option(

     

       37
       37
       +
               None,

     

       38
       38
       +
               "--debug-user",

     

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

     

       40
       40
       +
           ),

     

       41
       41
       +
       ) -> None:

     

       42
       42
       +
           """Manage the Thicket Zulip bot.

     

       43
       43
       +
       

     

       44
       44
       +
           Actions:

     

       45
       45
       +
           - run: Start the Zulip bot

     

       46
       46
       +
           - test: Test bot functionality

     

       47
       47
       +
           - status: Show bot status

     

       48
       48
       +
           """

     

       49
       49
       +
       

     

       50
       50
       +
           if action == "run":

     

       51
       51
       +
               _run_bot(config_file, thicket_config, daemon, debug_user)

     

       52
       52
       +
           elif action == "test":

     

       53
       53
       +
               _test_bot()

     

       54
       54
       +
           elif action == "status":

     

       55
       55
       +
               _bot_status(config_file)

     

       56
       56
       +
           else:

     

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

     

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

     

       59
       59
       +
               raise typer.Exit(1)

     

       60
       60
       +
       

     

       61
       61
       +
       

     

       62
       62
       +
       def _run_bot(

     

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

     

       64
       64
       +
       ) -> None:

     

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

     

       66
       66
       +
           if not config_file.exists():

     

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

     

       68
       68
       +
               print_info(

     

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

     

       70
       70
       +
               )

     

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

     

       72
       72
       +
               raise typer.Exit(1)

     

       73
       73
       +
       

     

       74
       74
       +
           if not thicket_config.exists():

     

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

     

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

     

       77
       77
       +
               raise typer.Exit(1)

     

       78
       78
       +
       

     

       79
       79
       +
           # Parse zuliprc to extract server URL

     

       80
       80
       +
           zulip_site_url = _parse_zulip_config(config_file)

     

       81
       81
       +
       

     

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

     

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

     

       84
       84
       +
       

     

       85
       85
       +
           if debug_user:

     

       86
       86
       +
               print_info(

     

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

     

       88
       88
       +
               )

     

       89
       89
       +
       

     

       90
       90
       +
           if daemon:

     

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

     

       92
       92
       +
           else:

     

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

     

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

     

       95
       95
       +
       

     

       96
       96
       +
           try:

     

       97
       97
       +
               # Build the command

     

       98
       98
       +
               cmd = [

     

       99
       99
       +
                   sys.executable,

     

       100
       100
       +
                   "-m",

     

       101
       101
       +
                   "zulip_bots.run",

     

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

     

       103
       103
       +
                   "--config-file",

     

       104
       104
       +
                   str(config_file),

     

       105
       105
       +
               ]

     

       106
       106
       +
       

     

       107
       107
       +
               # Add environment variables for bot configuration

     

       108
       108
       +
               import os

     

       109
       109
       +
       

     

       110
       110
       +
               env = os.environ.copy()

     

       111
       111
       +
       

     

       112
       112
       +
               # Always pass thicket config path

     

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

     

       114
       114
       +
       

     

       115
       115
       +
               # Add debug user if specified

     

       116
       116
       +
               if debug_user:

     

       117
       117
       +
                   env["THICKET_DEBUG_USER"] = debug_user

     

       118
       118
       +
       

     

       119
       119
       +
               # Pass Zulip server URL to bot

     

       120
       120
       +
               if zulip_site_url:

     

       121
       121
       +
                   env["THICKET_ZULIP_SITE_URL"] = zulip_site_url

     

       122
       122
       +
       

     

       123
       123
       +
               if daemon:

     

       124
       124
       +
                   # Run in background

     

       125
       125
       +
                   process = subprocess.Popen(

     

       126
       126
       +
                       cmd,

     

       127
       127
       +
                       stdout=subprocess.DEVNULL,

     

       128
       128
       +
                       stderr=subprocess.DEVNULL,

     

       129
       129
       +
                       start_new_session=True,

     

       130
       130
       +
                       env=env,

     

       131
       131
       +
                   )

     

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

     

       133
       133
       +
               else:

     

       134
       134
       +
                   # Run in foreground

     

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

     

       136
       136
       +
       

     

       137
       137
       +
           except subprocess.CalledProcessError as e:

     

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

     

       139
       139
       +
               raise typer.Exit(1) from e

     

       140
       140
       +
           except KeyboardInterrupt:

     

       141
       141
       +
               print_info("Bot stopped by user")

     

       142
       142
       +
       

     

       143
       143
       +
       

     

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

     

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

     

       146
       146
       +
           try:

     

       147
       147
       +
               import configparser

     

       148
       148
       +
       

     

       149
       149
       +
               config = configparser.ConfigParser()

     

       150
       150
       +
               config.read(config_file)

     

       151
       151
       +
       

     

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

     

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

     

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

     

       155
       155
       +
                   return site_url

     

       156
       156
       +
               else:

     

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

     

       158
       158
       +
                   return ""

     

       159
       159
       +
       

     

       160
       160
       +
           except Exception as e:

     

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

     

       162
       162
       +
               return ""

     

       163
       163
       +
       

     

       164
       164
       +
       

     

       165
       165
       +
       def _test_bot() -> None:

     

       166
       166
       +
           """Test bot functionality."""

     

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

     

       168
       168
       +
       

     

       169
       169
       +
           try:

     

       170
       170
       +
               from ...bots.test_bot import BotTester

     

       171
       171
       +
       

     

       172
       172
       +
               # Create bot tester

     

       173
       173
       +
               tester = BotTester()

     

       174
       174
       +
       

     

       175
       175
       +
               # Test basic functionality

     

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

     

       177
       177
       +
               responses = tester.send_command("help")

     

       178
       178
       +
               assert len(responses) == 1

     

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

     

       180
       180
       +
       

     

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

     

       182
       182
       +
               responses = tester.send_command("status")

     

       183
       183
       +
               assert len(responses) == 1

     

       184
       184
       +
               assert "Status" in tester.get_last_response_content()

     

       185
       185
       +
       

     

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

     

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

     

       188
       188
       +
               tester.assert_response_contains("Stream set to")

     

       189
       189
       +
       

     

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

     

       191
       191
       +
               tester.assert_response_contains("Topic set to")

     

       192
       192
       +
       

     

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

     

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

     

       195
       195
       +
       

     

       196
       196
       +
               print_success("All bot tests passed!")

     

       197
       197
       +
       

     

       198
       198
       +
           except Exception as e:

     

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

     

       200
       200
       +
               raise typer.Exit(1) from e

     

       201
       201
       +
       

     

       202
       202
       +
       

     

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

     

       204
       204
       +
           """Show bot status."""

     

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

     

       206
       206
       +
           console.print()

     

       207
       207
       +
       

     

       208
       208
       +
           # Check config file

     

       209
       209
       +
           if config_file.exists():

     

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

     

       211
       211
       +
           else:

     

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

     

       213
       213
       +
               console.print(

     

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

     

       215
       215
       +
               )

     

       216
       216
       +
               console.print(

     

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

     

       218
       218
       +
               )

     

       219
       219
       +
       

     

       220
       220
       +
           # Check dependencies

     

       221
       221
       +
           try:

     

       222
       222
       +
               import zulip_bots

     

       223
       223
       +
       

     

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

     

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

     

       226
       226
       +
           except ImportError:

     

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

     

       228
       228
       +
       

     

       229
       229
       +
           try:

     

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

     

       231
       231
       +
       

     

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

     

       233
       233
       +
           except ImportError as e:

     

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

     

       235
       235
       +
       

     

       236
       236
       +
           # Check bot file

     

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

     

       238
       238
       +
           if bot_file.exists():

     

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

     

       240
       240
       +
           else:

     

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

     

       242
       242
       +
       

     

       243
       243
       +
           console.print()

     

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

     

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

     

       246
       246
       +
           console.print()

     

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

+7 -3

src/thicket/cli/commands/duplicates.py

···

       10
       10
        
       from ..main import app

     

       11
       11
        
       from ..utils import (

     

       12
       12
        
           console,

     

       13
       13
       +
           get_tsv_mode,

     

       13
       14
        
           load_config,

     

       14
       15
        
           print_error,

     

       15
       16
        
           print_info,

     

       16
       17
        
           print_success,

     

       17
       17
       -
           get_tsv_mode,

     

       18
       18
        
       )

     

       19
       19
        
       

     

       20
       20
        
       

     
···

       75
       75
        
               print_info(f"Total duplicates: {len(duplicates.duplicates)}")

     

       76
       76
        
       

     

       77
       77
        
       

     

       78
       78
       -
       def add_duplicate(git_store: GitStore, duplicate_id: Optional[str], canonical_id: Optional[str]) -> None:

     

       78
       78
       +
       def add_duplicate(

     

       79
       79
       +
           git_store: GitStore, duplicate_id: Optional[str], canonical_id: Optional[str]

     

       80
       80
       +
       ) -> None:

     

       79
       81
        
           """Add a duplicate mapping."""

     

       80
       82
        
           if not duplicate_id:

     

       81
       83
        
               print_error("Duplicate ID is required")

     
···

       124
       126
        
           # Remove the mapping

     

       125
       127
        
           if git_store.remove_duplicate(duplicate_id):

     

       126
       128
        
               # Commit changes

     

       127
       127
       -
               git_store.commit_changes(f"Remove duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       129
       129
       +
               git_store.commit_changes(

     

       130
       130
       +
                   f"Remove duplicate mapping: {duplicate_id} -> {canonical_id}"

     

       131
       131
       +
               )

     

       128
       132
        
               print_success(f"Removed duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       129
       133
        
           else:

     

       130
       134
        
               print_error(f"Failed to remove duplicate mapping: {duplicate_id}")

-427

src/thicket/cli/commands/index_cmd.py

···

       1
       1
       -
       """CLI command for building reference index from blog entries."""

     

       2
       2
       -
       

     

       3
       3
       -
       import json

     

       4
       4
       -
       from pathlib import Path

     

       5
       5
       -
       from typing import Optional

     

       6
       6
       -
       

     

       7
       7
       -
       import typer

     

       8
       8
       -
       from rich.console import Console

     

       9
       9
       -
       from rich.progress import (

     

       10
       10
       -
           BarColumn,

     

       11
       11
       -
           Progress,

     

       12
       12
       -
           SpinnerColumn,

     

       13
       13
       -
           TaskProgressColumn,

     

       14
       14
       -
           TextColumn,

     

       15
       15
       -
       )

     

       16
       16
       -
       from rich.table import Table

     

       17
       17
       -
       

     

       18
       18
       -
       from ...core.git_store import GitStore

     

       19
       19
       -
       from ...core.reference_parser import ReferenceIndex, ReferenceParser

     

       20
       20
       -
       from ..main import app

     

       21
       21
       -
       from ..utils import get_tsv_mode, load_config

     

       22
       22
       -
       

     

       23
       23
       -
       console = Console()

     

       24
       24
       -
       

     

       25
       25
       -
       

     

       26
       26
       -
       @app.command()

     

       27
       27
       -
       def index(

     

       28
       28
       -
           config_file: Optional[Path] = typer.Option(

     

       29
       29
       -
               None,

     

       30
       30
       -
               "--config",

     

       31
       31
       -
               "-c",

     

       32
       32
       -
               help="Path to configuration file",

     

       33
       33
       -
           ),

     

       34
       34
       -
           output_file: Optional[Path] = typer.Option(

     

       35
       35
       -
               None,

     

       36
       36
       -
               "--output",

     

       37
       37
       -
               "-o",

     

       38
       38
       -
               help="Path to output index file (default: updates links.json in git store)",

     

       39
       39
       -
           ),

     

       40
       40
       -
           verbose: bool = typer.Option(

     

       41
       41
       -
               False,

     

       42
       42
       -
               "--verbose",

     

       43
       43
       -
               "-v",

     

       44
       44
       -
               help="Show detailed progress information",

     

       45
       45
       -
           ),

     

       46
       46
       -
       ) -> None:

     

       47
       47
       -
           """Build a reference index showing which blog entries reference others.

     

       48
       48
       -
       

     

       49
       49
       -
           This command analyzes all blog entries to detect cross-references between

     

       50
       50
       -
           different blogs, creating an index that can be used to build threaded

     

       51
       51
       -
           views of related content.

     

       52
       52
       -
           

     

       53
       53
       -
           Updates the unified links.json file with reference data.

     

       54
       54
       -
           """

     

       55
       55
       -
           try:

     

       56
       56
       -
               # Load configuration

     

       57
       57
       -
               config = load_config(config_file)

     

       58
       58
       -
       

     

       59
       59
       -
               # Initialize Git store

     

       60
       60
       -
               git_store = GitStore(config.git_store)

     

       61
       61
       -
       

     

       62
       62
       -
               # Initialize reference parser

     

       63
       63
       -
               parser = ReferenceParser()

     

       64
       64
       -
       

     

       65
       65
       -
               # Build user domain mapping

     

       66
       66
       -
               if verbose:

     

       67
       67
       -
                   console.print("Building user domain mapping...")

     

       68
       68
       -
               user_domains = parser.build_user_domain_mapping(git_store)

     

       69
       69
       -
       

     

       70
       70
       -
               if verbose:

     

       71
       71
       -
                   console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains")

     

       72
       72
       -
       

     

       73
       73
       -
               # Initialize reference index

     

       74
       74
       -
               ref_index = ReferenceIndex()

     

       75
       75
       -
               ref_index.user_domains = user_domains

     

       76
       76
       -
       

     

       77
       77
       -
               # Get all users

     

       78
       78
       -
               index = git_store._load_index()

     

       79
       79
       -
               users = list(index.users.keys())

     

       80
       80
       -
       

     

       81
       81
       -
               if not users:

     

       82
       82
       -
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       83
       83
       -
                   raise typer.Exit(0)

     

       84
       84
       -
       

     

       85
       85
       -
               # Process all entries

     

       86
       86
       -
               total_entries = 0

     

       87
       87
       -
               total_references = 0

     

       88
       88
       -
               all_references = []

     

       89
       89
       -
       

     

       90
       90
       -
               with Progress(

     

       91
       91
       -
                   SpinnerColumn(),

     

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

     

       93
       93
       -
                   BarColumn(),

     

       94
       94
       -
                   TaskProgressColumn(),

     

       95
       95
       -
                   console=console,

     

       96
       96
       -
               ) as progress:

     

       97
       97
       -
       

     

       98
       98
       -
                   # Count total entries first

     

       99
       99
       -
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       100
       100
       -
                   entry_counts = {}

     

       101
       101
       -
                   for username in users:

     

       102
       102
       -
                       entries = git_store.list_entries(username)

     

       103
       103
       -
                       entry_counts[username] = len(entries)

     

       104
       104
       -
                       total_entries += len(entries)

     

       105
       105
       -
                       progress.advance(counting_task)

     

       106
       106
       -
       

     

       107
       107
       -
                   progress.remove_task(counting_task)

     

       108
       108
       -
       

     

       109
       109
       -
                   # Process entries - extract references

     

       110
       110
       -
                   processing_task = progress.add_task(

     

       111
       111
       -
                       f"Extracting references from {total_entries} entries...",

     

       112
       112
       -
                       total=total_entries

     

       113
       113
       -
                   )

     

       114
       114
       -
       

     

       115
       115
       -
                   for username in users:

     

       116
       116
       -
                       entries = git_store.list_entries(username)

     

       117
       117
       -
       

     

       118
       118
       -
                       for entry in entries:

     

       119
       119
       -
                           # Extract references from this entry

     

       120
       120
       -
                           references = parser.extract_references(entry, username, user_domains)

     

       121
       121
       -
                           all_references.extend(references)

     

       122
       122
       -
       

     

       123
       123
       -
                           progress.advance(processing_task)

     

       124
       124
       -
       

     

       125
       125
       -
                           if verbose and references:

     

       126
       126
       -
                               console.print(f"  Found {len(references)} references in {username}:{entry.title[:50]}...")

     

       127
       127
       -
       

     

       128
       128
       -
                   progress.remove_task(processing_task)

     

       129
       129
       -
       

     

       130
       130
       -
                   # Resolve target_entry_ids for references

     

       131
       131
       -
                   if all_references:

     

       132
       132
       -
                       resolve_task = progress.add_task(

     

       133
       133
       -
                           f"Resolving {len(all_references)} references...",

     

       134
       134
       -
                           total=len(all_references)

     

       135
       135
       -
                       )

     

       136
       136
       -
       

     

       137
       137
       -
                       if verbose:

     

       138
       138
       -
                           console.print(f"Resolving target entry IDs for {len(all_references)} references...")

     

       139
       139
       -
       

     

       140
       140
       -
                       resolved_references = parser.resolve_target_entry_ids(all_references, git_store)

     

       141
       141
       -
       

     

       142
       142
       -
                       # Count resolved references

     

       143
       143
       -
                       resolved_count = sum(1 for ref in resolved_references if ref.target_entry_id is not None)

     

       144
       144
       -
                       if verbose:

     

       145
       145
       -
                           console.print(f"Resolved {resolved_count} out of {len(all_references)} references")

     

       146
       146
       -
       

     

       147
       147
       -
                       # Add resolved references to index

     

       148
       148
       -
                       for ref in resolved_references:

     

       149
       149
       -
                           ref_index.add_reference(ref)

     

       150
       150
       -
                           total_references += 1

     

       151
       151
       -
                           progress.advance(resolve_task)

     

       152
       152
       -
       

     

       153
       153
       -
                       progress.remove_task(resolve_task)

     

       154
       154
       -
       

     

       155
       155
       -
               # Determine output path

     

       156
       156
       -
               if output_file:

     

       157
       157
       -
                   output_path = output_file

     

       158
       158
       -
               else:

     

       159
       159
       -
                   output_path = config.git_store / "links.json"

     

       160
       160
       -
       

     

       161
       161
       -
               # Load existing links data or create new structure

     

       162
       162
       -
               if output_path.exists() and not output_file:

     

       163
       163
       -
                   # Load existing unified structure

     

       164
       164
       -
                   with open(output_path) as f:

     

       165
       165
       -
                       existing_data = json.load(f)

     

       166
       166
       -
               else:

     

       167
       167
       -
                   # Create new structure

     

       168
       168
       -
                   existing_data = {

     

       169
       169
       -
                       "links": {},

     

       170
       170
       -
                       "reverse_mapping": {},

     

       171
       171
       -
                       "user_domains": {}

     

       172
       172
       -
                   }

     

       173
       173
       -
               

     

       174
       174
       -
               # Update with reference data

     

       175
       175
       -
               existing_data["references"] = ref_index.to_dict()["references"]

     

       176
       176
       -
               existing_data["user_domains"] = {k: list(v) for k, v in user_domains.items()}

     

       177
       177
       -
       

     

       178
       178
       -
               # Save updated structure

     

       179
       179
       -
               with open(output_path, "w") as f:

     

       180
       180
       -
                   json.dump(existing_data, f, indent=2, default=str)

     

       181
       181
       -
       

     

       182
       182
       -
               # Show summary

     

       183
       183
       -
               if not get_tsv_mode():

     

       184
       184
       -
                   console.print("\n[green]✓ Reference index built successfully[/green]")

     

       185
       185
       -
       

     

       186
       186
       -
               # Create summary table or TSV output

     

       187
       187
       -
               if get_tsv_mode():

     

       188
       188
       -
                   print("Metric\tCount")

     

       189
       189
       -
                   print(f"Total Users\t{len(users)}")

     

       190
       190
       -
                   print(f"Total Entries\t{total_entries}")

     

       191
       191
       -
                   print(f"Total References\t{total_references}")

     

       192
       192
       -
                   print(f"Outbound Refs\t{len(ref_index.outbound_refs)}")

     

       193
       193
       -
                   print(f"Inbound Refs\t{len(ref_index.inbound_refs)}")

     

       194
       194
       -
                   print(f"Output File\t{output_path}")

     

       195
       195
       -
               else:

     

       196
       196
       -
                   table = Table(title="Reference Index Summary")

     

       197
       197
       -
                   table.add_column("Metric", style="cyan")

     

       198
       198
       -
                   table.add_column("Count", style="green")

     

       199
       199
       -
       

     

       200
       200
       -
                   table.add_row("Total Users", str(len(users)))

     

       201
       201
       -
                   table.add_row("Total Entries", str(total_entries))

     

       202
       202
       -
                   table.add_row("Total References", str(total_references))

     

       203
       203
       -
                   table.add_row("Outbound Refs", str(len(ref_index.outbound_refs)))

     

       204
       204
       -
                   table.add_row("Inbound Refs", str(len(ref_index.inbound_refs)))

     

       205
       205
       -
                   table.add_row("Output File", str(output_path))

     

       206
       206
       -
       

     

       207
       207
       -
                   console.print(table)

     

       208
       208
       -
       

     

       209
       209
       -
               # Show some interesting statistics

     

       210
       210
       -
               if total_references > 0:

     

       211
       211
       -
                   if not get_tsv_mode():

     

       212
       212
       -
                       console.print("\n[bold]Reference Statistics:[/bold]")

     

       213
       213
       -
       

     

       214
       214
       -
                   # Most referenced users

     

       215
       215
       -
                   target_counts = {}

     

       216
       216
       -
                   unresolved_domains = set()

     

       217
       217
       -
       

     

       218
       218
       -
                   for ref in ref_index.references:

     

       219
       219
       -
                       if ref.target_username:

     

       220
       220
       -
                           target_counts[ref.target_username] = target_counts.get(ref.target_username, 0) + 1

     

       221
       221
       -
                       else:

     

       222
       222
       -
                           # Track unresolved domains

     

       223
       223
       -
                           from urllib.parse import urlparse

     

       224
       224
       -
                           domain = urlparse(ref.target_url).netloc.lower()

     

       225
       225
       -
                           unresolved_domains.add(domain)

     

       226
       226
       -
       

     

       227
       227
       -
                   if target_counts:

     

       228
       228
       -
                       if get_tsv_mode():

     

       229
       229
       -
                           print("Referenced User\tReference Count")

     

       230
       230
       -
                           for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]:

     

       231
       231
       -
                               print(f"{username}\t{count}")

     

       232
       232
       -
                       else:

     

       233
       233
       -
                           console.print("\nMost referenced users:")

     

       234
       234
       -
                           for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]:

     

       235
       235
       -
                               console.print(f"  {username}: {count} references")

     

       236
       236
       -
       

     

       237
       237
       -
                   if unresolved_domains and verbose:

     

       238
       238
       -
                       if get_tsv_mode():

     

       239
       239
       -
                           print("Unresolved Domain\tCount")

     

       240
       240
       -
                           for domain in sorted(list(unresolved_domains)[:10]):

     

       241
       241
       -
                               print(f"{domain}\t1")

     

       242
       242
       -
                           if len(unresolved_domains) > 10:

     

       243
       243
       -
                               print(f"... and {len(unresolved_domains) - 10} more\t...")

     

       244
       244
       -
                       else:

     

       245
       245
       -
                           console.print(f"\nUnresolved domains: {len(unresolved_domains)}")

     

       246
       246
       -
                           for domain in sorted(list(unresolved_domains)[:10]):

     

       247
       247
       -
                               console.print(f"  {domain}")

     

       248
       248
       -
                           if len(unresolved_domains) > 10:

     

       249
       249
       -
                               console.print(f"  ... and {len(unresolved_domains) - 10} more")

     

       250
       250
       -
       

     

       251
       251
       -
           except Exception as e:

     

       252
       252
       -
               console.print(f"[red]Error building reference index: {e}[/red]")

     

       253
       253
       -
               if verbose:

     

       254
       254
       -
                   console.print_exception()

     

       255
       255
       -
               raise typer.Exit(1)

     

       256
       256
       -
       

     

       257
       257
       -
       

     

       258
       258
       -
       @app.command()

     

       259
       259
       -
       def threads(

     

       260
       260
       -
           config_file: Optional[Path] = typer.Option(

     

       261
       261
       -
               None,

     

       262
       262
       -
               "--config",

     

       263
       263
       -
               "-c",

     

       264
       264
       -
               help="Path to configuration file",

     

       265
       265
       -
           ),

     

       266
       266
       -
           index_file: Optional[Path] = typer.Option(

     

       267
       267
       -
               None,

     

       268
       268
       -
               "--index",

     

       269
       269
       -
               "-i",

     

       270
       270
       -
               help="Path to reference index file (default: links.json in git store)",

     

       271
       271
       -
           ),

     

       272
       272
       -
           username: Optional[str] = typer.Option(

     

       273
       273
       -
               None,

     

       274
       274
       -
               "--username",

     

       275
       275
       -
               "-u",

     

       276
       276
       -
               help="Show threads for specific username only",

     

       277
       277
       -
           ),

     

       278
       278
       -
           entry_id: Optional[str] = typer.Option(

     

       279
       279
       -
               None,

     

       280
       280
       -
               "--entry",

     

       281
       281
       -
               "-e",

     

       282
       282
       -
               help="Show thread for specific entry ID",

     

       283
       283
       -
           ),

     

       284
       284
       -
           min_size: int = typer.Option(

     

       285
       285
       -
               2,

     

       286
       286
       -
               "--min-size",

     

       287
       287
       -
               "-m",

     

       288
       288
       -
               help="Minimum thread size to display",

     

       289
       289
       -
           ),

     

       290
       290
       -
       ) -> None:

     

       291
       291
       -
           """Show threaded view of related blog entries.

     

       292
       292
       -
       

     

       293
       293
       -
           This command uses the reference index to show which blog entries

     

       294
       294
       -
           are connected through cross-references, creating an email-style

     

       295
       295
       -
           threaded view of the conversation.

     

       296
       296
       -
           

     

       297
       297
       -
           Reads reference data from the unified links.json file.

     

       298
       298
       -
           """

     

       299
       299
       -
           try:

     

       300
       300
       -
               # Load configuration

     

       301
       301
       -
               config = load_config(config_file)

     

       302
       302
       -
       

     

       303
       303
       -
               # Determine index file path

     

       304
       304
       -
               if index_file:

     

       305
       305
       -
                   index_path = index_file

     

       306
       306
       -
               else:

     

       307
       307
       -
                   index_path = config.git_store / "links.json"

     

       308
       308
       -
       

     

       309
       309
       -
               if not index_path.exists():

     

       310
       310
       -
                   console.print(f"[red]Links file not found: {index_path}[/red]")

     

       311
       311
       -
                   console.print("Run 'thicket links' and 'thicket index' first to build the reference index")

     

       312
       312
       -
                   raise typer.Exit(1)

     

       313
       313
       -
       

     

       314
       314
       -
               # Load unified data

     

       315
       315
       -
               with open(index_path) as f:

     

       316
       316
       -
                   unified_data = json.load(f)

     

       317
       317
       -
       

     

       318
       318
       -
               # Check if references exist in the unified structure

     

       319
       319
       -
               if "references" not in unified_data:

     

       320
       320
       -
                   console.print(f"[red]No references found in {index_path}[/red]")

     

       321
       321
       -
                   console.print("Run 'thicket index' first to build the reference index")

     

       322
       322
       -
                   raise typer.Exit(1)

     

       323
       323
       -
       

     

       324
       324
       -
               # Extract reference data and reconstruct ReferenceIndex

     

       325
       325
       -
               ref_index = ReferenceIndex.from_dict({

     

       326
       326
       -
                   "references": unified_data["references"],

     

       327
       327
       -
                   "user_domains": unified_data.get("user_domains", {})

     

       328
       328
       -
               })

     

       329
       329
       -
       

     

       330
       330
       -
               # Initialize Git store to get entry details

     

       331
       331
       -
               git_store = GitStore(config.git_store)

     

       332
       332
       -
       

     

       333
       333
       -
               if entry_id and username:

     

       334
       334
       -
                   # Show specific thread

     

       335
       335
       -
                   thread_members = ref_index.get_thread_members(username, entry_id)

     

       336
       336
       -
                   _display_thread(thread_members, ref_index, git_store, f"Thread for {username}:{entry_id}")

     

       337
       337
       -
       

     

       338
       338
       -
               elif username:

     

       339
       339
       -
                   # Show all threads involving this user

     

       340
       340
       -
                   user_index = git_store._load_index()

     

       341
       341
       -
                   user = user_index.get_user(username)

     

       342
       342
       -
                   if not user:

     

       343
       343
       -
                       console.print(f"[red]User not found: {username}[/red]")

     

       344
       344
       -
                       raise typer.Exit(1)

     

       345
       345
       -
       

     

       346
       346
       -
                   entries = git_store.list_entries(username)

     

       347
       347
       -
                   threads_found = set()

     

       348
       348
       -
       

     

       349
       349
       -
                   console.print(f"[bold]Threads involving {username}:[/bold]\n")

     

       350
       350
       -
       

     

       351
       351
       -
                   for entry in entries:

     

       352
       352
       -
                       thread_members = ref_index.get_thread_members(username, entry.id)

     

       353
       353
       -
                       if len(thread_members) >= min_size:

     

       354
       354
       -
                           thread_key = tuple(sorted(thread_members))

     

       355
       355
       -
                           if thread_key not in threads_found:

     

       356
       356
       -
                               threads_found.add(thread_key)

     

       357
       357
       -
                               _display_thread(thread_members, ref_index, git_store, f"Thread #{len(threads_found)}")

     

       358
       358
       -
       

     

       359
       359
       -
               else:

     

       360
       360
       -
                   # Show all threads

     

       361
       361
       -
                   console.print("[bold]All conversation threads:[/bold]\n")

     

       362
       362
       -
       

     

       363
       363
       -
                   all_threads = set()

     

       364
       364
       -
                   processed_entries = set()

     

       365
       365
       -
       

     

       366
       366
       -
                   # Get all entries

     

       367
       367
       -
                   user_index = git_store._load_index()

     

       368
       368
       -
                   for username in user_index.users.keys():

     

       369
       369
       -
                       entries = git_store.list_entries(username)

     

       370
       370
       -
                       for entry in entries:

     

       371
       371
       -
                           entry_key = (username, entry.id)

     

       372
       372
       -
                           if entry_key in processed_entries:

     

       373
       373
       -
                               continue

     

       374
       374
       -
       

     

       375
       375
       -
                           thread_members = ref_index.get_thread_members(username, entry.id)

     

       376
       376
       -
                           if len(thread_members) >= min_size:

     

       377
       377
       -
                               thread_key = tuple(sorted(thread_members))

     

       378
       378
       -
                               if thread_key not in all_threads:

     

       379
       379
       -
                                   all_threads.add(thread_key)

     

       380
       380
       -
                                   _display_thread(thread_members, ref_index, git_store, f"Thread #{len(all_threads)}")

     

       381
       381
       -
       

     

       382
       382
       -
                                   # Mark all members as processed

     

       383
       383
       -
                                   for member in thread_members:

     

       384
       384
       -
                                       processed_entries.add(member)

     

       385
       385
       -
       

     

       386
       386
       -
                   if not all_threads:

     

       387
       387
       -
                       console.print("[yellow]No conversation threads found[/yellow]")

     

       388
       388
       -
                       console.print(f"(minimum thread size: {min_size})")

     

       389
       389
       -
       

     

       390
       390
       -
           except Exception as e:

     

       391
       391
       -
               console.print(f"[red]Error showing threads: {e}[/red]")

     

       392
       392
       -
               raise typer.Exit(1)

     

       393
       393
       -
       

     

       394
       394
       -
       

     

       395
       395
       -
       def _display_thread(thread_members, ref_index, git_store, title):

     

       396
       396
       -
           """Display a single conversation thread."""

     

       397
       397
       -
           console.print(f"[bold cyan]{title}[/bold cyan]")

     

       398
       398
       -
           console.print(f"Thread size: {len(thread_members)} entries")

     

       399
       399
       -
       

     

       400
       400
       -
           # Get entry details for each member

     

       401
       401
       -
           thread_entries = []

     

       402
       402
       -
           for username, entry_id in thread_members:

     

       403
       403
       -
               entry = git_store.get_entry(username, entry_id)

     

       404
       404
       -
               if entry:

     

       405
       405
       -
                   thread_entries.append((username, entry))

     

       406
       406
       -
       

     

       407
       407
       -
           # Sort by publication date

     

       408
       408
       -
           thread_entries.sort(key=lambda x: x[1].published or x[1].updated)

     

       409
       409
       -
       

     

       410
       410
       -
           # Display entries

     

       411
       411
       -
           for i, (username, entry) in enumerate(thread_entries):

     

       412
       412
       -
               prefix = "├─" if i < len(thread_entries) - 1 else "└─"

     

       413
       413
       -
       

     

       414
       414
       -
               # Get references for this entry

     

       415
       415
       -
               outbound = ref_index.get_outbound_refs(username, entry.id)

     

       416
       416
       -
               inbound = ref_index.get_inbound_refs(username, entry.id)

     

       417
       417
       -
       

     

       418
       418
       -
               ref_info = ""

     

       419
       419
       -
               if outbound or inbound:

     

       420
       420
       -
                   ref_info = f" ({len(outbound)} out, {len(inbound)} in)"

     

       421
       421
       -
       

     

       422
       422
       -
               console.print(f"  {prefix} [{username}] {entry.title[:60]}...{ref_info}")

     

       423
       423
       -
       

     

       424
       424
       -
               if entry.published:

     

       425
       425
       -
                   console.print(f"    Published: {entry.published.strftime('%Y-%m-%d')}")

     

       426
       426
       -
       

     

       427
       427
       -
           console.print()  # Empty line after each thread

+106 -119

src/thicket/cli/commands/info_cmd.py

···

       1
       1
        
       """CLI command for displaying detailed information about a specific atom entry."""

     

       2
       2
        
       

     

       3
       3
       -
       import json

     

       4
       3
        
       from pathlib import Path

     

       5
       4
        
       from typing import Optional

     

       6
       5
        
       

     
···

       8
       7
        
       from rich.console import Console

     

       9
       8
        
       from rich.panel import Panel

     

       10
       9
        
       from rich.table import Table

     

       11
       11
       -
       from rich.text import Text

     

       12
       10
        
       

     

       13
       11
        
       from ...core.git_store import GitStore

     

       14
       14
       -
       from ...core.reference_parser import ReferenceIndex

     

       15
       12
        
       from ..main import app

     

       16
       16
       -
       from ..utils import load_config, get_tsv_mode

     

       13
       13
       +
       from ..utils import get_tsv_mode, load_config

     

       17
       14
        
       

     

       18
       15
        
       console = Console()

     

       19
       16
        
       

     
···

       21
       18
        
       @app.command()

     

       22
       19
        
       def info(

     

       23
       20
        
           identifier: str = typer.Argument(

     

       24
       24
       -
               ...,

     

       25
       25
       -
               help="The atom ID or URL of the entry to display information about"

     

       21
       21
       +
               ..., help="The atom ID or URL of the entry to display information about"

     

       26
       22
        
           ),

     

       27
       23
        
           username: Optional[str] = typer.Option(

     

       28
       24
        
               None,

     

       29
       25
        
               "--username",

     

       30
       26
        
               "-u",

     

       31
       31
       -
               help="Username to search for the entry (if not provided, searches all users)"

     

       27
       27
       +
               help="Username to search for the entry (if not provided, searches all users)",

     

       32
       28
        
           ),

     

       33
       29
        
           config_file: Optional[Path] = typer.Option(

     

       34
       30
        
               Path("thicket.yaml"),

     
···

       37
       33
        
               help="Path to configuration file",

     

       38
       34
        
           ),

     

       39
       35
        
           show_content: bool = typer.Option(

     

       40
       40
       -
               False,

     

       41
       41
       -
               "--content",

     

       42
       42
       -
               help="Include the full content of the entry in the output"

     

       36
       36
       +
               False, "--content", help="Include the full content of the entry in the output"

     

       43
       37
        
           ),

     

       44
       38
        
       ) -> None:

     

       45
       39
        
           """Display detailed information about a specific atom entry.

     

       46
       46
       -
           

     

       40
       40
       +
       

     

       47
       41
        
           You can specify the entry using either its atom ID or URL.

     

       48
       42
        
           Shows all metadata for the given entry, including title, dates, categories,

     

       49
       43
        
           and summarizes all inbound and outbound links to/from other posts.

     
···

       51
       45
        
           try:

     

       52
       46
        
               # Load configuration

     

       53
       47
        
               config = load_config(config_file)

     

       54
       54
       -
               

     

       48
       48
       +
       

     

       55
       49
        
               # Initialize Git store

     

       56
       50
        
               git_store = GitStore(config.git_store)

     

       57
       57
       -
               

     

       51
       51
       +
       

     

       58
       52
        
               # Find the entry

     

       59
       53
        
               entry = None

     

       60
       54
        
               found_username = None

     

       61
       61
       -
               

     

       55
       55
       +
       

     

       62
       56
        
               # Check if identifier looks like a URL

     

       63
       63
       -
               is_url = identifier.startswith(('http://', 'https://'))

     

       64
       64
       -
               

     

       57
       57
       +
               is_url = identifier.startswith(("http://", "https://"))

     

       58
       58
       +
       

     

       65
       59
        
               if username:

     

       66
       60
        
                   # Search specific username

     

       67
       61
        
                   if is_url:

     
···

       97
       91
        
                           if entry:

     

       98
       92
        
                               found_username = user

     

       99
       93
        
                               break

     

       100
       100
       -
               

     

       94
       94
       +
       

     

       101
       95
        
               if not entry or not found_username:

     

       102
       96
        
                   if username:

     

       103
       103
       -
                       console.print(f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found for user '{username}'[/red]")

     

       97
       97
       +
                       console.print(

     

       98
       98
       +
                           f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found for user '{username}'[/red]"

     

       99
       99
       +
                       )

     

       104
       100
        
                   else:

     

       105
       105
       -
                       console.print(f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found in any user's entries[/red]")

     

       101
       101
       +
                       console.print(

     

       102
       102
       +
                           f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found in any user's entries[/red]"

     

       103
       103
       +
                       )

     

       106
       104
        
                   raise typer.Exit(1)

     

       107
       107
       -
               

     

       108
       108
       -
               # Load reference index if available

     

       109
       109
       -
               links_path = config.git_store / "links.json"

     

       110
       110
       -
               ref_index = None

     

       111
       111
       -
               if links_path.exists():

     

       112
       112
       -
                   with open(links_path) as f:

     

       113
       113
       -
                       unified_data = json.load(f)

     

       114
       114
       -
                   

     

       115
       115
       -
                   # Check if references exist in the unified structure

     

       116
       116
       -
                   if "references" in unified_data:

     

       117
       117
       -
                       ref_index = ReferenceIndex.from_dict({

     

       118
       118
       -
                           "references": unified_data["references"],

     

       119
       119
       -
                           "user_domains": unified_data.get("user_domains", {})

     

       120
       120
       -
                       })

     

       121
       121
       -
               

     

       105
       105
       +
       

     

       122
       106
        
               # Display information

     

       123
       107
        
               if get_tsv_mode():

     

       124
       124
       -
                   _display_entry_info_tsv(entry, found_username, ref_index, show_content)

     

       108
       108
       +
                   _display_entry_info_tsv(entry, found_username, show_content)

     

       125
       109
        
               else:

     

       126
       110
        
                   _display_entry_info(entry, found_username)

     

       127
       127
       -
                   

     

       128
       128
       -
                   if ref_index:

     

       129
       129
       -
                       _display_link_info(entry, found_username, ref_index)

     

       130
       130
       -
                   else:

     

       131
       131
       -
                       console.print("\n[yellow]No reference index found. Run 'thicket links' and 'thicket index' to build cross-reference data.[/yellow]")

     

       132
       132
       -
                   

     

       111
       111
       +
       

     

       112
       112
       +
                   # Display links and backlinks from entry fields

     

       113
       113
       +
                   _display_link_info(entry, found_username, git_store)

     

       114
       114
       +
       

     

       133
       115
        
                   # Optionally display content

     

       134
       116
        
                   if show_content and entry.content:

     

       135
       117
        
                       _display_content(entry.content)

     

       136
       136
       -
                   

     

       118
       118
       +
       

     

       137
       119
        
           except Exception as e:

     

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

     

       139
       139
       -
               raise typer.Exit(1)

     

       121
       121
       +
               raise typer.Exit(1) from e

     

       140
       122
        
       

     

       141
       123
        
       

     

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

     

       143
       125
        
           """Display basic entry information in a structured format."""

     

       144
       144
       -
           

     

       126
       126
       +
       

     

       145
       127
        
           # Create main info panel

     

       146
       128
        
           info_table = Table.grid(padding=(0, 2))

     

       147
       129
        
           info_table.add_column("Field", style="cyan bold", width=15)

     

       148
       130
        
           info_table.add_column("Value", style="white")

     

       149
       149
       -
           

     

       131
       131
       +
       

     

       150
       132
        
           info_table.add_row("User", f"[green]{username}[/green]")

     

       151
       133
        
           info_table.add_row("Atom ID", f"[blue]{entry.id}[/blue]")

     

       152
       134
        
           info_table.add_row("Title", entry.title)

     

       153
       135
        
           info_table.add_row("Link", str(entry.link))

     

       154
       154
       -
           

     

       136
       136
       +
       

     

       155
       137
        
           if entry.published:

     

       156
       156
       -
               info_table.add_row("Published", entry.published.strftime("%Y-%m-%d %H:%M:%S UTC"))

     

       157
       157
       -
           

     

       138
       138
       +
               info_table.add_row(

     

       139
       139
       +
                   "Published", entry.published.strftime("%Y-%m-%d %H:%M:%S UTC")

     

       140
       140
       +
               )

     

       141
       141
       +
       

     

       158
       142
        
           info_table.add_row("Updated", entry.updated.strftime("%Y-%m-%d %H:%M:%S UTC"))

     

       159
       159
       -
           

     

       143
       143
       +
       

     

       160
       144
        
           if entry.summary:

     

       161
       145
        
               # Truncate long summaries

     

       162
       162
       -
               summary = entry.summary[:200] + "..." if len(entry.summary) > 200 else entry.summary

     

       146
       146
       +
               summary = (

     

       147
       147
       +
                   entry.summary[:200] + "..." if len(entry.summary) > 200 else entry.summary

     

       148
       148
       +
               )

     

       163
       149
        
               info_table.add_row("Summary", summary)

     

       164
       164
       -
           

     

       150
       150
       +
       

     

       165
       151
        
           if entry.categories:

     

       166
       152
        
               categories_text = ", ".join(entry.categories)

     

       167
       153
        
               info_table.add_row("Categories", categories_text)

     

       168
       168
       -
           

     

       154
       154
       +
       

     

       169
       155
        
           if entry.author:

     

       170
       156
        
               author_info = []

     

       171
       157
        
               if "name" in entry.author:

     
···

       174
       160
        
                   author_info.append(f"<{entry.author['email']}>")

     

       175
       161
        
               if author_info:

     

       176
       162
        
                   info_table.add_row("Author", " ".join(author_info))

     

       177
       177
       -
           

     

       163
       163
       +
       

     

       178
       164
        
           if entry.content_type:

     

       179
       165
        
               info_table.add_row("Content Type", entry.content_type)

     

       180
       180
       -
           

     

       166
       166
       +
       

     

       181
       167
        
           if entry.rights:

     

       182
       168
        
               info_table.add_row("Rights", entry.rights)

     

       183
       183
       -
           

     

       169
       169
       +
       

     

       184
       170
        
           if entry.source:

     

       185
       171
        
               info_table.add_row("Source Feed", entry.source)

     

       186
       186
       -
           

     

       172
       172
       +
       

     

       187
       173
        
           panel = Panel(

     

       188
       188
       -
               info_table,

     

       189
       189
       -
               title=f"[bold]Entry Information[/bold]",

     

       190
       190
       -
               border_style="blue"

     

       174
       174
       +
               info_table, title="[bold]Entry Information[/bold]", border_style="blue"

     

       191
       175
        
           )

     

       192
       192
       -
           

     

       176
       176
       +
       

     

       193
       177
        
           console.print(panel)

     

       194
       178
        
       

     

       195
       179
        
       

     

       196
       196
       -
       def _display_link_info(entry, username: str, ref_index: ReferenceIndex) -> None:

     

       180
       180
       +
       def _display_link_info(entry, username: str, git_store: GitStore) -> None:

     

       197
       181
        
           """Display inbound and outbound link information."""

     

       198
       198
       -
           

     

       199
       199
       -
           # Get links

     

       200
       200
       -
           outbound_refs = ref_index.get_outbound_refs(username, entry.id)

     

       201
       201
       -
           inbound_refs = ref_index.get_inbound_refs(username, entry.id)

     

       202
       202
       -
           

     

       203
       203
       -
           if not outbound_refs and not inbound_refs:

     

       182
       182
       +
       

     

       183
       183
       +
           # Get links from entry fields

     

       184
       184
       +
           outbound_links = getattr(entry, "links", [])

     

       185
       185
       +
           backlinks = getattr(entry, "backlinks", [])

     

       186
       186
       +
       

     

       187
       187
       +
           if not outbound_links and not backlinks:

     

       204
       188
        
               console.print("\n[dim]No cross-references found for this entry.[/dim]")

     

       205
       189
        
               return

     

       206
       206
       -
           

     

       190
       190
       +
       

     

       207
       191
        
           # Create links table

     

       208
       192
        
           links_table = Table(title="Cross-References")

     

       209
       193
        
           links_table.add_column("Direction", style="cyan", width=10)

     

       210
       210
       -
           links_table.add_column("Target/Source", style="green", width=20)

     

       211
       211
       -
           links_table.add_column("URL", style="blue", width=50)

     

       212
       212
       -
           

     

       213
       213
       -
           # Add outbound references

     

       214
       214
       -
           for ref in outbound_refs:

     

       215
       215
       -
               target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External"

     

       216
       216
       -
               links_table.add_row("→ Out", target_info, ref.target_url)

     

       217
       217
       -
           

     

       218
       218
       -
           # Add inbound references

     

       219
       219
       -
           for ref in inbound_refs:

     

       220
       220
       -
               source_info = f"{ref.source_username}:{ref.source_entry_id}"

     

       221
       221
       -
               links_table.add_row("← In", source_info, ref.target_url)

     

       222
       222
       -
           

     

       194
       194
       +
           links_table.add_column("Target/Source", style="green", width=30)

     

       195
       195
       +
           links_table.add_column("URL/ID", style="blue", width=60)

     

       196
       196
       +
       

     

       197
       197
       +
           # Add outbound links

     

       198
       198
       +
           for link in outbound_links:

     

       199
       199
       +
               links_table.add_row("→ Out", "External/Other", link)

     

       200
       200
       +
       

     

       201
       201
       +
           # Add backlinks (inbound references)

     

       202
       202
       +
           for backlink_id in backlinks:

     

       203
       203
       +
               # Try to find which user this entry belongs to

     

       204
       204
       +
               source_info = backlink_id

     

       205
       205
       +
               # Could enhance this by looking up the actual entry to get username

     

       206
       206
       +
               links_table.add_row("← In", "Entry", source_info)

     

       207
       207
       +
       

     

       223
       208
        
           console.print()

     

       224
       209
        
           console.print(links_table)

     

       225
       225
       -
           

     

       210
       210
       +
       

     

       226
       211
        
           # Summary

     

       227
       227
       -
           console.print(f"\n[bold]Summary:[/bold] {len(outbound_refs)} outbound, {len(inbound_refs)} inbound references")

     

       212
       212
       +
           console.print(

     

       213
       213
       +
               f"\n[bold]Summary:[/bold] {len(outbound_links)} outbound links, {len(backlinks)} inbound backlinks"

     

       214
       214
       +
           )

     

       228
       215
        
       

     

       229
       216
        
       

     

       230
       217
        
       def _display_content(content: str) -> None:

     

       231
       218
        
           """Display the full content of the entry."""

     

       232
       232
       -
           

     

       219
       219
       +
       

     

       233
       220
        
           # Truncate very long content

     

       234
       221
        
           display_content = content

     

       235
       222
        
           if len(content) > 5000:

     

       236
       223
        
               display_content = content[:5000] + "\n\n[... content truncated ...]"

     

       237
       237
       -
           

     

       224
       224
       +
       

     

       238
       225
        
           panel = Panel(

     

       239
       226
        
               display_content,

     

       240
       227
        
               title="[bold]Entry Content[/bold]",

     

       241
       228
        
               border_style="green",

     

       242
       242
       -
               expand=False

     

       229
       229
       +
               expand=False,

     

       243
       230
        
           )

     

       244
       244
       -
           

     

       231
       231
       +
       

     

       245
       232
        
           console.print()

     

       246
       233
        
           console.print(panel)

     

       247
       234
        
       

     

       248
       235
        
       

     

       249
       249
       -
       def _display_entry_info_tsv(entry, username: str, ref_index: Optional[ReferenceIndex], show_content: bool) -> None:

     

       236
       236
       +
       def _display_entry_info_tsv(entry, username: str, show_content: bool) -> None:

     

       250
       237
        
           """Display entry information in TSV format."""

     

       251
       251
       -
           

     

       238
       238
       +
       

     

       252
       239
        
           # Basic info

     

       253
       240
        
           print("Field\tValue")

     

       254
       241
        
           print(f"User\t{username}")

     

       255
       242
        
           print(f"Atom ID\t{entry.id}")

     

       256
       256
       -
           print(f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}")

     

       243
       243
       +
           print(

     

       244
       244
       +
               f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}"

     

       245
       245
       +
           )

     

       257
       246
        
           print(f"Link\t{entry.link}")

     

       258
       258
       -
           

     

       247
       247
       +
       

     

       259
       248
        
           if entry.published:

     

       260
       249
        
               print(f"Published\t{entry.published.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       261
       261
       -
           

     

       250
       250
       +
       

     

       262
       251
        
           print(f"Updated\t{entry.updated.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       263
       263
       -
           

     

       252
       252
       +
       

     

       264
       253
        
           if entry.summary:

     

       265
       254
        
               # Escape tabs and newlines in summary

     

       266
       266
       -
               summary = entry.summary.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       255
       255
       +
               summary = entry.summary.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       267
       256
        
               print(f"Summary\t{summary}")

     

       268
       268
       -
           

     

       257
       257
       +
       

     

       269
       258
        
           if entry.categories:

     

       270
       259
        
               print(f"Categories\t{', '.join(entry.categories)}")

     

       271
       271
       -
           

     

       260
       260
       +
       

     

       272
       261
        
           if entry.author:

     

       273
       262
        
               author_info = []

     

       274
       263
        
               if "name" in entry.author:

     
···

       277
       266
        
                   author_info.append(f"<{entry.author['email']}>")

     

       278
       267
        
               if author_info:

     

       279
       268
        
                   print(f"Author\t{' '.join(author_info)}")

     

       280
       280
       -
           

     

       269
       269
       +
       

     

       281
       270
        
           if entry.content_type:

     

       282
       271
        
               print(f"Content Type\t{entry.content_type}")

     

       283
       283
       -
           

     

       272
       272
       +
       

     

       284
       273
        
           if entry.rights:

     

       285
       274
        
               print(f"Rights\t{entry.rights}")

     

       286
       286
       -
           

     

       275
       275
       +
       

     

       287
       276
        
           if entry.source:

     

       288
       277
        
               print(f"Source Feed\t{entry.source}")

     

       289
       289
       -
           

     

       290
       290
       -
           # Add reference info if available

     

       291
       291
       -
           if ref_index:

     

       292
       292
       -
               outbound_refs = ref_index.get_outbound_refs(username, entry.id)

     

       293
       293
       -
               inbound_refs = ref_index.get_inbound_refs(username, entry.id)

     

       294
       294
       -
               

     

       295
       295
       -
               print(f"Outbound References\t{len(outbound_refs)}")

     

       296
       296
       -
               print(f"Inbound References\t{len(inbound_refs)}")

     

       297
       297
       -
               

     

       298
       298
       -
               # Show each reference

     

       299
       299
       -
               for ref in outbound_refs:

     

       300
       300
       -
                   target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External"

     

       301
       301
       -
                   print(f"Outbound Reference\t{target_info}\t{ref.target_url}")

     

       302
       302
       -
               

     

       303
       303
       -
               for ref in inbound_refs:

     

       304
       304
       -
                   source_info = f"{ref.source_username}:{ref.source_entry_id}"

     

       305
       305
       -
                   print(f"Inbound Reference\t{source_info}\t{ref.target_url}")

     

       306
       306
       -
           

     

       278
       278
       +
       

     

       279
       279
       +
           # Add links info from entry fields

     

       280
       280
       +
           outbound_links = getattr(entry, "links", [])

     

       281
       281
       +
           backlinks = getattr(entry, "backlinks", [])

     

       282
       282
       +
       

     

       283
       283
       +
           if outbound_links or backlinks:

     

       284
       284
       +
               print(f"Outbound Links\t{len(outbound_links)}")

     

       285
       285
       +
               print(f"Backlinks\t{len(backlinks)}")

     

       286
       286
       +
       

     

       287
       287
       +
               # Show each link

     

       288
       288
       +
               for link in outbound_links:

     

       289
       289
       +
                   print(f"→ Link\t{link}")

     

       290
       290
       +
       

     

       291
       291
       +
               for backlink_id in backlinks:

     

       292
       292
       +
                   print(f"← Backlink\t{backlink_id}")

     

       293
       293
       +
       

     

       307
       294
        
           # Show content if requested

     

       308
       295
        
           if show_content and entry.content:

     

       309
       296
        
               # Escape tabs and newlines in content

     

       310
       310
       -
               content = entry.content.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       311
       311
       -
               print(f"Content\t{content}")
     

       297
       297
       +
               content = entry.content.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       298
       298
       +
               print(f"Content\t{content}")

+5 -6

src/thicket/cli/commands/init.py

···

       14
       14
        
       

     

       15
       15
        
       @app.command()

     

       16
       16
        
       def init(

     

       17
       17
       -
           git_store: Path = typer.Argument(..., help="Path to Git repository for storing feeds"),

     

       17
       17
       +
           git_store: Path = typer.Argument(

     

       18
       18
       +
               ..., help="Path to Git repository for storing feeds"

     

       19
       19
       +
           ),

     

       18
       20
        
           cache_dir: Optional[Path] = typer.Option(

     

       19
       21
        
               None, "--cache-dir", "-c", help="Cache directory (default: ~/.cache/thicket)"

     

       20
       22
        
           ),

     
···

       30
       32
        
           # Set default paths

     

       31
       33
        
           if cache_dir is None:

     

       32
       34
        
               from platformdirs import user_cache_dir

     

       35
       35
       +
       

     

       33
       36
        
               cache_dir = Path(user_cache_dir("thicket"))

     

       34
       37
        
       

     

       35
       38
        
           if config_file is None:

     
···

       54
       57
        
       

     

       55
       58
        
           # Create configuration

     

       56
       59
        
           try:

     

       57
       57
       -
               config = ThicketConfig(

     

       58
       58
       -
                   git_store=git_store,

     

       59
       59
       -
                   cache_dir=cache_dir,

     

       60
       60
       -
                   users=[]

     

       61
       61
       -
               )

     

       60
       60
       +
               config = ThicketConfig(git_store=git_store, cache_dir=cache_dir, users=[])

     

       62
       61
        
       

     

       63
       62
        
               save_config(config, config_file)

     

       64
       63
        
               print_success(f"Created configuration file: {config_file}")

-423

src/thicket/cli/commands/links_cmd.py

···

       1
       1
       -
       """CLI command for extracting and categorizing all outbound links from blog entries."""

     

       2
       2
       -
       

     

       3
       3
       -
       import json

     

       4
       4
       -
       import re

     

       5
       5
       -
       from pathlib import Path

     

       6
       6
       -
       from typing import Dict, List, Optional, Set

     

       7
       7
       -
       from urllib.parse import urljoin, urlparse

     

       8
       8
       -
       

     

       9
       9
       -
       import typer

     

       10
       10
       -
       from rich.console import Console

     

       11
       11
       -
       from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn

     

       12
       12
       -
       from rich.table import Table

     

       13
       13
       -
       

     

       14
       14
       -
       from ...core.git_store import GitStore

     

       15
       15
       -
       from ..main import app

     

       16
       16
       -
       from ..utils import load_config, get_tsv_mode

     

       17
       17
       -
       

     

       18
       18
       -
       console = Console()

     

       19
       19
       -
       

     

       20
       20
       -
       

     

       21
       21
       -
       class LinkData:

     

       22
       22
       -
           """Represents a link found in a blog entry."""

     

       23
       23
       -
           

     

       24
       24
       -
           def __init__(self, url: str, entry_id: str, username: str):

     

       25
       25
       -
               self.url = url

     

       26
       26
       -
               self.entry_id = entry_id

     

       27
       27
       -
               self.username = username

     

       28
       28
       -
           

     

       29
       29
       -
           def to_dict(self) -> dict:

     

       30
       30
       -
               """Convert to dictionary for JSON serialization."""

     

       31
       31
       -
               return {

     

       32
       32
       -
                   "url": self.url,

     

       33
       33
       -
                   "entry_id": self.entry_id,

     

       34
       34
       -
                   "username": self.username

     

       35
       35
       -
               }

     

       36
       36
       -
           

     

       37
       37
       -
           @classmethod

     

       38
       38
       -
           def from_dict(cls, data: dict) -> "LinkData":

     

       39
       39
       -
               """Create from dictionary."""

     

       40
       40
       -
               return cls(

     

       41
       41
       -
                   url=data["url"],

     

       42
       42
       -
                   entry_id=data["entry_id"],

     

       43
       43
       -
                   username=data["username"]

     

       44
       44
       -
               )

     

       45
       45
       -
       

     

       46
       46
       -
       

     

       47
       47
       -
       class LinkCategorizer:

     

       48
       48
       -
           """Categorizes links as internal, user, or unknown."""

     

       49
       49
       -
           

     

       50
       50
       -
           def __init__(self, user_domains: Dict[str, Set[str]]):

     

       51
       51
       -
               self.user_domains = user_domains

     

       52
       52
       -
               # Create reverse mapping of domain -> username

     

       53
       53
       -
               self.domain_to_user = {}

     

       54
       54
       -
               for username, domains in user_domains.items():

     

       55
       55
       -
                   for domain in domains:

     

       56
       56
       -
                       self.domain_to_user[domain] = username

     

       57
       57
       -
           

     

       58
       58
       -
           def categorize_url(self, url: str, source_username: str) -> tuple[str, Optional[str]]:

     

       59
       59
       -
               """

     

       60
       60
       -
               Categorize a URL as 'internal', 'user', or 'unknown'.

     

       61
       61
       -
               Returns (category, target_username).

     

       62
       62
       -
               """

     

       63
       63
       -
               try:

     

       64
       64
       -
                   parsed = urlparse(url)

     

       65
       65
       -
                   domain = parsed.netloc.lower()

     

       66
       66
       -
                   

     

       67
       67
       -
                   # Check if it's a link to the same user's domain (internal)

     

       68
       68
       -
                   if domain in self.user_domains.get(source_username, set()):

     

       69
       69
       -
                       return "internal", source_username

     

       70
       70
       -
                   

     

       71
       71
       -
                   # Check if it's a link to another user's domain

     

       72
       72
       -
                   if domain in self.domain_to_user:

     

       73
       73
       -
                       return "user", self.domain_to_user[domain]

     

       74
       74
       -
                   

     

       75
       75
       -
                   # Everything else is unknown

     

       76
       76
       -
                   return "unknown", None

     

       77
       77
       -
                   

     

       78
       78
       -
               except Exception:

     

       79
       79
       -
                   return "unknown", None

     

       80
       80
       -
       

     

       81
       81
       -
       

     

       82
       82
       -
       class LinkExtractor:

     

       83
       83
       -
           """Extracts and resolves links from blog entries."""

     

       84
       84
       -
           

     

       85
       85
       -
           def __init__(self):

     

       86
       86
       -
               # Pattern for extracting links from HTML

     

       87
       87
       -
               self.link_pattern = re.compile(r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL)

     

       88
       88
       -
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       89
       89
       -
           

     

       90
       90
       -
           def extract_links_from_html(self, html_content: str, base_url: str) -> List[tuple[str, str]]:

     

       91
       91
       -
               """Extract all links from HTML content and resolve them against base URL."""

     

       92
       92
       -
               links = []

     

       93
       93
       -
               

     

       94
       94
       -
               # Extract links from <a> tags

     

       95
       95
       -
               for match in self.link_pattern.finditer(html_content):

     

       96
       96
       -
                   url = match.group(1)

     

       97
       97
       -
                   text = re.sub(r'<[^>]+>', '', match.group(2)).strip()  # Remove HTML tags from link text

     

       98
       98
       -
                   

     

       99
       99
       -
                   # Resolve relative URLs against base URL

     

       100
       100
       -
                   resolved_url = urljoin(base_url, url)

     

       101
       101
       -
                   links.append((resolved_url, text))

     

       102
       102
       -
               

     

       103
       103
       -
               return links

     

       104
       104
       -
           

     

       105
       105
       -
           

     

       106
       106
       -
           def extract_links_from_entry(self, entry, username: str, base_url: str) -> List[LinkData]:

     

       107
       107
       -
               """Extract all links from a blog entry."""

     

       108
       108
       -
               links = []

     

       109
       109
       -
               

     

       110
       110
       -
               # Combine all text content for analysis

     

       111
       111
       -
               content_to_search = []

     

       112
       112
       -
               if entry.content:

     

       113
       113
       -
                   content_to_search.append(entry.content)

     

       114
       114
       -
               if entry.summary:

     

       115
       115
       -
                   content_to_search.append(entry.summary)

     

       116
       116
       -
               

     

       117
       117
       -
               for content in content_to_search:

     

       118
       118
       -
                   extracted_links = self.extract_links_from_html(content, base_url)

     

       119
       119
       -
                   

     

       120
       120
       -
                   for url, link_text in extracted_links:

     

       121
       121
       -
                       # Skip empty URLs

     

       122
       122
       -
                       if not url or url.startswith('#'):

     

       123
       123
       -
                           continue

     

       124
       124
       -
                       

     

       125
       125
       -
                       link_data = LinkData(

     

       126
       126
       -
                           url=url,

     

       127
       127
       -
                           entry_id=entry.id,

     

       128
       128
       -
                           username=username

     

       129
       129
       -
                       )

     

       130
       130
       -
                       

     

       131
       131
       -
                       links.append(link_data)

     

       132
       132
       -
               

     

       133
       133
       -
               return links

     

       134
       134
       -
       

     

       135
       135
       -
       

     

       136
       136
       -
       @app.command()

     

       137
       137
       -
       def links(

     

       138
       138
       -
           config_file: Optional[Path] = typer.Option(

     

       139
       139
       -
               Path("thicket.yaml"),

     

       140
       140
       -
               "--config",

     

       141
       141
       -
               "-c",

     

       142
       142
       -
               help="Path to configuration file",

     

       143
       143
       -
           ),

     

       144
       144
       -
           output_file: Optional[Path] = typer.Option(

     

       145
       145
       -
               None,

     

       146
       146
       -
               "--output",

     

       147
       147
       -
               "-o",

     

       148
       148
       -
               help="Path to output unified links file (default: links.json in git store)",

     

       149
       149
       -
           ),

     

       150
       150
       -
           verbose: bool = typer.Option(

     

       151
       151
       -
               False,

     

       152
       152
       -
               "--verbose",

     

       153
       153
       -
               "-v",

     

       154
       154
       -
               help="Show detailed progress information",

     

       155
       155
       -
           ),

     

       156
       156
       -
       ) -> None:

     

       157
       157
       -
           """Extract and categorize all outbound links from blog entries.

     

       158
       158
       -
           

     

       159
       159
       -
           This command analyzes all blog entries to extract outbound links,

     

       160
       160
       -
           resolve them properly with respect to the feed's base URL, and

     

       161
       161
       -
           categorize them as internal, user, or unknown links.

     

       162
       162
       -
           

     

       163
       163
       -
           Creates a unified links.json file containing all link data.

     

       164
       164
       -
           """

     

       165
       165
       -
           try:

     

       166
       166
       -
               # Load configuration

     

       167
       167
       -
               config = load_config(config_file)

     

       168
       168
       -
       

     

       169
       169
       -
               # Initialize Git store

     

       170
       170
       -
               git_store = GitStore(config.git_store)

     

       171
       171
       -
               

     

       172
       172
       -
               # Build user domain mapping

     

       173
       173
       -
               if verbose:

     

       174
       174
       -
                   console.print("Building user domain mapping...")

     

       175
       175
       -
               

     

       176
       176
       -
               index = git_store._load_index()

     

       177
       177
       -
               user_domains = {}

     

       178
       178
       -
               

     

       179
       179
       -
               for username, user_metadata in index.users.items():

     

       180
       180
       -
                   domains = set()

     

       181
       181
       -
                   

     

       182
       182
       -
                   # Add domains from feeds

     

       183
       183
       -
                   for feed_url in user_metadata.feeds:

     

       184
       184
       -
                       domain = urlparse(feed_url).netloc.lower()

     

       185
       185
       -
                       if domain:

     

       186
       186
       -
                           domains.add(domain)

     

       187
       187
       -
                   

     

       188
       188
       -
                   # Add domain from homepage

     

       189
       189
       -
                   if user_metadata.homepage:

     

       190
       190
       -
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       191
       191
       -
                       if domain:

     

       192
       192
       -
                           domains.add(domain)

     

       193
       193
       -
                   

     

       194
       194
       -
                   user_domains[username] = domains

     

       195
       195
       -
               

     

       196
       196
       -
               if verbose:

     

       197
       197
       -
                   console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains")

     

       198
       198
       -
               

     

       199
       199
       -
               # Initialize components

     

       200
       200
       -
               link_extractor = LinkExtractor()

     

       201
       201
       -
               categorizer = LinkCategorizer(user_domains)

     

       202
       202
       -
               

     

       203
       203
       -
               # Get all users

     

       204
       204
       -
               users = list(index.users.keys())

     

       205
       205
       -
               

     

       206
       206
       -
               if not users:

     

       207
       207
       -
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       208
       208
       -
                   raise typer.Exit(0)

     

       209
       209
       -
               

     

       210
       210
       -
               # Process all entries

     

       211
       211
       -
               all_links = []

     

       212
       212
       -
               link_categories = {"internal": [], "user": [], "unknown": []}

     

       213
       213
       -
               link_dict = {}  # Dictionary with link URL as key, maps to list of atom IDs

     

       214
       214
       -
               reverse_dict = {}  # Dictionary with atom ID as key, maps to list of URLs

     

       215
       215
       -
               

     

       216
       216
       -
               with Progress(

     

       217
       217
       -
                   SpinnerColumn(),

     

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

     

       219
       219
       -
                   BarColumn(),

     

       220
       220
       -
                   TaskProgressColumn(),

     

       221
       221
       -
                   console=console,

     

       222
       222
       -
               ) as progress:

     

       223
       223
       -
                   

     

       224
       224
       -
                   # Count total entries first

     

       225
       225
       -
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       226
       226
       -
                   total_entries = 0

     

       227
       227
       -
                   

     

       228
       228
       -
                   for username in users:

     

       229
       229
       -
                       entries = git_store.list_entries(username)

     

       230
       230
       -
                       total_entries += len(entries)

     

       231
       231
       -
                       progress.advance(counting_task)

     

       232
       232
       -
                   

     

       233
       233
       -
                   progress.remove_task(counting_task)

     

       234
       234
       -
                   

     

       235
       235
       -
                   # Process entries

     

       236
       236
       -
                   processing_task = progress.add_task(

     

       237
       237
       -
                       f"Processing {total_entries} entries...", 

     

       238
       238
       -
                       total=total_entries

     

       239
       239
       -
                   )

     

       240
       240
       -
                   

     

       241
       241
       -
                   for username in users:

     

       242
       242
       -
                       entries = git_store.list_entries(username)

     

       243
       243
       -
                       user_metadata = index.users[username]

     

       244
       244
       -
                       

     

       245
       245
       -
                       # Get base URL for this user (use first feed URL)

     

       246
       246
       -
                       base_url = str(user_metadata.feeds[0]) if user_metadata.feeds else "https://example.com"

     

       247
       247
       -
                       

     

       248
       248
       -
                       for entry in entries:

     

       249
       249
       -
                           # Extract links from this entry

     

       250
       250
       -
                           entry_links = link_extractor.extract_links_from_entry(entry, username, base_url)

     

       251
       251
       -
                           

     

       252
       252
       -
                           # Track unique links per entry

     

       253
       253
       -
                           entry_urls_seen = set()

     

       254
       254
       -
                           

     

       255
       255
       -
                           # Categorize each link

     

       256
       256
       -
                           for link_data in entry_links:

     

       257
       257
       -
                               # Skip if we've already seen this URL in this entry

     

       258
       258
       -
                               if link_data.url in entry_urls_seen:

     

       259
       259
       -
                                   continue

     

       260
       260
       -
                               entry_urls_seen.add(link_data.url)

     

       261
       261
       -
                               

     

       262
       262
       -
                               category, target_username = categorizer.categorize_url(link_data.url, username)

     

       263
       263
       -
                               

     

       264
       264
       -
                               # Add to link dictionary (URL as key, maps to list of atom IDs)

     

       265
       265
       -
                               if link_data.url not in link_dict:

     

       266
       266
       -
                                   link_dict[link_data.url] = []

     

       267
       267
       -
                               if link_data.entry_id not in link_dict[link_data.url]:

     

       268
       268
       -
                                   link_dict[link_data.url].append(link_data.entry_id)

     

       269
       269
       -
                                   

     

       270
       270
       -
                                   # Also add to reverse mapping (atom ID -> list of URLs)

     

       271
       271
       -
                                   if link_data.entry_id not in reverse_dict:

     

       272
       272
       -
                                       reverse_dict[link_data.entry_id] = []

     

       273
       273
       -
                                   if link_data.url not in reverse_dict[link_data.entry_id]:

     

       274
       274
       -
                                       reverse_dict[link_data.entry_id].append(link_data.url)

     

       275
       275
       -
                               

     

       276
       276
       -
                               # Add category info to link data for categories tracking

     

       277
       277
       -
                               link_info = link_data.to_dict()

     

       278
       278
       -
                               link_info["category"] = category

     

       279
       279
       -
                               link_info["target_username"] = target_username

     

       280
       280
       -
                               

     

       281
       281
       -
                               all_links.append(link_info)

     

       282
       282
       -
                               link_categories[category].append(link_info)

     

       283
       283
       -
                           

     

       284
       284
       -
                           progress.advance(processing_task)

     

       285
       285
       -
                           

     

       286
       286
       -
                           if verbose and entry_links:

     

       287
       287
       -
                               console.print(f"  Found {len(entry_links)} links in {username}:{entry.title[:50]}...")

     

       288
       288
       -
               

     

       289
       289
       -
               # Determine output path

     

       290
       290
       -
               if output_file:

     

       291
       291
       -
                   output_path = output_file

     

       292
       292
       -
               else:

     

       293
       293
       -
                   output_path = config.git_store / "links.json"

     

       294
       294
       -
               

     

       295
       295
       -
               # Save all extracted links (not just filtered ones)

     

       296
       296
       -
               if verbose:

     

       297
       297
       -
                   console.print("Preparing output data...")

     

       298
       298
       -
               

     

       299
       299
       -
               # Build a set of all URLs that correspond to posts in the git database

     

       300
       300
       -
               registered_urls = set()

     

       301
       301
       -
               

     

       302
       302
       -
               # Get all entries from all users and build URL mappings

     

       303
       303
       -
               for username in users:

     

       304
       304
       -
                   entries = git_store.list_entries(username)

     

       305
       305
       -
                   user_metadata = index.users[username]

     

       306
       306
       -
                   

     

       307
       307
       -
                   for entry in entries:

     

       308
       308
       -
                       # Try to match entry URLs with extracted links

     

       309
       309
       -
                       if hasattr(entry, 'link') and entry.link:

     

       310
       310
       -
                           registered_urls.add(str(entry.link))

     

       311
       311
       -
                       

     

       312
       312
       -
                       # Also check entry alternate links if they exist

     

       313
       313
       -
                       if hasattr(entry, 'links') and entry.links:

     

       314
       314
       -
                           for link in entry.links:

     

       315
       315
       -
                               if hasattr(link, 'href') and link.href:

     

       316
       316
       -
                                   registered_urls.add(str(link.href))

     

       317
       317
       -
               

     

       318
       318
       -
               # Build unified structure with metadata

     

       319
       319
       -
               unified_links = {}

     

       320
       320
       -
               reverse_mapping = {}

     

       321
       321
       -
               

     

       322
       322
       -
               for url, entry_ids in link_dict.items():

     

       323
       323
       -
                   is_tracked = url in registered_urls

     

       324
       324
       -
                   target_username = None

     

       325
       325
       -
                   

     

       326
       326
       -
                   # Find target username if this is a tracked post

     

       327
       327
       -
                   if is_tracked:

     

       328
       328
       -
                       for username in users:

     

       329
       329
       -
                           user_domains_set = {domain for domain in user_domains.get(username, [])}

     

       330
       330
       -
                           if any(domain in url for domain in user_domains_set):

     

       331
       331
       -
                               target_username = username

     

       332
       332
       -
                               break

     

       333
       333
       -
                   

     

       334
       334
       -
                   unified_links[url] = {

     

       335
       335
       -
                       "referencing_entries": entry_ids,

     

       336
       336
       -
                       "is_tracked_post": is_tracked

     

       337
       337
       -
                   }

     

       338
       338
       -
                   

     

       339
       339
       -
                   if target_username:

     

       340
       340
       -
                       unified_links[url]["target_username"] = target_username

     

       341
       341
       -
                   

     

       342
       342
       -
                   # Build reverse mapping

     

       343
       343
       -
                   for entry_id in entry_ids:

     

       344
       344
       -
                       if entry_id not in reverse_mapping:

     

       345
       345
       -
                           reverse_mapping[entry_id] = []

     

       346
       346
       -
                       if url not in reverse_mapping[entry_id]:

     

       347
       347
       -
                           reverse_mapping[entry_id].append(url)

     

       348
       348
       -
               

     

       349
       349
       -
               # Create unified output data

     

       350
       350
       -
               output_data = {

     

       351
       351
       -
                   "links": unified_links,

     

       352
       352
       -
                   "reverse_mapping": reverse_mapping,

     

       353
       353
       -
                   "user_domains": {k: list(v) for k, v in user_domains.items()}

     

       354
       354
       -
               }

     

       355
       355
       -
               

     

       356
       356
       -
               if verbose:

     

       357
       357
       -
                   console.print(f"Found {len(registered_urls)} registered post URLs")

     

       358
       358
       -
                   console.print(f"Found {len(link_dict)} total links, {sum(1 for link in unified_links.values() if link['is_tracked_post'])} tracked posts")

     

       359
       359
       -
               

     

       360
       360
       -
               # Save unified data

     

       361
       361
       -
               with open(output_path, "w") as f:

     

       362
       362
       -
                   json.dump(output_data, f, indent=2, default=str)

     

       363
       363
       -
               

     

       364
       364
       -
               # Show summary

     

       365
       365
       -
               if not get_tsv_mode():

     

       366
       366
       -
                   console.print("\n[green]✓ Links extraction completed successfully[/green]")

     

       367
       367
       -
               

     

       368
       368
       -
               # Create summary table or TSV output

     

       369
       369
       -
               if get_tsv_mode():

     

       370
       370
       -
                   print("Category\tCount\tDescription")

     

       371
       371
       -
                   print(f"Internal\t{len(link_categories['internal'])}\tLinks to same user's domain")

     

       372
       372
       -
                   print(f"User\t{len(link_categories['user'])}\tLinks to other tracked users")

     

       373
       373
       -
                   print(f"Unknown\t{len(link_categories['unknown'])}\tLinks to external sites")

     

       374
       374
       -
                   print(f"Total Extracted\t{len(all_links)}\tAll extracted links")

     

       375
       375
       -
                   print(f"Saved to Output\t{len(output_data['links'])}\tLinks saved to output file")

     

       376
       376
       -
                   print(f"Cross-references\t{sum(1 for link in unified_links.values() if link['is_tracked_post'])}\tLinks to registered posts only")

     

       377
       377
       -
               else:

     

       378
       378
       -
                   table = Table(title="Links Summary")

     

       379
       379
       -
                   table.add_column("Category", style="cyan")

     

       380
       380
       -
                   table.add_column("Count", style="green")

     

       381
       381
       -
                   table.add_column("Description", style="white")

     

       382
       382
       -
                   

     

       383
       383
       -
                   table.add_row("Internal", str(len(link_categories["internal"])), "Links to same user's domain")

     

       384
       384
       -
                   table.add_row("User", str(len(link_categories["user"])), "Links to other tracked users")

     

       385
       385
       -
                   table.add_row("Unknown", str(len(link_categories["unknown"])), "Links to external sites")

     

       386
       386
       -
                   table.add_row("Total Extracted", str(len(all_links)), "All extracted links")

     

       387
       387
       -
                   table.add_row("Saved to Output", str(len(output_data['links'])), "Links saved to output file")

     

       388
       388
       -
                   table.add_row("Cross-references", str(sum(1 for link in unified_links.values() if link['is_tracked_post'])), "Links to registered posts only")

     

       389
       389
       -
                   

     

       390
       390
       -
                   console.print(table)

     

       391
       391
       -
               

     

       392
       392
       -
               # Show user links if verbose

     

       393
       393
       -
               if verbose and link_categories["user"]:

     

       394
       394
       -
                   if get_tsv_mode():

     

       395
       395
       -
                       print("User Link Source\tUser Link Target\tLink Count")

     

       396
       396
       -
                       user_link_counts = {}

     

       397
       397
       -
                       

     

       398
       398
       -
                       for link in link_categories["user"]:

     

       399
       399
       -
                           key = f"{link['username']} -> {link['target_username']}"

     

       400
       400
       -
                           user_link_counts[key] = user_link_counts.get(key, 0) + 1

     

       401
       401
       -
                       

     

       402
       402
       -
                       for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]:

     

       403
       403
       -
                           source, target = link_pair.split(" -> ")

     

       404
       404
       -
                           print(f"{source}\t{target}\t{count}")

     

       405
       405
       -
                   else:

     

       406
       406
       -
                       console.print("\n[bold]User-to-user links:[/bold]")

     

       407
       407
       -
                       user_link_counts = {}

     

       408
       408
       -
                       

     

       409
       409
       -
                       for link in link_categories["user"]:

     

       410
       410
       -
                           key = f"{link['username']} -> {link['target_username']}"

     

       411
       411
       -
                           user_link_counts[key] = user_link_counts.get(key, 0) + 1

     

       412
       412
       -
                       

     

       413
       413
       -
                       for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]:

     

       414
       414
       -
                           console.print(f"  {link_pair}: {count} links")

     

       415
       415
       -
               

     

       416
       416
       -
               if not get_tsv_mode():

     

       417
       417
       -
                   console.print(f"\nUnified links data saved to: {output_path}")

     

       418
       418
       -
       

     

       419
       419
       -
           except Exception as e:

     

       420
       420
       -
               console.print(f"[red]Error extracting links: {e}[/red]")

     

       421
       421
       -
               if verbose:

     

       422
       422
       -
                   console.print_exception()

     

       423
       423
       -
               raise typer.Exit(1)

+11 -11

src/thicket/cli/commands/list_cmd.py

···

       11
       11
        
       from ..main import app

     

       12
       12
        
       from ..utils import (

     

       13
       13
        
           console,

     

       14
       14
       +
           get_tsv_mode,

     

       14
       15
        
           load_config,

     

       16
       16
       +
           print_entries_tsv,

     

       15
       17
        
           print_error,

     

       16
       16
       -
           print_feeds_table,

     

       17
       18
        
           print_feeds_table_from_git,

     

       18
       19
        
           print_info,

     

       19
       19
       -
           print_users_table,

     

       20
       20
        
           print_users_table_from_git,

     

       21
       21
       -
           print_entries_tsv,

     

       22
       22
       -
           get_tsv_mode,

     

       23
       21
        
       )

     

       24
       22
        
       

     

       25
       23
        
       

     
···

       60
       58
        
           """List all users."""

     

       61
       59
        
           index = git_store._load_index()

     

       62
       60
        
           users = list(index.users.values())

     

       63
       63
       -
           

     

       61
       61
       +
       

     

       64
       62
        
           if not users:

     

       65
       63
        
               print_info("No users configured")

     

       66
       64
        
               return

     
···

       83
       81
        
           print_feeds_table_from_git(git_store, username)

     

       84
       82
        
       

     

       85
       83
        
       

     

       86
       86
       -
       def list_entries(git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None) -> None:

     

       84
       84
       +
       def list_entries(

     

       85
       85
       +
           git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None

     

       86
       86
       +
       ) -> None:

     

       87
       87
        
           """List entries, optionally filtered by user."""

     

       88
       88
        
       

     

       89
       89
        
           if username:

     
···

       123
       123
        
           """Clean HTML content for display in table."""

     

       124
       124
        
           if not content:

     

       125
       125
        
               return ""

     

       126
       126
       -
           

     

       126
       126
       +
       

     

       127
       127
        
           # Remove HTML tags

     

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

     

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

     

       129
       129
        
           # Replace multiple whitespace with single space

     

       130
       130
       -
           clean_text = re.sub(r'\s+', ' ', clean_text)

     

       130
       130
       +
           clean_text = re.sub(r"\s+", " ", clean_text)

     

       131
       131
        
           # Strip and limit length

     

       132
       132
        
           clean_text = clean_text.strip()

     

       133
       133
        
           if len(clean_text) > 100:

     

       134
       134
        
               clean_text = clean_text[:97] + "..."

     

       135
       135
       -
           

     

       135
       135
       +
       

     

       136
       136
        
           return clean_text

     

       137
       137
        
       

     

       138
       138
        
       

     
···

       141
       141
        
           if get_tsv_mode():

     

       142
       142
        
               print_entries_tsv(entries_by_user, usernames)

     

       143
       143
        
               return

     

       144
       144
       -
               

     

       144
       144
       +
       

     

       145
       145
        
           table = Table(title="Feed Entries")

     

       146
       146
        
           table.add_column("User", style="cyan", no_wrap=True)

     

       147
       147
        
           table.add_column("Title", style="bold")

+301

src/thicket/cli/commands/search.py

···

       1
       1
       +
       """Search command for thicket CLI."""

     

       2
       2
       +
       

     

       3
       3
       +
       import logging

     

       4
       4
       +
       from pathlib import Path

     

       5
       5
       +
       from typing import Optional

     

       6
       6
       +
       

     

       7
       7
       +
       import typer

     

       8
       8
       +
       from rich.console import Console

     

       9
       9
       +
       from rich.table import Table

     

       10
       10
       +
       

     

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

     

       12
       12
       +
       from ..main import app

     

       13
       13
       +
       

     

       14
       14
       +
       console = Console()

     

       15
       15
       +
       logger = logging.getLogger(__name__)

     

       16
       16
       +
       

     

       17
       17
       +
       

     

       18
       18
       +
       def _load_typesense_config() -> tuple[Optional[str], Optional[str]]:

     

       19
       19
       +
           """Load Typesense URL and API key from ~/.typesense directory."""

     

       20
       20
       +
           typesense_dir = Path.home() / ".typesense"

     

       21
       21
       +
           url_file = typesense_dir / "url"

     

       22
       22
       +
           key_file = typesense_dir / "api_key"

     

       23
       23
       +
       

     

       24
       24
       +
           url = None

     

       25
       25
       +
           api_key = None

     

       26
       26
       +
       

     

       27
       27
       +
           try:

     

       28
       28
       +
               if url_file.exists():

     

       29
       29
       +
                   url = url_file.read_text().strip()

     

       30
       30
       +
           except Exception as e:

     

       31
       31
       +
               logger.debug(f"Could not read Typesense URL from {url_file}: {e}")

     

       32
       32
       +
       

     

       33
       33
       +
           try:

     

       34
       34
       +
               if key_file.exists():

     

       35
       35
       +
                   api_key = key_file.read_text().strip()

     

       36
       36
       +
           except Exception as e:

     

       37
       37
       +
               logger.debug(f"Could not read Typesense API key from {key_file}: {e}")

     

       38
       38
       +
       

     

       39
       39
       +
           return url, api_key

     

       40
       40
       +
       

     

       41
       41
       +
       

     

       42
       42
       +
       @app.command("search")

     

       43
       43
       +
       def search_command(

     

       44
       44
       +
           query: str = typer.Argument(..., help="Search query"),

     

       45
       45
       +
           typesense_url: Optional[str] = typer.Option(

     

       46
       46
       +
               None,

     

       47
       47
       +
               "--typesense-url",

     

       48
       48
       +
               "-u",

     

       49
       49
       +
               help="Typesense server URL (e.g., http://localhost:8108). Defaults to ~/.typesense/url",

     

       50
       50
       +
           ),

     

       51
       51
       +
           api_key: Optional[str] = typer.Option(

     

       52
       52
       +
               None,

     

       53
       53
       +
               "--api-key",

     

       54
       54
       +
               "-k",

     

       55
       55
       +
               help="Typesense API key. Defaults to ~/.typesense/api_key",

     

       56
       56
       +
               hide_input=True,

     

       57
       57
       +
           ),

     

       58
       58
       +
           collection_name: str = typer.Option(

     

       59
       59
       +
               "thicket",

     

       60
       60
       +
               "--collection",

     

       61
       61
       +
               "-c",

     

       62
       62
       +
               help="Typesense collection name",

     

       63
       63
       +
           ),

     

       64
       64
       +
           config_path: Optional[str] = typer.Option(

     

       65
       65
       +
               None,

     

       66
       66
       +
               "--config",

     

       67
       67
       +
               "-C",

     

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

     

       69
       69
       +
           ),

     

       70
       70
       +
           limit: int = typer.Option(

     

       71
       71
       +
               20,

     

       72
       72
       +
               "--limit",

     

       73
       73
       +
               "-l",

     

       74
       74
       +
               help="Maximum number of results to display",

     

       75
       75
       +
           ),

     

       76
       76
       +
           user: Optional[str] = typer.Option(

     

       77
       77
       +
               None,

     

       78
       78
       +
               "--user",

     

       79
       79
       +
               help="Filter results by specific user",

     

       80
       80
       +
           ),

     

       81
       81
       +
           timeout: int = typer.Option(

     

       82
       82
       +
               10,

     

       83
       83
       +
               "--timeout",

     

       84
       84
       +
               "-t",

     

       85
       85
       +
               help="Connection timeout in seconds",

     

       86
       86
       +
           ),

     

       87
       87
       +
           raw: bool = typer.Option(

     

       88
       88
       +
               False,

     

       89
       89
       +
               "--raw",

     

       90
       90
       +
               help="Display raw JSON output instead of formatted table",

     

       91
       91
       +
           ),

     

       92
       92
       +
       ) -> None:

     

       93
       93
       +
           """Search thicket entries using Typesense full-text and semantic search.

     

       94
       94
       +
       

     

       95
       95
       +
           This command searches through all entries in the Typesense collection

     

       96
       96
       +
           using the provided query. The search covers entry titles, content,

     

       97
       97
       +
           summaries, user information, and metadata.

     

       98
       98
       +
       

     

       99
       99
       +
           Examples:

     

       100
       100
       +
       

     

       101
       101
       +
               # Basic search

     

       102
       102
       +
               thicket search "machine learning"

     

       103
       103
       +
       

     

       104
       104
       +
               # Search with user filter

     

       105
       105
       +
               thicket search "python programming" --user avsm

     

       106
       106
       +
       

     

       107
       107
       +
               # Limit results

     

       108
       108
       +
               thicket search "web development" --limit 10

     

       109
       109
       +
       

     

       110
       110
       +
               # Get raw JSON output

     

       111
       111
       +
               thicket search "database" --raw

     

       112
       112
       +
           """

     

       113
       113
       +
           try:

     

       114
       114
       +
               # Load Typesense configuration from defaults if not provided

     

       115
       115
       +
               default_url, default_api_key = _load_typesense_config()

     

       116
       116
       +
       

     

       117
       117
       +
               # Use provided values or defaults

     

       118
       118
       +
               final_url = typesense_url or default_url

     

       119
       119
       +
               final_api_key = api_key or default_api_key

     

       120
       120
       +
       

     

       121
       121
       +
               # Check that we have required configuration

     

       122
       122
       +
               if not final_url:

     

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

     

       124
       124
       +
                   console.print(

     

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

     

       126
       126
       +
                   )

     

       127
       127
       +
                   raise typer.Exit(1)

     

       128
       128
       +
       

     

       129
       129
       +
               if not final_api_key:

     

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

     

       131
       131
       +
                   console.print(

     

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

     

       133
       133
       +
                   )

     

       134
       134
       +
                   raise typer.Exit(1)

     

       135
       135
       +
       

     

       136
       136
       +
               # Create Typesense configuration

     

       137
       137
       +
               typesense_config = TypesenseConfig.from_url(

     

       138
       138
       +
                   final_url, final_api_key, collection_name

     

       139
       139
       +
               )

     

       140
       140
       +
               typesense_config.connection_timeout = timeout

     

       141
       141
       +
       

     

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

     

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

     

       144
       144
       +
               if user:

     

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

     

       146
       146
       +
       

     

       147
       147
       +
               # Initialize Typesense client

     

       148
       148
       +
               typesense_client = TypesenseClient(typesense_config)

     

       149
       149
       +
       

     

       150
       150
       +
               # Prepare search parameters

     

       151
       151
       +
               search_params = {

     

       152
       152
       +
                   "per_page": limit,

     

       153
       153
       +
               }

     

       154
       154
       +
       

     

       155
       155
       +
               # Add user filter if specified

     

       156
       156
       +
               if user:

     

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

     

       158
       158
       +
       

     

       159
       159
       +
               # Perform search

     

       160
       160
       +
               try:

     

       161
       161
       +
                   results = typesense_client.search(query, search_params)

     

       162
       162
       +
       

     

       163
       163
       +
                   if raw:

     

       164
       164
       +
                       import json

     

       165
       165
       +
       

     

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

     

       167
       167
       +
                       return

     

       168
       168
       +
       

     

       169
       169
       +
                   # Display results

     

       170
       170
       +
                   _display_search_results(results, query)

     

       171
       171
       +
       

     

       172
       172
       +
               except Exception as e:

     

       173
       173
       +
                   console.print(f"[red]❌ Search failed: {e}[/red]")

     

       174
       174
       +
                   raise typer.Exit(1) from e

     

       175
       175
       +
       

     

       176
       176
       +
           except Exception as e:

     

       177
       177
       +
               logger.error(f"Search failed: {e}")

     

       178
       178
       +
               console.print(f"[red]Error: {e}[/red]")

     

       179
       179
       +
               raise typer.Exit(1) from e

     

       180
       180
       +
       

     

       181
       181
       +
       

     

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

     

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

     

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

     

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

     

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

     

       187
       187
       +
       

     

       188
       188
       +
           if not hits:

     

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

     

       190
       190
       +
               return

     

       191
       191
       +
       

     

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

     

       193
       193
       +
       

     

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

     

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

     

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

     

       197
       197
       +
           table.add_column("Title", style="bold", width=45)

     

       198
       198
       +
           table.add_column("Updated", style="blue", width=12, no_wrap=True)

     

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

     

       200
       200
       +
       

     

       201
       201
       +
           for hit in hits:

     

       202
       202
       +
               doc = hit["document"]

     

       203
       203
       +
       

     

       204
       204
       +
               # Format score

     

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

     

       206
       206
       +
       

     

       207
       207
       +
               # Format user

     

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

     

       209
       209
       +
               if len(user_display) > 12:

     

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

     

       211
       211
       +
       

     

       212
       212
       +
               # Format title

     

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

     

       214
       214
       +
               if len(title) > 40:

     

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

     

       216
       216
       +
       

     

       217
       217
       +
               # Format date

     

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

     

       219
       219
       +
               if updated_timestamp:

     

       220
       220
       +
                   from datetime import datetime

     

       221
       221
       +
       

     

       222
       222
       +
                   updated_date = datetime.fromtimestamp(updated_timestamp)

     

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

     

       224
       224
       +
               else:

     

       225
       225
       +
                   updated_str = "Unknown"

     

       226
       226
       +
       

     

       227
       227
       +
               # Format summary

     

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

     

       229
       229
       +
               if summary:

     

       230
       230
       +
                   # Remove HTML tags and truncate

     

       231
       231
       +
                   import re

     

       232
       232
       +
       

     

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

     

       234
       234
       +
                   summary = summary.strip()

     

       235
       235
       +
                   if len(summary) > 60:

     

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

     

       237
       237
       +
               else:

     

       238
       238
       +
                   summary = ""

     

       239
       239
       +
       

     

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

     

       241
       241
       +
       

     

       242
       242
       +
           console.print(table)

     

       243
       243
       +
       

     

       244
       244
       +
           # Show additional info

     

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

     

       246
       246
       +
           if len(hits) < found:

     

       247
       247
       +
               console.print(

     

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

     

       249
       249
       +
               )

     

       250
       250
       +
       

     

       251
       251
       +
       

     

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

     

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

     

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

     

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

     

       256
       256
       +
       

     

       257
       257
       +
           if not hits:

     

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

     

       259
       259
       +
               return

     

       260
       260
       +
       

     

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

     

       262
       262
       +
       

     

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

     

       264
       264
       +
               doc = hit["document"]

     

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

     

       266
       266
       +
       

     

       267
       267
       +
               # Header with score and user

     

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

     

       269
       269
       +
               console.print(

     

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

     

       271
       271
       +
               )

     

       272
       272
       +
       

     

       273
       273
       +
               # Title

     

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

     

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

     

       276
       276
       +
       

     

       277
       277
       +
               # Date and link

     

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

     

       279
       279
       +
               if updated_timestamp:

     

       280
       280
       +
                   from datetime import datetime

     

       281
       281
       +
       

     

       282
       282
       +
                   updated_date = datetime.fromtimestamp(updated_timestamp)

     

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

     

       284
       284
       +
               else:

     

       285
       285
       +
                   updated_str = "Unknown date"

     

       286
       286
       +
       

     

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

     

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

     

       289
       289
       +
       

     

       290
       290
       +
               # Summary

     

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

     

       292
       292
       +
               if summary:

     

       293
       293
       +
                   import re

     

       294
       294
       +
       

     

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

     

       296
       296
       +
                   summary = summary.strip()

     

       297
       297
       +
                   if len(summary) > 150:

     

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

     

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

     

       300
       300
       +
       

     

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

+37 -7

src/thicket/cli/commands/sync.py

···

       5
       5
        
       from typing import Optional

     

       6
       6
        
       

     

       7
       7
        
       import typer

     

       8
       8
       +
       from pydantic import HttpUrl

     

       8
       9
        
       from rich.progress import track

     

       9
       10
        
       

     

       10
       11
        
       from ...core.feed_parser import FeedParser

     

       11
       12
        
       from ...core.git_store import GitStore

     

       13
       13
       +
       from ...core.opml_generator import OPMLGenerator

     

       12
       14
        
       from ..main import app

     

       13
       15
        
       from ..utils import (

     

       14
       16
        
           load_config,

     
···

       71
       73
        
               user_updated_entries = 0

     

       72
       74
        
       

     

       73
       75
        
               # Sync each feed for the user

     

       74
       74
       -
               for feed_url in track(user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"):

     

       76
       76
       +
               for feed_url in track(

     

       77
       77
       +
                   user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"

     

       78
       78
       +
               ):

     

       75
       79
        
                   try:

     

       76
       80
        
                       new_entries, updated_entries = asyncio.run(

     

       77
       81
        
                           sync_feed(git_store, user_metadata.username, feed_url, dry_run)

     
···

       83
       87
        
                       print_error(f"Failed to sync feed {feed_url}: {e}")

     

       84
       88
        
                       continue

     

       85
       89
        
       

     

       86
       86
       -
               print_info(f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated")

     

       90
       90
       +
               print_info(

     

       91
       91
       +
                   f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated"

     

       92
       92
       +
               )

     

       87
       93
        
               total_new_entries += user_new_entries

     

       88
       94
        
               total_updated_entries += user_updated_entries

     

       89
       95
        
       

     
···

       93
       99
        
               git_store.commit_changes(commit_message)

     

       94
       100
        
               print_success(f"Committed changes: {commit_message}")

     

       95
       101
        
       

     

       102
       102
       +
           # Generate OPML file with all feeds

     

       103
       103
       +
           if not dry_run:

     

       104
       104
       +
               try:

     

       105
       105
       +
                   opml_generator = OPMLGenerator()

     

       106
       106
       +
                   index = git_store._load_index()

     

       107
       107
       +
                   opml_path = config.git_store / "index.opml"

     

       108
       108
       +
       

     

       109
       109
       +
                   opml_generator.generate_opml(

     

       110
       110
       +
                       users=index.users,

     

       111
       111
       +
                       title="Thicket Feed Collection",

     

       112
       112
       +
                       output_path=opml_path,

     

       113
       113
       +
                   )

     

       114
       114
       +
                   print_info(f"Generated OPML file: {opml_path}")

     

       115
       115
       +
       

     

       116
       116
       +
               except Exception as e:

     

       117
       117
       +
                   print_error(f"Failed to generate OPML file: {e}")

     

       118
       118
       +
       

     

       96
       119
        
           # Summary

     

       97
       120
        
           if dry_run:

     

       98
       98
       -
               print_info(f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated")

     

       121
       121
       +
               print_info(

     

       122
       122
       +
                   f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated"

     

       123
       123
       +
               )

     

       99
       124
        
           else:

     

       100
       100
       -
               print_success(f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated")

     

       125
       125
       +
               print_success(

     

       126
       126
       +
                   f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated"

     

       127
       127
       +
               )

     

       101
       128
        
       

     

       102
       129
        
       

     

       103
       103
       -
       async def sync_feed(git_store: GitStore, username: str, feed_url, dry_run: bool) -> tuple[int, int]:

     

       130
       130
       +
       async def sync_feed(

     

       131
       131
       +
           git_store: GitStore, username: str, feed_url: str, dry_run: bool

     

       132
       132
       +
       ) -> tuple[int, int]:

     

       104
       133
        
           """Sync a single feed for a user."""

     

       105
       134
        
       

     

       106
       135
        
           parser = FeedParser()

     

       107
       136
        
       

     

       108
       137
        
           try:

     

       109
       138
        
               # Fetch and parse feed

     

       110
       110
       -
               content = await parser.fetch_feed(feed_url)

     

       111
       111
       -
               metadata, entries = parser.parse_feed(content, feed_url)

     

       139
       139
       +
               validated_feed_url = HttpUrl(feed_url)

     

       140
       140
       +
               content = await parser.fetch_feed(validated_feed_url)

     

       141
       141
       +
               metadata, entries = parser.parse_feed(content, validated_feed_url)

     

       112
       142
        
       

     

       113
       143
        
               new_entries = 0

     

       114
       144
        
               updated_entries = 0

+323

src/thicket/cli/commands/upload.py

···

       1
       1
       +
       """Upload command for thicket CLI."""

     

       2
       2
       +
       

     

       3
       3
       +
       import logging

     

       4
       4
       +
       from pathlib import Path

     

       5
       5
       +
       from typing import Optional

     

       6
       6
       +
       

     

       7
       7
       +
       import typer

     

       8
       8
       +
       from rich.console import Console

     

       9
       9
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       10
       10
       +
       

     

       11
       11
       +
       from ...core.git_store import GitStore

     

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

     

       13
       13
       +
       from ...models.config import ThicketConfig

     

       14
       14
       +
       from ..main import app

     

       15
       15
       +
       from ..utils import load_config

     

       16
       16
       +
       

     

       17
       17
       +
       console = Console()

     

       18
       18
       +
       logger = logging.getLogger(__name__)

     

       19
       19
       +
       

     

       20
       20
       +
       

     

       21
       21
       +
       def _load_typesense_config() -> tuple[Optional[str], Optional[str]]:

     

       22
       22
       +
           """Load Typesense URL and API key from ~/.typesense directory."""

     

       23
       23
       +
           typesense_dir = Path.home() / ".typesense"

     

       24
       24
       +
           url_file = typesense_dir / "url"

     

       25
       25
       +
           key_file = typesense_dir / "api_key"

     

       26
       26
       +
       

     

       27
       27
       +
           url = None

     

       28
       28
       +
           api_key = None

     

       29
       29
       +
       

     

       30
       30
       +
           try:

     

       31
       31
       +
               if url_file.exists():

     

       32
       32
       +
                   url = url_file.read_text().strip()

     

       33
       33
       +
           except Exception as e:

     

       34
       34
       +
               logger.debug(f"Could not read Typesense URL from {url_file}: {e}")

     

       35
       35
       +
       

     

       36
       36
       +
           try:

     

       37
       37
       +
               if key_file.exists():

     

       38
       38
       +
                   api_key = key_file.read_text().strip()

     

       39
       39
       +
           except Exception as e:

     

       40
       40
       +
               logger.debug(f"Could not read Typesense API key from {key_file}: {e}")

     

       41
       41
       +
       

     

       42
       42
       +
           return url, api_key

     

       43
       43
       +
       

     

       44
       44
       +
       

     

       45
       45
       +
       def _save_typesense_config(

     

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

     

       47
       47
       +
       ) -> None:

     

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

     

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

     

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

     

       51
       51
       +
       

     

       52
       52
       +
           if url:

     

       53
       53
       +
               url_file = typesense_dir / "url"

     

       54
       54
       +
               url_file.write_text(url)

     

       55
       55
       +
               url_file.chmod(0o600)

     

       56
       56
       +
       

     

       57
       57
       +
           if api_key:

     

       58
       58
       +
               key_file = typesense_dir / "api_key"

     

       59
       59
       +
               key_file.write_text(api_key)

     

       60
       60
       +
               key_file.chmod(0o600)  # Keep API key secure

     

       61
       61
       +
       

     

       62
       62
       +
       

     

       63
       63
       +
       @app.command("upload")

     

       64
       64
       +
       def upload_command(

     

       65
       65
       +
           typesense_url: Optional[str] = typer.Option(

     

       66
       66
       +
               None,

     

       67
       67
       +
               "--typesense-url",

     

       68
       68
       +
               "-u",

     

       69
       69
       +
               help="Typesense server URL (e.g., http://localhost:8108). Defaults to ~/.typesense/url",

     

       70
       70
       +
           ),

     

       71
       71
       +
           api_key: Optional[str] = typer.Option(

     

       72
       72
       +
               None,

     

       73
       73
       +
               "--api-key",

     

       74
       74
       +
               "-k",

     

       75
       75
       +
               help="Typesense API key. Defaults to ~/.typesense/api_key",

     

       76
       76
       +
               hide_input=True,

     

       77
       77
       +
           ),

     

       78
       78
       +
           collection_name: str = typer.Option(

     

       79
       79
       +
               "thicket_entries",

     

       80
       80
       +
               "--collection",

     

       81
       81
       +
               "-c",

     

       82
       82
       +
               help="Typesense collection name",

     

       83
       83
       +
           ),

     

       84
       84
       +
           config_path: Optional[str] = typer.Option(

     

       85
       85
       +
               None,

     

       86
       86
       +
               "--config",

     

       87
       87
       +
               "-C",

     

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

     

       89
       89
       +
           ),

     

       90
       90
       +
           git_store_path: Optional[str] = typer.Option(

     

       91
       91
       +
               None,

     

       92
       92
       +
               "--git-store",

     

       93
       93
       +
               "-g",

     

       94
       94
       +
               help="Path to Git store (overrides config)",

     

       95
       95
       +
           ),

     

       96
       96
       +
           timeout: int = typer.Option(

     

       97
       97
       +
               10,

     

       98
       98
       +
               "--timeout",

     

       99
       99
       +
               "-t",

     

       100
       100
       +
               help="Connection timeout in seconds",

     

       101
       101
       +
           ),

     

       102
       102
       +
           dry_run: bool = typer.Option(

     

       103
       103
       +
               False,

     

       104
       104
       +
               "--dry-run",

     

       105
       105
       +
               help="Show what would be uploaded without actually uploading",

     

       106
       106
       +
           ),

     

       107
       107
       +
       ) -> None:

     

       108
       108
       +
           """Upload thicket entries to a Typesense search engine.

     

       109
       109
       +
       

     

       110
       110
       +
           This command uploads all entries from the Git store to a Typesense server

     

       111
       111
       +
           for full-text and semantic search capabilities. The uploaded data includes

     

       112
       112
       +
           entry content, metadata, user information, and searchable text fields

     

       113
       113
       +
           optimized for embedding-based queries.

     

       114
       114
       +
       

     

       115
       115
       +
           Configuration defaults can be stored in ~/.typesense/ directory:

     

       116
       116
       +
           - URL in ~/.typesense/url

     

       117
       117
       +
           - API key in ~/.typesense/api_key

     

       118
       118
       +
       

     

       119
       119
       +
           Examples:

     

       120
       120
       +
       

     

       121
       121
       +
               # Upload using saved defaults (first run will save config)

     

       122
       122
       +
               thicket upload -u http://localhost:8108 -k your-api-key

     

       123
       123
       +
       

     

       124
       124
       +
               # Subsequent runs can omit URL and key if saved

     

       125
       125
       +
               thicket upload

     

       126
       126
       +
       

     

       127
       127
       +
               # Upload to remote server with custom collection name

     

       128
       128
       +
               thicket upload -u https://search.example.com -k api-key -c my_blog_entries

     

       129
       129
       +
       

     

       130
       130
       +
               # Dry run to see what would be uploaded

     

       131
       131
       +
               thicket upload --dry-run

     

       132
       132
       +
           """

     

       133
       133
       +
           try:

     

       134
       134
       +
               # Load Typesense configuration from defaults if not provided

     

       135
       135
       +
               default_url, default_api_key = _load_typesense_config()

     

       136
       136
       +
       

     

       137
       137
       +
               # Use provided values or defaults

     

       138
       138
       +
               final_url = typesense_url or default_url

     

       139
       139
       +
               final_api_key = api_key or default_api_key

     

       140
       140
       +
       

     

       141
       141
       +
               # Check that we have required configuration

     

       142
       142
       +
               if not final_url:

     

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

     

       144
       144
       +
                   console.print(

     

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

     

       146
       146
       +
                   )

     

       147
       147
       +
                   raise typer.Exit(1)

     

       148
       148
       +
       

     

       149
       149
       +
               if not final_api_key:

     

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

     

       151
       151
       +
                   console.print(

     

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

     

       153
       153
       +
                   )

     

       154
       154
       +
                   raise typer.Exit(1)

     

       155
       155
       +
       

     

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

     

       157
       157
       +
               if typesense_url or api_key:

     

       158
       158
       +
                   _save_typesense_config(typesense_url, api_key)

     

       159
       159
       +
       

     

       160
       160
       +
               # Load thicket configuration

     

       161
       161
       +
               config_path_obj = Path(config_path) if config_path else None

     

       162
       162
       +
               config = load_config(config_path_obj)

     

       163
       163
       +
       

     

       164
       164
       +
               # Override git store path if provided

     

       165
       165
       +
               if git_store_path:

     

       166
       166
       +
                   config.git_store = Path(git_store_path)

     

       167
       167
       +
       

     

       168
       168
       +
               console.print("[bold blue]Thicket Typesense Upload[/bold blue]")

     

       169
       169
       +
               console.print(f"Git store: {config.git_store}")

     

       170
       170
       +
               console.print(f"Typesense URL: {final_url}")

     

       171
       171
       +
       

     

       172
       172
       +
               # Show where config is loaded from

     

       173
       173
       +
               if not typesense_url and default_url:

     

       174
       174
       +
                   console.print("[dim]  (URL loaded from ~/.typesense/url)[/dim]")

     

       175
       175
       +
               if not api_key and default_api_key:

     

       176
       176
       +
                   console.print("[dim]  (API key loaded from ~/.typesense/api_key)[/dim]")

     

       177
       177
       +
       

     

       178
       178
       +
               console.print(f"Collection: {collection_name}")

     

       179
       179
       +
       

     

       180
       180
       +
               if dry_run:

     

       181
       181
       +
                   console.print("[yellow]DRY RUN MODE - No data will be uploaded[/yellow]")

     

       182
       182
       +
       

     

       183
       183
       +
               # Initialize Git store

     

       184
       184
       +
               git_store = GitStore(config.git_store)

     

       185
       185
       +
               if not git_store.repo or not config.git_store.exists():

     

       186
       186
       +
                   console.print("[red]Error: Git store is not valid or not initialized[/red]")

     

       187
       187
       +
                   console.print("Run 'thicket init' first to set up the Git store.")

     

       188
       188
       +
                   raise typer.Exit(1)

     

       189
       189
       +
       

     

       190
       190
       +
               # Create Typesense configuration

     

       191
       191
       +
               typesense_config = TypesenseConfig.from_url(

     

       192
       192
       +
                   final_url, final_api_key, collection_name

     

       193
       193
       +
               )

     

       194
       194
       +
               typesense_config.connection_timeout = timeout

     

       195
       195
       +
       

     

       196
       196
       +
               if dry_run:

     

       197
       197
       +
                   _dry_run_upload(git_store, config, typesense_config)

     

       198
       198
       +
               else:

     

       199
       199
       +
                   _perform_upload(git_store, config, typesense_config)

     

       200
       200
       +
       

     

       201
       201
       +
           except Exception as e:

     

       202
       202
       +
               logger.error(f"Upload failed: {e}")

     

       203
       203
       +
               console.print(f"[red]Error: {e}[/red]")

     

       204
       204
       +
               raise typer.Exit(1) from e

     

       205
       205
       +
       

     

       206
       206
       +
       

     

       207
       207
       +
       def _dry_run_upload(

     

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

     

       209
       209
       +
       ) -> None:

     

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

     

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

     

       212
       212
       +
       

     

       213
       213
       +
           index = git_store._load_index()

     

       214
       214
       +
           total_entries = 0

     

       215
       215
       +
       

     

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

     

       217
       217
       +
               try:

     

       218
       218
       +
                   user_dir = git_store.repo_path / user_metadata.directory

     

       219
       219
       +
                   if not user_dir.exists():

     

       220
       220
       +
                       console.print(f"  ⚠️  User {username}: Directory not found")

     

       221
       221
       +
                       continue

     

       222
       222
       +
       

     

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

     

       224
       224
       +
                   total_entries += len(entry_files)

     

       225
       225
       +
                   console.print(

     

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

     

       227
       227
       +
                   )

     

       228
       228
       +
               except Exception as e:

     

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

     

       230
       230
       +
       

     

       231
       231
       +
           console.print("\n[bold]Summary:[/bold]")

     

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

     

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

     

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

     

       235
       235
       +
           console.print(

     

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

     

       237
       237
       +
           )

     

       238
       238
       +
       

     

       239
       239
       +
           if total_entries > 0:

     

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

     

       241
       241
       +
           else:

     

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

     

       243
       243
       +
       

     

       244
       244
       +
       

     

       245
       245
       +
       def _perform_upload(

     

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

     

       247
       247
       +
       ) -> None:

     

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

     

       249
       249
       +
           with Progress(

     

       250
       250
       +
               SpinnerColumn(),

     

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

     

       252
       252
       +
               console=console,

     

       253
       253
       +
           ) as progress:

     

       254
       254
       +
               # Test connection

     

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

     

       256
       256
       +
       

     

       257
       257
       +
               try:

     

       258
       258
       +
                   typesense_client = TypesenseClient(typesense_config)

     

       259
       259
       +
                   # Test connection by attempting to list collections

     

       260
       260
       +
                   typesense_client.client.collections.retrieve()

     

       261
       261
       +
                   progress.stop()

     

       262
       262
       +
                   console.print("[green]✅ Connected to Typesense server[/green]")

     

       263
       263
       +
               except Exception as e:

     

       264
       264
       +
                   progress.stop()

     

       265
       265
       +
                   console.print(f"[red]❌ Failed to connect to Typesense: {e}[/red]")

     

       266
       266
       +
                   raise typer.Exit(1) from e

     

       267
       267
       +
       

     

       268
       268
       +
               # Perform upload

     

       269
       269
       +
               with Progress(

     

       270
       270
       +
                   SpinnerColumn(),

     

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

     

       272
       272
       +
                   console=console,

     

       273
       273
       +
               ) as upload_progress:

     

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

     

       275
       275
       +
       

     

       276
       276
       +
                   try:

     

       277
       277
       +
                       result = typesense_client.upload_from_git_store(git_store, config)

     

       278
       278
       +
                       upload_progress.stop()

     

       279
       279
       +
       

     

       280
       280
       +
                       # Parse results if available

     

       281
       281
       +
                       if result:

     

       282
       282
       +
                           if isinstance(result, list):

     

       283
       283
       +
                               # Batch import results

     

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

     

       285
       285
       +
                               total_count = len(result)

     

       286
       286
       +
                               console.print(

     

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

     

       288
       288
       +
                               )

     

       289
       289
       +
       

     

       290
       290
       +
                               # Show any errors

     

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

     

       292
       292
       +
                               if errors:

     

       293
       293
       +
                                   console.print(

     

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

     

       295
       295
       +
                                   )

     

       296
       296
       +
                                   for i, error in enumerate(

     

       297
       297
       +
                                       errors[:5]

     

       298
       298
       +
                                   ):  # Show first 5 errors

     

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

     

       300
       300
       +
                                   if len(errors) > 5:

     

       301
       301
       +
                                       console.print(

     

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

     

       303
       303
       +
                                       )

     

       304
       304
       +
                           else:

     

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

     

       306
       306
       +
                       else:

     

       307
       307
       +
                           console.print(

     

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

     

       309
       309
       +
                           )

     

       310
       310
       +
       

     

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

     

       312
       312
       +
                       console.print(

     

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

     

       314
       314
       +
                       )

     

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

     

       316
       316
       +
                       console.print(

     

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

     

       318
       318
       +
                       )

     

       319
       319
       +
       

     

       320
       320
       +
                   except Exception as e:

     

       321
       321
       +
                       upload_progress.stop()

     

       322
       322
       +
                       console.print(f"[red]❌ Upload failed: {e}[/red]")

     

       323
       323
       +
                       raise typer.Exit(1) from e

+268

src/thicket/cli/commands/zulip.py

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       from pathlib import Path

     

       4
       4
       +
       from typing import Optional

     

       5
       5
       +
       

     

       6
       6
       +
       import typer

     

       7
       7
       +
       from rich.console import Console

     

       8
       8
       +
       from rich.table import Table

     

       9
       9
       +
       

     

       10
       10
       +
       from ...core.git_store import GitStore

     

       11
       11
       +
       from ..main import app

     

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

     

       13
       13
       +
       

     

       14
       14
       +
       console = Console()

     

       15
       15
       +
       

     

       16
       16
       +
       

     

       17
       17
       +
       @app.command()

     

       18
       18
       +
       def zulip_add(

     

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

     

       20
       20
       +
           server: str = typer.Argument(

     

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

     

       22
       22
       +
           ),

     

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

     

       24
       24
       +
           config_file: Path = typer.Option(

     

       25
       25
       +
               Path("thicket.yaml"),

     

       26
       26
       +
               "--config",

     

       27
       27
       +
               "-c",

     

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

     

       29
       29
       +
           ),

     

       30
       30
       +
       ) -> None:

     

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

     

       32
       32
       +
       

     

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

     

       34
       34
       +
           @mentions when the bot posts their articles.

     

       35
       35
       +
       

     

       36
       36
       +
           Example:

     

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

     

       38
       38
       +
           """

     

       39
       39
       +
           try:

     

       40
       40
       +
               config = load_config(config_file)

     

       41
       41
       +
               git_store = GitStore(config.git_store)

     

       42
       42
       +
       

     

       43
       43
       +
               # Check if user exists

     

       44
       44
       +
               user = git_store.get_user(username)

     

       45
       45
       +
               if not user:

     

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

     

       47
       47
       +
                   raise typer.Exit(1)

     

       48
       48
       +
       

     

       49
       49
       +
               # Add association

     

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

     

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

     

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

     

       53
       53
       +
               else:

     

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

     

       55
       55
       +
       

     

       56
       56
       +
           except Exception as e:

     

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

     

       58
       58
       +
               raise typer.Exit(1) from e

     

       59
       59
       +
       

     

       60
       60
       +
       

     

       61
       61
       +
       @app.command()

     

       62
       62
       +
       def zulip_remove(

     

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

     

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

     

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

     

       66
       66
       +
           config_file: Path = typer.Option(

     

       67
       67
       +
               Path("thicket.yaml"),

     

       68
       68
       +
               "--config",

     

       69
       69
       +
               "-c",

     

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

     

       71
       71
       +
           ),

     

       72
       72
       +
       ) -> None:

     

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

     

       74
       74
       +
       

     

       75
       75
       +
           Example:

     

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

     

       77
       77
       +
           """

     

       78
       78
       +
           try:

     

       79
       79
       +
               config = load_config(config_file)

     

       80
       80
       +
               git_store = GitStore(config.git_store)

     

       81
       81
       +
       

     

       82
       82
       +
               # Check if user exists

     

       83
       83
       +
               user = git_store.get_user(username)

     

       84
       84
       +
               if not user:

     

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

     

       86
       86
       +
                   raise typer.Exit(1)

     

       87
       87
       +
       

     

       88
       88
       +
               # Remove association

     

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

     

       90
       90
       +
                   print_success(

     

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

     

       92
       92
       +
                   )

     

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

     

       94
       94
       +
               else:

     

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

     

       96
       96
       +
                   raise typer.Exit(1)

     

       97
       97
       +
       

     

       98
       98
       +
           except Exception as e:

     

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

     

       100
       100
       +
               raise typer.Exit(1) from e

     

       101
       101
       +
       

     

       102
       102
       +
       

     

       103
       103
       +
       @app.command()

     

       104
       104
       +
       def zulip_list(

     

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

     

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

     

       107
       107
       +
           ),

     

       108
       108
       +
           config_file: Path = typer.Option(

     

       109
       109
       +
               Path("thicket.yaml"),

     

       110
       110
       +
               "--config",

     

       111
       111
       +
               "-c",

     

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

     

       113
       113
       +
           ),

     

       114
       114
       +
       ) -> None:

     

       115
       115
       +
           """List Zulip associations for users.

     

       116
       116
       +
       

     

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

     

       118
       118
       +
       

     

       119
       119
       +
           Examples:

     

       120
       120
       +
               thicket zulip-list          # List all associations

     

       121
       121
       +
               thicket zulip-list alice    # List associations for alice

     

       122
       122
       +
           """

     

       123
       123
       +
           try:

     

       124
       124
       +
               config = load_config(config_file)

     

       125
       125
       +
               git_store = GitStore(config.git_store)

     

       126
       126
       +
       

     

       127
       127
       +
               # Create table

     

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

     

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

     

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

     

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

     

       132
       132
       +
       

     

       133
       133
       +
               if username:

     

       134
       134
       +
                   # List for specific user

     

       135
       135
       +
                   user = git_store.get_user(username)

     

       136
       136
       +
                   if not user:

     

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

     

       138
       138
       +
                       raise typer.Exit(1)

     

       139
       139
       +
       

     

       140
       140
       +
                   if not user.zulip_associations:

     

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

     

       142
       142
       +
                       return

     

       143
       143
       +
       

     

       144
       144
       +
                   for assoc in user.zulip_associations:

     

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

     

       146
       146
       +
               else:

     

       147
       147
       +
                   # List for all users

     

       148
       148
       +
                   index = git_store._load_index()

     

       149
       149
       +
                   has_associations = False

     

       150
       150
       +
       

     

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

     

       152
       152
       +
                       for assoc in user.zulip_associations:

     

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

     

       154
       154
       +
                           has_associations = True

     

       155
       155
       +
       

     

       156
       156
       +
                   if not has_associations:

     

       157
       157
       +
                       print_info("No Zulip associations found")

     

       158
       158
       +
                       return

     

       159
       159
       +
       

     

       160
       160
       +
               console.print(table)

     

       161
       161
       +
       

     

       162
       162
       +
           except Exception as e:

     

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

     

       164
       164
       +
               raise typer.Exit(1) from e

     

       165
       165
       +
       

     

       166
       166
       +
       

     

       167
       167
       +
       @app.command()

     

       168
       168
       +
       def zulip_import(

     

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

     

       170
       170
       +
           config_file: Path = typer.Option(

     

       171
       171
       +
               Path("thicket.yaml"),

     

       172
       172
       +
               "--config",

     

       173
       173
       +
               "-c",

     

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

     

       175
       175
       +
           ),

     

       176
       176
       +
           dry_run: bool = typer.Option(

     

       177
       177
       +
               False,

     

       178
       178
       +
               "--dry-run",

     

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

     

       180
       180
       +
           ),

     

       181
       181
       +
       ) -> None:

     

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

     

       183
       183
       +
       

     

       184
       184
       +
           CSV format (no header):

     

       185
       185
       +
               username,server,user_id

     

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

     

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

     

       188
       188
       +
       

     

       189
       189
       +
           Example:

     

       190
       190
       +
               thicket zulip-import associations.csv

     

       191
       191
       +
           """

     

       192
       192
       +
           import csv

     

       193
       193
       +
       

     

       194
       194
       +
           try:

     

       195
       195
       +
               config = load_config(config_file)

     

       196
       196
       +
               git_store = GitStore(config.git_store)

     

       197
       197
       +
       

     

       198
       198
       +
               if not csv_file.exists():

     

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

     

       200
       200
       +
                   raise typer.Exit(1)

     

       201
       201
       +
       

     

       202
       202
       +
               added = 0

     

       203
       203
       +
               skipped = 0

     

       204
       204
       +
               errors = 0

     

       205
       205
       +
       

     

       206
       206
       +
               with open(csv_file) as f:

     

       207
       207
       +
                   reader = csv.reader(f)

     

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

     

       209
       209
       +
                       if len(row) != 3:

     

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

     

       211
       211
       +
                           errors += 1

     

       212
       212
       +
                           continue

     

       213
       213
       +
       

     

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

     

       215
       215
       +
       

     

       216
       216
       +
                       # Skip empty lines

     

       217
       217
       +
                       if not username:

     

       218
       218
       +
                           continue

     

       219
       219
       +
       

     

       220
       220
       +
                       # Check if user exists

     

       221
       221
       +
                       user = git_store.get_user(username)

     

       222
       222
       +
                       if not user:

     

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

     

       224
       224
       +
                           errors += 1

     

       225
       225
       +
                           continue

     

       226
       226
       +
       

     

       227
       227
       +
                       if dry_run:

     

       228
       228
       +
                           # Check if association would be added

     

       229
       229
       +
                           exists = any(

     

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

     

       231
       231
       +
                               for a in user.zulip_associations

     

       232
       232
       +
                           )

     

       233
       233
       +
                           if exists:

     

       234
       234
       +
                               print_info(

     

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

     

       236
       236
       +
                               )

     

       237
       237
       +
                               skipped += 1

     

       238
       238
       +
                           else:

     

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

     

       240
       240
       +
                               added += 1

     

       241
       241
       +
                       else:

     

       242
       242
       +
                           # Actually add association

     

       243
       243
       +
                           if git_store.add_zulip_association(username, server, user_id):

     

       244
       244
       +
                               print_success(f"Added: {username} -> {user_id}@{server}")

     

       245
       245
       +
                               added += 1

     

       246
       246
       +
                           else:

     

       247
       247
       +
                               print_info(

     

       248
       248
       +
                                   f"Skipped existing: {username} -> {user_id}@{server}"

     

       249
       249
       +
                               )

     

       250
       250
       +
                               skipped += 1

     

       251
       251
       +
       

     

       252
       252
       +
               # Summary

     

       253
       253
       +
               console.print()

     

       254
       254
       +
               if dry_run:

     

       255
       255
       +
                   console.print("[bold]Dry run summary:[/bold]")

     

       256
       256
       +
                   console.print(f"  Would add: {added}")

     

       257
       257
       +
               else:

     

       258
       258
       +
                   console.print("[bold]Import summary:[/bold]")

     

       259
       259
       +
                   console.print(f"  Added: {added}")

     

       260
       260
       +
                   if not dry_run and added > 0:

     

       261
       261
       +
                       git_store.commit_changes(f"Import {added} Zulip associations from CSV")

     

       262
       262
       +
       

     

       263
       263
       +
               console.print(f"  Skipped: {skipped}")

     

       264
       264
       +
               console.print(f"  Errors: {errors}")

     

       265
       265
       +
       

     

       266
       266
       +
           except Exception as e:

     

       267
       267
       +
               print_error(f"Failed to import Zulip associations: {e}")

     

       268
       268
       +
               raise typer.Exit(1) from e

+9 -1

src/thicket/cli/main.py

···

       47
       47
        
       

     

       48
       48
        
       

     

       49
       49
        
       # Import commands to register them

     

       50
       50
       -
       from .commands import add, duplicates, index_cmd, info_cmd, init, links_cmd, list_cmd, sync

     

       50
       50
       +
       from .commands import (  # noqa: F401, E402

     

       51
       51
       +
           add,

     

       52
       52
       +
           duplicates,

     

       53
       53
       +
           info_cmd,

     

       54
       54
       +
           init,

     

       55
       55
       +
           list_cmd,

     

       56
       56
       +
           sync,

     

       57
       57
       +
           upload,

     

       58
       58
       +
       )

     

       51
       59
        
       

     

       52
       60
        
       if __name__ == "__main__":

     

       53
       61
        
           app()

+32 -20

src/thicket/cli/utils.py

···

       8
       8
        
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       9
       9
        
       from rich.table import Table

     

       10
       10
        
       

     

       11
       11
       -
       from ..models import ThicketConfig, UserMetadata

     

       12
       11
        
       from ..core.git_store import GitStore

     

       12
       12
       +
       from ..models import ThicketConfig, UserMetadata

     

       13
       13
        
       

     

       14
       14
        
       console = Console()

     

       15
       15
        
       

     
···

       17
       17
        
       def get_tsv_mode() -> bool:

     

       18
       18
        
           """Get the global TSV mode setting."""

     

       19
       19
        
           from .main import tsv_mode

     

       20
       20
       +
       

     

       20
       21
        
           return tsv_mode

     

       21
       22
        
       

     

       22
       23
        
       

     
···

       37
       38
        
               default_config = Path("thicket.yaml")

     

       38
       39
        
               if default_config.exists():

     

       39
       40
        
                   import yaml

     

       41
       41
       +
       

     

       40
       42
        
                   with open(default_config) as f:

     

       41
       43
        
                       config_data = yaml.safe_load(f)

     

       42
       44
        
                   return ThicketConfig(**config_data)

     

       43
       43
       -
               

     

       45
       45
       +
       

     

       44
       46
        
               # Fall back to environment variables

     

       45
       47
        
               return ThicketConfig()

     

       46
       48
        
           except Exception as e:

     

       47
       49
        
               console.print(f"[red]Error loading configuration: {e}[/red]")

     

       48
       48
       -
               console.print("[yellow]Run 'thicket init' to create a new configuration.[/yellow]")

     

       50
       50
       +
               console.print(

     

       51
       51
       +
                   "[yellow]Run 'thicket init' to create a new configuration.[/yellow]"

     

       52
       52
       +
               )

     

       49
       53
        
               raise typer.Exit(1) from e

     

       50
       54
        
       

     

       51
       55
        
       

     
···

       78
       82
        
           if get_tsv_mode():

     

       79
       83
        
               print_users_tsv(config)

     

       80
       84
        
               return

     

       81
       81
       -
               

     

       85
       85
       +
       

     

       82
       86
        
           table = Table(title="Users and Feeds")

     

       83
       87
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       84
       88
        
           table.add_column("Display Name", style="magenta")

     
···

       104
       108
        
           if get_tsv_mode():

     

       105
       109
        
               print_feeds_tsv(config, username)

     

       106
       110
        
               return

     

       107
       107
       -
               

     

       111
       111
       +
       

     

       108
       112
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       109
       113
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       110
       114
        
           table.add_column("Feed URL", style="blue")

     
···

       154
       158
        
           if get_tsv_mode():

     

       155
       159
        
               print_users_tsv_from_git(users)

     

       156
       160
        
               return

     

       157
       157
       -
               

     

       161
       161
       +
       

     

       158
       162
        
           table = Table(title="Users and Feeds")

     

       159
       163
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       160
       164
        
           table.add_column("Display Name", style="magenta")

     
···

       175
       179
        
           console.print(table)

     

       176
       180
        
       

     

       177
       181
        
       

     

       178
       178
       -
       def print_feeds_table_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       182
       182
       +
       def print_feeds_table_from_git(

     

       183
       183
       +
           git_store: GitStore, username: Optional[str] = None

     

       184
       184
       +
       ) -> None:

     

       179
       185
        
           """Print a table of feeds from git repository."""

     

       180
       186
        
           if get_tsv_mode():

     

       181
       187
        
               print_feeds_tsv_from_git(git_store, username)

     

       182
       188
        
               return

     

       183
       183
       -
               

     

       189
       189
       +
       

     

       184
       190
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       185
       191
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       186
       192
        
           table.add_column("Feed URL", style="blue")

     
···

       209
       215
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       210
       216
        
           for user in config.users:

     

       211
       217
        
               feeds_str = ",".join(str(feed) for feed in user.feeds)

     

       212
       212
       -
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       218
       218
       +
               print(

     

       219
       219
       +
                   f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}"

     

       220
       220
       +
               )

     

       213
       221
        
       

     

       214
       222
        
       

     

       215
       223
        
       def print_users_tsv_from_git(users: list[UserMetadata]) -> None:

     
···

       217
       225
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       218
       226
        
           for user in users:

     

       219
       227
        
               feeds_str = ",".join(user.feeds)

     

       220
       220
       -
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       228
       228
       +
               print(

     

       229
       229
       +
                   f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}"

     

       230
       230
       +
               )

     

       221
       231
        
       

     

       222
       232
        
       

     

       223
       233
        
       def print_feeds_tsv(config: ThicketConfig, username: Optional[str] = None) -> None:

     
···

       225
       235
        
           print("Username\tFeed URL\tStatus")

     

       226
       236
        
           users = [config.find_user(username)] if username else config.users

     

       227
       237
        
           users = [u for u in users if u is not None]

     

       228
       228
       -
           

     

       238
       238
       +
       

     

       229
       239
        
           for user in users:

     

       230
       240
        
               for feed in user.feeds:

     

       231
       241
        
                   print(f"{user.username}\t{feed}\tActive")

     

       232
       242
        
       

     

       233
       243
        
       

     

       234
       234
       -
       def print_feeds_tsv_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       244
       244
       +
       def print_feeds_tsv_from_git(

     

       245
       245
       +
           git_store: GitStore, username: Optional[str] = None

     

       246
       246
       +
       ) -> None:

     

       235
       247
        
           """Print feeds from git repository in TSV format."""

     

       236
       248
        
           print("Username\tFeed URL\tStatus")

     

       237
       237
       -
           

     

       249
       249
       +
       

     

       238
       250
        
           if username:

     

       239
       251
        
               user = git_store.get_user(username)

     

       240
       252
        
               users = [user] if user else []

     

       241
       253
        
           else:

     

       242
       254
        
               index = git_store._load_index()

     

       243
       255
        
               users = list(index.users.values())

     

       244
       244
       -
           

     

       256
       256
       +
       

     

       245
       257
        
           for user in users:

     

       246
       258
        
               for feed in user.feeds:

     

       247
       259
        
                   print(f"{user.username}\t{feed}\tActive")

     
···

       250
       262
        
       def print_entries_tsv(entries_by_user: list[list], usernames: list[str]) -> None:

     

       251
       263
        
           """Print entries in TSV format."""

     

       252
       264
        
           print("User\tAtom ID\tTitle\tUpdated\tURL")

     

       253
       253
       -
           

     

       265
       265
       +
       

     

       254
       266
        
           # Combine all entries with usernames

     

       255
       267
        
           all_entries = []

     

       256
       268
        
           for entries, username in zip(entries_by_user, usernames):

     

       257
       269
        
               for entry in entries:

     

       258
       270
        
                   all_entries.append((username, entry))

     

       259
       259
       -
           

     

       271
       271
       +
       

     

       260
       272
        
           # Sort by updated time (newest first)

     

       261
       273
        
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       262
       262
       -
           

     

       274
       274
       +
       

     

       263
       275
        
           for username, entry in all_entries:

     

       264
       276
        
               # Format updated time

     

       265
       277
        
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       266
       266
       -
               

     

       278
       278
       +
       

     

       267
       279
        
               # Escape tabs and newlines in title to preserve TSV format

     

       268
       268
       -
               title = entry.title.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       269
       269
       -
               

     

       280
       280
       +
               title = entry.title.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       281
       281
       +
       

     

       270
       282
        
               print(f"{username}\t{entry.id}\t{title}\t{updated_str}\t{entry.link}")

+84 -55

src/thicket/core/feed_parser.py

···

       19
       19
        
               """Initialize the feed parser."""

     

       20
       20
        
               self.user_agent = user_agent

     

       21
       21
        
               self.allowed_tags = [

     

       22
       22
       -
                   "a", "abbr", "acronym", "b", "blockquote", "br", "code", "em",

     

       23
       23
       -
                   "i", "li", "ol", "p", "pre", "strong", "ul", "h1", "h2", "h3",

     

       24
       24
       -
                   "h4", "h5", "h6", "img", "div", "span",

     

       22
       22
       +
                   "a",

     

       23
       23
       +
                   "abbr",

     

       24
       24
       +
                   "acronym",

     

       25
       25
       +
                   "b",

     

       26
       26
       +
                   "blockquote",

     

       27
       27
       +
                   "br",

     

       28
       28
       +
                   "code",

     

       29
       29
       +
                   "em",

     

       30
       30
       +
                   "i",

     

       31
       31
       +
                   "li",

     

       32
       32
       +
                   "ol",

     

       33
       33
       +
                   "p",

     

       34
       34
       +
                   "pre",

     

       35
       35
       +
                   "strong",

     

       36
       36
       +
                   "ul",

     

       37
       37
       +
                   "h1",

     

       38
       38
       +
                   "h2",

     

       39
       39
       +
                   "h3",

     

       40
       40
       +
                   "h4",

     

       41
       41
       +
                   "h5",

     

       42
       42
       +
                   "h6",

     

       43
       43
       +
                   "img",

     

       44
       44
       +
                   "div",

     

       45
       45
       +
                   "span",

     

       25
       46
        
               ]

     

       26
       47
        
               self.allowed_attributes = {

     

       27
       48
        
                   "a": ["href", "title"],

     
···

       43
       64
        
                   response.raise_for_status()

     

       44
       65
        
                   return response.text

     

       45
       66
        
       

     

       46
       46
       -
           def parse_feed(self, content: str, source_url: Optional[HttpUrl] = None) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       67
       67
       +
           def parse_feed(

     

       68
       68
       +
               self, content: str, source_url: Optional[HttpUrl] = None

     

       69
       69
       +
           ) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       47
       70
        
               """Parse feed content and return metadata and entries."""

     

       48
       71
        
               parsed = feedparser.parse(content)

     

       49
       72
        
       

     
···

       74
       97
        
               author_email = None

     

       75
       98
        
               author_uri = None

     

       76
       99
        
       

     

       77
       77
       -
               if hasattr(feed, 'author_detail'):

     

       78
       78
       -
                   author_name = feed.author_detail.get('name')

     

       79
       79
       -
                   author_email = feed.author_detail.get('email')

     

       80
       80
       -
                   author_uri = feed.author_detail.get('href')

     

       81
       81
       -
               elif hasattr(feed, 'author'):

     

       100
       100
       +
               if hasattr(feed, "author_detail"):

     

       101
       101
       +
                   author_name = feed.author_detail.get("name")

     

       102
       102
       +
                   author_email = feed.author_detail.get("email")

     

       103
       103
       +
                   author_uri = feed.author_detail.get("href")

     

       104
       104
       +
               elif hasattr(feed, "author"):

     

       82
       105
        
                   author_name = feed.author

     

       83
       106
        
       

     

       84
       107
        
               # Parse managing editor for RSS feeds

     

       85
       85
       -
               if not author_email and hasattr(feed, 'managingEditor'):

     

       108
       108
       +
               if not author_email and hasattr(feed, "managingEditor"):

     

       86
       109
        
                   author_email = feed.managingEditor

     

       87
       110
        
       

     

       88
       111
        
               # Parse feed link

     

       89
       112
        
               feed_link = None

     

       90
       90
       -
               if hasattr(feed, 'link'):

     

       113
       113
       +
               if hasattr(feed, "link"):

     

       91
       114
        
                   try:

     

       92
       115
        
                       feed_link = HttpUrl(feed.link)

     

       93
       116
        
                   except ValidationError:

     
···

       98
       121
        
               icon = None

     

       99
       122
        
               image_url = None

     

       100
       123
        
       

     

       101
       101
       -
               if hasattr(feed, 'image'):

     

       124
       124
       +
               if hasattr(feed, "image"):

     

       102
       125
        
                   try:

     

       103
       103
       -
                       image_url = HttpUrl(feed.image.get('href', feed.image.get('url', '')))

     

       126
       126
       +
                       image_url = HttpUrl(feed.image.get("href", feed.image.get("url", "")))

     

       104
       127
        
                   except (ValidationError, AttributeError):

     

       105
       128
        
                       pass

     

       106
       129
        
       

     

       107
       107
       -
               if hasattr(feed, 'icon'):

     

       130
       130
       +
               if hasattr(feed, "icon"):

     

       108
       131
        
                   try:

     

       109
       132
        
                       icon = HttpUrl(feed.icon)

     

       110
       133
        
                   except ValidationError:

     

       111
       134
        
                       pass

     

       112
       135
        
       

     

       113
       113
       -
               if hasattr(feed, 'logo'):

     

       136
       136
       +
               if hasattr(feed, "logo"):

     

       114
       137
        
                   try:

     

       115
       138
        
                       logo = HttpUrl(feed.logo)

     

       116
       139
        
                   except ValidationError:

     

       117
       140
        
                       pass

     

       118
       141
        
       

     

       119
       142
        
               return FeedMetadata(

     

       120
       120
       -
                   title=getattr(feed, 'title', None),

     

       143
       143
       +
                   title=getattr(feed, "title", None),

     

       121
       144
        
                   author_name=author_name,

     

       122
       145
        
                   author_email=author_email,

     

       123
       146
        
                   author_uri=HttpUrl(author_uri) if author_uri else None,

     
···

       125
       148
        
                   logo=logo,

     

       126
       149
        
                   icon=icon,

     

       127
       150
        
                   image_url=image_url,

     

       128
       128
       -
                   description=getattr(feed, 'description', None),

     

       151
       151
       +
                   description=getattr(feed, "description", None),

     

       129
       152
        
               )

     

       130
       153
        
       

     

       131
       131
       -
           def _normalize_entry(self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None) -> AtomEntry:

     

       154
       154
       +
           def _normalize_entry(

     

       155
       155
       +
               self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None

     

       156
       156
       +
           ) -> AtomEntry:

     

       132
       157
        
               """Normalize an entry to Atom format."""

     

       133
       158
        
               # Parse timestamps

     

       134
       134
       -
               updated = self._parse_timestamp(entry.get('updated_parsed') or entry.get('published_parsed'))

     

       135
       135
       -
               published = self._parse_timestamp(entry.get('published_parsed'))

     

       159
       159
       +
               updated = self._parse_timestamp(

     

       160
       160
       +
                   entry.get("updated_parsed") or entry.get("published_parsed")

     

       161
       161
       +
               )

     

       162
       162
       +
               published = self._parse_timestamp(entry.get("published_parsed"))

     

       136
       163
        
       

     

       137
       164
        
               # Parse content

     

       138
       165
        
               content = self._extract_content(entry)

     
···

       143
       170
        
       

     

       144
       171
        
               # Parse categories/tags

     

       145
       172
        
               categories = []

     

       146
       146
       -
               if hasattr(entry, 'tags'):

     

       147
       147
       -
                   categories = [tag.get('term', '') for tag in entry.tags if tag.get('term')]

     

       173
       173
       +
               if hasattr(entry, "tags"):

     

       174
       174
       +
                   categories = [tag.get("term", "") for tag in entry.tags if tag.get("term")]

     

       148
       175
        
       

     

       149
       176
        
               # Sanitize HTML content

     

       150
       177
        
               if content:

     

       151
       178
        
                   content = self._sanitize_html(content)

     

       152
       179
        
       

     

       153
       153
       -
               summary = entry.get('summary', '')

     

       180
       180
       +
               summary = entry.get("summary", "")

     

       154
       181
        
               if summary:

     

       155
       182
        
                   summary = self._sanitize_html(summary)

     

       156
       183
        
       

     

       157
       184
        
               return AtomEntry(

     

       158
       158
       -
                   id=entry.get('id', entry.get('link', '')),

     

       159
       159
       -
                   title=entry.get('title', ''),

     

       160
       160
       -
                   link=HttpUrl(entry.get('link', '')),

     

       185
       185
       +
                   id=entry.get("id", entry.get("link", "")),

     

       186
       186
       +
                   title=entry.get("title", ""),

     

       187
       187
       +
                   link=HttpUrl(entry.get("link", "")),

     

       161
       188
        
                   updated=updated,

     

       162
       189
        
                   published=published,

     

       163
       190
        
                   summary=summary or None,

     
···

       165
       192
        
                   content_type=content_type,

     

       166
       193
        
                   author=author,

     

       167
       194
        
                   categories=categories,

     

       168
       168
       -
                   rights=entry.get('rights', None),

     

       195
       195
       +
                   rights=entry.get("rights", None),

     

       169
       196
        
                   source=str(source_url) if source_url else None,

     

       170
       197
        
               )

     

       171
       198
        
       

     
···

       178
       205
        
           def _extract_content(self, entry: feedparser.FeedParserDict) -> Optional[str]:

     

       179
       206
        
               """Extract the best content from an entry."""

     

       180
       207
        
               # Prefer content over summary

     

       181
       181
       -
               if hasattr(entry, 'content') and entry.content:

     

       208
       208
       +
               if hasattr(entry, "content") and entry.content:

     

       182
       209
        
                   # Find the best content (prefer text/html, then text/plain)

     

       183
       210
        
                   for content_item in entry.content:

     

       184
       184
       -
                       if content_item.get('type') in ['text/html', 'html']:

     

       185
       185
       -
                           return content_item.get('value', '')

     

       186
       186
       -
                       elif content_item.get('type') in ['text/plain', 'text']:

     

       187
       187
       -
                           return content_item.get('value', '')

     

       211
       211
       +
                       if content_item.get("type") in ["text/html", "html"]:

     

       212
       212
       +
                           return content_item.get("value", "")

     

       213
       213
       +
                       elif content_item.get("type") in ["text/plain", "text"]:

     

       214
       214
       +
                           return content_item.get("value", "")

     

       188
       215
        
                   # Fallback to first content item

     

       189
       189
       -
                   return entry.content[0].get('value', '')

     

       216
       216
       +
                   return entry.content[0].get("value", "")

     

       190
       217
        
       

     

       191
       218
        
               # Fallback to summary

     

       192
       192
       -
               return entry.get('summary', '')

     

       219
       219
       +
               return entry.get("summary", "")

     

       193
       220
        
       

     

       194
       221
        
           def _extract_content_type(self, entry: feedparser.FeedParserDict) -> str:

     

       195
       222
        
               """Extract content type from entry."""

     

       196
       196
       -
               if hasattr(entry, 'content') and entry.content:

     

       197
       197
       -
                   content_type = entry.content[0].get('type', 'html')

     

       223
       223
       +
               if hasattr(entry, "content") and entry.content:

     

       224
       224
       +
                   content_type = entry.content[0].get("type", "html")

     

       198
       225
        
                   # Normalize content type

     

       199
       199
       -
                   if content_type in ['text/html', 'html']:

     

       200
       200
       -
                       return 'html'

     

       201
       201
       -
                   elif content_type in ['text/plain', 'text']:

     

       202
       202
       -
                       return 'text'

     

       203
       203
       -
                   elif content_type == 'xhtml':

     

       204
       204
       -
                       return 'xhtml'

     

       205
       205
       -
               return 'html'

     

       226
       226
       +
                   if content_type in ["text/html", "html"]:

     

       227
       227
       +
                       return "html"

     

       228
       228
       +
                   elif content_type in ["text/plain", "text"]:

     

       229
       229
       +
                       return "text"

     

       230
       230
       +
                   elif content_type == "xhtml":

     

       231
       231
       +
                       return "xhtml"

     

       232
       232
       +
               return "html"

     

       206
       233
        
       

     

       207
       234
        
           def _extract_author(self, entry: feedparser.FeedParserDict) -> Optional[dict]:

     

       208
       235
        
               """Extract author information from entry."""

     

       209
       236
        
               author = {}

     

       210
       237
        
       

     

       211
       211
       -
               if hasattr(entry, 'author_detail'):

     

       212
       212
       -
                   author.update({

     

       213
       213
       -
                       'name': entry.author_detail.get('name'),

     

       214
       214
       -
                       'email': entry.author_detail.get('email'),

     

       215
       215
       -
                       'uri': entry.author_detail.get('href'),

     

       216
       216
       -
                   })

     

       217
       217
       -
               elif hasattr(entry, 'author'):

     

       218
       218
       -
                   author['name'] = entry.author

     

       238
       238
       +
               if hasattr(entry, "author_detail"):

     

       239
       239
       +
                   author.update(

     

       240
       240
       +
                       {

     

       241
       241
       +
                           "name": entry.author_detail.get("name"),

     

       242
       242
       +
                           "email": entry.author_detail.get("email"),

     

       243
       243
       +
                           "uri": entry.author_detail.get("href"),

     

       244
       244
       +
                       }

     

       245
       245
       +
                   )

     

       246
       246
       +
               elif hasattr(entry, "author"):

     

       247
       247
       +
                   author["name"] = entry.author

     

       219
       248
        
       

     

       220
       249
        
               return author if author else None

     

       221
       250
        
       

     
···

       236
       265
        
               # Start with the path component

     

       237
       266
        
               if parsed.path:

     

       238
       267
        
                   # Remove leading slash and replace problematic characters

     

       239
       239
       -
                   safe_id = parsed.path.lstrip('/').replace('/', '_').replace('\\', '_')

     

       268
       268
       +
                   safe_id = parsed.path.lstrip("/").replace("/", "_").replace("\\", "_")

     

       240
       269
        
               else:

     

       241
       270
        
                   # Use the entire ID as fallback

     

       242
       271
        
                   safe_id = entry_id

     
···

       244
       273
        
               # Replace problematic characters

     

       245
       274
        
               safe_chars = []

     

       246
       275
        
               for char in safe_id:

     

       247
       247
       -
                   if char.isalnum() or char in '-_.':

     

       276
       276
       +
                   if char.isalnum() or char in "-_.":

     

       248
       277
        
                       safe_chars.append(char)

     

       249
       278
        
                   else:

     

       250
       250
       -
                       safe_chars.append('_')

     

       279
       279
       +
                       safe_chars.append("_")

     

       251
       280
        
       

     

       252
       252
       -
               safe_id = ''.join(safe_chars)

     

       281
       281
       +
               safe_id = "".join(safe_chars)

     

       253
       282
        
       

     

       254
       283
        
               # Ensure it's not too long (max 200 chars)

     

       255
       284
        
               if len(safe_id) > 200:

+107 -18

src/thicket/core/git_store.py

···

       53
       53
        
               """Save the index to index.json."""

     

       54
       54
        
               index_path = self.repo_path / "index.json"

     

       55
       55
        
               with open(index_path, "w") as f:

     

       56
       56
       -
                   json.dump(index.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       56
       56
       +
                   json.dump(

     

       57
       57
       +
                       index.model_dump(mode="json", exclude_none=True),

     

       58
       58
       +
                       f,

     

       59
       59
       +
                       indent=2,

     

       60
       60
       +
                       default=str,

     

       61
       61
       +
                   )

     

       57
       62
        
       

     

       58
       63
        
           def _load_index(self) -> GitStoreIndex:

     

       59
       64
        
               """Load the index from index.json."""

     
···

       86
       91
        
       

     

       87
       92
        
               return DuplicateMap(**data)

     

       88
       93
        
       

     

       89
       89
       -
           def add_user(self, username: str, display_name: Optional[str] = None,

     

       90
       90
       -
                        email: Optional[str] = None, homepage: Optional[str] = None,

     

       91
       91
       -
                        icon: Optional[str] = None, feeds: Optional[list[str]] = None) -> UserMetadata:

     

       94
       94
       +
           def add_user(

     

       95
       95
       +
               self,

     

       96
       96
       +
               username: str,

     

       97
       97
       +
               display_name: Optional[str] = None,

     

       98
       98
       +
               email: Optional[str] = None,

     

       99
       99
       +
               homepage: Optional[str] = None,

     

       100
       100
       +
               icon: Optional[str] = None,

     

       101
       101
       +
               feeds: Optional[list[str]] = None,

     

       102
       102
       +
           ) -> UserMetadata:

     

       92
       103
        
               """Add a new user to the Git store."""

     

       93
       104
        
               index = self._load_index()

     

       94
       105
        
       

     
···

       108
       119
        
                   created=datetime.now(),

     

       109
       120
        
                   last_updated=datetime.now(),

     

       110
       121
        
               )

     

       111
       111
       -
       

     

       112
       122
        
       

     

       113
       123
        
               # Update index

     

       114
       124
        
               index.add_user(user_metadata)

     
···

       136
       146
        
       

     

       137
       147
        
               user.update_timestamp()

     

       138
       148
        
       

     

       139
       139
       -
       

     

       140
       149
        
               # Update index

     

       141
       150
        
               index.add_user(user)

     

       142
       151
        
               self._save_index(index)

     

       143
       152
        
       

     

       144
       153
        
               return True

     

       145
       154
        
       

     

       155
       155
       +
           def add_zulip_association(self, username: str, server: str, user_id: str) -> bool:

     

       156
       156
       +
               """Add a Zulip association to a user."""

     

       157
       157
       +
               index = self._load_index()

     

       158
       158
       +
               user = index.get_user(username)

     

       159
       159
       +
       

     

       160
       160
       +
               if not user:

     

       161
       161
       +
                   return False

     

       162
       162
       +
       

     

       163
       163
       +
               result = user.add_zulip_association(server, user_id)

     

       164
       164
       +
               if result:

     

       165
       165
       +
                   index.add_user(user)

     

       166
       166
       +
                   self._save_index(index)

     

       167
       167
       +
       

     

       168
       168
       +
               return result

     

       169
       169
       +
       

     

       170
       170
       +
           def remove_zulip_association(

     

       171
       171
       +
               self, username: str, server: str, user_id: str

     

       172
       172
       +
           ) -> bool:

     

       173
       173
       +
               """Remove a Zulip association from a user."""

     

       174
       174
       +
               index = self._load_index()

     

       175
       175
       +
               user = index.get_user(username)

     

       176
       176
       +
       

     

       177
       177
       +
               if not user:

     

       178
       178
       +
                   return False

     

       179
       179
       +
       

     

       180
       180
       +
               result = user.remove_zulip_association(server, user_id)

     

       181
       181
       +
               if result:

     

       182
       182
       +
                   index.add_user(user)

     

       183
       183
       +
                   self._save_index(index)

     

       184
       184
       +
       

     

       185
       185
       +
               return result

     

       186
       186
       +
       

     

       187
       187
       +
           def get_zulip_associations(self, username: str) -> list:

     

       188
       188
       +
               """Get all Zulip associations for a user."""

     

       189
       189
       +
               user = self.get_user(username)

     

       190
       190
       +
               if user:

     

       191
       191
       +
                   return user.zulip_associations

     

       192
       192
       +
               return []

     

       193
       193
       +
       

     

       146
       194
        
           def store_entry(self, username: str, entry: AtomEntry) -> bool:

     

       147
       195
        
               """Store an entry in the user's directory."""

     

       148
       196
        
               user = self.get_user(username)

     
···

       151
       199
        
       

     

       152
       200
        
               # Sanitize entry ID for filename

     

       153
       201
        
               from .feed_parser import FeedParser

     

       202
       202
       +
       

     

       154
       203
        
               parser = FeedParser()

     

       155
       204
        
               safe_id = parser.sanitize_entry_id(entry.id)

     

       156
       205
        
       

     
···

       163
       212
        
       

     

       164
       213
        
               # Save entry

     

       165
       214
        
               with open(entry_path, "w") as f:

     

       166
       166
       -
                   json.dump(entry.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       215
       215
       +
                   json.dump(

     

       216
       216
       +
                       entry.model_dump(mode="json", exclude_none=True),

     

       217
       217
       +
                       f,

     

       218
       218
       +
                       indent=2,

     

       219
       219
       +
                       default=str,

     

       220
       220
       +
                   )

     

       167
       221
        
       

     

       168
       222
        
               # Update user metadata if new entry

     

       169
       223
        
               if not entry_exists:

     
···

       181
       235
        
       

     

       182
       236
        
               # Sanitize entry ID

     

       183
       237
        
               from .feed_parser import FeedParser

     

       238
       238
       +
       

     

       184
       239
        
               parser = FeedParser()

     

       185
       240
        
               safe_id = parser.sanitize_entry_id(entry_id)

     

       186
       241
        
       

     
···

       193
       248
        
       

     

       194
       249
        
               return AtomEntry(**data)

     

       195
       250
        
       

     

       196
       196
       -
           def list_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     

       251
       251
       +
           def list_entries(

     

       252
       252
       +
               self, username: str, limit: Optional[int] = None

     

       253
       253
       +
           ) -> list[AtomEntry]:

     

       197
       254
        
               """List entries for a user."""

     

       198
       255
        
               user = self.get_user(username)

     

       199
       256
        
               if not user:

     
···

       204
       261
        
                   return []

     

       205
       262
        
       

     

       206
       263
        
               entries = []

     

       207
       207
       -
               entry_files = sorted(user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)

     

       208
       208
       -
       

     

       264
       264
       +
               entry_files = sorted(

     

       265
       265
       +
                   user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True

     

       266
       266
       +
               )

     

       209
       267
        
       

     

       210
       268
        
               if limit:

     

       211
       269
        
                   entry_files = entry_files[:limit]

     
···

       260
       318
        
                   "total_entries": index.total_entries,

     

       261
       319
        
                   "total_duplicates": len(duplicates.duplicates),

     

       262
       320
        
                   "last_updated": index.last_updated,

     

       263
       263
       -
                   "repository_size": sum(f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()),

     

       321
       321
       +
                   "repository_size": sum(

     

       322
       322
       +
                       f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()

     

       323
       323
       +
                   ),

     

       264
       324
        
               }

     

       265
       325
        
       

     

       266
       266
       -
           def search_entries(self, query: str, username: Optional[str] = None,

     

       267
       267
       -
                             limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       326
       326
       +
           def search_entries(

     

       327
       327
       +
               self, query: str, username: Optional[str] = None, limit: Optional[int] = None

     

       328
       328
       +
           ) -> list[tuple[str, AtomEntry]]:

     

       268
       329
        
               """Search entries by content."""

     

       269
       330
        
               results = []

     

       270
       331
        
       

     
···

       288
       349
        
                           entry = AtomEntry(**data)

     

       289
       350
        
       

     

       290
       351
        
                           # Simple text search in title, summary, and content

     

       291
       291
       -
                           searchable_text = " ".join(filter(None, [

     

       292
       292
       -
                               entry.title,

     

       293
       293
       -
                               entry.summary or "",

     

       294
       294
       -
                               entry.content or "",

     

       295
       295
       -
                           ])).lower()

     

       352
       352
       +
                           searchable_text = " ".join(

     

       353
       353
       +
                               filter(

     

       354
       354
       +
                                   None,

     

       355
       355
       +
                                   [

     

       356
       356
       +
                                       entry.title,

     

       357
       357
       +
                                       entry.summary or "",

     

       358
       358
       +
                                       entry.content or "",

     

       359
       359
       +
                                   ],

     

       360
       360
       +
                               )

     

       361
       361
       +
                           ).lower()

     

       296
       362
        
       

     

       297
       363
        
                           if query.lower() in searchable_text:

     

       298
       364
        
                               results.append((user.username, entry))

     
···

       308
       374
        
               results.sort(key=lambda x: x[1].updated, reverse=True)

     

       309
       375
        
       

     

       310
       376
        
               return results[:limit] if limit else results

     

       377
       377
       +
       

     

       378
       378
       +
           def list_users(self) -> list[str]:

     

       379
       379
       +
               """Get list of all usernames in the git store."""

     

       380
       380
       +
               index = self._load_index()

     

       381
       381
       +
               return list(index.users.keys())

     

       382
       382
       +
       

     

       383
       383
       +
           def get_user_feeds(self, username: str) -> list[str]:

     

       384
       384
       +
               """Get list of feed URLs for a specific user from their metadata."""

     

       385
       385
       +
               user = self.get_user(username)

     

       386
       386
       +
               if not user:

     

       387
       387
       +
                   return []

     

       388
       388
       +
       

     

       389
       389
       +
               # Feed URLs are stored in the user metadata

     

       390
       390
       +
               return user.feeds

     

       391
       391
       +
       

     

       392
       392
       +
           def list_all_users_with_feeds(self) -> list[tuple[str, list[str]]]:

     

       393
       393
       +
               """Get all users and their feed URLs."""

     

       394
       394
       +
               result = []

     

       395
       395
       +
               for username in self.list_users():

     

       396
       396
       +
                   feeds = self.get_user_feeds(username)

     

       397
       397
       +
                   if feeds:  # Only include users that have feeds configured

     

       398
       398
       +
                       result.append((username, feeds))

     

       399
       399
       +
               return result

+166

src/thicket/core/opml_generator.py

···

       1
       1
       +
       """OPML generation for thicket."""

     

       2
       2
       +
       

     

       3
       3
       +
       import xml.etree.ElementTree as ET

     

       4
       4
       +
       from datetime import datetime

     

       5
       5
       +
       from pathlib import Path

     

       6
       6
       +
       from typing import Optional

     

       7
       7
       +
       from xml.dom import minidom

     

       8
       8
       +
       

     

       9
       9
       +
       from ..models import UserMetadata

     

       10
       10
       +
       

     

       11
       11
       +
       

     

       12
       12
       +
       class OPMLGenerator:

     

       13
       13
       +
           """Generates OPML files from feed collections."""

     

       14
       14
       +
       

     

       15
       15
       +
           def __init__(self) -> None:

     

       16
       16
       +
               """Initialize the OPML generator."""

     

       17
       17
       +
               pass

     

       18
       18
       +
       

     

       19
       19
       +
           def generate_opml(

     

       20
       20
       +
               self,

     

       21
       21
       +
               users: dict[str, UserMetadata],

     

       22
       22
       +
               title: str = "Thicket Feeds",

     

       23
       23
       +
               output_path: Optional[Path] = None,

     

       24
       24
       +
           ) -> str:

     

       25
       25
       +
               """Generate OPML XML content from user metadata.

     

       26
       26
       +
       

     

       27
       27
       +
               Args:

     

       28
       28
       +
                   users: Dictionary of username -> UserMetadata

     

       29
       29
       +
                   title: Title for the OPML file

     

       30
       30
       +
                   output_path: Optional path to write the OPML file

     

       31
       31
       +
       

     

       32
       32
       +
               Returns:

     

       33
       33
       +
                   OPML XML content as string

     

       34
       34
       +
               """

     

       35
       35
       +
               # Create root OPML element

     

       36
       36
       +
               opml = ET.Element("opml", version="2.0")

     

       37
       37
       +
       

     

       38
       38
       +
               # Create head section

     

       39
       39
       +
               head = ET.SubElement(opml, "head")

     

       40
       40
       +
               title_elem = ET.SubElement(head, "title")

     

       41
       41
       +
               title_elem.text = title

     

       42
       42
       +
       

     

       43
       43
       +
               date_created = ET.SubElement(head, "dateCreated")

     

       44
       44
       +
               date_created.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       45
       45
       +
       

     

       46
       46
       +
               date_modified = ET.SubElement(head, "dateModified")

     

       47
       47
       +
               date_modified.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       48
       48
       +
       

     

       49
       49
       +
               # Create body section

     

       50
       50
       +
               body = ET.SubElement(opml, "body")

     

       51
       51
       +
       

     

       52
       52
       +
               # Add each user as an outline with their feeds as sub-outlines

     

       53
       53
       +
               for username, user_metadata in sorted(users.items()):

     

       54
       54
       +
                   user_outline = ET.SubElement(body, "outline")

     

       55
       55
       +
                   user_outline.set("text", user_metadata.display_name or username)

     

       56
       56
       +
                   user_outline.set("title", user_metadata.display_name or username)

     

       57
       57
       +
       

     

       58
       58
       +
                   # Add user metadata as attributes if available

     

       59
       59
       +
                   if user_metadata.homepage:

     

       60
       60
       +
                       user_outline.set("htmlUrl", user_metadata.homepage)

     

       61
       61
       +
                   if user_metadata.email:

     

       62
       62
       +
                       user_outline.set("email", user_metadata.email)

     

       63
       63
       +
       

     

       64
       64
       +
                   # Add each feed as a sub-outline

     

       65
       65
       +
                   for feed_url in sorted(user_metadata.feeds):

     

       66
       66
       +
                       feed_outline = ET.SubElement(user_outline, "outline")

     

       67
       67
       +
                       feed_outline.set("type", "rss")

     

       68
       68
       +
                       feed_outline.set("text", feed_url)

     

       69
       69
       +
                       feed_outline.set("title", feed_url)

     

       70
       70
       +
                       feed_outline.set("xmlUrl", feed_url)

     

       71
       71
       +
                       feed_outline.set("htmlUrl", feed_url)

     

       72
       72
       +
       

     

       73
       73
       +
               # Convert to pretty-printed XML string

     

       74
       74
       +
               xml_str = self._prettify_xml(opml)

     

       75
       75
       +
       

     

       76
       76
       +
               # Write to file if path provided

     

       77
       77
       +
               if output_path:

     

       78
       78
       +
                   output_path.write_text(xml_str, encoding="utf-8")

     

       79
       79
       +
       

     

       80
       80
       +
               return xml_str

     

       81
       81
       +
       

     

       82
       82
       +
           def _prettify_xml(self, elem: ET.Element) -> str:

     

       83
       83
       +
               """Return a pretty-printed XML string for the Element."""

     

       84
       84
       +
               rough_string = ET.tostring(elem, encoding="unicode")

     

       85
       85
       +
               reparsed = minidom.parseString(rough_string)

     

       86
       86
       +
               return reparsed.toprettyxml(indent="  ")

     

       87
       87
       +
       

     

       88
       88
       +
           def generate_flat_opml(

     

       89
       89
       +
               self,

     

       90
       90
       +
               users: dict[str, UserMetadata],

     

       91
       91
       +
               title: str = "Thicket Feeds (Flat)",

     

       92
       92
       +
               output_path: Optional[Path] = None,

     

       93
       93
       +
           ) -> str:

     

       94
       94
       +
               """Generate a flat OPML file with all feeds at the top level.

     

       95
       95
       +
       

     

       96
       96
       +
               This format may be more compatible with some feed readers.

     

       97
       97
       +
       

     

       98
       98
       +
               Args:

     

       99
       99
       +
                   users: Dictionary of username -> UserMetadata

     

       100
       100
       +
                   title: Title for the OPML file

     

       101
       101
       +
                   output_path: Optional path to write the OPML file

     

       102
       102
       +
       

     

       103
       103
       +
               Returns:

     

       104
       104
       +
                   OPML XML content as string

     

       105
       105
       +
               """

     

       106
       106
       +
               # Create root OPML element

     

       107
       107
       +
               opml = ET.Element("opml", version="2.0")

     

       108
       108
       +
       

     

       109
       109
       +
               # Create head section

     

       110
       110
       +
               head = ET.SubElement(opml, "head")

     

       111
       111
       +
               title_elem = ET.SubElement(head, "title")

     

       112
       112
       +
               title_elem.text = title

     

       113
       113
       +
       

     

       114
       114
       +
               date_created = ET.SubElement(head, "dateCreated")

     

       115
       115
       +
               date_created.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       116
       116
       +
       

     

       117
       117
       +
               date_modified = ET.SubElement(head, "dateModified")

     

       118
       118
       +
               date_modified.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       119
       119
       +
       

     

       120
       120
       +
               # Create body section

     

       121
       121
       +
               body = ET.SubElement(opml, "body")

     

       122
       122
       +
       

     

       123
       123
       +
               # Collect all feeds with their associated user info

     

       124
       124
       +
               all_feeds = []

     

       125
       125
       +
               for username, user_metadata in users.items():

     

       126
       126
       +
                   for feed_url in user_metadata.feeds:

     

       127
       127
       +
                       all_feeds.append(

     

       128
       128
       +
                           {

     

       129
       129
       +
                               "url": feed_url,

     

       130
       130
       +
                               "username": username,

     

       131
       131
       +
                               "display_name": user_metadata.display_name or username,

     

       132
       132
       +
                               "homepage": user_metadata.homepage,

     

       133
       133
       +
                           }

     

       134
       134
       +
                       )

     

       135
       135
       +
       

     

       136
       136
       +
               # Sort feeds by URL for consistency

     

       137
       137
       +
               all_feeds.sort(key=lambda f: f["url"] or "")

     

       138
       138
       +
       

     

       139
       139
       +
               # Add each feed as a top-level outline

     

       140
       140
       +
               for feed_info in all_feeds:

     

       141
       141
       +
                   feed_outline = ET.SubElement(body, "outline")

     

       142
       142
       +
                   feed_outline.set("type", "rss")

     

       143
       143
       +
       

     

       144
       144
       +
                   # Create a descriptive title that includes the user

     

       145
       145
       +
                   title_text = f"{feed_info['display_name']}: {feed_info['url']}"

     

       146
       146
       +
                   feed_outline.set("text", title_text)

     

       147
       147
       +
                   feed_outline.set("title", title_text)

     

       148
       148
       +
                   url = feed_info["url"] or ""

     

       149
       149
       +
                   feed_outline.set("xmlUrl", url)

     

       150
       150
       +
                   homepage_url = feed_info.get("homepage") or url

     

       151
       151
       +
                   feed_outline.set("htmlUrl", homepage_url or "")

     

       152
       152
       +
       

     

       153
       153
       +
                   # Add custom attributes for user info

     

       154
       154
       +
                   feed_outline.set("thicketUser", feed_info["username"] or "")

     

       155
       155
       +
                   homepage = feed_info.get("homepage")

     

       156
       156
       +
                   if homepage:

     

       157
       157
       +
                       feed_outline.set("thicketHomepage", homepage)

     

       158
       158
       +
       

     

       159
       159
       +
               # Convert to pretty-printed XML string

     

       160
       160
       +
               xml_str = self._prettify_xml(opml)

     

       161
       161
       +
       

     

       162
       162
       +
               # Write to file if path provided

     

       163
       163
       +
               if output_path:

     

       164
       164
       +
                   output_path.write_text(xml_str, encoding="utf-8")

     

       165
       165
       +
       

     

       166
       166
       +
               return xml_str

-301

src/thicket/core/reference_parser.py

···

       1
       1
       -
       """Reference detection and parsing for blog entries."""

     

       2
       2
       -
       

     

       3
       3
       -
       import re

     

       4
       4
       -
       from typing import Optional

     

       5
       5
       -
       from urllib.parse import urlparse

     

       6
       6
       -
       

     

       7
       7
       -
       from ..models import AtomEntry

     

       8
       8
       -
       

     

       9
       9
       -
       

     

       10
       10
       -
       class BlogReference:

     

       11
       11
       -
           """Represents a reference from one blog entry to another."""

     

       12
       12
       -
       

     

       13
       13
       -
           def __init__(

     

       14
       14
       -
               self,

     

       15
       15
       -
               source_entry_id: str,

     

       16
       16
       -
               source_username: str,

     

       17
       17
       -
               target_url: str,

     

       18
       18
       -
               target_username: Optional[str] = None,

     

       19
       19
       -
               target_entry_id: Optional[str] = None,

     

       20
       20
       -
           ):

     

       21
       21
       -
               self.source_entry_id = source_entry_id

     

       22
       22
       -
               self.source_username = source_username

     

       23
       23
       -
               self.target_url = target_url

     

       24
       24
       -
               self.target_username = target_username

     

       25
       25
       -
               self.target_entry_id = target_entry_id

     

       26
       26
       -
       

     

       27
       27
       -
           def to_dict(self) -> dict:

     

       28
       28
       -
               """Convert to dictionary for JSON serialization."""

     

       29
       29
       -
               result = {

     

       30
       30
       -
                   "source_entry_id": self.source_entry_id,

     

       31
       31
       -
                   "source_username": self.source_username,

     

       32
       32
       -
                   "target_url": self.target_url,

     

       33
       33
       -
               }

     

       34
       34
       -
       

     

       35
       35
       -
               # Only include optional fields if they are not None

     

       36
       36
       -
               if self.target_username is not None:

     

       37
       37
       -
                   result["target_username"] = self.target_username

     

       38
       38
       -
               if self.target_entry_id is not None:

     

       39
       39
       -
                   result["target_entry_id"] = self.target_entry_id

     

       40
       40
       -
       

     

       41
       41
       -
               return result

     

       42
       42
       -
       

     

       43
       43
       -
           @classmethod

     

       44
       44
       -
           def from_dict(cls, data: dict) -> "BlogReference":

     

       45
       45
       -
               """Create from dictionary."""

     

       46
       46
       -
               return cls(

     

       47
       47
       -
                   source_entry_id=data["source_entry_id"],

     

       48
       48
       -
                   source_username=data["source_username"],

     

       49
       49
       -
                   target_url=data["target_url"],

     

       50
       50
       -
                   target_username=data.get("target_username"),

     

       51
       51
       -
                   target_entry_id=data.get("target_entry_id"),

     

       52
       52
       -
               )

     

       53
       53
       -
       

     

       54
       54
       -
       

     

       55
       55
       -
       class ReferenceIndex:

     

       56
       56
       -
           """Index of blog-to-blog references for creating threaded views."""

     

       57
       57
       -
       

     

       58
       58
       -
           def __init__(self):

     

       59
       59
       -
               self.references: list[BlogReference] = []

     

       60
       60
       -
               self.outbound_refs: dict[

     

       61
       61
       -
                   str, list[BlogReference]

     

       62
       62
       -
               ] = {}  # entry_id -> outbound refs

     

       63
       63
       -
               self.inbound_refs: dict[

     

       64
       64
       -
                   str, list[BlogReference]

     

       65
       65
       -
               ] = {}  # entry_id -> inbound refs

     

       66
       66
       -
               self.user_domains: dict[str, set[str]] = {}  # username -> set of domains

     

       67
       67
       -
       

     

       68
       68
       -
           def add_reference(self, ref: BlogReference) -> None:

     

       69
       69
       -
               """Add a reference to the index."""

     

       70
       70
       -
               self.references.append(ref)

     

       71
       71
       -
       

     

       72
       72
       -
               # Update outbound references

     

       73
       73
       -
               source_key = f"{ref.source_username}:{ref.source_entry_id}"

     

       74
       74
       -
               if source_key not in self.outbound_refs:

     

       75
       75
       -
                   self.outbound_refs[source_key] = []

     

       76
       76
       -
               self.outbound_refs[source_key].append(ref)

     

       77
       77
       -
       

     

       78
       78
       -
               # Update inbound references if we can identify the target

     

       79
       79
       -
               if ref.target_username and ref.target_entry_id:

     

       80
       80
       -
                   target_key = f"{ref.target_username}:{ref.target_entry_id}"

     

       81
       81
       -
                   if target_key not in self.inbound_refs:

     

       82
       82
       -
                       self.inbound_refs[target_key] = []

     

       83
       83
       -
                   self.inbound_refs[target_key].append(ref)

     

       84
       84
       -
       

     

       85
       85
       -
           def get_outbound_refs(self, username: str, entry_id: str) -> list[BlogReference]:

     

       86
       86
       -
               """Get all outbound references from an entry."""

     

       87
       87
       -
               key = f"{username}:{entry_id}"

     

       88
       88
       -
               return self.outbound_refs.get(key, [])

     

       89
       89
       -
       

     

       90
       90
       -
           def get_inbound_refs(self, username: str, entry_id: str) -> list[BlogReference]:

     

       91
       91
       -
               """Get all inbound references to an entry."""

     

       92
       92
       -
               key = f"{username}:{entry_id}"

     

       93
       93
       -
               return self.inbound_refs.get(key, [])

     

       94
       94
       -
       

     

       95
       95
       -
           def get_thread_members(self, username: str, entry_id: str) -> set[tuple[str, str]]:

     

       96
       96
       -
               """Get all entries that are part of the same thread."""

     

       97
       97
       -
               visited = set()

     

       98
       98
       -
               to_visit = [(username, entry_id)]

     

       99
       99
       -
               thread_members = set()

     

       100
       100
       -
       

     

       101
       101
       -
               while to_visit:

     

       102
       102
       -
                   current_user, current_entry = to_visit.pop()

     

       103
       103
       -
                   if (current_user, current_entry) in visited:

     

       104
       104
       -
                       continue

     

       105
       105
       -
       

     

       106
       106
       -
                   visited.add((current_user, current_entry))

     

       107
       107
       -
                   thread_members.add((current_user, current_entry))

     

       108
       108
       -
       

     

       109
       109
       -
                   # Add outbound references

     

       110
       110
       -
                   for ref in self.get_outbound_refs(current_user, current_entry):

     

       111
       111
       -
                       if ref.target_username and ref.target_entry_id:

     

       112
       112
       -
                           to_visit.append((ref.target_username, ref.target_entry_id))

     

       113
       113
       -
       

     

       114
       114
       -
                   # Add inbound references

     

       115
       115
       -
                   for ref in self.get_inbound_refs(current_user, current_entry):

     

       116
       116
       -
                       to_visit.append((ref.source_username, ref.source_entry_id))

     

       117
       117
       -
       

     

       118
       118
       -
               return thread_members

     

       119
       119
       -
       

     

       120
       120
       -
           def to_dict(self) -> dict:

     

       121
       121
       -
               """Convert to dictionary for JSON serialization."""

     

       122
       122
       -
               return {

     

       123
       123
       -
                   "references": [ref.to_dict() for ref in self.references],

     

       124
       124
       -
                   "user_domains": {k: list(v) for k, v in self.user_domains.items()},

     

       125
       125
       -
               }

     

       126
       126
       -
       

     

       127
       127
       -
           @classmethod

     

       128
       128
       -
           def from_dict(cls, data: dict) -> "ReferenceIndex":

     

       129
       129
       -
               """Create from dictionary."""

     

       130
       130
       -
               index = cls()

     

       131
       131
       -
               for ref_data in data.get("references", []):

     

       132
       132
       -
                   ref = BlogReference.from_dict(ref_data)

     

       133
       133
       -
                   index.add_reference(ref)

     

       134
       134
       -
       

     

       135
       135
       -
               for username, domains in data.get("user_domains", {}).items():

     

       136
       136
       -
                   index.user_domains[username] = set(domains)

     

       137
       137
       -
       

     

       138
       138
       -
               return index

     

       139
       139
       -
       

     

       140
       140
       -
       

     

       141
       141
       -
       class ReferenceParser:

     

       142
       142
       -
           """Parses blog entries to detect references to other blogs."""

     

       143
       143
       -
       

     

       144
       144
       -
           def __init__(self):

     

       145
       145
       -
               # Common blog platforms and patterns

     

       146
       146
       -
               self.blog_patterns = [

     

       147
       147
       -
                   r"https?://[^/]+\.(?:org|com|net|io|dev|me|co\.uk)/.*",  # Common blog domains

     

       148
       148
       -
                   r"https?://[^/]+\.github\.io/.*",  # GitHub Pages

     

       149
       149
       -
                   r"https?://[^/]+\.substack\.com/.*",  # Substack

     

       150
       150
       -
                   r"https?://medium\.com/.*",  # Medium

     

       151
       151
       -
                   r"https?://[^/]+\.wordpress\.com/.*",  # WordPress.com

     

       152
       152
       -
                   r"https?://[^/]+\.blogspot\.com/.*",  # Blogger

     

       153
       153
       -
               ]

     

       154
       154
       -
       

     

       155
       155
       -
               # Compile regex patterns

     

       156
       156
       -
               self.link_pattern = re.compile(

     

       157
       157
       -
                   r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL

     

       158
       158
       -
               )

     

       159
       159
       -
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       160
       160
       -
       

     

       161
       161
       -
           def extract_links_from_html(self, html_content: str) -> list[tuple[str, str]]:

     

       162
       162
       -
               """Extract all links from HTML content."""

     

       163
       163
       -
               links = []

     

       164
       164
       -
       

     

       165
       165
       -
               # Extract links from <a> tags

     

       166
       166
       -
               for match in self.link_pattern.finditer(html_content):

     

       167
       167
       -
                   url = match.group(1)

     

       168
       168
       -
                   text = re.sub(

     

       169
       169
       -
                       r"<[^>]+>", "", match.group(2)

     

       170
       170
       -
                   ).strip()  # Remove HTML tags from link text

     

       171
       171
       -
                   links.append((url, text))

     

       172
       172
       -
       

     

       173
       173
       -
               return links

     

       174
       174
       -
       

     

       175
       175
       -
           def is_blog_url(self, url: str) -> bool:

     

       176
       176
       -
               """Check if a URL likely points to a blog post."""

     

       177
       177
       -
               for pattern in self.blog_patterns:

     

       178
       178
       -
                   if re.match(pattern, url):

     

       179
       179
       -
                       return True

     

       180
       180
       -
               return False

     

       181
       181
       -
       

     

       182
       182
       -
           def resolve_target_user(

     

       183
       183
       -
               self, url: str, user_domains: dict[str, set[str]]

     

       184
       184
       -
           ) -> Optional[str]:

     

       185
       185
       -
               """Try to resolve a URL to a known user based on domain mapping."""

     

       186
       186
       -
               parsed_url = urlparse(url)

     

       187
       187
       -
               domain = parsed_url.netloc.lower()

     

       188
       188
       -
       

     

       189
       189
       -
               for username, domains in user_domains.items():

     

       190
       190
       -
                   if domain in domains:

     

       191
       191
       -
                       return username

     

       192
       192
       -
       

     

       193
       193
       -
               return None

     

       194
       194
       -
       

     

       195
       195
       -
           def extract_references(

     

       196
       196
       -
               self, entry: AtomEntry, username: str, user_domains: dict[str, set[str]]

     

       197
       197
       -
           ) -> list[BlogReference]:

     

       198
       198
       -
               """Extract all blog references from an entry."""

     

       199
       199
       -
               references = []

     

       200
       200
       -
       

     

       201
       201
       -
               # Combine all text content for analysis

     

       202
       202
       -
               content_to_search = []

     

       203
       203
       -
               if entry.content:

     

       204
       204
       -
                   content_to_search.append(entry.content)

     

       205
       205
       -
               if entry.summary:

     

       206
       206
       -
                   content_to_search.append(entry.summary)

     

       207
       207
       -
       

     

       208
       208
       -
               for content in content_to_search:

     

       209
       209
       -
                   links = self.extract_links_from_html(content)

     

       210
       210
       -
       

     

       211
       211
       -
                   for url, _link_text in links:

     

       212
       212
       -
                       # Skip internal links (same domain as the entry)

     

       213
       213
       -
                       entry_domain = (

     

       214
       214
       -
                           urlparse(str(entry.link)).netloc.lower() if entry.link else ""

     

       215
       215
       -
                       )

     

       216
       216
       -
                       link_domain = urlparse(url).netloc.lower()

     

       217
       217
       -
       

     

       218
       218
       -
                       if link_domain == entry_domain:

     

       219
       219
       -
                           continue

     

       220
       220
       -
       

     

       221
       221
       -
                       # Check if this looks like a blog URL

     

       222
       222
       -
                       if not self.is_blog_url(url):

     

       223
       223
       -
                           continue

     

       224
       224
       -
       

     

       225
       225
       -
                       # Try to resolve to a known user

     

       226
       226
       -
                       target_username = self.resolve_target_user(url, user_domains)

     

       227
       227
       -
       

     

       228
       228
       -
                       ref = BlogReference(

     

       229
       229
       -
                           source_entry_id=entry.id,

     

       230
       230
       -
                           source_username=username,

     

       231
       231
       -
                           target_url=url,

     

       232
       232
       -
                           target_username=target_username,

     

       233
       233
       -
                           target_entry_id=None,  # Will be resolved later if possible

     

       234
       234
       -
                       )

     

       235
       235
       -
       

     

       236
       236
       -
                       references.append(ref)

     

       237
       237
       -
       

     

       238
       238
       -
               return references

     

       239
       239
       -
       

     

       240
       240
       -
           def build_user_domain_mapping(self, git_store: "GitStore") -> dict[str, set[str]]:

     

       241
       241
       -
               """Build mapping of usernames to their known domains."""

     

       242
       242
       -
               user_domains = {}

     

       243
       243
       -
               index = git_store._load_index()

     

       244
       244
       -
       

     

       245
       245
       -
               for username, user_metadata in index.users.items():

     

       246
       246
       -
                   domains = set()

     

       247
       247
       -
       

     

       248
       248
       -
                   # Add domains from feeds

     

       249
       249
       -
                   for feed_url in user_metadata.feeds:

     

       250
       250
       -
                       domain = urlparse(feed_url).netloc.lower()

     

       251
       251
       -
                       if domain:

     

       252
       252
       -
                           domains.add(domain)

     

       253
       253
       -
       

     

       254
       254
       -
                   # Add domain from homepage

     

       255
       255
       -
                   if user_metadata.homepage:

     

       256
       256
       -
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       257
       257
       -
                       if domain:

     

       258
       258
       -
                           domains.add(domain)

     

       259
       259
       -
       

     

       260
       260
       -
                   user_domains[username] = domains

     

       261
       261
       -
       

     

       262
       262
       -
               return user_domains

     

       263
       263
       -
       

     

       264
       264
       -
           def resolve_target_entry_ids(

     

       265
       265
       -
               self, references: list[BlogReference], git_store: "GitStore"

     

       266
       266
       -
           ) -> list[BlogReference]:

     

       267
       267
       -
               """Resolve target_entry_id for references that have target_username but no target_entry_id."""

     

       268
       268
       -
               resolved_refs = []

     

       269
       269
       -
       

     

       270
       270
       -
               for ref in references:

     

       271
       271
       -
                   # If we already have a target_entry_id, keep the reference as-is

     

       272
       272
       -
                   if ref.target_entry_id is not None:

     

       273
       273
       -
                       resolved_refs.append(ref)

     

       274
       274
       -
                       continue

     

       275
       275
       -
       

     

       276
       276
       -
                   # If we don't have a target_username, we can't resolve it

     

       277
       277
       -
                   if ref.target_username is None:

     

       278
       278
       -
                       resolved_refs.append(ref)

     

       279
       279
       -
                       continue

     

       280
       280
       -
       

     

       281
       281
       -
                   # Try to find the entry by matching the URL

     

       282
       282
       -
                   entries = git_store.list_entries(ref.target_username)

     

       283
       283
       -
                   resolved_entry_id = None

     

       284
       284
       -
       

     

       285
       285
       -
                   for entry in entries:

     

       286
       286
       -
                       # Check if the entry's link matches the target URL

     

       287
       287
       -
                       if entry.link and str(entry.link) == ref.target_url:

     

       288
       288
       -
                           resolved_entry_id = entry.id

     

       289
       289
       -
                           break

     

       290
       290
       -
       

     

       291
       291
       -
                   # Create a new reference with the resolved target_entry_id

     

       292
       292
       -
                   resolved_ref = BlogReference(

     

       293
       293
       -
                       source_entry_id=ref.source_entry_id,

     

       294
       294
       -
                       source_username=ref.source_username,

     

       295
       295
       -
                       target_url=ref.target_url,

     

       296
       296
       -
                       target_username=ref.target_username,

     

       297
       297
       -
                       target_entry_id=resolved_entry_id,

     

       298
       298
       -
                   )

     

       299
       299
       -
                   resolved_refs.append(resolved_ref)

     

       300
       300
       -
       

     

       301
       301
       -
               return resolved_refs

+428

src/thicket/core/typesense_client.py

···

       1
       1
       +
       """Typesense integration for thicket."""

     

       2
       2
       +
       

     

       3
       3
       +
       import json

     

       4
       4
       +
       import logging

     

       5
       5
       +
       from datetime import datetime

     

       6
       6
       +
       from typing import Any, Optional

     

       7
       7
       +
       from urllib.parse import urlparse

     

       8
       8
       +
       

     

       9
       9
       +
       import typesense

     

       10
       10
       +
       from pydantic import BaseModel, ConfigDict

     

       11
       11
       +
       

     

       12
       12
       +
       from ..models.config import ThicketConfig, UserConfig

     

       13
       13
       +
       from ..models.feed import AtomEntry

     

       14
       14
       +
       from ..models.user import UserMetadata

     

       15
       15
       +
       from .git_store import GitStore

     

       16
       16
       +
       

     

       17
       17
       +
       logger = logging.getLogger(__name__)

     

       18
       18
       +
       

     

       19
       19
       +
       

     

       20
       20
       +
       class TypesenseConfig(BaseModel):

     

       21
       21
       +
           """Configuration for Typesense connection."""

     

       22
       22
       +
       

     

       23
       23
       +
           model_config = ConfigDict(str_strip_whitespace=True)

     

       24
       24
       +
       

     

       25
       25
       +
           host: str

     

       26
       26
       +
           port: int = 8108

     

       27
       27
       +
           protocol: str = "http"

     

       28
       28
       +
           api_key: str

     

       29
       29
       +
           connection_timeout: int = 5

     

       30
       30
       +
           collection_name: str = "thicket_entries"

     

       31
       31
       +
       

     

       32
       32
       +
           @classmethod

     

       33
       33
       +
           def from_url(

     

       34
       34
       +
               cls, url: str, api_key: str, collection_name: str = "thicket_entries"

     

       35
       35
       +
           ) -> "TypesenseConfig":

     

       36
       36
       +
               """Create config from Typesense URL."""

     

       37
       37
       +
               parsed = urlparse(url)

     

       38
       38
       +
               return cls(

     

       39
       39
       +
                   host=parsed.hostname or "localhost",

     

       40
       40
       +
                   port=parsed.port or (443 if parsed.scheme == "https" else 8108),

     

       41
       41
       +
                   protocol=parsed.scheme or "http",

     

       42
       42
       +
                   api_key=api_key,

     

       43
       43
       +
                   collection_name=collection_name,

     

       44
       44
       +
               )

     

       45
       45
       +
       

     

       46
       46
       +
       

     

       47
       47
       +
       class TypesenseDocument(BaseModel):

     

       48
       48
       +
           """Document model for Typesense indexing."""

     

       49
       49
       +
       

     

       50
       50
       +
           model_config = ConfigDict(

     

       51
       51
       +
               json_encoders={datetime: lambda v: int(v.timestamp())},

     

       52
       52
       +
               str_strip_whitespace=True,

     

       53
       53
       +
           )

     

       54
       54
       +
       

     

       55
       55
       +
           # Primary fields from AtomEntry

     

       56
       56
       +
           id: str  # Sanitized entry ID

     

       57
       57
       +
           original_id: str  # Original Atom ID

     

       58
       58
       +
           title: str

     

       59
       59
       +
           link: str

     

       60
       60
       +
           updated: int  # Unix timestamp

     

       61
       61
       +
           published: Optional[int] = None  # Unix timestamp

     

       62
       62
       +
           summary: Optional[str] = None

     

       63
       63
       +
           content: Optional[str] = None

     

       64
       64
       +
           content_type: str = "html"

     

       65
       65
       +
           categories: list[str] = []

     

       66
       66
       +
           rights: Optional[str] = None

     

       67
       67
       +
           source: Optional[str] = None

     

       68
       68
       +
       

     

       69
       69
       +
           # User/feed metadata

     

       70
       70
       +
           username: str

     

       71
       71
       +
           user_display_name: Optional[str] = None

     

       72
       72
       +
           user_email: Optional[str] = None

     

       73
       73
       +
           user_homepage: Optional[str] = None

     

       74
       74
       +
           user_icon: Optional[str] = None

     

       75
       75
       +
       

     

       76
       76
       +
           # Author information from entry

     

       77
       77
       +
           author_name: Optional[str] = None

     

       78
       78
       +
           author_email: Optional[str] = None

     

       79
       79
       +
           author_uri: Optional[str] = None

     

       80
       80
       +
       

     

       81
       81
       +
           # Searchable text fields for embedding/semantic search

     

       82
       82
       +
           searchable_content: str  # Combined title + summary + content

     

       83
       83
       +
           searchable_metadata: str  # Combined user info + categories + author

     

       84
       84
       +
       

     

       85
       85
       +
           @classmethod

     

       86
       86
       +
           def from_atom_entry_with_metadata(

     

       87
       87
       +
               cls,

     

       88
       88
       +
               entry: AtomEntry,

     

       89
       89
       +
               sanitized_id: str,

     

       90
       90
       +
               user_metadata: "UserMetadata",  # Import will be added at top

     

       91
       91
       +
           ) -> "TypesenseDocument":

     

       92
       92
       +
               """Create TypesenseDocument from AtomEntry and UserMetadata from git store."""

     

       93
       93
       +
               # Extract author information if available

     

       94
       94
       +
               author_name = None

     

       95
       95
       +
               author_email = None

     

       96
       96
       +
               author_uri = None

     

       97
       97
       +
               if entry.author:

     

       98
       98
       +
                   author_name = entry.author.get("name")

     

       99
       99
       +
                   author_email = entry.author.get("email")

     

       100
       100
       +
                   author_uri = entry.author.get("uri")

     

       101
       101
       +
       

     

       102
       102
       +
               # Create searchable content combining all text fields

     

       103
       103
       +
               content_parts = [entry.title]

     

       104
       104
       +
               if entry.summary:

     

       105
       105
       +
                   content_parts.append(entry.summary)

     

       106
       106
       +
               if entry.content:

     

       107
       107
       +
                   content_parts.append(entry.content)

     

       108
       108
       +
               searchable_content = " ".join(content_parts)

     

       109
       109
       +
       

     

       110
       110
       +
               # Create searchable metadata

     

       111
       111
       +
               metadata_parts = [user_metadata.username]

     

       112
       112
       +
               if user_metadata.display_name:

     

       113
       113
       +
                   metadata_parts.append(user_metadata.display_name)

     

       114
       114
       +
               if author_name:

     

       115
       115
       +
                   metadata_parts.append(author_name)

     

       116
       116
       +
               if entry.categories:

     

       117
       117
       +
                   metadata_parts.extend(entry.categories)

     

       118
       118
       +
               searchable_metadata = " ".join(metadata_parts)

     

       119
       119
       +
       

     

       120
       120
       +
               return cls(

     

       121
       121
       +
                   id=sanitized_id,

     

       122
       122
       +
                   original_id=entry.id,

     

       123
       123
       +
                   title=entry.title,

     

       124
       124
       +
                   link=str(entry.link),

     

       125
       125
       +
                   updated=int(entry.updated.timestamp()),

     

       126
       126
       +
                   published=int(entry.published.timestamp()) if entry.published else None,

     

       127
       127
       +
                   summary=entry.summary,

     

       128
       128
       +
                   content=entry.content,

     

       129
       129
       +
                   content_type=entry.content_type or "html",

     

       130
       130
       +
                   categories=entry.categories,

     

       131
       131
       +
                   rights=entry.rights,

     

       132
       132
       +
                   source=entry.source,

     

       133
       133
       +
                   username=user_metadata.username,

     

       134
       134
       +
                   user_display_name=user_metadata.display_name,

     

       135
       135
       +
                   user_email=user_metadata.email,

     

       136
       136
       +
                   user_homepage=user_metadata.homepage,

     

       137
       137
       +
                   user_icon=user_metadata.icon if user_metadata.icon != "None" else None,

     

       138
       138
       +
                   author_name=author_name,

     

       139
       139
       +
                   author_email=author_email,

     

       140
       140
       +
                   author_uri=author_uri,

     

       141
       141
       +
                   searchable_content=searchable_content,

     

       142
       142
       +
                   searchable_metadata=searchable_metadata,

     

       143
       143
       +
               )

     

       144
       144
       +
       

     

       145
       145
       +
           @classmethod

     

       146
       146
       +
           def from_atom_entry(

     

       147
       147
       +
               cls,

     

       148
       148
       +
               entry: AtomEntry,

     

       149
       149
       +
               sanitized_id: str,

     

       150
       150
       +
               user_config: UserConfig,

     

       151
       151
       +
           ) -> "TypesenseDocument":

     

       152
       152
       +
               """Create TypesenseDocument from AtomEntry and UserConfig."""

     

       153
       153
       +
               # Extract author information if available

     

       154
       154
       +
               author_name = None

     

       155
       155
       +
               author_email = None

     

       156
       156
       +
               author_uri = None

     

       157
       157
       +
               if entry.author:

     

       158
       158
       +
                   author_name = entry.author.get("name")

     

       159
       159
       +
                   author_email = entry.author.get("email")

     

       160
       160
       +
                   author_uri = entry.author.get("uri")

     

       161
       161
       +
       

     

       162
       162
       +
               # Create searchable content combining all text fields

     

       163
       163
       +
               content_parts = [entry.title]

     

       164
       164
       +
               if entry.summary:

     

       165
       165
       +
                   content_parts.append(entry.summary)

     

       166
       166
       +
               if entry.content:

     

       167
       167
       +
                   content_parts.append(entry.content)

     

       168
       168
       +
               searchable_content = " ".join(content_parts)

     

       169
       169
       +
       

     

       170
       170
       +
               # Create searchable metadata

     

       171
       171
       +
               metadata_parts = [user_config.username]

     

       172
       172
       +
               if user_config.display_name:

     

       173
       173
       +
                   metadata_parts.append(user_config.display_name)

     

       174
       174
       +
               if author_name:

     

       175
       175
       +
                   metadata_parts.append(author_name)

     

       176
       176
       +
               if entry.categories:

     

       177
       177
       +
                   metadata_parts.extend(entry.categories)

     

       178
       178
       +
               searchable_metadata = " ".join(metadata_parts)

     

       179
       179
       +
       

     

       180
       180
       +
               return cls(

     

       181
       181
       +
                   id=sanitized_id,

     

       182
       182
       +
                   original_id=entry.id,

     

       183
       183
       +
                   title=entry.title,

     

       184
       184
       +
                   link=str(entry.link),

     

       185
       185
       +
                   updated=int(entry.updated.timestamp()),

     

       186
       186
       +
                   published=int(entry.published.timestamp()) if entry.published else None,

     

       187
       187
       +
                   summary=entry.summary,

     

       188
       188
       +
                   content=entry.content,

     

       189
       189
       +
                   content_type=entry.content_type or "html",

     

       190
       190
       +
                   categories=entry.categories,

     

       191
       191
       +
                   rights=entry.rights,

     

       192
       192
       +
                   source=entry.source,

     

       193
       193
       +
                   username=user_config.username,

     

       194
       194
       +
                   user_display_name=user_config.display_name,

     

       195
       195
       +
                   user_email=str(user_config.email) if user_config.email else None,

     

       196
       196
       +
                   user_homepage=str(user_config.homepage) if user_config.homepage else None,

     

       197
       197
       +
                   user_icon=str(user_config.icon) if user_config.icon else None,

     

       198
       198
       +
                   author_name=author_name,

     

       199
       199
       +
                   author_email=author_email,

     

       200
       200
       +
                   author_uri=author_uri,

     

       201
       201
       +
                   searchable_content=searchable_content,

     

       202
       202
       +
                   searchable_metadata=searchable_metadata,

     

       203
       203
       +
               )

     

       204
       204
       +
       

     

       205
       205
       +
       

     

       206
       206
       +
       class TypesenseClient:

     

       207
       207
       +
           """Client for interacting with Typesense search engine."""

     

       208
       208
       +
       

     

       209
       209
       +
           def __init__(self, config: TypesenseConfig):

     

       210
       210
       +
               """Initialize Typesense client."""

     

       211
       211
       +
               self.config = config

     

       212
       212
       +
               self.client = typesense.Client(

     

       213
       213
       +
                   {

     

       214
       214
       +
                       "nodes": [

     

       215
       215
       +
                           {

     

       216
       216
       +
                               "host": config.host,

     

       217
       217
       +
                               "port": config.port,

     

       218
       218
       +
                               "protocol": config.protocol,

     

       219
       219
       +
                           }

     

       220
       220
       +
                       ],

     

       221
       221
       +
                       "api_key": config.api_key,

     

       222
       222
       +
                       "connection_timeout_seconds": config.connection_timeout,

     

       223
       223
       +
                   }

     

       224
       224
       +
               )

     

       225
       225
       +
       

     

       226
       226
       +
           def get_collection_schema(self) -> dict[str, Any]:

     

       227
       227
       +
               """Get the Typesense collection schema for thicket entries."""

     

       228
       228
       +
               return {

     

       229
       229
       +
                   "name": self.config.collection_name,

     

       230
       230
       +
                   "fields": [

     

       231
       231
       +
                       # Primary identifiers

     

       232
       232
       +
                       {"name": "id", "type": "string", "facet": False},

     

       233
       233
       +
                       {"name": "original_id", "type": "string", "facet": False},

     

       234
       234
       +
                       # Content fields - optimized for search

     

       235
       235
       +
                       {"name": "title", "type": "string", "facet": False},

     

       236
       236
       +
                       {"name": "summary", "type": "string", "optional": True, "facet": False},

     

       237
       237
       +
                       {"name": "content", "type": "string", "optional": True, "facet": False},

     

       238
       238
       +
                       {"name": "content_type", "type": "string", "facet": True},

     

       239
       239
       +
                       # Searchable combined fields for embeddings/semantic search

     

       240
       240
       +
                       {"name": "searchable_content", "type": "string", "facet": False},

     

       241
       241
       +
                       {"name": "searchable_metadata", "type": "string", "facet": False},

     

       242
       242
       +
                       # Temporal fields

     

       243
       243
       +
                       {"name": "updated", "type": "int64", "facet": False, "sort": True},

     

       244
       244
       +
                       {

     

       245
       245
       +
                           "name": "published",

     

       246
       246
       +
                           "type": "int64",

     

       247
       247
       +
                           "optional": True,

     

       248
       248
       +
                           "facet": False,

     

       249
       249
       +
                           "sort": True,

     

       250
       250
       +
                       },

     

       251
       251
       +
                       # Link and source

     

       252
       252
       +
                       {"name": "link", "type": "string", "facet": False},

     

       253
       253
       +
                       {"name": "source", "type": "string", "optional": True, "facet": False},

     

       254
       254
       +
                       # Categories and classification

     

       255
       255
       +
                       {

     

       256
       256
       +
                           "name": "categories",

     

       257
       257
       +
                           "type": "string[]",

     

       258
       258
       +
                           "facet": True,

     

       259
       259
       +
                           "optional": True,

     

       260
       260
       +
                       },

     

       261
       261
       +
                       {"name": "rights", "type": "string", "optional": True, "facet": False},

     

       262
       262
       +
                       # User/feed metadata - facetable for filtering

     

       263
       263
       +
                       {"name": "username", "type": "string", "facet": True},

     

       264
       264
       +
                       {

     

       265
       265
       +
                           "name": "user_display_name",

     

       266
       266
       +
                           "type": "string",

     

       267
       267
       +
                           "optional": True,

     

       268
       268
       +
                           "facet": True,

     

       269
       269
       +
                       },

     

       270
       270
       +
                       {

     

       271
       271
       +
                           "name": "user_email",

     

       272
       272
       +
                           "type": "string",

     

       273
       273
       +
                           "optional": True,

     

       274
       274
       +
                           "facet": False,

     

       275
       275
       +
                       },

     

       276
       276
       +
                       {

     

       277
       277
       +
                           "name": "user_homepage",

     

       278
       278
       +
                           "type": "string",

     

       279
       279
       +
                           "optional": True,

     

       280
       280
       +
                           "facet": False,

     

       281
       281
       +
                       },

     

       282
       282
       +
                       {

     

       283
       283
       +
                           "name": "user_icon",

     

       284
       284
       +
                           "type": "string",

     

       285
       285
       +
                           "optional": True,

     

       286
       286
       +
                           "facet": False,

     

       287
       287
       +
                       },

     

       288
       288
       +
                       # Author information from entries

     

       289
       289
       +
                       {

     

       290
       290
       +
                           "name": "author_name",

     

       291
       291
       +
                           "type": "string",

     

       292
       292
       +
                           "optional": True,

     

       293
       293
       +
                           "facet": True,

     

       294
       294
       +
                       },

     

       295
       295
       +
                       {

     

       296
       296
       +
                           "name": "author_email",

     

       297
       297
       +
                           "type": "string",

     

       298
       298
       +
                           "optional": True,

     

       299
       299
       +
                           "facet": False,

     

       300
       300
       +
                       },

     

       301
       301
       +
                       {

     

       302
       302
       +
                           "name": "author_uri",

     

       303
       303
       +
                           "type": "string",

     

       304
       304
       +
                           "optional": True,

     

       305
       305
       +
                           "facet": False,

     

       306
       306
       +
                       },

     

       307
       307
       +
                   ],

     

       308
       308
       +
                   "default_sorting_field": "updated",

     

       309
       309
       +
               }

     

       310
       310
       +
       

     

       311
       311
       +
           def create_collection(self) -> dict[str, Any]:

     

       312
       312
       +
               """Create the Typesense collection with the appropriate schema."""

     

       313
       313
       +
               try:

     

       314
       314
       +
                   # Try to delete existing collection first

     

       315
       315
       +
                   try:

     

       316
       316
       +
                       self.client.collections[self.config.collection_name].delete()

     

       317
       317
       +
                       logger.info(

     

       318
       318
       +
                           f"Deleted existing collection: {self.config.collection_name}"

     

       319
       319
       +
                       )

     

       320
       320
       +
                   except typesense.exceptions.ObjectNotFound:

     

       321
       321
       +
                       logger.info(

     

       322
       322
       +
                           f"Collection {self.config.collection_name} does not exist, creating new one"

     

       323
       323
       +
                       )

     

       324
       324
       +
       

     

       325
       325
       +
                   # Create new collection

     

       326
       326
       +
                   schema = self.get_collection_schema()

     

       327
       327
       +
                   result = self.client.collections.create(schema)

     

       328
       328
       +
                   logger.info(f"Created collection: {self.config.collection_name}")

     

       329
       329
       +
                   return result

     

       330
       330
       +
       

     

       331
       331
       +
               except Exception as e:

     

       332
       332
       +
                   logger.error(f"Failed to create collection: {e}")

     

       333
       333
       +
                   raise

     

       334
       334
       +
       

     

       335
       335
       +
           def index_documents(self, documents: list[TypesenseDocument]) -> dict[str, Any]:

     

       336
       336
       +
               """Index a batch of documents in Typesense."""

     

       337
       337
       +
               try:

     

       338
       338
       +
                   # Convert documents to dict format for Typesense

     

       339
       339
       +
                   document_dicts = [doc.model_dump() for doc in documents]

     

       340
       340
       +
       

     

       341
       341
       +
                   # Use import endpoint for batch indexing

     

       342
       342
       +
                   result = self.client.collections[

     

       343
       343
       +
                       self.config.collection_name

     

       344
       344
       +
                   ].documents.import_(

     

       345
       345
       +
                       document_dicts,

     

       346
       346
       +
                       {"action": "upsert"},  # Update if exists, insert if not

     

       347
       347
       +
                   )

     

       348
       348
       +
       

     

       349
       349
       +
                   logger.info(f"Indexed {len(documents)} documents")

     

       350
       350
       +
                   return result

     

       351
       351
       +
       

     

       352
       352
       +
               except Exception as e:

     

       353
       353
       +
                   logger.error(f"Failed to index documents: {e}")

     

       354
       354
       +
                   raise

     

       355
       355
       +
       

     

       356
       356
       +
           def upload_from_git_store(

     

       357
       357
       +
               self, git_store: GitStore, config: ThicketConfig

     

       358
       358
       +
           ) -> dict[str, Any]:

     

       359
       359
       +
               """Upload all entries from the Git store to Typesense."""

     

       360
       360
       +
               logger.info("Starting Typesense upload from Git store")

     

       361
       361
       +
       

     

       362
       362
       +
               # Create collection

     

       363
       363
       +
               self.create_collection()

     

       364
       364
       +
       

     

       365
       365
       +
               documents = []

     

       366
       366
       +
               index = git_store._load_index()

     

       367
       367
       +
       

     

       368
       368
       +
               for username, user_metadata in index.users.items():

     

       369
       369
       +
                   logger.info(f"Processing entries for user: {username}")

     

       370
       370
       +
       

     

       371
       371
       +
                   # Load user entries from directory

     

       372
       372
       +
                   try:

     

       373
       373
       +
                       user_dir = git_store.repo_path / user_metadata.directory

     

       374
       374
       +
                       if not user_dir.exists():

     

       375
       375
       +
                           logger.warning(

     

       376
       376
       +
                               f"Directory not found for user {username}: {user_dir}"

     

       377
       377
       +
                           )

     

       378
       378
       +
                           continue

     

       379
       379
       +
       

     

       380
       380
       +
                       entry_files = list(user_dir.glob("*.json"))

     

       381
       381
       +
                       logger.info(f"Found {len(entry_files)} entry files for {username}")

     

       382
       382
       +
       

     

       383
       383
       +
                       for entry_file in entry_files:

     

       384
       384
       +
                           try:

     

       385
       385
       +
                               with open(entry_file) as f:

     

       386
       386
       +
                                   data = json.load(f)

     

       387
       387
       +
       

     

       388
       388
       +
                               entry = AtomEntry(**data)

     

       389
       389
       +
                               sanitized_id = entry_file.stem  # filename without extension

     

       390
       390
       +
       

     

       391
       391
       +
                               doc = TypesenseDocument.from_atom_entry_with_metadata(

     

       392
       392
       +
                                   entry, sanitized_id, user_metadata

     

       393
       393
       +
                               )

     

       394
       394
       +
                               documents.append(doc)

     

       395
       395
       +
                           except Exception as e:

     

       396
       396
       +
                               logger.error(

     

       397
       397
       +
                                   f"Failed to convert entry {entry_file} to document: {e}"

     

       398
       398
       +
                               )

     

       399
       399
       +
       

     

       400
       400
       +
                   except Exception as e:

     

       401
       401
       +
                       logger.error(f"Failed to load entries for user {username}: {e}")

     

       402
       402
       +
       

     

       403
       403
       +
               if documents:

     

       404
       404
       +
                   logger.info(f"Uploading {len(documents)} documents to Typesense")

     

       405
       405
       +
                   result = self.index_documents(documents)

     

       406
       406
       +
                   logger.info("Upload completed successfully")

     

       407
       407
       +
                   return result

     

       408
       408
       +
               else:

     

       409
       409
       +
                   logger.warning("No documents to upload")

     

       410
       410
       +
                   return {}

     

       411
       411
       +
       

     

       412
       412
       +
           def search(

     

       413
       413
       +
               self, query: str, search_parameters: Optional[dict[str, Any]] = None

     

       414
       414
       +
           ) -> dict[str, Any]:

     

       415
       415
       +
               """Search the collection."""

     

       416
       416
       +
               default_params = {

     

       417
       417
       +
                   "q": query,

     

       418
       418
       +
                   "query_by": "title,searchable_content,searchable_metadata",

     

       419
       419
       +
                   "sort_by": "updated:desc",

     

       420
       420
       +
                   "per_page": 20,

     

       421
       421
       +
               }

     

       422
       422
       +
       

     

       423
       423
       +
               if search_parameters:

     

       424
       424
       +
                   default_params.update(search_parameters)

     

       425
       425
       +
       

     

       426
       426
       +
               return self.client.collections[self.config.collection_name].documents.search(

     

       427
       427
       +
                   default_params

     

       428
       428
       +
               )

+2 -1

src/thicket/models/__init__.py

···

       2
       2
        
       

     

       3
       3
        
       from .config import ThicketConfig, UserConfig

     

       4
       4
        
       from .feed import AtomEntry, DuplicateMap, FeedMetadata

     

       5
       5
       -
       from .user import GitStoreIndex, UserMetadata

     

       5
       5
       +
       from .user import GitStoreIndex, UserMetadata, ZulipAssociation

     

       6
       6
        
       

     

       7
       7
        
       __all__ = [

     

       8
       8
        
           "ThicketConfig",

     
···

       12
       12
        
           "FeedMetadata",

     

       13
       13
        
           "GitStoreIndex",

     

       14
       14
        
           "UserMetadata",

     

       15
       15
       +
           "ZulipAssociation",

     

       15
       16
        
       ]

+24

src/thicket/models/config.py

···

       31
       31
        
           git_store: Path

     

       32
       32
        
           cache_dir: Path

     

       33
       33
        
           users: list[UserConfig] = []

     

       34
       34
       +
       

     

       35
       35
       +
           def find_user(self, username: str) -> Optional[UserConfig]:

     

       36
       36
       +
               """Find a user by username."""

     

       37
       37
       +
               for user in self.users:

     

       38
       38
       +
                   if user.username == username:

     

       39
       39
       +
                       return user

     

       40
       40
       +
               return None

     

       41
       41
       +
       

     

       42
       42
       +
           def add_user(self, user: UserConfig) -> bool:

     

       43
       43
       +
               """Add a user to the configuration. Returns True if added, False if already exists."""

     

       44
       44
       +
               if self.find_user(user.username) is not None:

     

       45
       45
       +
                   return False

     

       46
       46
       +
               self.users.append(user)

     

       47
       47
       +
               return True

     

       48
       48
       +
       

     

       49
       49
       +
           def add_feed_to_user(self, username: str, feed_url: HttpUrl) -> bool:

     

       50
       50
       +
               """Add a feed to an existing user. Returns True if added, False if user not found or feed already exists."""

     

       51
       51
       +
               user = self.find_user(username)

     

       52
       52
       +
               if user is None:

     

       53
       53
       +
                   return False

     

       54
       54
       +
               if feed_url in user.feeds:

     

       55
       55
       +
                   return False

     

       56
       56
       +
               user.feeds.append(feed_url)

     

       57
       57
       +
               return True

+2 -2

src/thicket/models/feed.py

···

       1
       1
        
       """Feed and entry models for thicket."""

     

       2
       2
        
       

     

       3
       3
        
       from datetime import datetime

     

       4
       4
       -
       from typing import TYPE_CHECKING, Optional

     

       4
       4
       +
       from typing import TYPE_CHECKING, Any, Optional

     

       5
       5
        
       

     

       6
       6
        
       from pydantic import BaseModel, ConfigDict, EmailStr, HttpUrl

     

       7
       7
        
       

     
···

       25
       25
        
           summary: Optional[str] = None

     

       26
       26
        
           content: Optional[str] = None  # Full body content from Atom entry

     

       27
       27
        
           content_type: Optional[str] = "html"  # text, html, xhtml

     

       28
       28
       -
           author: Optional[dict] = None

     

       28
       28
       +
           author: Optional[dict[str, Any]] = None

     

       29
       29
        
           categories: list[str] = []

     

       30
       30
        
           rights: Optional[str] = None  # Copyright info

     

       31
       31
        
           source: Optional[str] = None  # Source feed URL

+41 -4

src/thicket/models/user.py

···

       3
       3
        
       from datetime import datetime

     

       4
       4
        
       from typing import Optional

     

       5
       5
        
       

     

       6
       6
       -
       from pydantic import BaseModel, ConfigDict

     

       6
       6
       +
       from pydantic import BaseModel, ConfigDict, Field

     

       7
       7
       +
       

     

       8
       8
       +
       

     

       9
       9
       +
       class ZulipAssociation(BaseModel):

     

       10
       10
       +
           """Association between a user and their Zulip identity."""

     

       11
       11
       +
       

     

       12
       12
       +
           server: str  # Zulip server URL (e.g., "yourorg.zulipchat.com")

     

       13
       13
       +
           user_id: str  # Zulip user ID or email for @mentions

     

       14
       14
       +
       

     

       15
       15
       +
           def __hash__(self) -> int:

     

       16
       16
       +
               """Make hashable for use in sets."""

     

       17
       17
       +
               return hash((self.server, self.user_id))

     

       7
       18
        
       

     

       8
       19
        
       

     

       9
       20
        
       class UserMetadata(BaseModel):

     
···

       20
       31
        
           homepage: Optional[str] = None

     

       21
       32
        
           icon: Optional[str] = None

     

       22
       33
        
           feeds: list[str] = []

     

       34
       34
       +
           zulip_associations: list[ZulipAssociation] = Field(

     

       35
       35
       +
               default_factory=list

     

       36
       36
       +
           )  # Zulip server/user pairs

     

       23
       37
        
           directory: str  # Directory name in Git store

     

       24
       38
        
           created: datetime

     

       25
       39
        
           last_updated: datetime

     
···

       34
       48
        
               self.entry_count += count

     

       35
       49
        
               self.update_timestamp()

     

       36
       50
        
       

     

       51
       51
       +
           def add_zulip_association(self, server: str, user_id: str) -> bool:

     

       52
       52
       +
               """Add a Zulip association if it doesn't exist. Returns True if added."""

     

       53
       53
       +
               association = ZulipAssociation(server=server, user_id=user_id)

     

       54
       54
       +
               if association not in self.zulip_associations:

     

       55
       55
       +
                   self.zulip_associations.append(association)

     

       56
       56
       +
                   self.update_timestamp()

     

       57
       57
       +
                   return True

     

       58
       58
       +
               return False

     

       59
       59
       +
       

     

       60
       60
       +
           def remove_zulip_association(self, server: str, user_id: str) -> bool:

     

       61
       61
       +
               """Remove a Zulip association. Returns True if removed."""

     

       62
       62
       +
               association = ZulipAssociation(server=server, user_id=user_id)

     

       63
       63
       +
               if association in self.zulip_associations:

     

       64
       64
       +
                   self.zulip_associations.remove(association)

     

       65
       65
       +
                   self.update_timestamp()

     

       66
       66
       +
                   return True

     

       67
       67
       +
               return False

     

       68
       68
       +
       

     

       69
       69
       +
           def get_zulip_mention(self, server: str) -> Optional[str]:

     

       70
       70
       +
               """Get the Zulip user_id for @mentions on a specific server."""

     

       71
       71
       +
               for association in self.zulip_associations:

     

       72
       72
       +
                   if association.server == server:

     

       73
       73
       +
                       return association.user_id

     

       74
       74
       +
               return None

     

       75
       75
       +
       

     

       37
       76
        
       

     

       38
       77
        
       class GitStoreIndex(BaseModel):

     

       39
       78
        
           """Index of all users and their directories in the Git store."""

     

       40
       79
        
       

     

       41
       41
       -
           model_config = ConfigDict(

     

       42
       42
       -
               json_encoders={datetime: lambda v: v.isoformat()}

     

       43
       43
       -
           )

     

       80
       80
       +
           model_config = ConfigDict(json_encoders={datetime: lambda v: v.isoformat()})

     

       44
       81
        
       

     

       45
       82
        
           users: dict[str, UserMetadata] = {}  # username -> UserMetadata

     

       46
       83
        
           created: datetime

+297

tests/test_bot.py

···

       1
       1
       +
       """Tests for the Thicket Zulip bot."""

     

       2
       2
       +
       

     

       3
       3
       +
       import pytest

     

       4
       4
       +
       

     

       5
       5
       +
       from thicket.bots.test_bot import (

     

       6
       6
       +
           BotTester,

     

       7
       7
       +
           MockBotHandler,

     

       8
       8
       +
           create_test_entry,

     

       9
       9
       +
           create_test_message,

     

       10
       10
       +
       )

     

       11
       11
       +
       from thicket.bots.thicket_bot import ThicketBotHandler

     

       12
       12
       +
       

     

       13
       13
       +
       

     

       14
       14
       +
       class TestThicketBot:

     

       15
       15
       +
           """Test suite for ThicketBotHandler."""

     

       16
       16
       +
       

     

       17
       17
       +
           def setup_method(self) -> None:

     

       18
       18
       +
               """Set up test environment."""

     

       19
       19
       +
               self.bot = ThicketBotHandler()

     

       20
       20
       +
               self.handler = MockBotHandler()

     

       21
       21
       +
       

     

       22
       22
       +
           def test_usage(self) -> None:

     

       23
       23
       +
               """Test bot usage message."""

     

       24
       24
       +
               usage = self.bot.usage()

     

       25
       25
       +
               assert "Thicket Feed Bot" in usage

     

       26
       26
       +
               assert "@thicket status" in usage

     

       27
       27
       +
               assert "@thicket config" in usage

     

       28
       28
       +
       

     

       29
       29
       +
           def test_help_command(self) -> None:

     

       30
       30
       +
               """Test help command response."""

     

       31
       31
       +
               message = create_test_message("@thicket help")

     

       32
       32
       +
               self.bot.handle_message(message, self.handler)

     

       33
       33
       +
       

     

       34
       34
       +
               assert len(self.handler.sent_messages) == 1

     

       35
       35
       +
               response = self.handler.sent_messages[0]["content"]

     

       36
       36
       +
               assert "Thicket Feed Bot" in response

     

       37
       37
       +
       

     

       38
       38
       +
           def test_status_command_unconfigured(self) -> None:

     

       39
       39
       +
               """Test status command when bot is not configured."""

     

       40
       40
       +
               message = create_test_message("@thicket status")

     

       41
       41
       +
               self.bot.handle_message(message, self.handler)

     

       42
       42
       +
       

     

       43
       43
       +
               assert len(self.handler.sent_messages) == 1

     

       44
       44
       +
               response = self.handler.sent_messages[0]["content"]

     

       45
       45
       +
               assert "Not configured" in response

     

       46
       46
       +
               assert "Stream:" in response

     

       47
       47
       +
               assert "Topic:" in response

     

       48
       48
       +
       

     

       49
       49
       +
           def test_config_stream_command(self) -> None:

     

       50
       50
       +
               """Test setting stream configuration."""

     

       51
       51
       +
               message = create_test_message("@thicket config stream general")

     

       52
       52
       +
               self.bot.handle_message(message, self.handler)

     

       53
       53
       +
       

     

       54
       54
       +
               assert len(self.handler.sent_messages) == 1

     

       55
       55
       +
               response = self.handler.sent_messages[0]["content"]

     

       56
       56
       +
               assert "Stream set to: **general**" in response

     

       57
       57
       +
               assert self.bot.stream_name == "general"

     

       58
       58
       +
       

     

       59
       59
       +
           def test_config_topic_command(self) -> None:

     

       60
       60
       +
               """Test setting topic configuration."""

     

       61
       61
       +
               message = create_test_message("@thicket config topic 'Feed Updates'")

     

       62
       62
       +
               self.bot.handle_message(message, self.handler)

     

       63
       63
       +
       

     

       64
       64
       +
               assert len(self.handler.sent_messages) == 1

     

       65
       65
       +
               response = self.handler.sent_messages[0]["content"]

     

       66
       66
       +
               assert "Topic set to:" in response and "Feed Updates" in response

     

       67
       67
       +
               assert self.bot.topic_name == "'Feed Updates'"

     

       68
       68
       +
       

     

       69
       69
       +
           def test_config_interval_command(self) -> None:

     

       70
       70
       +
               """Test setting sync interval."""

     

       71
       71
       +
               message = create_test_message("@thicket config interval 600")

     

       72
       72
       +
               self.bot.handle_message(message, self.handler)

     

       73
       73
       +
       

     

       74
       74
       +
               assert len(self.handler.sent_messages) == 1

     

       75
       75
       +
               response = self.handler.sent_messages[0]["content"]

     

       76
       76
       +
               assert "Sync interval set to: **600s**" in response

     

       77
       77
       +
               assert self.bot.sync_interval == 600

     

       78
       78
       +
       

     

       79
       79
       +
           def test_config_interval_too_small(self) -> None:

     

       80
       80
       +
               """Test setting sync interval that's too small."""

     

       81
       81
       +
               message = create_test_message("@thicket config interval 30")

     

       82
       82
       +
               self.bot.handle_message(message, self.handler)

     

       83
       83
       +
       

     

       84
       84
       +
               assert len(self.handler.sent_messages) == 1

     

       85
       85
       +
               response = self.handler.sent_messages[0]["content"]

     

       86
       86
       +
               assert "must be at least 60 seconds" in response

     

       87
       87
       +
               assert self.bot.sync_interval != 30

     

       88
       88
       +
       

     

       89
       89
       +
           def test_config_path_nonexistent(self) -> None:

     

       90
       90
       +
               """Test setting config path that doesn't exist."""

     

       91
       91
       +
               message = create_test_message("@thicket config path /nonexistent/config.yaml")

     

       92
       92
       +
               self.bot.handle_message(message, self.handler)

     

       93
       93
       +
       

     

       94
       94
       +
               assert len(self.handler.sent_messages) == 1

     

       95
       95
       +
               response = self.handler.sent_messages[0]["content"]

     

       96
       96
       +
               assert "Config file not found" in response

     

       97
       97
       +
       

     

       98
       98
       +
           def test_unknown_command(self) -> None:

     

       99
       99
       +
               """Test unknown command handling."""

     

       100
       100
       +
               message = create_test_message("@thicket unknown")

     

       101
       101
       +
               self.bot.handle_message(message, self.handler)

     

       102
       102
       +
       

     

       103
       103
       +
               assert len(self.handler.sent_messages) == 1

     

       104
       104
       +
               response = self.handler.sent_messages[0]["content"]

     

       105
       105
       +
               assert "Unknown command: unknown" in response

     

       106
       106
       +
       

     

       107
       107
       +
           def test_config_persistence(self) -> None:

     

       108
       108
       +
               """Test that configuration is persisted."""

     

       109
       109
       +
               # Set some config

     

       110
       110
       +
               self.bot.stream_name = "test-stream"

     

       111
       111
       +
               self.bot.topic_name = "test-topic"

     

       112
       112
       +
               self.bot.sync_interval = 600

     

       113
       113
       +
       

     

       114
       114
       +
               # Save config

     

       115
       115
       +
               self.bot._save_bot_config(self.handler)

     

       116
       116
       +
       

     

       117
       117
       +
               # Create new bot instance

     

       118
       118
       +
               new_bot = ThicketBotHandler()

     

       119
       119
       +
               new_bot._load_bot_config(self.handler)

     

       120
       120
       +
       

     

       121
       121
       +
               # Check config was loaded

     

       122
       122
       +
               assert new_bot.stream_name == "test-stream"

     

       123
       123
       +
               assert new_bot.topic_name == "test-topic"

     

       124
       124
       +
               assert new_bot.sync_interval == 600

     

       125
       125
       +
       

     

       126
       126
       +
           def test_posted_entries_persistence(self) -> None:

     

       127
       127
       +
               """Test that posted entries are persisted."""

     

       128
       128
       +
               # Add some entries

     

       129
       129
       +
               self.bot.posted_entries = {"user1:entry1", "user2:entry2"}

     

       130
       130
       +
       

     

       131
       131
       +
               # Save entries

     

       132
       132
       +
               self.bot._save_posted_entries(self.handler)

     

       133
       133
       +
       

     

       134
       134
       +
               # Create new bot instance

     

       135
       135
       +
               new_bot = ThicketBotHandler()

     

       136
       136
       +
               new_bot._load_posted_entries(self.handler)

     

       137
       137
       +
       

     

       138
       138
       +
               # Check entries were loaded

     

       139
       139
       +
               assert new_bot.posted_entries == {"user1:entry1", "user2:entry2"}

     

       140
       140
       +
       

     

       141
       141
       +
           def test_mention_detection(self) -> None:

     

       142
       142
       +
               """Test bot mention detection."""

     

       143
       143
       +
               assert self.bot._is_mentioned("@Thicket Bot help", self.handler)

     

       144
       144
       +
               assert self.bot._is_mentioned("@thicket status", self.handler)

     

       145
       145
       +
               assert not self.bot._is_mentioned("regular message", self.handler)

     

       146
       146
       +
       

     

       147
       147
       +
           def test_mention_cleaning(self) -> None:

     

       148
       148
       +
               """Test cleaning mentions from messages."""

     

       149
       149
       +
               cleaned = self.bot._clean_mention("@Thicket Bot status", self.handler)

     

       150
       150
       +
               assert cleaned == "status"

     

       151
       151
       +
       

     

       152
       152
       +
               cleaned = self.bot._clean_mention("@thicket help", self.handler)

     

       153
       153
       +
               assert cleaned == "help"

     

       154
       154
       +
       

     

       155
       155
       +
           def test_sync_now_uninitialized(self) -> None:

     

       156
       156
       +
               """Test sync now command when not initialized."""

     

       157
       157
       +
               message = create_test_message("@thicket sync now")

     

       158
       158
       +
               self.bot.handle_message(message, self.handler)

     

       159
       159
       +
       

     

       160
       160
       +
               assert len(self.handler.sent_messages) == 1

     

       161
       161
       +
               response = self.handler.sent_messages[0]["content"]

     

       162
       162
       +
               assert "not initialized" in response.lower()

     

       163
       163
       +
       

     

       164
       164
       +
           def test_debug_mode_initialization(self) -> None:

     

       165
       165
       +
               """Test debug mode initialization."""

     

       166
       166
       +
               import os

     

       167
       167
       +
       

     

       168
       168
       +
               # Mock environment variable

     

       169
       169
       +
               os.environ["THICKET_DEBUG_USER"] = "testuser"

     

       170
       170
       +
       

     

       171
       171
       +
               try:

     

       172
       172
       +
                   bot = ThicketBotHandler()

     

       173
       173
       +
                   # Simulate initialize call

     

       174
       174
       +
                   bot.debug_user = os.getenv("THICKET_DEBUG_USER")

     

       175
       175
       +
       

     

       176
       176
       +
                   assert bot.debug_user == "testuser"

     

       177
       177
       +
                   assert bot.debug_zulip_user_id is None  # Not validated yet

     

       178
       178
       +
               finally:

     

       179
       179
       +
                   # Clean up

     

       180
       180
       +
                   if "THICKET_DEBUG_USER" in os.environ:

     

       181
       181
       +
                       del os.environ["THICKET_DEBUG_USER"]

     

       182
       182
       +
       

     

       183
       183
       +
           def test_debug_mode_status(self) -> None:

     

       184
       184
       +
               """Test status command in debug mode."""

     

       185
       185
       +
               self.bot.debug_user = "testuser"

     

       186
       186
       +
               self.bot.debug_zulip_user_id = "test.user"

     

       187
       187
       +
       

     

       188
       188
       +
               message = create_test_message("@thicket status")

     

       189
       189
       +
               self.bot.handle_message(message, self.handler)

     

       190
       190
       +
       

     

       191
       191
       +
               assert len(self.handler.sent_messages) == 1

     

       192
       192
       +
               response = self.handler.sent_messages[0]["content"]

     

       193
       193
       +
               assert "**Debug Mode:** ENABLED" in response

     

       194
       194
       +
               assert "**Debug User:** testuser" in response

     

       195
       195
       +
               assert "**Debug Zulip ID:** test.user" in response

     

       196
       196
       +
       

     

       197
       197
       +
           def test_debug_mode_check_initialization(self) -> None:

     

       198
       198
       +
               """Test initialization check in debug mode."""

     

       199
       199
       +
               from unittest.mock import Mock

     

       200
       200
       +
       

     

       201
       201
       +
               # Setup mock git store and config

     

       202
       202
       +
               self.bot.git_store = Mock()

     

       203
       203
       +
               self.bot.config = Mock()

     

       204
       204
       +
               self.bot.debug_user = "testuser"

     

       205
       205
       +
               self.bot.debug_zulip_user_id = "test.user"

     

       206
       206
       +
       

     

       207
       207
       +
               message = create_test_message("@thicket sync now")

     

       208
       208
       +
       

     

       209
       209
       +
               # Should pass with debug mode properly set up

     

       210
       210
       +
               result = self.bot._check_initialization(message, self.handler)

     

       211
       211
       +
               assert result is True

     

       212
       212
       +
       

     

       213
       213
       +
               # Should fail if debug_zulip_user_id is missing

     

       214
       214
       +
               self.bot.debug_zulip_user_id = None

     

       215
       215
       +
               result = self.bot._check_initialization(message, self.handler)

     

       216
       216
       +
               assert result is False

     

       217
       217
       +
               assert len(self.handler.sent_messages) == 1

     

       218
       218
       +
               assert (

     

       219
       219
       +
                   "Debug mode validation failed" in self.handler.sent_messages[0]["content"]

     

       220
       220
       +
               )

     

       221
       221
       +
       

     

       222
       222
       +
           def test_debug_mode_dm_posting(self) -> None:

     

       223
       223
       +
               """Test that debug mode posts DMs instead of stream messages."""

     

       224
       224
       +
               from unittest.mock import Mock

     

       225
       225
       +
       

     

       226
       226
       +
               # Setup bot in debug mode

     

       227
       227
       +
               self.bot.debug_user = "testuser"

     

       228
       228
       +
               self.bot.debug_zulip_user_id = "test.user@example.com"

     

       229
       229
       +
               self.bot.git_store = Mock()

     

       230
       230
       +
       

     

       231
       231
       +
               # Create a test entry

     

       232
       232
       +
               entry = create_test_entry()

     

       233
       233
       +
       

     

       234
       234
       +
               # Mock the handler config

     

       235
       235
       +
               self.handler.config_info = {

     

       236
       236
       +
                   "full_name": "Thicket Bot",

     

       237
       237
       +
                   "email": "thicket-bot@example.com",

     

       238
       238
       +
                   "site": "https://example.zulipchat.com",

     

       239
       239
       +
               }

     

       240
       240
       +
       

     

       241
       241
       +
               # Mock git store user

     

       242
       242
       +
               mock_user = Mock()

     

       243
       243
       +
               mock_user.get_zulip_mention.return_value = "author.user"

     

       244
       244
       +
               self.bot.git_store.get_user.return_value = mock_user

     

       245
       245
       +
       

     

       246
       246
       +
               # Post entry

     

       247
       247
       +
               self.bot._post_entry_to_zulip(entry, self.handler, "testauthor")

     

       248
       248
       +
       

     

       249
       249
       +
               # Check that a DM was sent

     

       250
       250
       +
               assert len(self.handler.sent_messages) == 1

     

       251
       251
       +
               message = self.handler.sent_messages[0]

     

       252
       252
       +
       

     

       253
       253
       +
               # Verify it's a DM

     

       254
       254
       +
               assert message["type"] == "private"

     

       255
       255
       +
               assert message["to"] == ["test.user@example.com"]

     

       256
       256
       +
               assert "DEBUG:" in message["content"]

     

       257
       257
       +
               assert entry.title in message["content"]

     

       258
       258
       +
               assert "@**author.user** posted:" in message["content"]

     

       259
       259
       +
       

     

       260
       260
       +
       

     

       261
       261
       +
       class TestBotTester:

     

       262
       262
       +
           """Test the bot testing utilities."""

     

       263
       263
       +
       

     

       264
       264
       +
           def test_bot_tester_basic(self) -> None:

     

       265
       265
       +
               """Test basic bot tester functionality."""

     

       266
       266
       +
               tester = BotTester()

     

       267
       267
       +
       

     

       268
       268
       +
               # Test help command

     

       269
       269
       +
               responses = tester.send_command("help")

     

       270
       270
       +
               assert len(responses) == 1

     

       271
       271
       +
               assert "Thicket Feed Bot" in tester.get_last_response_content()

     

       272
       272
       +
       

     

       273
       273
       +
           def test_bot_tester_config(self) -> None:

     

       274
       274
       +
               """Test bot tester configuration."""

     

       275
       275
       +
               tester = BotTester()

     

       276
       276
       +
       

     

       277
       277
       +
               # Configure stream

     

       278
       278
       +
               tester.send_command("config stream general")

     

       279
       279
       +
               tester.assert_response_contains("Stream set to")

     

       280
       280
       +
       

     

       281
       281
       +
               # Configure topic

     

       282
       282
       +
               tester.send_command("config topic test")

     

       283
       283
       +
               tester.assert_response_contains("Topic set to")

     

       284
       284
       +
       

     

       285
       285
       +
           def test_assert_response_contains(self) -> None:

     

       286
       286
       +
               """Test response assertion helper."""

     

       287
       287
       +
               tester = BotTester()

     

       288
       288
       +
       

     

       289
       289
       +
               # Send command

     

       290
       290
       +
               tester.send_command("help")

     

       291
       291
       +
       

     

       292
       292
       +
               # This should pass

     

       293
       293
       +
               tester.assert_response_contains("Thicket Feed Bot")

     

       294
       294
       +
       

     

       295
       295
       +
               # This should fail

     

       296
       296
       +
               with pytest.raises(AssertionError):

     

       297
       297
       +
                   tester.assert_response_contains("nonexistent text")

+2 -1

tests/test_feed_parser.py

···

       100
       100
        
               html_with_attrs = '<a href="https://example.com" onclick="alert()">Link</a>'

     

       101
       101
        
               sanitized = parser._sanitize_html(html_with_attrs)

     

       102
       102
        
               assert 'href="https://example.com"' in sanitized

     

       103
       103
       -
               assert 'onclick' not in sanitized

     

       103
       103
       +
               assert "onclick" not in sanitized

     

       104
       104
        
       

     

       105
       105
        
           def test_extract_feed_metadata(self):

     

       106
       106
        
               """Test feed metadata extraction."""

     
···

       108
       108
        
       

     

       109
       109
        
               # Test with feedparser parsed data

     

       110
       110
        
               import feedparser

     

       111
       111
       +
       

     

       111
       112
        
               parsed = feedparser.parse("""<?xml version="1.0" encoding="utf-8"?>

     

       112
       113
        
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       113
       114
        
         <title>Test Feed</title>

+7 -2

tests/test_git_store.py

···

       191
       191
        
               duplicates = store.get_duplicates()

     

       192
       192
        
               assert len(duplicates.duplicates) == 1

     

       193
       193
        
               assert duplicates.is_duplicate("https://example.com/dup")

     

       194
       194
       -
               assert duplicates.get_canonical("https://example.com/dup") == "https://example.com/canonical"

     

       194
       194
       +
               assert (

     

       195
       195
       +
                   duplicates.get_canonical("https://example.com/dup")

     

       196
       196
       +
                   == "https://example.com/canonical"

     

       197
       197
       +
               )

     

       195
       198
        
       

     

       196
       199
        
               # Remove duplicate

     

       197
       200
        
               result = store.remove_duplicate("https://example.com/dup")

     
···

       220
       223
        
                   entry = AtomEntry(

     

       221
       224
        
                       id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",

     

       222
       225
        
                       title=title,

     

       223
       223
       -
                       link=HttpUrl(f"https://example.com/entry/{title.lower().replace(' ', '-')}"),

     

       226
       226
       +
                       link=HttpUrl(

     

       227
       227
       +
                           f"https://example.com/entry/{title.lower().replace(' ', '-')}"

     

       228
       228
       +
                       ),

     

       224
       229
        
                       updated=datetime.now(),

     

       225
       230
        
                       summary=summary,

     

       226
       231
        
                   )

+88 -4

tests/test_models.py

···

       12
       12
        
           ThicketConfig,

     

       13
       13
        
           UserConfig,

     

       14
       14
        
           UserMetadata,

     

       15
       15
       +
           ZulipAssociation,

     

       15
       16
        
       )

     

       16
       17
        
       

     

       17
       18
        
       

     
···

       126
       127
        
                   git_store=temp_dir / "git_store",

     

       127
       128
        
                   cache_dir=temp_dir / "cache",

     

       128
       129
        
                   users=[

     

       129
       129
       -
                       UserConfig(username="testuser", feeds=["https://example.com/feed1.xml"]),

     

       130
       130
       +
                       UserConfig(

     

       131
       131
       +
                           username="testuser", feeds=["https://example.com/feed1.xml"]

     

       132
       132
       +
                       ),

     

       130
       133
        
                   ],

     

       131
       134
        
               )

     

       132
       135
        
       

     

       133
       133
       -
               result = config.add_feed_to_user("testuser", HttpUrl("https://example.com/feed2.xml"))

     

       136
       136
       +
               result = config.add_feed_to_user(

     

       137
       137
       +
                   "testuser", HttpUrl("https://example.com/feed2.xml")

     

       138
       138
       +
               )

     

       134
       139
        
               assert result is True

     

       135
       140
        
       

     

       136
       141
        
               user = config.find_user("testuser")

     
···

       138
       143
        
               assert HttpUrl("https://example.com/feed2.xml") in user.feeds

     

       139
       144
        
       

     

       140
       145
        
               # Test adding to non-existent user

     

       141
       141
       -
               result = config.add_feed_to_user("nonexistent", HttpUrl("https://example.com/feed.xml"))

     

       146
       146
       +
               result = config.add_feed_to_user(

     

       147
       147
       +
                   "nonexistent", HttpUrl("https://example.com/feed.xml")

     

       148
       148
       +
               )

     

       142
       149
        
               assert result is False

     

       143
       150
        
       

     

       144
       151
        
       

     
···

       293
       300
        
               user_config = metadata.to_user_config("testuser", feed_url)

     

       294
       301
        
       

     

       295
       302
        
               assert user_config.display_name == "Test Feed"  # Falls back to title

     

       296
       296
       -
               assert user_config.homepage == HttpUrl("https://example.com")  # Falls back to link

     

       303
       303
       +
               assert user_config.homepage == HttpUrl(

     

       304
       304
       +
                   "https://example.com"

     

       305
       305
       +
               )  # Falls back to link

     

       297
       306
        
               assert user_config.icon == HttpUrl("https://example.com/icon.png")

     

       298
       307
        
               assert user_config.email is None

     

       299
       308
        
       

     
···

       350
       359
        
       

     

       351
       360
        
               assert metadata.entry_count == original_count + 3

     

       352
       361
        
               assert metadata.last_updated > original_time

     

       362
       362
       +
       

     

       363
       363
       +
           def test_zulip_associations(self):

     

       364
       364
       +
               """Test Zulip association methods."""

     

       365
       365
       +
               metadata = UserMetadata(

     

       366
       366
       +
                   username="testuser",

     

       367
       367
       +
                   directory="testuser",

     

       368
       368
       +
                   created=datetime.now(),

     

       369
       369
       +
                   last_updated=datetime.now(),

     

       370
       370
       +
               )

     

       371
       371
       +
       

     

       372
       372
       +
               # Test adding association

     

       373
       373
       +
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       374
       374
       +
               assert result is True

     

       375
       375
       +
               assert len(metadata.zulip_associations) == 1

     

       376
       376
       +
               assert metadata.zulip_associations[0].server == "example.zulipchat.com"

     

       377
       377
       +
               assert metadata.zulip_associations[0].user_id == "alice"

     

       378
       378
       +
       

     

       379
       379
       +
               # Test adding duplicate association

     

       380
       380
       +
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       381
       381
       +
               assert result is False

     

       382
       382
       +
               assert len(metadata.zulip_associations) == 1

     

       383
       383
       +
       

     

       384
       384
       +
               # Test adding different association

     

       385
       385
       +
               result = metadata.add_zulip_association("other.zulipchat.com", "alice")

     

       386
       386
       +
               assert result is True

     

       387
       387
       +
               assert len(metadata.zulip_associations) == 2

     

       388
       388
       +
       

     

       389
       389
       +
               # Test get_zulip_mention

     

       390
       390
       +
               mention = metadata.get_zulip_mention("example.zulipchat.com")

     

       391
       391
       +
               assert mention == "alice"

     

       392
       392
       +
       

     

       393
       393
       +
               mention = metadata.get_zulip_mention("other.zulipchat.com")

     

       394
       394
       +
               assert mention == "alice"

     

       395
       395
       +
       

     

       396
       396
       +
               mention = metadata.get_zulip_mention("nonexistent.zulipchat.com")

     

       397
       397
       +
               assert mention is None

     

       398
       398
       +
       

     

       399
       399
       +
               # Test removing association

     

       400
       400
       +
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       401
       401
       +
               assert result is True

     

       402
       402
       +
               assert len(metadata.zulip_associations) == 1

     

       403
       403
       +
       

     

       404
       404
       +
               # Test removing non-existent association

     

       405
       405
       +
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       406
       406
       +
               assert result is False

     

       407
       407
       +
               assert len(metadata.zulip_associations) == 1

     

       408
       408
       +
       

     

       409
       409
       +
       

     

       410
       410
       +
       class TestZulipAssociation:

     

       411
       411
       +
           """Test ZulipAssociation model."""

     

       412
       412
       +
       

     

       413
       413
       +
           def test_valid_association(self):

     

       414
       414
       +
               """Test creating valid Zulip association."""

     

       415
       415
       +
               assoc = ZulipAssociation(

     

       416
       416
       +
                   server="example.zulipchat.com", user_id="alice@example.com"

     

       417
       417
       +
               )

     

       418
       418
       +
       

     

       419
       419
       +
               assert assoc.server == "example.zulipchat.com"

     

       420
       420
       +
               assert assoc.user_id == "alice@example.com"

     

       421
       421
       +
       

     

       422
       422
       +
           def test_association_hash(self):

     

       423
       423
       +
               """Test that associations are hashable."""

     

       424
       424
       +
               assoc1 = ZulipAssociation(server="example.zulipchat.com", user_id="alice")

     

       425
       425
       +
               assoc2 = ZulipAssociation(server="example.zulipchat.com", user_id="alice")

     

       426
       426
       +
               assoc3 = ZulipAssociation(server="other.zulipchat.com", user_id="alice")

     

       427
       427
       +
       

     

       428
       428
       +
               # Same associations should have same hash

     

       429
       429
       +
               assert hash(assoc1) == hash(assoc2)

     

       430
       430
       +
       

     

       431
       431
       +
               # Different associations should have different hash

     

       432
       432
       +
               assert hash(assoc1) != hash(assoc3)

     

       433
       433
       +
       

     

       434
       434
       +
               # Can be used in sets

     

       435
       435
       +
               assoc_set = {assoc1, assoc2, assoc3}

     

       436
       436
       +
               assert len(assoc_set) == 2  # assoc1 and assoc2 are considered the same

+345 -1

uv.lock

···

       1
       1
        
       version = 1

     

       2
       2
       -
       revision = 2

     

       2
       2
       +
       revision = 3

     

       3
       3
        
       requires-python = ">=3.9"

     

       4
       4
        
       resolution-markers = [

     

       5
       5
        
           "python_full_version >= '3.10'",

     
···

       28
       28
        
       sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }

     

       29
       29
        
       wheels = [

     

       30
       30
        
           { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },

     

       31
       31
       +
       ]

     

       32
       32
       +
       

     

       33
       33
       +
       [[package]]

     

       34
       34
       +
       name = "beautifulsoup4"

     

       35
       35
       +
       version = "4.13.4"

     

       36
       36
       +
       source = { registry = "https://pypi.org/simple" }

     

       37
       37
       +
       dependencies = [

     

       38
       38
       +
           { name = "soupsieve" },

     

       39
       39
       +
           { name = "typing-extensions" },

     

       40
       40
       +
       ]

     

       41
       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
       42
       +
       wheels = [

     

       43
       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" },

     

       31
       44
        
       ]

     

       32
       45
        
       

     

       33
       46
        
       [[package]]

     
···

       91
       104
        
       ]

     

       92
       105
        
       

     

       93
       106
        
       [[package]]

     

       107
       107
       +
       name = "charset-normalizer"

     

       108
       108
       +
       version = "3.4.3"

     

       109
       109
       +
       source = { registry = "https://pypi.org/simple" }

     

       110
       110
       +
       sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371, upload-time = "2025-08-09T07:57:28.46Z" }

     

       111
       111
       +
       wheels = [

     

       112
       112
       +
           { url = "https://files.pythonhosted.org/packages/d6/98/f3b8013223728a99b908c9344da3aa04ee6e3fa235f19409033eda92fb78/charset_normalizer-3.4.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fb7f67a1bfa6e40b438170ebdc8158b78dc465a5a67b6dde178a46987b244a72", size = 207695, upload-time = "2025-08-09T07:55:36.452Z" },

     

       113
       113
       +
           { url = "https://files.pythonhosted.org/packages/21/40/5188be1e3118c82dcb7c2a5ba101b783822cfb413a0268ed3be0468532de/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc9370a2da1ac13f0153780040f465839e6cccb4a1e44810124b4e22483c93fe", size = 147153, upload-time = "2025-08-09T07:55:38.467Z" },

     

       114
       114
       +
           { url = "https://files.pythonhosted.org/packages/37/60/5d0d74bc1e1380f0b72c327948d9c2aca14b46a9efd87604e724260f384c/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:07a0eae9e2787b586e129fdcbe1af6997f8d0e5abaa0bc98c0e20e124d67e601", size = 160428, upload-time = "2025-08-09T07:55:40.072Z" },

     

       115
       115
       +
           { url = "https://files.pythonhosted.org/packages/85/9a/d891f63722d9158688de58d050c59dc3da560ea7f04f4c53e769de5140f5/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:74d77e25adda8581ffc1c720f1c81ca082921329452eba58b16233ab1842141c", size = 157627, upload-time = "2025-08-09T07:55:41.706Z" },

     

       116
       116
       +
           { url = "https://files.pythonhosted.org/packages/65/1a/7425c952944a6521a9cfa7e675343f83fd82085b8af2b1373a2409c683dc/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0e909868420b7049dafd3a31d45125b31143eec59235311fc4c57ea26a4acd2", size = 152388, upload-time = "2025-08-09T07:55:43.262Z" },

     

       117
       117
       +
           { url = "https://files.pythonhosted.org/packages/f0/c9/a2c9c2a355a8594ce2446085e2ec97fd44d323c684ff32042e2a6b718e1d/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c6f162aabe9a91a309510d74eeb6507fab5fff92337a15acbe77753d88d9dcf0", size = 150077, upload-time = "2025-08-09T07:55:44.903Z" },

     

       118
       118
       +
           { url = "https://files.pythonhosted.org/packages/3b/38/20a1f44e4851aa1c9105d6e7110c9d020e093dfa5836d712a5f074a12bf7/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca4c094de7771a98d7fbd67d9e5dbf1eb73efa4f744a730437d8a3a5cf994f0", size = 161631, upload-time = "2025-08-09T07:55:46.346Z" },

     

       119
       119
       +
           { url = "https://files.pythonhosted.org/packages/a4/fa/384d2c0f57edad03d7bec3ebefb462090d8905b4ff5a2d2525f3bb711fac/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:02425242e96bcf29a49711b0ca9f37e451da7c70562bc10e8ed992a5a7a25cc0", size = 159210, upload-time = "2025-08-09T07:55:47.539Z" },

     

       120
       120
       +
           { url = "https://files.pythonhosted.org/packages/33/9e/eca49d35867ca2db336b6ca27617deed4653b97ebf45dfc21311ce473c37/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:78deba4d8f9590fe4dae384aeff04082510a709957e968753ff3c48399f6f92a", size = 153739, upload-time = "2025-08-09T07:55:48.744Z" },

     

       121
       121
       +
           { url = "https://files.pythonhosted.org/packages/2a/91/26c3036e62dfe8de8061182d33be5025e2424002125c9500faff74a6735e/charset_normalizer-3.4.3-cp310-cp310-win32.whl", hash = "sha256:d79c198e27580c8e958906f803e63cddb77653731be08851c7df0b1a14a8fc0f", size = 99825, upload-time = "2025-08-09T07:55:50.305Z" },

     

       122
       122
       +
           { url = "https://files.pythonhosted.org/packages/e2/c6/f05db471f81af1fa01839d44ae2a8bfeec8d2a8b4590f16c4e7393afd323/charset_normalizer-3.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:c6e490913a46fa054e03699c70019ab869e990270597018cef1d8562132c2669", size = 107452, upload-time = "2025-08-09T07:55:51.461Z" },

     

       123
       123
       +
           { url = "https://files.pythonhosted.org/packages/7f/b5/991245018615474a60965a7c9cd2b4efbaabd16d582a5547c47ee1c7730b/charset_normalizer-3.4.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b256ee2e749283ef3ddcff51a675ff43798d92d746d1a6e4631bf8c707d22d0b", size = 204483, upload-time = "2025-08-09T07:55:53.12Z" },

     

       124
       124
       +
           { url = "https://files.pythonhosted.org/packages/c7/2a/ae245c41c06299ec18262825c1569c5d3298fc920e4ddf56ab011b417efd/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13faeacfe61784e2559e690fc53fa4c5ae97c6fcedb8eb6fb8d0a15b475d2c64", size = 145520, upload-time = "2025-08-09T07:55:54.712Z" },

     

       125
       125
       +
           { url = "https://files.pythonhosted.org/packages/3a/a4/b3b6c76e7a635748c4421d2b92c7b8f90a432f98bda5082049af37ffc8e3/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:00237675befef519d9af72169d8604a067d92755e84fe76492fef5441db05b91", size = 158876, upload-time = "2025-08-09T07:55:56.024Z" },

     

       126
       126
       +
           { url = "https://files.pythonhosted.org/packages/e2/e6/63bb0e10f90a8243c5def74b5b105b3bbbfb3e7bb753915fe333fb0c11ea/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:585f3b2a80fbd26b048a0be90c5aae8f06605d3c92615911c3a2b03a8a3b796f", size = 156083, upload-time = "2025-08-09T07:55:57.582Z" },

     

       127
       127
       +
           { url = "https://files.pythonhosted.org/packages/87/df/b7737ff046c974b183ea9aa111b74185ac8c3a326c6262d413bd5a1b8c69/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e78314bdc32fa80696f72fa16dc61168fda4d6a0c014e0380f9d02f0e5d8a07", size = 150295, upload-time = "2025-08-09T07:55:59.147Z" },

     

       128
       128
       +
           { url = "https://files.pythonhosted.org/packages/61/f1/190d9977e0084d3f1dc169acd060d479bbbc71b90bf3e7bf7b9927dec3eb/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:96b2b3d1a83ad55310de8c7b4a2d04d9277d5591f40761274856635acc5fcb30", size = 148379, upload-time = "2025-08-09T07:56:00.364Z" },

     

       129
       129
       +
           { url = "https://files.pythonhosted.org/packages/4c/92/27dbe365d34c68cfe0ca76f1edd70e8705d82b378cb54ebbaeabc2e3029d/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:939578d9d8fd4299220161fdd76e86c6a251987476f5243e8864a7844476ba14", size = 160018, upload-time = "2025-08-09T07:56:01.678Z" },

     

       130
       130
       +
           { url = "https://files.pythonhosted.org/packages/99/04/baae2a1ea1893a01635d475b9261c889a18fd48393634b6270827869fa34/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:fd10de089bcdcd1be95a2f73dbe6254798ec1bda9f450d5828c96f93e2536b9c", size = 157430, upload-time = "2025-08-09T07:56:02.87Z" },

     

       131
       131
       +
           { url = "https://files.pythonhosted.org/packages/2f/36/77da9c6a328c54d17b960c89eccacfab8271fdaaa228305330915b88afa9/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1e8ac75d72fa3775e0b7cb7e4629cec13b7514d928d15ef8ea06bca03ef01cae", size = 151600, upload-time = "2025-08-09T07:56:04.089Z" },

     

       132
       132
       +
           { url = "https://files.pythonhosted.org/packages/64/d4/9eb4ff2c167edbbf08cdd28e19078bf195762e9bd63371689cab5ecd3d0d/charset_normalizer-3.4.3-cp311-cp311-win32.whl", hash = "sha256:6cf8fd4c04756b6b60146d98cd8a77d0cdae0e1ca20329da2ac85eed779b6849", size = 99616, upload-time = "2025-08-09T07:56:05.658Z" },

     

       133
       133
       +
           { url = "https://files.pythonhosted.org/packages/f4/9c/996a4a028222e7761a96634d1820de8a744ff4327a00ada9c8942033089b/charset_normalizer-3.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:31a9a6f775f9bcd865d88ee350f0ffb0e25936a7f930ca98995c05abf1faf21c", size = 107108, upload-time = "2025-08-09T07:56:07.176Z" },

     

       134
       134
       +
           { url = "https://files.pythonhosted.org/packages/e9/5e/14c94999e418d9b87682734589404a25854d5f5d0408df68bc15b6ff54bb/charset_normalizer-3.4.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e28e334d3ff134e88989d90ba04b47d84382a828c061d0d1027b1b12a62b39b1", size = 205655, upload-time = "2025-08-09T07:56:08.475Z" },

     

       135
       135
       +
           { url = "https://files.pythonhosted.org/packages/7d/a8/c6ec5d389672521f644505a257f50544c074cf5fc292d5390331cd6fc9c3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0cacf8f7297b0c4fcb74227692ca46b4a5852f8f4f24b3c766dd94a1075c4884", size = 146223, upload-time = "2025-08-09T07:56:09.708Z" },

     

       136
       136
       +
           { url = "https://files.pythonhosted.org/packages/fc/eb/a2ffb08547f4e1e5415fb69eb7db25932c52a52bed371429648db4d84fb1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c6fd51128a41297f5409deab284fecbe5305ebd7e5a1f959bee1c054622b7018", size = 159366, upload-time = "2025-08-09T07:56:11.326Z" },

     

       137
       137
       +
           { url = "https://files.pythonhosted.org/packages/82/10/0fd19f20c624b278dddaf83b8464dcddc2456cb4b02bb902a6da126b87a1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cfb2aad70f2c6debfbcb717f23b7eb55febc0bb23dcffc0f076009da10c6392", size = 157104, upload-time = "2025-08-09T07:56:13.014Z" },

     

       138
       138
       +
           { url = "https://files.pythonhosted.org/packages/16/ab/0233c3231af734f5dfcf0844aa9582d5a1466c985bbed6cedab85af9bfe3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1606f4a55c0fd363d754049cdf400175ee96c992b1f8018b993941f221221c5f", size = 151830, upload-time = "2025-08-09T07:56:14.428Z" },

     

       139
       139
       +
           { url = "https://files.pythonhosted.org/packages/ae/02/e29e22b4e02839a0e4a06557b1999d0a47db3567e82989b5bb21f3fbbd9f/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:027b776c26d38b7f15b26a5da1044f376455fb3766df8fc38563b4efbc515154", size = 148854, upload-time = "2025-08-09T07:56:16.051Z" },

     

       140
       140
       +
           { url = "https://files.pythonhosted.org/packages/05/6b/e2539a0a4be302b481e8cafb5af8792da8093b486885a1ae4d15d452bcec/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:42e5088973e56e31e4fa58eb6bd709e42fc03799c11c42929592889a2e54c491", size = 160670, upload-time = "2025-08-09T07:56:17.314Z" },

     

       141
       141
       +
           { url = "https://files.pythonhosted.org/packages/31/e7/883ee5676a2ef217a40ce0bffcc3d0dfbf9e64cbcfbdf822c52981c3304b/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cc34f233c9e71701040d772aa7490318673aa7164a0efe3172b2981218c26d93", size = 158501, upload-time = "2025-08-09T07:56:18.641Z" },

     

       142
       142
       +
           { url = "https://files.pythonhosted.org/packages/c1/35/6525b21aa0db614cf8b5792d232021dca3df7f90a1944db934efa5d20bb1/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320e8e66157cc4e247d9ddca8e21f427efc7a04bbd0ac8a9faf56583fa543f9f", size = 153173, upload-time = "2025-08-09T07:56:20.289Z" },

     

       143
       143
       +
           { url = "https://files.pythonhosted.org/packages/50/ee/f4704bad8201de513fdc8aac1cabc87e38c5818c93857140e06e772b5892/charset_normalizer-3.4.3-cp312-cp312-win32.whl", hash = "sha256:fb6fecfd65564f208cbf0fba07f107fb661bcd1a7c389edbced3f7a493f70e37", size = 99822, upload-time = "2025-08-09T07:56:21.551Z" },

     

       144
       144
       +
           { url = "https://files.pythonhosted.org/packages/39/f5/3b3836ca6064d0992c58c7561c6b6eee1b3892e9665d650c803bd5614522/charset_normalizer-3.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:86df271bf921c2ee3818f0522e9a5b8092ca2ad8b065ece5d7d9d0e9f4849bcc", size = 107543, upload-time = "2025-08-09T07:56:23.115Z" },

     

       145
       145
       +
           { url = "https://files.pythonhosted.org/packages/65/ca/2135ac97709b400c7654b4b764daf5c5567c2da45a30cdd20f9eefe2d658/charset_normalizer-3.4.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:14c2a87c65b351109f6abfc424cab3927b3bdece6f706e4d12faaf3d52ee5efe", size = 205326, upload-time = "2025-08-09T07:56:24.721Z" },

     

       146
       146
       +
           { url = "https://files.pythonhosted.org/packages/71/11/98a04c3c97dd34e49c7d247083af03645ca3730809a5509443f3c37f7c99/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41d1fc408ff5fdfb910200ec0e74abc40387bccb3252f3f27c0676731df2b2c8", size = 146008, upload-time = "2025-08-09T07:56:26.004Z" },

     

       147
       147
       +
           { url = "https://files.pythonhosted.org/packages/60/f5/4659a4cb3c4ec146bec80c32d8bb16033752574c20b1252ee842a95d1a1e/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1bb60174149316da1c35fa5233681f7c0f9f514509b8e399ab70fea5f17e45c9", size = 159196, upload-time = "2025-08-09T07:56:27.25Z" },

     

       148
       148
       +
           { url = "https://files.pythonhosted.org/packages/86/9e/f552f7a00611f168b9a5865a1414179b2c6de8235a4fa40189f6f79a1753/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30d006f98569de3459c2fc1f2acde170b7b2bd265dc1943e87e1a4efe1b67c31", size = 156819, upload-time = "2025-08-09T07:56:28.515Z" },

     

       149
       149
       +
           { url = "https://files.pythonhosted.org/packages/7e/95/42aa2156235cbc8fa61208aded06ef46111c4d3f0de233107b3f38631803/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:416175faf02e4b0810f1f38bcb54682878a4af94059a1cd63b8747244420801f", size = 151350, upload-time = "2025-08-09T07:56:29.716Z" },

     

       150
       150
       +
           { url = "https://files.pythonhosted.org/packages/c2/a9/3865b02c56f300a6f94fc631ef54f0a8a29da74fb45a773dfd3dcd380af7/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6aab0f181c486f973bc7262a97f5aca3ee7e1437011ef0c2ec04b5a11d16c927", size = 148644, upload-time = "2025-08-09T07:56:30.984Z" },

     

       151
       151
       +
           { url = "https://files.pythonhosted.org/packages/77/d9/cbcf1a2a5c7d7856f11e7ac2d782aec12bdfea60d104e60e0aa1c97849dc/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabf8315679312cfa71302f9bd509ded4f2f263fb5b765cf1433b39106c3cc9", size = 160468, upload-time = "2025-08-09T07:56:32.252Z" },

     

       152
       152
       +
           { url = "https://files.pythonhosted.org/packages/f6/42/6f45efee8697b89fda4d50580f292b8f7f9306cb2971d4b53f8914e4d890/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:bd28b817ea8c70215401f657edef3a8aa83c29d447fb0b622c35403780ba11d5", size = 158187, upload-time = "2025-08-09T07:56:33.481Z" },

     

       153
       153
       +
           { url = "https://files.pythonhosted.org/packages/70/99/f1c3bdcfaa9c45b3ce96f70b14f070411366fa19549c1d4832c935d8e2c3/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18343b2d246dc6761a249ba1fb13f9ee9a2bcd95decc767319506056ea4ad4dc", size = 152699, upload-time = "2025-08-09T07:56:34.739Z" },

     

       154
       154
       +
           { url = "https://files.pythonhosted.org/packages/a3/ad/b0081f2f99a4b194bcbb1934ef3b12aa4d9702ced80a37026b7607c72e58/charset_normalizer-3.4.3-cp313-cp313-win32.whl", hash = "sha256:6fb70de56f1859a3f71261cbe41005f56a7842cc348d3aeb26237560bfa5e0ce", size = 99580, upload-time = "2025-08-09T07:56:35.981Z" },

     

       155
       155
       +
           { url = "https://files.pythonhosted.org/packages/9a/8f/ae790790c7b64f925e5c953b924aaa42a243fb778fed9e41f147b2a5715a/charset_normalizer-3.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:cf1ebb7d78e1ad8ec2a8c4732c7be2e736f6e5123a4146c5b89c9d1f585f8cef", size = 107366, upload-time = "2025-08-09T07:56:37.339Z" },

     

       156
       156
       +
           { url = "https://files.pythonhosted.org/packages/8e/91/b5a06ad970ddc7a0e513112d40113e834638f4ca1120eb727a249fb2715e/charset_normalizer-3.4.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3cd35b7e8aedeb9e34c41385fda4f73ba609e561faedfae0a9e75e44ac558a15", size = 204342, upload-time = "2025-08-09T07:56:38.687Z" },

     

       157
       157
       +
           { url = "https://files.pythonhosted.org/packages/ce/ec/1edc30a377f0a02689342f214455c3f6c2fbedd896a1d2f856c002fc3062/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b89bc04de1d83006373429975f8ef9e7932534b8cc9ca582e4db7d20d91816db", size = 145995, upload-time = "2025-08-09T07:56:40.048Z" },

     

       158
       158
       +
           { url = "https://files.pythonhosted.org/packages/17/e5/5e67ab85e6d22b04641acb5399c8684f4d37caf7558a53859f0283a650e9/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2001a39612b241dae17b4687898843f254f8748b796a2e16f1051a17078d991d", size = 158640, upload-time = "2025-08-09T07:56:41.311Z" },

     

       159
       159
       +
           { url = "https://files.pythonhosted.org/packages/f1/e5/38421987f6c697ee3722981289d554957c4be652f963d71c5e46a262e135/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8dcfc373f888e4fb39a7bc57e93e3b845e7f462dacc008d9749568b1c4ece096", size = 156636, upload-time = "2025-08-09T07:56:43.195Z" },

     

       160
       160
       +
           { url = "https://files.pythonhosted.org/packages/a0/e4/5a075de8daa3ec0745a9a3b54467e0c2967daaaf2cec04c845f73493e9a1/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b97b8404387b96cdbd30ad660f6407799126d26a39ca65729162fd810a99aa", size = 150939, upload-time = "2025-08-09T07:56:44.819Z" },

     

       161
       161
       +
           { url = "https://files.pythonhosted.org/packages/02/f7/3611b32318b30974131db62b4043f335861d4d9b49adc6d57c1149cc49d4/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ccf600859c183d70eb47e05a44cd80a4ce77394d1ac0f79dbd2dd90a69a3a049", size = 148580, upload-time = "2025-08-09T07:56:46.684Z" },

     

       162
       162
       +
           { url = "https://files.pythonhosted.org/packages/7e/61/19b36f4bd67f2793ab6a99b979b4e4f3d8fc754cbdffb805335df4337126/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:53cd68b185d98dde4ad8990e56a58dea83a4162161b1ea9272e5c9182ce415e0", size = 159870, upload-time = "2025-08-09T07:56:47.941Z" },

     

       163
       163
       +
           { url = "https://files.pythonhosted.org/packages/06/57/84722eefdd338c04cf3030ada66889298eaedf3e7a30a624201e0cbe424a/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:30a96e1e1f865f78b030d65241c1ee850cdf422d869e9028e2fc1d5e4db73b92", size = 157797, upload-time = "2025-08-09T07:56:49.756Z" },

     

       164
       164
       +
           { url = "https://files.pythonhosted.org/packages/72/2a/aff5dd112b2f14bcc3462c312dce5445806bfc8ab3a7328555da95330e4b/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d716a916938e03231e86e43782ca7878fb602a125a91e7acb8b5112e2e96ac16", size = 152224, upload-time = "2025-08-09T07:56:51.369Z" },

     

       165
       165
       +
           { url = "https://files.pythonhosted.org/packages/b7/8c/9839225320046ed279c6e839d51f028342eb77c91c89b8ef2549f951f3ec/charset_normalizer-3.4.3-cp314-cp314-win32.whl", hash = "sha256:c6dbd0ccdda3a2ba7c2ecd9d77b37f3b5831687d8dc1b6ca5f56a4880cc7b7ce", size = 100086, upload-time = "2025-08-09T07:56:52.722Z" },

     

       166
       166
       +
           { url = "https://files.pythonhosted.org/packages/ee/7a/36fbcf646e41f710ce0a563c1c9a343c6edf9be80786edeb15b6f62e17db/charset_normalizer-3.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:73dc19b562516fc9bcf6e5d6e596df0b4eb98d87e4f79f3ae71840e6ed21361c", size = 107400, upload-time = "2025-08-09T07:56:55.172Z" },

     

       167
       167
       +
           { url = "https://files.pythonhosted.org/packages/c2/ca/9a0983dd5c8e9733565cf3db4df2b0a2e9a82659fd8aa2a868ac6e4a991f/charset_normalizer-3.4.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:70bfc5f2c318afece2f5838ea5e4c3febada0be750fcf4775641052bbba14d05", size = 207520, upload-time = "2025-08-09T07:57:11.026Z" },

     

       168
       168
       +
           { url = "https://files.pythonhosted.org/packages/39/c6/99271dc37243a4f925b09090493fb96c9333d7992c6187f5cfe5312008d2/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23b6b24d74478dc833444cbd927c338349d6ae852ba53a0d02a2de1fce45b96e", size = 147307, upload-time = "2025-08-09T07:57:12.4Z" },

     

       169
       169
       +
           { url = "https://files.pythonhosted.org/packages/e4/69/132eab043356bba06eb333cc2cc60c6340857d0a2e4ca6dc2b51312886b3/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:34a7f768e3f985abdb42841e20e17b330ad3aaf4bb7e7aeeb73db2e70f077b99", size = 160448, upload-time = "2025-08-09T07:57:13.712Z" },

     

       170
       170
       +
           { url = "https://files.pythonhosted.org/packages/04/9a/914d294daa4809c57667b77470533e65def9c0be1ef8b4c1183a99170e9d/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb731e5deb0c7ef82d698b0f4c5bb724633ee2a489401594c5c88b02e6cb15f7", size = 157758, upload-time = "2025-08-09T07:57:14.979Z" },

     

       171
       171
       +
           { url = "https://files.pythonhosted.org/packages/b0/a8/6f5bcf1bcf63cb45625f7c5cadca026121ff8a6c8a3256d8d8cd59302663/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:257f26fed7d7ff59921b78244f3cd93ed2af1800ff048c33f624c87475819dd7", size = 152487, upload-time = "2025-08-09T07:57:16.332Z" },

     

       172
       172
       +
           { url = "https://files.pythonhosted.org/packages/c4/72/d3d0e9592f4e504f9dea08b8db270821c909558c353dc3b457ed2509f2fb/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1ef99f0456d3d46a50945c98de1774da86f8e992ab5c77865ea8b8195341fc19", size = 150054, upload-time = "2025-08-09T07:57:17.576Z" },

     

       173
       173
       +
           { url = "https://files.pythonhosted.org/packages/20/30/5f64fe3981677fe63fa987b80e6c01042eb5ff653ff7cec1b7bd9268e54e/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:2c322db9c8c89009a990ef07c3bcc9f011a3269bc06782f916cd3d9eed7c9312", size = 161703, upload-time = "2025-08-09T07:57:20.012Z" },

     

       174
       174
       +
           { url = "https://files.pythonhosted.org/packages/e1/ef/dd08b2cac9284fd59e70f7d97382c33a3d0a926e45b15fc21b3308324ffd/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:511729f456829ef86ac41ca78c63a5cb55240ed23b4b737faca0eb1abb1c41bc", size = 159096, upload-time = "2025-08-09T07:57:21.329Z" },

     

       175
       175
       +
           { url = "https://files.pythonhosted.org/packages/45/8c/dcef87cfc2b3f002a6478f38906f9040302c68aebe21468090e39cde1445/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:88ab34806dea0671532d3f82d82b85e8fc23d7b2dd12fa837978dad9bb392a34", size = 153852, upload-time = "2025-08-09T07:57:22.608Z" },

     

       176
       176
       +
           { url = "https://files.pythonhosted.org/packages/63/86/9cbd533bd37883d467fcd1bd491b3547a3532d0fbb46de2b99feeebf185e/charset_normalizer-3.4.3-cp39-cp39-win32.whl", hash = "sha256:16a8770207946ac75703458e2c743631c79c59c5890c80011d536248f8eaa432", size = 99840, upload-time = "2025-08-09T07:57:23.883Z" },

     

       177
       177
       +
           { url = "https://files.pythonhosted.org/packages/ce/d6/7e805c8e5c46ff9729c49950acc4ee0aeb55efb8b3a56687658ad10c3216/charset_normalizer-3.4.3-cp39-cp39-win_amd64.whl", hash = "sha256:d22dbedd33326a4a5190dd4fe9e9e693ef12160c77382d9e87919bce54f3d4ca", size = 107438, upload-time = "2025-08-09T07:57:25.287Z" },

     

       178
       178
       +
           { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175, upload-time = "2025-08-09T07:57:26.864Z" },

     

       179
       179
       +
       ]

     

       180
       180
       +
       

     

       181
       181
       +
       [[package]]

     

       94
       182
        
       name = "click"

     

       95
       183
        
       version = "8.1.8"

     

       96
       184
        
       source = { registry = "https://pypi.org/simple" }

     
···

       209
       297
        
       ]

     

       210
       298
        
       

     

       211
       299
        
       [[package]]

     

       300
       300
       +
       name = "distro"

     

       301
       301
       +
       version = "1.9.0"

     

       302
       302
       +
       source = { registry = "https://pypi.org/simple" }

     

       303
       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
       304
       +
       wheels = [

     

       305
       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
       306
       +
       ]

     

       307
       307
       +
       

     

       308
       308
       +
       [[package]]

     

       212
       309
        
       name = "dnspython"

     

       213
       310
        
       version = "2.7.0"

     

       214
       311
        
       source = { registry = "https://pypi.org/simple" }

     
···

       288
       385
        
       ]

     

       289
       386
        
       

     

       290
       387
        
       [[package]]

     

       388
       388
       +
       name = "html2text"

     

       389
       389
       +
       version = "2025.4.15"

     

       390
       390
       +
       source = { registry = "https://pypi.org/simple" }

     

       391
       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
       392
       +
       wheels = [

     

       393
       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
       394
       +
       ]

     

       395
       395
       +
       

     

       396
       396
       +
       [[package]]

     

       291
       397
        
       name = "httpcore"

     

       292
       398
        
       version = "1.0.9"

     

       293
       399
        
       source = { registry = "https://pypi.org/simple" }

     
···

       325
       431
        
       ]

     

       326
       432
        
       

     

       327
       433
        
       [[package]]

     

       434
       434
       +
       name = "importlib-metadata"

     

       435
       435
       +
       version = "8.7.0"

     

       436
       436
       +
       source = { registry = "https://pypi.org/simple" }

     

       437
       437
       +
       dependencies = [

     

       438
       438
       +
           { name = "zipp" },

     

       439
       439
       +
       ]

     

       440
       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
       441
       +
       wheels = [

     

       442
       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
       443
       +
       ]

     

       444
       444
       +
       

     

       445
       445
       +
       [[package]]

     

       328
       446
        
       name = "iniconfig"

     

       329
       447
        
       version = "2.1.0"

     

       330
       448
        
       source = { registry = "https://pypi.org/simple" }

     
···

       334
       452
        
       ]

     

       335
       453
        
       

     

       336
       454
        
       [[package]]

     

       455
       455
       +
       name = "lxml"

     

       456
       456
       +
       version = "6.0.0"

     

       457
       457
       +
       source = { registry = "https://pypi.org/simple" }

     

       458
       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
       459
       +
       wheels = [

     

       460
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       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
       546
       +
       ]

     

       547
       547
       +
       

     

       548
       548
       +
       [[package]]

     

       337
       549
        
       name = "markdown-it-py"

     

       338
       550
        
       version = "3.0.0"

     

       339
       551
        
       source = { registry = "https://pypi.org/simple" }

     
···

       346
       558
        
       ]

     

       347
       559
        
       

     

       348
       560
        
       [[package]]

     

       561
       561
       +
       name = "markdownify"

     

       562
       562
       +
       version = "1.2.0"

     

       563
       563
       +
       source = { registry = "https://pypi.org/simple" }

     

       564
       564
       +
       dependencies = [

     

       565
       565
       +
           { name = "beautifulsoup4" },

     

       566
       566
       +
           { name = "six" },

     

       567
       567
       +
       ]

     

       568
       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
       569
       +
       wheels = [

     

       570
       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
       571
       +
       ]

     

       572
       572
       +
       

     

       573
       573
       +
       [[package]]

     

       349
       574
        
       name = "mdurl"

     

       350
       575
        
       version = "0.1.2"

     

       351
       576
        
       source = { registry = "https://pypi.org/simple" }

     
···

       499
       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" },

     

       500
       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" },

     

       501
       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
       727
       +
       ]

     

       728
       728
       +
       

     

       729
       729
       +
       [[package]]

     

       730
       730
       +
       name = "pip"

     

       731
       731
       +
       version = "25.2"

     

       732
       732
       +
       source = { registry = "https://pypi.org/simple" }

     

       733
       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
       734
       +
       wheels = [

     

       735
       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" },

     

       502
       736
        
       ]

     

       503
       737
        
       

     

       504
       738
        
       [[package]]

     
···

       786
       1020
        
       ]

     

       787
       1021
        
       

     

       788
       1022
        
       [[package]]

     

       1023
       1023
       +
       name = "requests"

     

       1024
       1024
       +
       version = "2.32.4"

     

       1025
       1025
       +
       source = { registry = "https://pypi.org/simple" }

     

       1026
       1026
       +
       dependencies = [

     

       1027
       1027
       +
           { name = "certifi" },

     

       1028
       1028
       +
           { name = "charset-normalizer" },

     

       1029
       1029
       +
           { name = "idna" },

     

       1030
       1030
       +
           { name = "urllib3" },

     

       1031
       1031
       +
       ]

     

       1032
       1032
       +
       sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload-time = "2025-06-09T16:43:07.34Z" }

     

       1033
       1033
       +
       wheels = [

     

       1034
       1034
       +
           { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload-time = "2025-06-09T16:43:05.728Z" },

     

       1035
       1035
       +
       ]

     

       1036
       1036
       +
       

     

       1037
       1037
       +
       [[package]]

     

       789
       1038
        
       name = "rich"

     

       790
       1039
        
       version = "14.0.0"

     

       791
       1040
        
       source = { registry = "https://pypi.org/simple" }

     
···

       864
       1113
        
       sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }

     

       865
       1114
        
       wheels = [

     

       866
       1115
        
           { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },

     

       1116
       1116
       +
       ]

     

       1117
       1117
       +
       

     

       1118
       1118
       +
       [[package]]

     

       1119
       1119
       +
       name = "soupsieve"

     

       1120
       1120
       +
       version = "2.7"

     

       1121
       1121
       +
       source = { registry = "https://pypi.org/simple" }

     

       1122
       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
       1123
       +
       wheels = [

     

       1124
       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" },

     

       867
       1125
        
       ]

     

       868
       1126
        
       

     

       869
       1127
        
       [[package]]

     
···

       875
       1133
        
           { name = "feedparser" },

     

       876
       1134
        
           { name = "gitpython" },

     

       877
       1135
        
           { name = "httpx" },

     

       1136
       1136
       +
           { name = "importlib-metadata" },

     

       1137
       1137
       +
           { name = "markdownify" },

     

       878
       1138
        
           { name = "pendulum" },

     

       879
       1139
        
           { name = "platformdirs" },

     

       880
       1140
        
           { name = "pydantic" },

     
···

       882
       1142
        
           { name = "pyyaml" },

     

       883
       1143
        
           { name = "rich" },

     

       884
       1144
        
           { name = "typer" },

     

       1145
       1145
       +
           { name = "typesense" },

     

       1146
       1146
       +
           { name = "zulip" },

     

       1147
       1147
       +
           { name = "zulip-bots" },

     

       885
       1148
        
       ]

     

       886
       1149
        
       

     

       887
       1150
        
       [package.optional-dependencies]

     
···

       893
       1156
        
           { name = "pytest-cov" },

     

       894
       1157
        
           { name = "ruff" },

     

       895
       1158
        
           { name = "types-pyyaml" },

     

       1159
       1159
       +
       ]

     

       1160
       1160
       +
       

     

       1161
       1161
       +
       [package.dev-dependencies]

     

       1162
       1162
       +
       dev = [

     

       1163
       1163
       +
           { name = "mypy" },

     

       1164
       1164
       +
           { name = "pytest" },

     

       896
       1165
        
       ]

     

       897
       1166
        
       

     

       898
       1167
        
       [package.metadata]

     
···

       903
       1172
        
           { name = "feedparser", specifier = ">=6.0.11" },

     

       904
       1173
        
           { name = "gitpython", specifier = ">=3.1.40" },

     

       905
       1174
        
           { name = "httpx", specifier = ">=0.28.0" },

     

       1175
       1175
       +
           { name = "importlib-metadata", specifier = ">=8.7.0" },

     

       1176
       1176
       +
           { name = "markdownify", specifier = ">=1.2.0" },

     

       906
       1177
        
           { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13.0" },

     

       907
       1178
        
           { name = "pendulum", specifier = ">=3.0.0" },

     

       908
       1179
        
           { name = "platformdirs", specifier = ">=4.0.0" },

     
···

       916
       1187
        
           { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },

     

       917
       1188
        
           { name = "typer", specifier = ">=0.15.0" },

     

       918
       1189
        
           { name = "types-pyyaml", marker = "extra == 'dev'", specifier = ">=6.0.0" },

     

       1190
       1190
       +
           { name = "typesense", specifier = ">=1.1.1" },

     

       1191
       1191
       +
           { name = "zulip", specifier = ">=0.9.0" },

     

       1192
       1192
       +
           { name = "zulip-bots", specifier = ">=0.9.0" },

     

       919
       1193
        
       ]

     

       920
       1194
        
       provides-extras = ["dev"]

     

       1195
       1195
       +
       

     

       1196
       1196
       +
       [package.metadata.requires-dev]

     

       1197
       1197
       +
       dev = [

     

       1198
       1198
       +
           { name = "mypy", specifier = ">=1.17.0" },

     

       1199
       1199
       +
           { name = "pytest", specifier = ">=8.4.1" },

     

       1200
       1200
       +
       ]

     

       921
       1201
        
       

     

       922
       1202
        
       [[package]]

     

       923
       1203
        
       name = "tomli"

     
···

       984
       1264
        
       ]

     

       985
       1265
        
       

     

       986
       1266
        
       [[package]]

     

       1267
       1267
       +
       name = "typesense"

     

       1268
       1268
       +
       version = "1.1.1"

     

       1269
       1269
       +
       source = { registry = "https://pypi.org/simple" }

     

       1270
       1270
       +
       dependencies = [

     

       1271
       1271
       +
           { name = "requests" },

     

       1272
       1272
       +
       ]

     

       1273
       1273
       +
       sdist = { url = "https://files.pythonhosted.org/packages/9b/2c/6f012a17934d50f73d20f1138b3bc42cfb7ec465052bd8e56c0dcf8ce92d/typesense-1.1.1.tar.gz", hash = "sha256:876280e5f2bb8a4a24ae427863ee8216d2e9e76cfe96e0a87a379e66078dc591", size = 45214, upload-time = "2025-05-20T18:13:32.865Z" }

     

       1274
       1274
       +
       wheels = [

     

       1275
       1275
       +
           { url = "https://files.pythonhosted.org/packages/1b/8f/6306446e5ce28ddddd8babf407597b9afa3fff521794fe2dcfb16f12e16a/typesense-1.1.1-py3-none-any.whl", hash = "sha256:633aeb26c24e17be654ea22f20d3f76f87c804f259d0a560b7e0ae817f24077a", size = 70604, upload-time = "2025-05-20T18:13:30.975Z" },

     

       1276
       1276
       +
       ]

     

       1277
       1277
       +
       

     

       1278
       1278
       +
       [[package]]

     

       987
       1279
        
       name = "typing-extensions"

     

       988
       1280
        
       version = "4.14.1"

     

       989
       1281
        
       source = { registry = "https://pypi.org/simple" }

     
···

       1011
       1303
        
       sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }

     

       1012
       1304
        
       wheels = [

     

       1013
       1305
        
           { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },

     

       1306
       1306
       +
       ]

     

       1307
       1307
       +
       

     

       1308
       1308
       +
       [[package]]

     

       1309
       1309
       +
       name = "urllib3"

     

       1310
       1310
       +
       version = "2.5.0"

     

       1311
       1311
       +
       source = { registry = "https://pypi.org/simple" }

     

       1312
       1312
       +
       sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" }

     

       1313
       1313
       +
       wheels = [

     

       1314
       1314
       +
           { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },

     

       1014
       1315
        
       ]

     

       1015
       1316
        
       

     

       1016
       1317
        
       [[package]]

     
···

       1021
       1322
        
       wheels = [

     

       1022
       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" },

     

       1023
       1324
        
       ]

     

       1325
       1325
       +
       

     

       1326
       1326
       +
       [[package]]

     

       1327
       1327
       +
       name = "zipp"

     

       1328
       1328
       +
       version = "3.23.0"

     

       1329
       1329
       +
       source = { registry = "https://pypi.org/simple" }

     

       1330
       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
       1331
       +
       wheels = [

     

       1332
       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
       1333
       +
       ]

     

       1334
       1334
       +
       

     

       1335
       1335
       +
       [[package]]

     

       1336
       1336
       +
       name = "zulip"

     

       1337
       1337
       +
       version = "0.9.0"

     

       1338
       1338
       +
       source = { registry = "https://pypi.org/simple" }

     

       1339
       1339
       +
       dependencies = [

     

       1340
       1340
       +
           { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },

     

       1341
       1341
       +
           { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },

     

       1342
       1342
       +
           { name = "distro" },

     

       1343
       1343
       +
           { name = "requests" },

     

       1344
       1344
       +
           { name = "typing-extensions" },

     

       1345
       1345
       +
       ]

     

       1346
       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
       1347
       +
       wheels = [

     

       1348
       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
       1349
       +
       ]

     

       1350
       1350
       +
       

     

       1351
       1351
       +
       [[package]]

     

       1352
       1352
       +
       name = "zulip-bots"

     

       1353
       1353
       +
       version = "0.9.0"

     

       1354
       1354
       +
       source = { registry = "https://pypi.org/simple" }

     

       1355
       1355
       +
       dependencies = [

     

       1356
       1356
       +
           { name = "beautifulsoup4" },

     

       1357
       1357
       +
           { name = "html2text" },

     

       1358
       1358
       +
           { name = "importlib-metadata", marker = "python_full_version < '3.10'" },

     

       1359
       1359
       +
           { name = "lxml" },

     

       1360
       1360
       +
           { name = "pip" },

     

       1361
       1361
       +
           { name = "typing-extensions" },

     

       1362
       1362
       +
           { name = "zulip" },

     

       1363
       1363
       +
       ]

     

       1364
       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
       1365
       +
       wheels = [

     

       1366
       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
       1367
       +
       ]

Compare changes