comparing 3f3c4dd1264b25b9eef84f66de1fd5af01f20cfa and main on anil.recoil.org/thicket

.gitignore

···

       203
        
       .streamlit/secrets.toml

     

       204
        
       

     

       205
        
       thicket.yaml

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       203
        
       .streamlit/secrets.toml

     

       204
        
       

     

       205
        
       thicket.yaml

     

       206
       +
       

     

       207
       +
       # Bot configuration files with secrets

     

       208
       +
       bot-config/zuliprc

     

       209
       +
       bot-config/*.key  

     

       210
       +
       bot-config/*.secret

+26

README.md

···

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

     

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

     

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

     

       0
        
       
     

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

     

       13
        
       

     

       14
        
       ## Installation

     
···

       109
        
       # Remove duplicate mapping

     

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

     

       111
        
       ```

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       112
        
       

     

       113
        
       ## Configuration

     

       114

···

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

     

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

     

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

     

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

     

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

     

       14
        
       

     

       15
        
       ## Installation

     
···

       110
        
       # Remove duplicate mapping

     

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

     

       112
        
       ```

     

       113
       +
       

     

       114
       +
       ### Zulip Bot Integration

     

       115
       +
       ```bash

     

       116
       +
       # Test bot functionality

     

       117
       +
       thicket bot test

     

       118
       +
       

     

       119
       +
       # Show bot status 

     

       120
       +
       thicket bot status

     

       121
       +
       

     

       122
       +
       # Run bot (requires configuration)

     

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

     

       124
       +
       ```

     

       125
       +
       

     

       126
       +
       **Bot Setup:**

     

       127
       +
       1. Create a Zulip bot in your organization

     

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

     

       129
       +
       3. Configure with your bot's credentials

     

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

     

       131
       +
          ```

     

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

     

       133
       +
          @thicket config stream general

     

       134
       +
          @thicket config topic "Feed Updates"

     

       135
       +
          ```

     

       136
       +
       

     

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

     

       138
        
       

     

       139
        
       ## Configuration

     

       140

+400

SPEC.md

···

       1
       +
       # Thicket Git Store Specification

     

       2
       +
       

     

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

     

       4
       +
       

     

       5
       +
       ## Overview

     

       6
       +
       

     

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

     

       8
       +
       

     

       9
       +
       ## Repository Structure

     

       10
       +
       

     

       11
       +
       ```

     

       12
       +
       <git_store>/

     

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

     

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

     

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

     

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

     

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

     

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

     

       19
       +
       │   └── ...

     

       20
       +
       ├── <username2>/

     

       21
       +
       │   ├── <entry_id3>.json

     

       22
       +
       │   └── ...

     

       23
       +
       └── ...

     

       24
       +
       ```

     

       25
       +
       

     

       26
       +
       ## JSON Schemas

     

       27
       +
       

     

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

     

       29
       +
       

     

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

     

       31
       +
       

     

       32
       +
       **Schema:**

     

       33
       +
       ```json

     

       34
       +
       {

     

       35
       +
         "users": {

     

       36
       +
           "<username>": {

     

       37
       +
             "username": "string",

     

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

     

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

     

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

     

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

     

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

     

       43
       +
             "zulip_associations": [

     

       44
       +
               {

     

       45
       +
                 "server": "string",

     

       46
       +
                 "user_id": "string"

     

       47
       +
               },

     

       48
       +
               ...

     

       49
       +
             ],

     

       50
       +
             "directory": "string",

     

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

     

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

     

       53
       +
             "entry_count": "integer"

     

       54
       +
           }

     

       55
       +
         },

     

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

     

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

     

       58
       +
         "total_entries": "integer"

     

       59
       +
       }

     

       60
       +
       ```

     

       61
       +
       

     

       62
       +
       **Example:**

     

       63
       +
       ```json

     

       64
       +
       {

     

       65
       +
         "users": {

     

       66
       +
           "johndoe": {

     

       67
       +
             "username": "johndoe",

     

       68
       +
             "display_name": "John Doe",

     

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

     

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

     

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

     

       72
       +
             "feeds": [

     

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

     

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

     

       75
       +
             ],

     

       76
       +
             "zulip_associations": [

     

       77
       +
               {

     

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

     

       79
       +
                 "user_id": "john.doe"

     

       80
       +
               },

     

       81
       +
               {

     

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

     

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

     

       84
       +
               }

     

       85
       +
             ],

     

       86
       +
             "directory": "johndoe",

     

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

     

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

     

       89
       +
             "entry_count": 42

     

       90
       +
           }

     

       91
       +
         },

     

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

     

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

     

       94
       +
         "total_entries": 42

     

       95
       +
       }

     

       96
       +
       ```

     

       97
       +
       

     

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

     

       99
       +
       

     

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

     

       101
       +
       

     

       102
       +
       **Schema:**

     

       103
       +
       ```json

     

       104
       +
       {

     

       105
       +
         "duplicates": {

     

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

     

       107
       +
         },

     

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

     

       109
       +
       }

     

       110
       +
       ```

     

       111
       +
       

     

       112
       +
       **Example:**

     

       113
       +
       ```json

     

       114
       +
       {

     

       115
       +
         "duplicates": {

     

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

     

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

     

       118
       +
         },

     

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

     

       120
       +
       }

     

       121
       +
       ```

     

       122
       +
       

     

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

     

       124
       +
       

     

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

     

       126
       +
       

     

       127
       +
       **Schema:**

     

       128
       +
       ```json

     

       129
       +
       {

     

       130
       +
         "id": "string",

     

       131
       +
         "title": "string", 

     

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

     

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

     

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

     

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

     

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

     

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

     

       138
       +
         "author": {

     

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

     

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

     

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

     

       142
       +
         } | null,

     

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

     

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

     

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

     

       146
       +
       }

     

       147
       +
       ```

     

       148
       +
       

     

       149
       +
       **Example:**

     

       150
       +
       ```json

     

       151
       +
       {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       159
       +
         "content_type": "html",

     

       160
       +
         "author": {

     

       161
       +
           "name": "John Doe",

     

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

     

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

     

       164
       +
         },

     

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

     

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

     

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

     

       168
       +
       }

     

       169
       +
       ```

     

       170
       +
       

     

       171
       +
       ## Python Class Integration

     

       172
       +
       

     

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

     

       174
       +
       

     

       175
       +
       ### Core Data Models

     

       176
       +
       

     

       177
       +
       ```python

     

       178
       +
       from thicket.models import (

     

       179
       +
           AtomEntry,           # Feed entry representation

     

       180
       +
           GitStoreIndex,       # Repository index

     

       181
       +
           UserMetadata,        # User information  

     

       182
       +
           DuplicateMap,        # Duplicate ID mappings

     

       183
       +
           FeedMetadata,        # Feed-level metadata

     

       184
       +
           ThicketConfig,       # Configuration

     

       185
       +
           UserConfig,          # User configuration

     

       186
       +
           ZulipAssociation     # Zulip server/user_id pairs

     

       187
       +
       )

     

       188
       +
       ```

     

       189
       +
       

     

       190
       +
       ### Repository Operations

     

       191
       +
       

     

       192
       +
       ```python

     

       193
       +
       from thicket.core.git_store import GitStore

     

       194
       +
       from thicket.core.feed_parser import FeedParser

     

       195
       +
       

     

       196
       +
       # Initialize git store

     

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

     

       198
       +
       

     

       199
       +
       # Read data

     

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

     

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

     

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

     

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

     

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

     

       205
       +
       

     

       206
       +
       # Write data  

     

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

     

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

     

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

     

       210
       +
       store.commit_changes("Commit message")

     

       211
       +
       

     

       212
       +
       # Zulip associations

     

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

     

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

     

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

     

       216
       +
       

     

       217
       +
       # Search and statistics

     

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

     

       219
       +
       stats = store.get_stats()

     

       220
       +
       ```

     

       221
       +
       

     

       222
       +
       ### Feed Processing

     

       223
       +
       

     

       224
       +
       ```python

     

       225
       +
       from thicket.core.feed_parser import FeedParser

     

       226
       +
       from pydantic import HttpUrl

     

       227
       +
       

     

       228
       +
       parser = FeedParser()

     

       229
       +
       

     

       230
       +
       # Fetch and parse feeds

     

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

     

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

     

       233
       +
       

     

       234
       +
       # Entry ID sanitization for filenames

     

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

     

       236
       +
       ```

     

       237
       +
       

     

       238
       +
       ## File Naming and ID Sanitization

     

       239
       +
       

     

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

     

       241
       +
       

     

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

     

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

     

       244
       +
       - Other characters are replaced with underscores

     

       245
       +
       - Maximum length is 200 characters

     

       246
       +
       - Empty results default to "entry"

     

       247
       +
       

     

       248
       +
       **Examples:**

     

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

     

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

     

       251
       +
       

     

       252
       +
       ## Data Validation

     

       253
       +
       

     

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

     

       255
       +
       

     

       256
       +
       ```python

     

       257
       +
       from thicket.models import AtomEntry

     

       258
       +
       from pydantic import ValidationError

     

       259
       +
       

     

       260
       +
       try:

     

       261
       +
           entry = AtomEntry(**json_data)

     

       262
       +
           # Data is valid, safe to store

     

       263
       +
           store.store_entry(username, entry)

     

       264
       +
       except ValidationError as e:

     

       265
       +
           # Handle validation errors

     

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

     

       267
       +
       ```

     

       268
       +
       

     

       269
       +
       ## Timestamps

     

       270
       +
       

     

       271
       +
       All timestamps use ISO 8601 format in UTC:

     

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

     

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

     

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

     

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

     

       276
       +
       

     

       277
       +
       ## Content Sanitization

     

       278
       +
       

     

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

     

       280
       +
       

     

       281
       +
       **Allowed HTML tags:**

     

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

     

       283
       +
       

     

       284
       +
       **Allowed attributes:**

     

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

     

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

     

       287
       +
       - `blockquote`: `cite`

     

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

     

       289
       +
       

     

       290
       +
       ## Error Handling and Robustness

     

       291
       +
       

     

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

     

       293
       +
       

     

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

     

       295
       +
       - Malformed JSON files are ignored in listings

     

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

     

       297
       +
       - Git operations are atomic where possible

     

       298
       +
       

     

       299
       +
       ## Example Usage

     

       300
       +
       

     

       301
       +
       ### Reading the Store

     

       302
       +
       

     

       303
       +
       ```python

     

       304
       +
       from pathlib import Path

     

       305
       +
       from thicket.core.git_store import GitStore

     

       306
       +
       

     

       307
       +
       # Initialize

     

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

     

       309
       +
       

     

       310
       +
       # Get all users

     

       311
       +
       index = store._load_index()

     

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

     

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

     

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

     

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

     

       316
       +
       

     

       317
       +
       # Get recent entries for a user

     

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

     

       319
       +
       for entry in entries:

     

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

     

       321
       +
       ```

     

       322
       +
       

     

       323
       +
       ### Adding Data

     

       324
       +
       

     

       325
       +
       ```python

     

       326
       +
       from thicket.models import AtomEntry

     

       327
       +
       from datetime import datetime

     

       328
       +
       from pydantic import HttpUrl

     

       329
       +
       

     

       330
       +
       # Create entry

     

       331
       +
       entry = AtomEntry(

     

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

     

       333
       +
           title="New Post",

     

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

     

       335
       +
           updated=datetime.now(),

     

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

     

       337
       +
           content_type="html"

     

       338
       +
       )

     

       339
       +
       

     

       340
       +
       # Store entry

     

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

     

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

     

       343
       +
       ```

     

       344
       +
       

     

       345
       +
       ## Zulip Integration

     

       346
       +
       

     

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

     

       348
       +
       

     

       349
       +
       ### Zulip Associations

     

       350
       +
       

     

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

     

       352
       +
       

     

       353
       +
       ```python

     

       354
       +
       # UserMetadata includes zulip_associations field

     

       355
       +
       user.zulip_associations = [

     

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

     

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

     

       358
       +
       ]

     

       359
       +
       

     

       360
       +
       # Methods for managing associations

     

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

     

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

     

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

     

       364
       +
       ```

     

       365
       +
       

     

       366
       +
       ### CLI Management

     

       367
       +
       

     

       368
       +
       ```bash

     

       369
       +
       # Add association

     

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

     

       371
       +
       

     

       372
       +
       # Remove association  

     

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

     

       374
       +
       

     

       375
       +
       # List associations

     

       376
       +
       thicket zulip-list           # All users

     

       377
       +
       thicket zulip-list alice     # Specific user

     

       378
       +
       

     

       379
       +
       # Bulk import from CSV

     

       380
       +
       thicket zulip-import associations.csv

     

       381
       +
       ```

     

       382
       +
       

     

       383
       +
       ### Bot Behavior

     

       384
       +
       

     

       385
       +
       When the Thicket Zulip bot posts articles:

     

       386
       +
       

     

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

     

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

     

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

     

       390
       +
       

     

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

     

       392
       +
       

     

       393
       +
       ## Versioning and Compatibility

     

       394
       +
       

     

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

     

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

     

       397
       +
       

     

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

     

       399
       +
       

     

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

+97

bot-config/README.md

···

       1
       +
       # Thicket Bot Configuration

     

       2
       +
       

     

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

     

       4
       +
       

     

       5
       +
       ## Setup Instructions

     

       6
       +
       

     

       7
       +
       ### 1. Zulip Bot Configuration

     

       8
       +
       

     

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

     

       10
       +
          ```bash

     

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

     

       12
       +
          ```

     

       13
       +
       

     

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

     

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

     

       16
       +
          - Choose "Generic bot" type

     

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

     

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

     

       19
       +
       

     

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

     

       21
       +
          ```ini

     

       22
       +
          [api]

     

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

     

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

     

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

     

       26
       +
          ```

     

       27
       +
       

     

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

     

       29
       +
       

     

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

     

       31
       +
          ```bash

     

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

     

       33
       +
          ```

     

       34
       +
       

     

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

     

       36
       +
          - Sync intervals and batch sizes

     

       37
       +
          - Default stream/topic settings

     

       38
       +
          - Rate limiting parameters

     

       39
       +
          - Notification preferences

     

       40
       +
       

     

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

     

       42
       +
       

     

       43
       +
       ## File Descriptions

     

       44
       +
       

     

       45
       +
       ### `zuliprc` (Required)

     

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

     

       47
       +
       

     

       48
       +
       ### `botrc` (Optional)

     

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

     

       50
       +
       

     

       51
       +
       ### Template Files

     

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

     

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

     

       54
       +
       

     

       55
       +
       ## Running the Bot

     

       56
       +
       

     

       57
       +
       Once configured, run the bot with:

     

       58
       +
       

     

       59
       +
       ```bash

     

       60
       +
       # Run in foreground

     

       61
       +
       thicket bot run

     

       62
       +
       

     

       63
       +
       # Run in background (daemon mode)

     

       64
       +
       thicket bot run --daemon

     

       65
       +
       

     

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

     

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

     

       68
       +
       

     

       69
       +
       # Custom config paths

     

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

     

       71
       +
       ```

     

       72
       +
       

     

       73
       +
       ## Bot Commands

     

       74
       +
       

     

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

     

       76
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       83
       +
       

     

       84
       +
       ## Security Notes

     

       85
       +
       

     

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

     

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

     

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

     

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

     

       90
       +
       

     

       91
       +
       ## Troubleshooting

     

       92
       +
       

     

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

     

       94
       +
       - View bot logs when running in foreground mode

     

       95
       +
       - Verify Zulip credentials are correct

     

       96
       +
       - Ensure thicket.yaml configuration exists

     

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

+28

bot-config/botrc

···

       1
       +
       [bot]

     

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

     

       3
       +
       sync_interval = 300

     

       4
       +
       

     

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

     

       6
       +
       max_entries_per_sync = 10

     

       7
       +
       

     

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

     

       9
       +
       # Leave empty to require configuration via chat

     

       10
       +
       default_stream = 

     

       11
       +
       default_topic = 

     

       12
       +
       

     

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

     

       14
       +
       rate_limit_delay = 5

     

       15
       +
       

     

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

     

       17
       +
       posts_per_batch = 5

     

       18
       +
       

     

       19
       +
       [catchup]

     

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

     

       21
       +
       catchup_entries = 5

     

       22
       +
       

     

       23
       +
       [notifications]

     

       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       +
       config_change_notifications = true

     

       26
       +
       

     

       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       +
       username_claim_notifications = true

+34

bot-config/botrc.template

···

       1
       +
       [bot]

     

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

     

       3
       +
       sync_interval = 300

     

       4
       +
       

     

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

     

       6
       +
       max_entries_per_sync = 10

     

       7
       +
       

     

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

     

       9
       +
       # Leave empty to require configuration via chat

     

       10
       +
       default_stream = 

     

       11
       +
       default_topic = 

     

       12
       +
       

     

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

     

       14
       +
       rate_limit_delay = 5

     

       15
       +
       

     

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

     

       17
       +
       posts_per_batch = 5

     

       18
       +
       

     

       19
       +
       [catchup]

     

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

     

       21
       +
       catchup_entries = 5

     

       22
       +
       

     

       23
       +
       [notifications]

     

       24
       +
       # Whether to send notifications when bot configuration changes

     

       25
       +
       config_change_notifications = true

     

       26
       +
       

     

       27
       +
       # Whether to send notifications when users claim usernames  

     

       28
       +
       username_claim_notifications = true

     

       29
       +
       

     

       30
       +
       # Instructions:

     

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

     

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

     

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

     

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

+16

bot-config/zuliprc.template

···

       1
       +
       [api]

     

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

     

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

     

       4
       +
       

     

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

     

       6
       +
       key=YOUR_BOT_API_KEY_HERE

     

       7
       +
       

     

       8
       +
       # Your Zulip server URL

     

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

     

       10
       +
       

     

       11
       +
       # Instructions:

     

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

     

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

     

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

     

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

     

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

+11 -6

pyproject.toml

···

       40
        
           "platformdirs>=4.0.0",

     

       41
        
           "pyyaml>=6.0.0",

     

       42
        
           "email_validator",

     

       43
       -
           "textual>=4.0.0",

     

       44
       -
           "flask>=3.1.1",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
       ]

     

       46
        
       

     

       47
        
       [project.optional-dependencies]

     
···

       140
        
           "-ra",

     

       141
        
           "--strict-markers",

     

       142
        
           "--strict-config",

     

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

     

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

     

       145
       -
           "--cov-report=html",

     

       146
       -
           "--cov-report=xml",

     

       147
        
       ]

     

       148
        
       filterwarnings = [

     

       149
        
           "error",

     
···

       172
        
           "class .*\\bProtocol\\):",

     

       173
        
           "@(abc\\.)?abstractmethod",

     

       174
        
       ]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       40
        
           "platformdirs>=4.0.0",

     

       41
        
           "pyyaml>=6.0.0",

     

       42
        
           "email_validator",

     

       43
       +
           "typesense>=1.1.1",

     

       44
       +
           "zulip>=0.9.0",

     

       45
       +
           "zulip-bots>=0.9.0",

     

       46
       +
           "importlib-metadata>=8.7.0",

     

       47
       +
           "markdownify>=1.2.0",

     

       48
        
       ]

     

       49
        
       

     

       50
        
       [project.optional-dependencies]

     
···

       143
        
           "-ra",

     

       144
        
           "--strict-markers",

     

       145
        
           "--strict-config",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       146
        
       ]

     

       147
        
       filterwarnings = [

     

       148
        
           "error",

     
···

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

     

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

     

       173
        
       ]

     

       174
       +
       

     

       175
       +
       [dependency-groups]

     

       176
       +
       dev = [

     

       177
       +
           "mypy>=1.17.0",

     

       178
       +
           "pytest>=8.4.1",

     

       179
       +
       ]

src/thicket/bots/__init__.py

···

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

     

       2
       +
       

     

       3
       +
       from .thicket_bot import ThicketBotHandler

     

       4
       +
       

     

       5
       +
       __all__ = ["ThicketBotHandler"]

src/thicket/bots/requirements.txt

···

       1
       +
       # Requirements for Thicket Zulip bot

     

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

     

       3
       +
       pydantic>=2.11.0

     

       4
       +
       GitPython>=3.1.40

     

       5
       +
       feedparser>=6.0.11

     

       6
       +
       httpx>=0.28.0

     

       7
       +
       pyyaml>=6.0.0

+201

src/thicket/bots/test_bot.py

···

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

     

       2
       +
       

     

       3
       +
       import json

     

       4
       +
       from pathlib import Path

     

       5
       +
       from typing import Any, Optional

     

       6
       +
       

     

       7
       +
       from ..models import AtomEntry

     

       8
       +
       from .thicket_bot import ThicketBotHandler

     

       9
       +
       

     

       10
       +
       

     

       11
       +
       class MockBotHandler:

     

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

     

       13
       +
       

     

       14
       +
           def __init__(self) -> None:

     

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

     

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

     

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

     

       18
       +
               self.config_info = {

     

       19
       +
                   "full_name": "Thicket Bot",

     

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

     

       21
       +
               }

     

       22
       +
       

     

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

     

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

     

       25
       +
               return self.config_info

     

       26
       +
       

     

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

     

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

     

       29
       +
               reply = {

     

       30
       +
                   "type": "reply",

     

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

     

       32
       +
                   "content": content,

     

       33
       +
                   "original_message": message,

     

       34
       +
               }

     

       35
       +
               self.sent_messages.append(reply)

     

       36
       +
       

     

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

     

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

     

       39
       +
               self.sent_messages.append(message)

     

       40
       +
       

     

       41
       +
           @property

     

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

     

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

     

       44
       +
               return MockStorage(self.storage_data)

     

       45
       +
       

     

       46
       +
       

     

       47
       +
       class MockStorage:

     

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

     

       49
       +
       

     

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

     

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

     

       52
       +
               self.storage_data = storage_data

     

       53
       +
       

     

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

     

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

     

       56
       +
               return self

     

       57
       +
       

     

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

     

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

     

       60
       +
               pass

     

       61
       +
       

     

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

     

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

     

       64
       +
               return self.storage_data.get(key)

     

       65
       +
       

     

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

     

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

     

       68
       +
               self.storage_data[key] = value

     

       69
       +
       

     

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

     

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

     

       72
       +
               return key in self.storage_data

     

       73
       +
       

     

       74
       +
       

     

       75
       +
       def create_test_message(

     

       76
       +
           content: str,

     

       77
       +
           sender: str = "Test User",

     

       78
       +
           sender_id: int = 12345,

     

       79
       +
           message_type: str = "stream",

     

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

     

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

     

       82
       +
           return {

     

       83
       +
               "content": content,

     

       84
       +
               "sender_full_name": sender,

     

       85
       +
               "sender_id": sender_id,

     

       86
       +
               "type": message_type,

     

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

     

       88
       +
               "stream_id": 1,

     

       89
       +
               "subject": "test topic",

     

       90
       +
           }

     

       91
       +
       

     

       92
       +
       

     

       93
       +
       def create_test_entry(

     

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

     

       95
       +
           title: str = "Test Article",

     

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

     

       97
       +
       ) -> AtomEntry:

     

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

     

       99
       +
           from datetime import datetime

     

       100
       +
       

     

       101
       +
           from pydantic import HttpUrl

     

       102
       +
       

     

       103
       +
           return AtomEntry(

     

       104
       +
               id=entry_id,

     

       105
       +
               title=title,

     

       106
       +
               link=HttpUrl(link),

     

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

     

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

     

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

     

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

     

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

     

       112
       +
           )

     

       113
       +
       

     

       114
       +
       

     

       115
       +
       class BotTester:

     

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

     

       117
       +
       

     

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

     

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

     

       120
       +
               self.bot = ThicketBotHandler()

     

       121
       +
               self.handler = MockBotHandler()

     

       122
       +
       

     

       123
       +
               if config_path:

     

       124
       +
                   # Configure bot with test config

     

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

     

       126
       +
       

     

       127
       +
           def configure_bot(

     

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

     

       129
       +
           ) -> None:

     

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

     

       131
       +
               # Set bot configuration

     

       132
       +
               config_data = {

     

       133
       +
                   "stream_name": stream,

     

       134
       +
                   "topic_name": topic,

     

       135
       +
                   "sync_interval": 300,

     

       136
       +
                   "max_entries_per_sync": 10,

     

       137
       +
                   "config_path": str(config_path),

     

       138
       +
               }

     

       139
       +
       

     

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

     

       141
       +
       

     

       142
       +
               # Initialize bot

     

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

     

       144
       +
       

     

       145
       +
           def send_command(

     

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

     

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

     

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

     

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

     

       150
       +
       

     

       151
       +
               # Clear previous messages

     

       152
       +
               self.handler.sent_messages.clear()

     

       153
       +
       

     

       154
       +
               # Send command

     

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

     

       156
       +
       

     

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

     

       158
       +
       

     

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

     

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

     

       161
       +
               if self.handler.sent_messages:

     

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

     

       163
       +
               return None

     

       164
       +
       

     

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

     

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

     

       167
       +
               if self.handler.sent_messages:

     

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

     

       169
       +
               return None

     

       170
       +
       

     

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

     

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

     

       173
       +
               content = self.get_last_response_content()

     

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

     

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

     

       176
       +
       

     

       177
       +
       

     

       178
       +
       # Example usage for testing

     

       179
       +
       if __name__ == "__main__":

     

       180
       +
           # Create a test config file

     

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

     

       182
       +
       

     

       183
       +
           # Create bot tester

     

       184
       +
           tester = BotTester()

     

       185
       +
       

     

       186
       +
           # Test help command

     

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

     

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

     

       189
       +
       

     

       190
       +
           # Test status command

     

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

     

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

     

       193
       +
       

     

       194
       +
           # Test configuration

     

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

     

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

     

       197
       +
       

     

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

     

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

     

       200
       +
       

     

       201
       +
           print("All tests passed!")

+1257

src/thicket/bots/thicket_bot.py

···

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

     

       2
       +
       

     

       3
       +
       import asyncio

     

       4
       +
       import json

     

       5
       +
       import logging

     

       6
       +
       import os

     

       7
       +
       import time

     

       8
       +
       from pathlib import Path

     

       9
       +
       from typing import Any, Optional

     

       10
       +
       

     

       11
       +
       from zulip_bots.lib import BotHandler

     

       12
       +
       

     

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

     

       14
       +
       try:

     

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

     

       16
       +
           from ..core.git_store import GitStore

     

       17
       +
           from ..models import AtomEntry, ThicketConfig

     

       18
       +
       except ImportError:

     

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

     

       20
       +
           import sys

     

       21
       +
       

     

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

     

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

     

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

     

       25
       +
       

     

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

     

       27
       +
           from thicket.core.git_store import GitStore

     

       28
       +
           from thicket.models import AtomEntry, ThicketConfig

     

       29
       +
       

     

       30
       +
       

     

       31
       +
       class ThicketBotHandler:

     

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

     

       33
       +
       

     

       34
       +
           def __init__(self) -> None:

     

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

     

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

     

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

     

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

     

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

     

       40
       +
       

     

       41
       +
               # Bot configuration from storage

     

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

     

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

     

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

     

       45
       +
               self.max_entries_per_sync: int = 10

     

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

     

       47
       +
       

     

       48
       +
               # Bot behavior settings (loaded from botrc)

     

       49
       +
               self.rate_limit_delay: int = 5

     

       50
       +
               self.posts_per_batch: int = 5

     

       51
       +
               self.catchup_entries: int = 5

     

       52
       +
               self.config_change_notifications: bool = True

     

       53
       +
               self.username_claim_notifications: bool = True

     

       54
       +
       

     

       55
       +
               # Track last sync time for schedule queries

     

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

     

       57
       +
       

     

       58
       +
               # Debug mode configuration

     

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

     

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

     

       61
       +
       

     

       62
       +
           def usage(self) -> str:

     

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

     

       64
       +
               return """

     

       65
       +
               **Thicket Feed Bot**

     

       66
       +
       

     

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

     

       68
       +
       

     

       69
       +
               Commands:

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       79
       +
               """

     

       80
       +
       

     

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

     

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

     

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

     

       84
       +
       

     

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

     

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

     

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

     

       88
       +
               if config_path_env:

     

       89
       +
                   self.config_path = Path(config_path_env)

     

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

     

       91
       +
       

     

       92
       +
               # Load default configuration from botrc file

     

       93
       +
               self._load_botrc_defaults()

     

       94
       +
       

     

       95
       +
               # Load bot configuration from persistent storage

     

       96
       +
               self._load_bot_config(bot_handler)

     

       97
       +
       

     

       98
       +
               # Initialize thicket components

     

       99
       +
               if self.config_path:

     

       100
       +
                   try:

     

       101
       +
                       self._initialize_thicket()

     

       102
       +
                       self._load_posted_entries(bot_handler)

     

       103
       +
       

     

       104
       +
                       # Validate debug mode if enabled

     

       105
       +
                       if self.debug_user:

     

       106
       +
                           self._validate_debug_mode(bot_handler)

     

       107
       +
       

     

       108
       +
                   except Exception as e:

     

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

     

       110
       +
       

     

       111
       +
               # Start background sync loop

     

       112
       +
               self._schedule_sync(bot_handler)

     

       113
       +
       

     

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

     

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

     

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

     

       117
       +
               sender = message["sender_full_name"]

     

       118
       +
       

     

       119
       +
               # Only respond to mentions

     

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

     

       121
       +
                   return

     

       122
       +
       

     

       123
       +
               # Parse command

     

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

     

       125
       +
               command_parts = cleaned_content.split()

     

       126
       +
       

     

       127
       +
               if not command_parts:

     

       128
       +
                   self._send_help(message, bot_handler)

     

       129
       +
                   return

     

       130
       +
       

     

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

     

       132
       +
       

     

       133
       +
               try:

     

       134
       +
                   if command == "help":

     

       135
       +
                       self._send_help(message, bot_handler)

     

       136
       +
                   elif command == "status":

     

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

     

       138
       +
                   elif (

     

       139
       +
                       command == "sync"

     

       140
       +
                       and len(command_parts) > 1

     

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

     

       142
       +
                   ):

     

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

     

       144
       +
                   elif command == "reset":

     

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

     

       146
       +
                   elif command == "config":

     

       147
       +
                       self._handle_config_command(

     

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

     

       149
       +
                       )

     

       150
       +
                   elif command == "schedule":

     

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

     

       152
       +
                   elif command == "claim":

     

       153
       +
                       self._handle_claim_command(

     

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

     

       155
       +
                       )

     

       156
       +
                   else:

     

       157
       +
                       bot_handler.send_reply(

     

       158
       +
                           message,

     

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

     

       160
       +
                       )

     

       161
       +
               except Exception as e:

     

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

     

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

     

       164
       +
       

     

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

     

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

     

       167
       +
               try:

     

       168
       +
                   # Get bot's actual name from Zulip

     

       169
       +
                   bot_info = bot_handler._client.get_profile()

     

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

     

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

     

       172
       +
                       if bot_name:

     

       173
       +
                           return (

     

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

     

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

     

       176
       +
                           )

     

       177
       +
               except Exception as e:

     

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

     

       179
       +
       

     

       180
       +
               # Fallback to generic check

     

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

     

       182
       +
       

     

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

     

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

     

       185
       +
               import re

     

       186
       +
       

     

       187
       +
               try:

     

       188
       +
                   # Get bot's actual name from Zulip

     

       189
       +
                   bot_info = bot_handler._client.get_profile()

     

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

     

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

     

       192
       +
                       if bot_name:

     

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

     

       194
       +
                           escaped_name = re.escape(bot_name)

     

       195
       +
                           content = re.sub(

     

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

     

       197
       +
                               "",

     

       198
       +
                               content,

     

       199
       +
                               flags=re.IGNORECASE,

     

       200
       +
                           ).strip()

     

       201
       +
                           return content

     

       202
       +
               except Exception as e:

     

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

     

       204
       +
       

     

       205
       +
               # Fallback to removing @thicket

     

       206
       +
               content = re.sub(

     

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

     

       208
       +
               ).strip()

     

       209
       +
               return content

     

       210
       +
       

     

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

     

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

     

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

     

       214
       +
       

     

       215
       +
           def _send_status(

     

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

     

       217
       +
           ) -> None:

     

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

     

       219
       +
               status_lines = [

     

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

     

       221
       +
                   "",

     

       222
       +
               ]

     

       223
       +
       

     

       224
       +
               # Debug mode status

     

       225
       +
               if self.debug_user:

     

       226
       +
                   status_lines.extend(

     

       227
       +
                       [

     

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

     

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

     

       230
       +
                           "",

     

       231
       +
                       ]

     

       232
       +
                   )

     

       233
       +
               else:

     

       234
       +
                   status_lines.extend(

     

       235
       +
                       [

     

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

     

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

     

       238
       +
                           "",

     

       239
       +
                       ]

     

       240
       +
                   )

     

       241
       +
       

     

       242
       +
               status_lines.extend(

     

       243
       +
                   [

     

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

     

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

     

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

     

       247
       +
                       "",

     

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

     

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

     

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

     

       251
       +
                       "",

     

       252
       +
                       self._get_schedule_info(),

     

       253
       +
                   ]

     

       254
       +
               )

     

       255
       +
       

     

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

     

       257
       +
       

     

       258
       +
           def _handle_force_sync(

     

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

     

       260
       +
           ) -> None:

     

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

     

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

     

       263
       +
                   return

     

       264
       +
       

     

       265
       +
               bot_handler.send_reply(

     

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

     

       267
       +
               )

     

       268
       +
       

     

       269
       +
               try:

     

       270
       +
                   new_entries = self._perform_sync(bot_handler)

     

       271
       +
                   bot_handler.send_reply(

     

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

     

       273
       +
                   )

     

       274
       +
               except Exception as e:

     

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

     

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

     

       277
       +
       

     

       278
       +
           def _handle_reset_command(

     

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

     

       280
       +
           ) -> None:

     

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

     

       282
       +
               try:

     

       283
       +
                   self.posted_entries.clear()

     

       284
       +
                   self._save_posted_entries(bot_handler)

     

       285
       +
                   bot_handler.send_reply(

     

       286
       +
                       message,

     

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

     

       288
       +
                   )

     

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

     

       290
       +
               except Exception as e:

     

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

     

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

     

       293
       +
       

     

       294
       +
           def _handle_schedule_command(

     

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

     

       296
       +
           ) -> None:

     

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

     

       298
       +
               schedule_info = self._get_schedule_info()

     

       299
       +
               bot_handler.send_reply(

     

       300
       +
                   message,

     

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

     

       302
       +
               )

     

       303
       +
       

     

       304
       +
           def _handle_claim_command(

     

       305
       +
               self,

     

       306
       +
               message: dict[str, Any],

     

       307
       +
               bot_handler: BotHandler,

     

       308
       +
               args: list[str],

     

       309
       +
               sender: str,

     

       310
       +
           ) -> None:

     

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

     

       312
       +
               if not args:

     

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

     

       314
       +
                   return

     

       315
       +
       

     

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

     

       317
       +
                   return

     

       318
       +
       

     

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

     

       320
       +
       

     

       321
       +
               # Get sender's Zulip user info

     

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

     

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

     

       324
       +
       

     

       325
       +
               if not sender_user_id or not sender_email:

     

       326
       +
                   bot_handler.send_reply(

     

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

     

       328
       +
                   )

     

       329
       +
                   return

     

       330
       +
       

     

       331
       +
               try:

     

       332
       +
                   # Get current Zulip server from environment

     

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

     

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

     

       335
       +
       

     

       336
       +
                   if not server_url:

     

       337
       +
                       bot_handler.send_reply(

     

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

     

       339
       +
                       )

     

       340
       +
                       return

     

       341
       +
       

     

       342
       +
                   # Check if username exists in thicket

     

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

     

       344
       +
                   if not user:

     

       345
       +
                       bot_handler.send_reply(

     

       346
       +
                           message,

     

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

     

       348
       +
                       )

     

       349
       +
                       return

     

       350
       +
       

     

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

     

       352
       +
                   existing_zulip_id = user.get_zulip_mention(server_url)

     

       353
       +
                   if existing_zulip_id:

     

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

     

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

     

       356
       +
                           sender_user_id

     

       357
       +
                       ):

     

       358
       +
                           bot_handler.send_reply(

     

       359
       +
                               message,

     

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

     

       361
       +
                           )

     

       362
       +
                       else:

     

       363
       +
                           bot_handler.send_reply(

     

       364
       +
                               message,

     

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

     

       366
       +
                           )

     

       367
       +
                       return

     

       368
       +
       

     

       369
       +
                   # Claim the username - prefer email for consistency

     

       370
       +
                   success = self.git_store.add_zulip_association(

     

       371
       +
                       username, server_url, sender_email

     

       372
       +
                   )

     

       373
       +
       

     

       374
       +
                   if success:

     

       375
       +
                       reply_msg = (

     

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

     

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

     

       378
       +
                       )

     

       379
       +
                       bot_handler.send_reply(message, reply_msg)

     

       380
       +
       

     

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

     

       382
       +
                       if (

     

       383
       +
                           self.username_claim_notifications

     

       384
       +
                           and not self.debug_user

     

       385
       +
                           and self.stream_name

     

       386
       +
                           and self.topic_name

     

       387
       +
                       ):

     

       388
       +
                           try:

     

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

     

       390
       +
                               bot_handler.send_message(

     

       391
       +
                                   {

     

       392
       +
                                       "type": "stream",

     

       393
       +
                                       "to": self.stream_name,

     

       394
       +
                                       "subject": self.topic_name,

     

       395
       +
                                       "content": notification_msg,

     

       396
       +
                                   }

     

       397
       +
                               )

     

       398
       +
                           except Exception as e:

     

       399
       +
                               self.logger.error(

     

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

     

       401
       +
                               )

     

       402
       +
       

     

       403
       +
                       self.logger.info(

     

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

     

       405
       +
                       )

     

       406
       +
                   else:

     

       407
       +
                       bot_handler.send_reply(

     

       408
       +
                           message,

     

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

     

       410
       +
                       )

     

       411
       +
       

     

       412
       +
               except Exception as e:

     

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

     

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

     

       415
       +
       

     

       416
       +
           def _handle_config_command(

     

       417
       +
               self,

     

       418
       +
               message: dict[str, Any],

     

       419
       +
               bot_handler: BotHandler,

     

       420
       +
               args: list[str],

     

       421
       +
               sender: str,

     

       422
       +
           ) -> None:

     

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

     

       424
       +
               if len(args) < 2:

     

       425
       +
                   bot_handler.send_reply(

     

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

     

       427
       +
                   )

     

       428
       +
                   return

     

       429
       +
       

     

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

     

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

     

       432
       +
       

     

       433
       +
               if setting == "stream":

     

       434
       +
                   old_value = self.stream_name

     

       435
       +
                   self.stream_name = value

     

       436
       +
                   self._save_bot_config(bot_handler)

     

       437
       +
                   bot_handler.send_reply(

     

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

     

       439
       +
                   )

     

       440
       +
                   self._send_config_change_notification(

     

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

     

       442
       +
                   )

     

       443
       +
       

     

       444
       +
               elif setting == "topic":

     

       445
       +
                   old_value = self.topic_name

     

       446
       +
                   self.topic_name = value

     

       447
       +
                   self._save_bot_config(bot_handler)

     

       448
       +
                   bot_handler.send_reply(

     

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

     

       450
       +
                   )

     

       451
       +
                   self._send_config_change_notification(

     

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

     

       453
       +
                   )

     

       454
       +
       

     

       455
       +
               elif setting == "interval":

     

       456
       +
                   try:

     

       457
       +
                       interval = int(value)

     

       458
       +
                       if interval < 60:

     

       459
       +
                           bot_handler.send_reply(

     

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

     

       461
       +
                           )

     

       462
       +
                           return

     

       463
       +
                       old_value = self.sync_interval

     

       464
       +
                       self.sync_interval = interval

     

       465
       +
                       self._save_bot_config(bot_handler)

     

       466
       +
                       bot_handler.send_reply(

     

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

     

       468
       +
                       )

     

       469
       +
                       self._send_config_change_notification(

     

       470
       +
                           bot_handler,

     

       471
       +
                           sender,

     

       472
       +
                           "sync interval",

     

       473
       +
                           f"{old_value}s",

     

       474
       +
                           f"{interval}s",

     

       475
       +
                       )

     

       476
       +
                   except ValueError:

     

       477
       +
                       bot_handler.send_reply(

     

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

     

       479
       +
                       )

     

       480
       +
       

     

       481
       +
               elif setting == "max_entries":

     

       482
       +
                   try:

     

       483
       +
                       max_entries = int(value)

     

       484
       +
                       if max_entries < 1 or max_entries > 50:

     

       485
       +
                           bot_handler.send_reply(

     

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

     

       487
       +
                           )

     

       488
       +
                           return

     

       489
       +
                       old_value = self.max_entries_per_sync

     

       490
       +
                       self.max_entries_per_sync = max_entries

     

       491
       +
                       self._save_bot_config(bot_handler)

     

       492
       +
                       bot_handler.send_reply(

     

       493
       +
                           message,

     

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

     

       495
       +
                       )

     

       496
       +
                       self._send_config_change_notification(

     

       497
       +
                           bot_handler,

     

       498
       +
                           sender,

     

       499
       +
                           "max entries per sync",

     

       500
       +
                           str(old_value),

     

       501
       +
                           str(max_entries),

     

       502
       +
                       )

     

       503
       +
                   except ValueError:

     

       504
       +
                       bot_handler.send_reply(

     

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

     

       506
       +
                       )

     

       507
       +
       

     

       508
       +
               else:

     

       509
       +
                   bot_handler.send_reply(

     

       510
       +
                       message,

     

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

     

       512
       +
                   )

     

       513
       +
       

     

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

     

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

     

       516
       +
               try:

     

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

     

       518
       +
                   if config_data:

     

       519
       +
                       config = json.loads(config_data)

     

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

     

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

     

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

     

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

     

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

     

       525
       +
               except Exception:

     

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

     

       527
       +
                   pass

     

       528
       +
       

     

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

     

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

     

       531
       +
               try:

     

       532
       +
                   config_data = {

     

       533
       +
                       "stream_name": self.stream_name,

     

       534
       +
                       "topic_name": self.topic_name,

     

       535
       +
                       "sync_interval": self.sync_interval,

     

       536
       +
                       "max_entries_per_sync": self.max_entries_per_sync,

     

       537
       +
                       "last_sync_time": self.last_sync_time,

     

       538
       +
                   }

     

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

     

       540
       +
               except Exception as e:

     

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

     

       542
       +
       

     

       543
       +
           def _load_botrc_defaults(self) -> None:

     

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

     

       545
       +
               try:

     

       546
       +
                   import configparser

     

       547
       +
                   from pathlib import Path

     

       548
       +
       

     

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

     

       550
       +
                   if not botrc_path.exists():

     

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

     

       552
       +
                       return

     

       553
       +
       

     

       554
       +
                   config = configparser.ConfigParser()

     

       555
       +
                   config.read(botrc_path)

     

       556
       +
       

     

       557
       +
                   if "bot" in config:

     

       558
       +
                       bot_section = config["bot"]

     

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

     

       560
       +
                       self.max_entries_per_sync = bot_section.getint(

     

       561
       +
                           "max_entries_per_sync", 10

     

       562
       +
                       )

     

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

     

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

     

       565
       +
       

     

       566
       +
                       # Set defaults only if not already configured

     

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

     

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

     

       569
       +
                       if default_stream:

     

       570
       +
                           self.stream_name = default_stream

     

       571
       +
                       if default_topic:

     

       572
       +
                           self.topic_name = default_topic

     

       573
       +
       

     

       574
       +
                   if "catchup" in config:

     

       575
       +
                       catchup_section = config["catchup"]

     

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

     

       577
       +
       

     

       578
       +
                   if "notifications" in config:

     

       579
       +
                       notifications_section = config["notifications"]

     

       580
       +
                       self.config_change_notifications = notifications_section.getboolean(

     

       581
       +
                           "config_change_notifications", True

     

       582
       +
                       )

     

       583
       +
                       self.username_claim_notifications = notifications_section.getboolean(

     

       584
       +
                           "username_claim_notifications", True

     

       585
       +
                       )

     

       586
       +
       

     

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

     

       588
       +
       

     

       589
       +
               except Exception as e:

     

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

     

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

     

       592
       +
       

     

       593
       +
           def _initialize_thicket(self) -> None:

     

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

     

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

     

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

     

       597
       +
       

     

       598
       +
               # Load thicket configuration

     

       599
       +
               import yaml

     

       600
       +
       

     

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

     

       602
       +
                   config_data = yaml.safe_load(f)

     

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

     

       604
       +
       

     

       605
       +
               # Initialize git store

     

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

     

       607
       +
       

     

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

     

       609
       +
       

     

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

     

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

     

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

     

       613
       +
                   return

     

       614
       +
       

     

       615
       +
               # Get current Zulip server from environment

     

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

     

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

     

       618
       +
       

     

       619
       +
               # Check if debug user exists in thicket

     

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

     

       621
       +
               if not user:

     

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

     

       623
       +
       

     

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

     

       625
       +
               if not server_url:

     

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

     

       627
       +
       

     

       628
       +
               zulip_user_id = user.get_zulip_mention(server_url)

     

       629
       +
               if not zulip_user_id:

     

       630
       +
                   raise ValueError(

     

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

     

       632
       +
                   )

     

       633
       +
       

     

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

     

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

     

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

     

       637
       +
               if actual_user_id and actual_user_id != zulip_user_id:

     

       638
       +
                   # Successfully resolved to numeric ID

     

       639
       +
                   self.debug_zulip_user_id = actual_user_id

     

       640
       +
                   self.logger.info(

     

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

     

       642
       +
                   )

     

       643
       +
               else:

     

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

     

       645
       +
                   self.debug_zulip_user_id = zulip_user_id

     

       646
       +
                   self.logger.info(

     

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

     

       648
       +
                   )

     

       649
       +
       

     

       650
       +
           def _lookup_zulip_user_id(

     

       651
       +
               self, bot_handler: BotHandler, email_or_id: str

     

       652
       +
           ) -> Optional[str]:

     

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

     

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

     

       655
       +
               if email_or_id.isdigit():

     

       656
       +
                   return email_or_id

     

       657
       +
       

     

       658
       +
               try:

     

       659
       +
                   client = bot_handler._client

     

       660
       +
                   if not client:

     

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

     

       662
       +
                       return None

     

       663
       +
       

     

       664
       +
                   # First try the get_user_by_email API if available

     

       665
       +
                   try:

     

       666
       +
                       user_result = client.get_user_by_email(email_or_id)

     

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

     

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

     

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

     

       670
       +
                           if user_id:

     

       671
       +
                               self.logger.info(

     

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

     

       673
       +
                               )

     

       674
       +
                               return str(user_id)

     

       675
       +
                   except (AttributeError, Exception):

     

       676
       +
                       pass

     

       677
       +
       

     

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

     

       679
       +
                   users_result = client.get_users()

     

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

     

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

     

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

     

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

     

       684
       +
       

     

       685
       +
                           if (

     

       686
       +
                               user_email == email_or_id

     

       687
       +
                               or delivery_email == email_or_id

     

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

     

       689
       +
                           ):

     

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

     

       691
       +
                               return str(user_id)

     

       692
       +
       

     

       693
       +
                       self.logger.error(

     

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

     

       695
       +
                       )

     

       696
       +
                       return None

     

       697
       +
                   else:

     

       698
       +
                       self.logger.error(

     

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

     

       700
       +
                       )

     

       701
       +
                       return None

     

       702
       +
       

     

       703
       +
               except Exception as e:

     

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

     

       705
       +
                   return None

     

       706
       +
       

     

       707
       +
           def _lookup_zulip_user_info(

     

       708
       +
               self, bot_handler: BotHandler, email_or_id: str

     

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

     

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

     

       711
       +
               if email_or_id.isdigit():

     

       712
       +
                   return email_or_id, None

     

       713
       +
       

     

       714
       +
               try:

     

       715
       +
                   client = bot_handler._client

     

       716
       +
                   if not client:

     

       717
       +
                       return None, None

     

       718
       +
       

     

       719
       +
                   # Try get_user_by_email API first

     

       720
       +
                   try:

     

       721
       +
                       user_result = client.get_user_by_email(email_or_id)

     

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

     

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

     

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

     

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

     

       726
       +
                           if user_id:

     

       727
       +
                               return str(user_id), full_name

     

       728
       +
                   except AttributeError:

     

       729
       +
                       pass

     

       730
       +
       

     

       731
       +
                   # Fallback: search all users

     

       732
       +
                   users_result = client.get_users()

     

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

     

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

     

       735
       +
                           if (

     

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

     

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

     

       738
       +
                           ):

     

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

     

       740
       +
       

     

       741
       +
                   return None, None

     

       742
       +
       

     

       743
       +
               except Exception as e:

     

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

     

       745
       +
                   return None, None

     

       746
       +
       

     

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

     

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

     

       749
       +
               try:

     

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

     

       751
       +
                   if posted_data:

     

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

     

       753
       +
               except Exception:

     

       754
       +
                   # Empty set on first run is expected

     

       755
       +
                   self.posted_entries = set()

     

       756
       +
       

     

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

     

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

     

       759
       +
               try:

     

       760
       +
                   bot_handler.storage.put(

     

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

     

       762
       +
                   )

     

       763
       +
               except Exception as e:

     

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

     

       765
       +
       

     

       766
       +
           def _check_initialization(

     

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

     

       768
       +
           ) -> bool:

     

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

     

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

     

       771
       +
                   bot_handler.send_reply(

     

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

     

       773
       +
                   )

     

       774
       +
                   return False

     

       775
       +
       

     

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

     

       777
       +
               if self.debug_user:

     

       778
       +
                   return True

     

       779
       +
       

     

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

     

       781
       +
                   bot_handler.send_reply(

     

       782
       +
                       message,

     

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

     

       784
       +
                   )

     

       785
       +
                   return False

     

       786
       +
       

     

       787
       +
               return True

     

       788
       +
       

     

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

     

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

     

       791
       +
       

     

       792
       +
               def sync_loop():

     

       793
       +
                   while True:

     

       794
       +
                       try:

     

       795
       +
                           # Check if we can sync

     

       796
       +
                           can_sync = self.git_store and (

     

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

     

       798
       +
                           )

     

       799
       +
       

     

       800
       +
                           if can_sync:

     

       801
       +
                               self._perform_sync(bot_handler)

     

       802
       +
       

     

       803
       +
                           time.sleep(self.sync_interval)

     

       804
       +
                       except Exception as e:

     

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

     

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

     

       807
       +
       

     

       808
       +
               # Start background thread

     

       809
       +
               import threading

     

       810
       +
       

     

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

     

       812
       +
               sync_thread.start()

     

       813
       +
       

     

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

     

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

     

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

     

       817
       +
                   return []

     

       818
       +
       

     

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

     

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

     

       821
       +
       

     

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

     

       823
       +
               users_with_feeds = self.git_store.list_all_users_with_feeds()

     

       824
       +
       

     

       825
       +
               # Sync each user's feeds

     

       826
       +
               for username, feed_urls in users_with_feeds:

     

       827
       +
                   for feed_url in feed_urls:

     

       828
       +
                       try:

     

       829
       +
                           # Run async sync function

     

       830
       +
                           loop = asyncio.new_event_loop()

     

       831
       +
                           asyncio.set_event_loop(loop)

     

       832
       +
                           try:

     

       833
       +
                               new_count, _ = loop.run_until_complete(

     

       834
       +
                                   sync_feed(

     

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

     

       836
       +
                                   )

     

       837
       +
                               )

     

       838
       +
       

     

       839
       +
                               entries_to_check = []

     

       840
       +
       

     

       841
       +
                               if new_count > 0:

     

       842
       +
                                   # Get the newly added entries

     

       843
       +
                                   entries_to_check = self.git_store.list_entries(

     

       844
       +
                                       username, limit=new_count

     

       845
       +
                                   )

     

       846
       +
       

     

       847
       +
                               # Always check for catchup mode on first run

     

       848
       +
                               if is_first_run:

     

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

     

       850
       +
                                   catchup_entries = self.git_store.list_entries(

     

       851
       +
                                       username, limit=self.catchup_entries

     

       852
       +
                                   )

     

       853
       +
                                   entries_to_check = (

     

       854
       +
                                       catchup_entries

     

       855
       +
                                       if not entries_to_check

     

       856
       +
                                       else entries_to_check

     

       857
       +
                                   )

     

       858
       +
       

     

       859
       +
                               for entry in entries_to_check:

     

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

     

       861
       +
                                   if entry_key not in self.posted_entries:

     

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

     

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

     

       864
       +
                                           break

     

       865
       +
       

     

       866
       +
                           finally:

     

       867
       +
                               loop.close()

     

       868
       +
       

     

       869
       +
                       except Exception as e:

     

       870
       +
                           self.logger.error(

     

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

     

       872
       +
                           )

     

       873
       +
       

     

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

     

       875
       +
                           break

     

       876
       +
       

     

       877
       +
               # Post new entries to Zulip with rate limiting

     

       878
       +
               if new_entries:

     

       879
       +
                   posted_count = 0

     

       880
       +
       

     

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

     

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

     

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

     

       884
       +
                       posted_count += 1

     

       885
       +
       

     

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

     

       887
       +
                       if (

     

       888
       +
                           posted_count % self.posts_per_batch == 0

     

       889
       +
                           and i < len(new_entries) - 1

     

       890
       +
                       ):

     

       891
       +
                           time.sleep(self.rate_limit_delay)

     

       892
       +
       

     

       893
       +
                   self._save_posted_entries(bot_handler)

     

       894
       +
       

     

       895
       +
               # Update last sync time

     

       896
       +
               self.last_sync_time = time.time()

     

       897
       +
       

     

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

     

       899
       +
       

     

       900
       +
           def _post_entry_to_zulip(

     

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

     

       902
       +
           ) -> None:

     

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

     

       904
       +
               try:

     

       905
       +
                   # Get current Zulip server from environment

     

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

     

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

     

       908
       +
       

     

       909
       +
                   # Build author/date info consistently

     

       910
       +
                   mention_info = ""

     

       911
       +
                   if server_url and self.git_store:

     

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

     

       913
       +
                       if user:

     

       914
       +
                           zulip_user_id = user.get_zulip_mention(server_url)

     

       915
       +
                           if zulip_user_id:

     

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

     

       917
       +
                               _, zulip_full_name = self._lookup_zulip_user_info(

     

       918
       +
                                   bot_handler, zulip_user_id

     

       919
       +
                               )

     

       920
       +
                               display_name = zulip_full_name or user.display_name or username

     

       921
       +
       

     

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

     

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

     

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

     

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

     

       926
       +
                               else:

     

       927
       +
                                   author_info = ""

     

       928
       +
       

     

       929
       +
                               published_info = ""

     

       930
       +
                               if entry.published:

     

       931
       +
                                   published_info = (

     

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

     

       933
       +
                                   )

     

       934
       +
       

     

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

     

       936
       +
       

     

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

     

       938
       +
                   if not mention_info:

     

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

     

       940
       +
                       display_name = user.display_name if user else username

     

       941
       +
       

     

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

     

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

     

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

     

       945
       +
                       else:

     

       946
       +
                           author_info = ""

     

       947
       +
       

     

       948
       +
                       published_info = ""

     

       949
       +
                       if entry.published:

     

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

     

       951
       +
       

     

       952
       +
                       mention_info = (

     

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

     

       954
       +
                       )

     

       955
       +
       

     

       956
       +
                   # Format the message with HTML processing

     

       957
       +
                   message_lines = [

     

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

     

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

     

       960
       +
                   ]

     

       961
       +
       

     

       962
       +
                   if entry.summary:

     

       963
       +
                       # Process HTML in summary and truncate if needed

     

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

     

       965
       +
                       if len(processed_summary) > 400:

     

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

     

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

     

       968
       +
       

     

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

     

       970
       +
       

     

       971
       +
                   # Choose destination based on mode

     

       972
       +
                   if self.debug_user and self.debug_zulip_user_id:

     

       973
       +
                       # Debug mode: send DM

     

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

     

       975
       +
       

     

       976
       +
                       # Ensure we have the numeric user ID

     

       977
       +
                       user_id_to_use = self.debug_zulip_user_id

     

       978
       +
                       if not user_id_to_use.isdigit():

     

       979
       +
                           # Need to look up the numeric ID

     

       980
       +
                           resolved_id = self._lookup_zulip_user_id(

     

       981
       +
                               bot_handler, user_id_to_use

     

       982
       +
                           )

     

       983
       +
                           if resolved_id:

     

       984
       +
                               user_id_to_use = resolved_id

     

       985
       +
                               self.logger.debug(

     

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

     

       987
       +
                               )

     

       988
       +
                           else:

     

       989
       +
                               self.logger.error(

     

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

     

       991
       +
                               )

     

       992
       +
                               return

     

       993
       +
       

     

       994
       +
                       try:

     

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

     

       996
       +
                           user_id_int = int(user_id_to_use)

     

       997
       +
                           bot_handler.send_message(

     

       998
       +
                               {

     

       999
       +
                                   "type": "private",

     

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

     

       1001
       +
                                   "content": debug_message,

     

       1002
       +
                               }

     

       1003
       +
                           )

     

       1004
       +
                       except ValueError:

     

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

     

       1006
       +
                           try:

     

       1007
       +
                               bot_handler.send_message(

     

       1008
       +
                                   {

     

       1009
       +
                                       "type": "private",

     

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

     

       1011
       +
                                       "content": debug_message,

     

       1012
       +
                                   }

     

       1013
       +
                               )

     

       1014
       +
                           except Exception as e2:

     

       1015
       +
                               self.logger.error(

     

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

     

       1017
       +
                               )

     

       1018
       +
                               return

     

       1019
       +
                       except Exception as e:

     

       1020
       +
                           self.logger.error(

     

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

     

       1022
       +
                           )

     

       1023
       +
                           return

     

       1024
       +
                       self.logger.info(

     

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

     

       1026
       +
                       )

     

       1027
       +
                   else:

     

       1028
       +
                       # Normal mode: send to stream/topic

     

       1029
       +
                       bot_handler.send_message(

     

       1030
       +
                           {

     

       1031
       +
                               "type": "stream",

     

       1032
       +
                               "to": self.stream_name,

     

       1033
       +
                               "subject": self.topic_name,

     

       1034
       +
                               "content": message_content,

     

       1035
       +
                           }

     

       1036
       +
                       )

     

       1037
       +
                       self.logger.info(

     

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

     

       1039
       +
                       )

     

       1040
       +
       

     

       1041
       +
               except Exception as e:

     

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

     

       1043
       +
       

     

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

     

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

     

       1046
       +
               if not html_content:

     

       1047
       +
                   return ""

     

       1048
       +
       

     

       1049
       +
               try:

     

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

     

       1051
       +
                   from markdownify import markdownify as md

     

       1052
       +
       

     

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

     

       1054
       +
                   markdown = md(

     

       1055
       +
                       html_content,

     

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

     

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

     

       1058
       +
                       convert=[

     

       1059
       +
                           "a",

     

       1060
       +
                           "b",

     

       1061
       +
                           "strong",

     

       1062
       +
                           "i",

     

       1063
       +
                           "em",

     

       1064
       +
                           "code",

     

       1065
       +
                           "pre",

     

       1066
       +
                           "p",

     

       1067
       +
                           "br",

     

       1068
       +
                           "ul",

     

       1069
       +
                           "ol",

     

       1070
       +
                           "li",

     

       1071
       +
                           "h1",

     

       1072
       +
                           "h2",

     

       1073
       +
                           "h3",

     

       1074
       +
                           "h4",

     

       1075
       +
                           "h5",

     

       1076
       +
                           "h6",

     

       1077
       +
                       ],

     

       1078
       +
                   ).strip()

     

       1079
       +
       

     

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

     

       1081
       +
                   import re

     

       1082
       +
       

     

       1083
       +
                   # Convert markdown headers to bold with period

     

       1084
       +
                   markdown = re.sub(

     

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

     

       1086
       +
                   )

     

       1087
       +
       

     

       1088
       +
                   # Clean up excessive newlines and make more compact

     

       1089
       +
                   markdown = re.sub(

     

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

     

       1091
       +
                   )  # Multiple newlines become space

     

       1092
       +
                   markdown = re.sub(

     

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

     

       1094
       +
                   )  # Double newlines become sentence breaks

     

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

     

       1096
       +
       

     

       1097
       +
                   # Clean up double periods and excessive whitespace

     

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

     

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

     

       1100
       +
                   return markdown.strip()

     

       1101
       +
       

     

       1102
       +
               except ImportError:

     

       1103
       +
                   # Fallback: manual HTML processing

     

       1104
       +
                   import re

     

       1105
       +
       

     

       1106
       +
                   content = html_content

     

       1107
       +
       

     

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

     

       1109
       +
                   content = re.sub(

     

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

     

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

     

       1112
       +
                       content,

     

       1113
       +
                       flags=re.IGNORECASE,

     

       1114
       +
                   )

     

       1115
       +
       

     

       1116
       +
                   # Convert common HTML elements to Markdown

     

       1117
       +
                   content = re.sub(

     

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

     

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

     

       1120
       +
                       content,

     

       1121
       +
                       flags=re.IGNORECASE,

     

       1122
       +
                   )

     

       1123
       +
                   content = re.sub(

     

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

     

       1125
       +
                       r"*\1*",

     

       1126
       +
                       content,

     

       1127
       +
                       flags=re.IGNORECASE,

     

       1128
       +
                   )

     

       1129
       +
                   content = re.sub(

     

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

     

       1131
       +
                       r"`\1`",

     

       1132
       +
                       content,

     

       1133
       +
                       flags=re.IGNORECASE,

     

       1134
       +
                   )

     

       1135
       +
                   content = re.sub(

     

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

     

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

     

       1138
       +
                       content,

     

       1139
       +
                       flags=re.IGNORECASE,

     

       1140
       +
                   )

     

       1141
       +
       

     

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

     

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

     

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

     

       1145
       +
                   content = re.sub(

     

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

     

       1147
       +
                   )

     

       1148
       +
       

     

       1149
       +
                   # Remove remaining HTML tags

     

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

     

       1151
       +
       

     

       1152
       +
                   # Clean up whitespace and make compact

     

       1153
       +
                   content = re.sub(

     

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

     

       1155
       +
                   )  # Multiple whitespace becomes single space

     

       1156
       +
                   content = re.sub(

     

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

     

       1158
       +
                   )  # Multiple periods become single period

     

       1159
       +
                   return content.strip()

     

       1160
       +
       

     

       1161
       +
               except Exception as e:

     

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

     

       1163
       +
                   # Last resort: just strip HTML tags

     

       1164
       +
                   import re

     

       1165
       +
       

     

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

     

       1167
       +
       

     

       1168
       +
           def _get_schedule_info(self) -> str:

     

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

     

       1170
       +
               lines = []

     

       1171
       +
       

     

       1172
       +
               if self.last_sync_time:

     

       1173
       +
                   import datetime

     

       1174
       +
       

     

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

     

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

     

       1177
       +
                   now = datetime.datetime.now()

     

       1178
       +
       

     

       1179
       +
                   # Calculate time until next sync

     

       1180
       +
                   time_until_next = next_sync - now

     

       1181
       +
       

     

       1182
       +
                   if time_until_next.total_seconds() > 0:

     

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

     

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

     

       1185
       +
       

     

       1186
       +
                       if hours > 0:

     

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

     

       1188
       +
                       elif minutes > 0:

     

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

     

       1190
       +
                       else:

     

       1191
       +
                           time_str = f"{seconds}s"

     

       1192
       +
       

     

       1193
       +
                       lines.extend(

     

       1194
       +
                           [

     

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

     

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

     

       1197
       +
                           ]

     

       1198
       +
                       )

     

       1199
       +
                   else:

     

       1200
       +
                       lines.extend(

     

       1201
       +
                           [

     

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

     

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

     

       1204
       +
                           ]

     

       1205
       +
                       )

     

       1206
       +
               else:

     

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

     

       1208
       +
       

     

       1209
       +
               # Add sync frequency info

     

       1210
       +
               if self.sync_interval >= 3600:

     

       1211
       +
                   frequency_str = (

     

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

     

       1213
       +
                   )

     

       1214
       +
               elif self.sync_interval >= 60:

     

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

     

       1216
       +
               else:

     

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

     

       1218
       +
       

     

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

     

       1220
       +
       

     

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

     

       1222
       +
       

     

       1223
       +
           def _send_config_change_notification(

     

       1224
       +
               self,

     

       1225
       +
               bot_handler: BotHandler,

     

       1226
       +
               changer: str,

     

       1227
       +
               setting: str,

     

       1228
       +
               old_value: Optional[str],

     

       1229
       +
               new_value: str,

     

       1230
       +
           ) -> None:

     

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

     

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

     

       1233
       +
                   return

     

       1234
       +
       

     

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

     

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

     

       1237
       +
                   return

     

       1238
       +
       

     

       1239
       +
               try:

     

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

     

       1241
       +
                   notification_msg = (

     

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

     

       1243
       +
                   )

     

       1244
       +
       

     

       1245
       +
                   bot_handler.send_message(

     

       1246
       +
                       {

     

       1247
       +
                           "type": "stream",

     

       1248
       +
                           "to": self.stream_name,

     

       1249
       +
                           "subject": self.topic_name,

     

       1250
       +
                           "content": notification_msg,

     

       1251
       +
                       }

     

       1252
       +
                   )

     

       1253
       +
               except Exception as e:

     

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

     

       1255
       +
       

     

       1256
       +
       

     

       1257
       +
       handler_class = ThicketBotHandler

+24 -2

src/thicket/cli/commands/__init__.py

···

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

     

       2
        
       

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

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

     

       2
        
       

     

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

     

       4
       +
       from . import (

     

       5
       +
           add,

     

       6
       +
           bot,

     

       7
       +
           duplicates,

     

       8
       +
           info_cmd,

     

       9
       +
           init,

     

       10
       +
           list_cmd,

     

       11
       +
           search,

     

       12
       +
           sync,

     

       13
       +
           upload,

     

       14
       +
           zulip,

     

       15
       +
       )

     

       16
        
       

     

       17
       +
       __all__ = [

     

       18
       +
           "add",

     

       19
       +
           "bot",

     

       20
       +
           "duplicates",

     

       21
       +
           "info_cmd",

     

       22
       +
           "init",

     

       23
       +
           "list_cmd",

     

       24
       +
           "search",

     

       25
       +
           "sync",

     

       26
       +
           "upload",

     

       27
       +
           "zulip",

     

       28
       +
       ]

+44 -9

src/thicket/cli/commands/add.py

···

       23
        
       def add_command(

     

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

     

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

     

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

     

       0
        
       
     

       0
        
       
     

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

     

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

     

       0
        
       
     

       0
        
       
     

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

     

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

     

       0
        
       
     

       0
        
       
     

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

     

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

     

       33
        
           ),

     

       34
        
           auto_discover: bool = typer.Option(

     

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

     

       0
        
       
     

       0
        
       
     

       36
        
           ),

     

       37
        
       ) -> None:

     

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

     

       39
        
       

     

       40
        
           if subcommand == "user":

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       42
        
           elif subcommand == "feed":

     

       43
        
               add_feed(username, feed_url, config_file)

     

       44
        
           else:

     
···

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

     

       90
        
       

     

       91
        
           # Prepare user data with manual overrides taking precedence

     

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

     

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

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
       

     

       97
        
           # Add user to Git store

     

       98
        
           git_store.add_user(

···

       23
        
       def add_command(

     

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

     

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

     

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

     

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

     

       28
       +
           ),

     

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

     

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

     

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

     

       32
       +
           ),

     

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

     

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

     

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

     

       36
       +
           ),

     

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

     

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

     

       39
        
           ),

     

       40
        
           auto_discover: bool = typer.Option(

     

       41
       +
               True,

     

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

     

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

     

       44
        
           ),

     

       45
        
       ) -> None:

     

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

     

       47
        
       

     

       48
        
           if subcommand == "user":

     

       49
       +
               add_user(

     

       50
       +
                   username,

     

       51
       +
                   feed_url,

     

       52
       +
                   email,

     

       53
       +
                   homepage,

     

       54
       +
                   icon,

     

       55
       +
                   display_name,

     

       56
       +
                   config_file,

     

       57
       +
                   auto_discover,

     

       58
       +
               )

     

       59
        
           elif subcommand == "feed":

     

       60
        
               add_feed(username, feed_url, config_file)

     

       61
        
           else:

     
···

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

     

       107
        
       

     

       108
        
           # Prepare user data with manual overrides taking precedence

     

       109
       +
           user_display_name = display_name or (

     

       110
       +
               discovered_metadata.author_name or discovered_metadata.title

     

       111
       +
               if discovered_metadata

     

       112
       +
               else None

     

       113
       +
           )

     

       114
       +
           user_email = email or (

     

       115
       +
               discovered_metadata.author_email if discovered_metadata else None

     

       116
       +
           )

     

       117
       +
           user_homepage = homepage or (

     

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

     

       119
       +
               if discovered_metadata

     

       120
       +
               else None

     

       121
       +
           )

     

       122
       +
           user_icon = icon or (

     

       123
       +
               str(

     

       124
       +
                   discovered_metadata.logo

     

       125
       +
                   or discovered_metadata.icon

     

       126
       +
                   or discovered_metadata.image_url

     

       127
       +
               )

     

       128
       +
               if discovered_metadata

     

       129
       +
               else None

     

       130
       +
           )

     

       131
        
       

     

       132
        
           # Add user to Git store

     

       133
        
           git_store.add_user(

+247

src/thicket/cli/commands/bot.py

···

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

     

       2
       +
       

     

       3
       +
       import subprocess

     

       4
       +
       import sys

     

       5
       +
       from pathlib import Path

     

       6
       +
       

     

       7
       +
       import typer

     

       8
       +
       from rich.console import Console

     

       9
       +
       

     

       10
       +
       from ..main import app

     

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

     

       12
       +
       

     

       13
       +
       console = Console()

     

       14
       +
       

     

       15
       +
       

     

       16
       +
       @app.command()

     

       17
       +
       def bot(

     

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

     

       19
       +
           config_file: Path = typer.Option(

     

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

     

       21
       +
               "--config",

     

       22
       +
               "-c",

     

       23
       +
               help="Zulip bot configuration file",

     

       24
       +
           ),

     

       25
       +
           thicket_config: Path = typer.Option(

     

       26
       +
               Path("thicket.yaml"),

     

       27
       +
               "--thicket-config",

     

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

     

       29
       +
           ),

     

       30
       +
           daemon: bool = typer.Option(

     

       31
       +
               False,

     

       32
       +
               "--daemon",

     

       33
       +
               "-d",

     

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

     

       35
       +
           ),

     

       36
       +
           debug_user: str = typer.Option(

     

       37
       +
               None,

     

       38
       +
               "--debug-user",

     

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

     

       40
       +
           ),

     

       41
       +
       ) -> None:

     

       42
       +
           """Manage the Thicket Zulip bot.

     

       43
       +
       

     

       44
       +
           Actions:

     

       45
       +
           - run: Start the Zulip bot

     

       46
       +
           - test: Test bot functionality

     

       47
       +
           - status: Show bot status

     

       48
       +
           """

     

       49
       +
       

     

       50
       +
           if action == "run":

     

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

     

       52
       +
           elif action == "test":

     

       53
       +
               _test_bot()

     

       54
       +
           elif action == "status":

     

       55
       +
               _bot_status(config_file)

     

       56
       +
           else:

     

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

     

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

     

       59
       +
               raise typer.Exit(1)

     

       60
       +
       

     

       61
       +
       

     

       62
       +
       def _run_bot(

     

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

     

       64
       +
       ) -> None:

     

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

     

       66
       +
           if not config_file.exists():

     

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

     

       68
       +
               print_info(

     

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

     

       70
       +
               )

     

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

     

       72
       +
               raise typer.Exit(1)

     

       73
       +
       

     

       74
       +
           if not thicket_config.exists():

     

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

     

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

     

       77
       +
               raise typer.Exit(1)

     

       78
       +
       

     

       79
       +
           # Parse zuliprc to extract server URL

     

       80
       +
           zulip_site_url = _parse_zulip_config(config_file)

     

       81
       +
       

     

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

     

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

     

       84
       +
       

     

       85
       +
           if debug_user:

     

       86
       +
               print_info(

     

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

     

       88
       +
               )

     

       89
       +
       

     

       90
       +
           if daemon:

     

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

     

       92
       +
           else:

     

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

     

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

     

       95
       +
       

     

       96
       +
           try:

     

       97
       +
               # Build the command

     

       98
       +
               cmd = [

     

       99
       +
                   sys.executable,

     

       100
       +
                   "-m",

     

       101
       +
                   "zulip_bots.run",

     

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

     

       103
       +
                   "--config-file",

     

       104
       +
                   str(config_file),

     

       105
       +
               ]

     

       106
       +
       

     

       107
       +
               # Add environment variables for bot configuration

     

       108
       +
               import os

     

       109
       +
       

     

       110
       +
               env = os.environ.copy()

     

       111
       +
       

     

       112
       +
               # Always pass thicket config path

     

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

     

       114
       +
       

     

       115
       +
               # Add debug user if specified

     

       116
       +
               if debug_user:

     

       117
       +
                   env["THICKET_DEBUG_USER"] = debug_user

     

       118
       +
       

     

       119
       +
               # Pass Zulip server URL to bot

     

       120
       +
               if zulip_site_url:

     

       121
       +
                   env["THICKET_ZULIP_SITE_URL"] = zulip_site_url

     

       122
       +
       

     

       123
       +
               if daemon:

     

       124
       +
                   # Run in background

     

       125
       +
                   process = subprocess.Popen(

     

       126
       +
                       cmd,

     

       127
       +
                       stdout=subprocess.DEVNULL,

     

       128
       +
                       stderr=subprocess.DEVNULL,

     

       129
       +
                       start_new_session=True,

     

       130
       +
                       env=env,

     

       131
       +
                   )

     

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

     

       133
       +
               else:

     

       134
       +
                   # Run in foreground

     

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

     

       136
       +
       

     

       137
       +
           except subprocess.CalledProcessError as e:

     

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

     

       139
       +
               raise typer.Exit(1) from e

     

       140
       +
           except KeyboardInterrupt:

     

       141
       +
               print_info("Bot stopped by user")

     

       142
       +
       

     

       143
       +
       

     

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

     

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

     

       146
       +
           try:

     

       147
       +
               import configparser

     

       148
       +
       

     

       149
       +
               config = configparser.ConfigParser()

     

       150
       +
               config.read(config_file)

     

       151
       +
       

     

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

     

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

     

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

     

       155
       +
                   return site_url

     

       156
       +
               else:

     

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

     

       158
       +
                   return ""

     

       159
       +
       

     

       160
       +
           except Exception as e:

     

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

     

       162
       +
               return ""

     

       163
       +
       

     

       164
       +
       

     

       165
       +
       def _test_bot() -> None:

     

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

     

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

     

       168
       +
       

     

       169
       +
           try:

     

       170
       +
               from ...bots.test_bot import BotTester

     

       171
       +
       

     

       172
       +
               # Create bot tester

     

       173
       +
               tester = BotTester()

     

       174
       +
       

     

       175
       +
               # Test basic functionality

     

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

     

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

     

       178
       +
               assert len(responses) == 1

     

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

     

       180
       +
       

     

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

     

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

     

       183
       +
               assert len(responses) == 1

     

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

     

       185
       +
       

     

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

     

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

     

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

     

       189
       +
       

     

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

     

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

     

       192
       +
       

     

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

     

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

     

       195
       +
       

     

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

     

       197
       +
       

     

       198
       +
           except Exception as e:

     

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

     

       200
       +
               raise typer.Exit(1) from e

     

       201
       +
       

     

       202
       +
       

     

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

     

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

     

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

     

       206
       +
           console.print()

     

       207
       +
       

     

       208
       +
           # Check config file

     

       209
       +
           if config_file.exists():

     

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

     

       211
       +
           else:

     

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

     

       213
       +
               console.print(

     

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

     

       215
       +
               )

     

       216
       +
               console.print(

     

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

     

       218
       +
               )

     

       219
       +
       

     

       220
       +
           # Check dependencies

     

       221
       +
           try:

     

       222
       +
               import zulip_bots

     

       223
       +
       

     

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

     

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

     

       226
       +
           except ImportError:

     

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

     

       228
       +
       

     

       229
       +
           try:

     

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

     

       231
       +
       

     

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

     

       233
       +
           except ImportError as e:

     

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

     

       235
       +
       

     

       236
       +
           # Check bot file

     

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

     

       238
       +
           if bot_file.exists():

     

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

     

       240
       +
           else:

     

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

     

       242
       +
       

     

       243
       +
           console.print()

     

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

     

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

     

       246
       +
           console.print()

     

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

+7 -3

src/thicket/cli/commands/duplicates.py

···

       10
        
       from ..main import app

     

       11
        
       from ..utils import (

     

       12
        
           console,

     

       0
        
       
     

       13
        
           load_config,

     

       14
        
           print_error,

     

       15
        
           print_info,

     

       16
        
           print_success,

     

       17
       -
           get_tsv_mode,

     

       18
        
       )

     

       19
        
       

     

       20
        
       

     
···

       75
        
               print_info(f"Total duplicates: {len(duplicates.duplicates)}")

     

       76
        
       

     

       77
        
       

     

       78
       -
       def add_duplicate(git_store: GitStore, duplicate_id: Optional[str], canonical_id: Optional[str]) -> None:

     

       0
        
       
     

       0
        
       
     

       79
        
           """Add a duplicate mapping."""

     

       80
        
           if not duplicate_id:

     

       81
        
               print_error("Duplicate ID is required")

     
···

       124
        
           # Remove the mapping

     

       125
        
           if git_store.remove_duplicate(duplicate_id):

     

       126
        
               # Commit changes

     

       127
       -
               git_store.commit_changes(f"Remove duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       0
        
       
     

       0
        
       
     

       128
        
               print_success(f"Removed duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       129
        
           else:

     

       130
        
               print_error(f"Failed to remove duplicate mapping: {duplicate_id}")

···

       10
        
       from ..main import app

     

       11
        
       from ..utils import (

     

       12
        
           console,

     

       13
       +
           get_tsv_mode,

     

       14
        
           load_config,

     

       15
        
           print_error,

     

       16
        
           print_info,

     

       17
        
           print_success,

     

       0
        
       
     

       18
        
       )

     

       19
        
       

     

       20
        
       

     
···

       75
        
               print_info(f"Total duplicates: {len(duplicates.duplicates)}")

     

       76
        
       

     

       77
        
       

     

       78
       +
       def add_duplicate(

     

       79
       +
           git_store: GitStore, duplicate_id: Optional[str], canonical_id: Optional[str]

     

       80
       +
       ) -> None:

     

       81
        
           """Add a duplicate mapping."""

     

       82
        
           if not duplicate_id:

     

       83
        
               print_error("Duplicate ID is required")

     
···

       126
        
           # Remove the mapping

     

       127
        
           if git_store.remove_duplicate(duplicate_id):

     

       128
        
               # Commit changes

     

       129
       +
               git_store.commit_changes(

     

       130
       +
                   f"Remove duplicate mapping: {duplicate_id} -> {canonical_id}"

     

       131
       +
               )

     

       132
        
               print_success(f"Removed duplicate mapping: {duplicate_id} -> {canonical_id}")

     

       133
        
           else:

     

       134
        
               print_error(f"Failed to remove duplicate mapping: {duplicate_id}")

+79 -73

src/thicket/cli/commands/info_cmd.py

···

       7
        
       from rich.console import Console

     

       8
        
       from rich.panel import Panel

     

       9
        
       from rich.table import Table

     

       10
       -
       from rich.text import Text

     

       11
        
       

     

       12
        
       from ...core.git_store import GitStore

     

       13
        
       from ..main import app

     

       14
       -
       from ..utils import load_config, get_tsv_mode

     

       15
        
       

     

       16
        
       console = Console()

     

       17
        
       

     
···

       19
        
       @app.command()

     

       20
        
       def info(

     

       21
        
           identifier: str = typer.Argument(

     

       22
       -
               ...,

     

       23
       -
               help="The atom ID or URL of the entry to display information about"

     

       24
        
           ),

     

       25
        
           username: Optional[str] = typer.Option(

     

       26
        
               None,

     

       27
        
               "--username",

     

       28
        
               "-u",

     

       29
       -
               help="Username to search for the entry (if not provided, searches all users)"

     

       30
        
           ),

     

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

     

       32
        
               Path("thicket.yaml"),

     
···

       35
        
               help="Path to configuration file",

     

       36
        
           ),

     

       37
        
           show_content: bool = typer.Option(

     

       38
       -
               False,

     

       39
       -
               "--content",

     

       40
       -
               help="Include the full content of the entry in the output"

     

       41
        
           ),

     

       42
        
       ) -> None:

     

       43
        
           """Display detailed information about a specific atom entry.

     

       44
       -
           

     

       45
        
           You can specify the entry using either its atom ID or URL.

     

       46
        
           Shows all metadata for the given entry, including title, dates, categories,

     

       47
        
           and summarizes all inbound and outbound links to/from other posts.

     
···

       49
        
           try:

     

       50
        
               # Load configuration

     

       51
        
               config = load_config(config_file)

     

       52
       -
               

     

       53
        
               # Initialize Git store

     

       54
        
               git_store = GitStore(config.git_store)

     

       55
       -
               

     

       56
        
               # Find the entry

     

       57
        
               entry = None

     

       58
        
               found_username = None

     

       59
       -
               

     

       60
        
               # Check if identifier looks like a URL

     

       61
       -
               is_url = identifier.startswith(('http://', 'https://'))

     

       62
       -
               

     

       63
        
               if username:

     

       64
        
                   # Search specific username

     

       65
        
                   if is_url:

     
···

       95
        
                           if entry:

     

       96
        
                               found_username = user

     

       97
        
                               break

     

       98
       -
               

     

       99
        
               if not entry or not found_username:

     

       100
        
                   if username:

     

       101
       -
                       console.print(f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found for user '{username}'[/red]")

     

       0
        
       
     

       0
        
       
     

       102
        
                   else:

     

       103
       -
                       console.print(f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found in any user's entries[/red]")

     

       0
        
       
     

       0
        
       
     

       104
        
                   raise typer.Exit(1)

     

       105
       -
               

     

       106
        
               # Display information

     

       107
        
               if get_tsv_mode():

     

       108
        
                   _display_entry_info_tsv(entry, found_username, show_content)

     

       109
        
               else:

     

       110
        
                   _display_entry_info(entry, found_username)

     

       111
       -
                   

     

       112
        
                   # Display links and backlinks from entry fields

     

       113
        
                   _display_link_info(entry, found_username, git_store)

     

       114
       -
                   

     

       115
        
                   # Optionally display content

     

       116
        
                   if show_content and entry.content:

     

       117
        
                       _display_content(entry.content)

     

       118
       -
                   

     

       119
        
           except Exception as e:

     

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

     

       121
       -
               raise typer.Exit(1)

     

       122
        
       

     

       123
        
       

     

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

     

       125
        
           """Display basic entry information in a structured format."""

     

       126
       -
           

     

       127
        
           # Create main info panel

     

       128
        
           info_table = Table.grid(padding=(0, 2))

     

       129
        
           info_table.add_column("Field", style="cyan bold", width=15)

     

       130
        
           info_table.add_column("Value", style="white")

     

       131
       -
           

     

       132
        
           info_table.add_row("User", f"[green]{username}[/green]")

     

       133
        
           info_table.add_row("Atom ID", f"[blue]{entry.id}[/blue]")

     

       134
        
           info_table.add_row("Title", entry.title)

     

       135
        
           info_table.add_row("Link", str(entry.link))

     

       136
       -
           

     

       137
        
           if entry.published:

     

       138
       -
               info_table.add_row("Published", entry.published.strftime("%Y-%m-%d %H:%M:%S UTC"))

     

       139
       -
           

     

       0
        
       
     

       0
        
       
     

       140
        
           info_table.add_row("Updated", entry.updated.strftime("%Y-%m-%d %H:%M:%S UTC"))

     

       141
       -
           

     

       142
        
           if entry.summary:

     

       143
        
               # Truncate long summaries

     

       144
       -
               summary = entry.summary[:200] + "..." if len(entry.summary) > 200 else entry.summary

     

       0
        
       
     

       0
        
       
     

       145
        
               info_table.add_row("Summary", summary)

     

       146
       -
           

     

       147
        
           if entry.categories:

     

       148
        
               categories_text = ", ".join(entry.categories)

     

       149
        
               info_table.add_row("Categories", categories_text)

     

       150
       -
           

     

       151
        
           if entry.author:

     

       152
        
               author_info = []

     

       153
        
               if "name" in entry.author:

     
···

       156
        
                   author_info.append(f"<{entry.author['email']}>")

     

       157
        
               if author_info:

     

       158
        
                   info_table.add_row("Author", " ".join(author_info))

     

       159
       -
           

     

       160
        
           if entry.content_type:

     

       161
        
               info_table.add_row("Content Type", entry.content_type)

     

       162
       -
           

     

       163
        
           if entry.rights:

     

       164
        
               info_table.add_row("Rights", entry.rights)

     

       165
       -
           

     

       166
        
           if entry.source:

     

       167
        
               info_table.add_row("Source Feed", entry.source)

     

       168
       -
           

     

       169
        
           panel = Panel(

     

       170
       -
               info_table,

     

       171
       -
               title=f"[bold]Entry Information[/bold]",

     

       172
       -
               border_style="blue"

     

       173
        
           )

     

       174
       -
           

     

       175
        
           console.print(panel)

     

       176
        
       

     

       177
        
       

     

       178
        
       def _display_link_info(entry, username: str, git_store: GitStore) -> None:

     

       179
        
           """Display inbound and outbound link information."""

     

       180
       -
           

     

       181
        
           # Get links from entry fields

     

       182
       -
           outbound_links = getattr(entry, 'links', [])

     

       183
       -
           backlinks = getattr(entry, 'backlinks', [])

     

       184
       -
           

     

       185
        
           if not outbound_links and not backlinks:

     

       186
        
               console.print("\n[dim]No cross-references found for this entry.[/dim]")

     

       187
        
               return

     

       188
       -
           

     

       189
        
           # Create links table

     

       190
        
           links_table = Table(title="Cross-References")

     

       191
        
           links_table.add_column("Direction", style="cyan", width=10)

     

       192
        
           links_table.add_column("Target/Source", style="green", width=30)

     

       193
        
           links_table.add_column("URL/ID", style="blue", width=60)

     

       194
       -
           

     

       195
        
           # Add outbound links

     

       196
        
           for link in outbound_links:

     

       197
        
               links_table.add_row("→ Out", "External/Other", link)

     

       198
       -
           

     

       199
        
           # Add backlinks (inbound references)

     

       200
        
           for backlink_id in backlinks:

     

       201
        
               # Try to find which user this entry belongs to

     

       202
        
               source_info = backlink_id

     

       203
        
               # Could enhance this by looking up the actual entry to get username

     

       204
        
               links_table.add_row("← In", "Entry", source_info)

     

       205
       -
           

     

       206
        
           console.print()

     

       207
        
           console.print(links_table)

     

       208
       -
           

     

       209
        
           # Summary

     

       210
       -
           console.print(f"\n[bold]Summary:[/bold] {len(outbound_links)} outbound links, {len(backlinks)} inbound backlinks")

     

       0
        
       
     

       0
        
       
     

       211
        
       

     

       212
        
       

     

       213
        
       def _display_content(content: str) -> None:

     

       214
        
           """Display the full content of the entry."""

     

       215
       -
           

     

       216
        
           # Truncate very long content

     

       217
        
           display_content = content

     

       218
        
           if len(content) > 5000:

     

       219
        
               display_content = content[:5000] + "\n\n[... content truncated ...]"

     

       220
       -
           

     

       221
        
           panel = Panel(

     

       222
        
               display_content,

     

       223
        
               title="[bold]Entry Content[/bold]",

     

       224
        
               border_style="green",

     

       225
       -
               expand=False

     

       226
        
           )

     

       227
       -
           

     

       228
        
           console.print()

     

       229
        
           console.print(panel)

     

       230
        
       

     

       231
        
       

     

       232
        
       def _display_entry_info_tsv(entry, username: str, show_content: bool) -> None:

     

       233
        
           """Display entry information in TSV format."""

     

       234
       -
           

     

       235
        
           # Basic info

     

       236
        
           print("Field\tValue")

     

       237
        
           print(f"User\t{username}")

     

       238
        
           print(f"Atom ID\t{entry.id}")

     

       239
       -
           print(f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}")

     

       0
        
       
     

       0
        
       
     

       240
        
           print(f"Link\t{entry.link}")

     

       241
       -
           

     

       242
        
           if entry.published:

     

       243
        
               print(f"Published\t{entry.published.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       244
       -
           

     

       245
        
           print(f"Updated\t{entry.updated.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       246
       -
           

     

       247
        
           if entry.summary:

     

       248
        
               # Escape tabs and newlines in summary

     

       249
       -
               summary = entry.summary.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       250
        
               print(f"Summary\t{summary}")

     

       251
       -
           

     

       252
        
           if entry.categories:

     

       253
        
               print(f"Categories\t{', '.join(entry.categories)}")

     

       254
       -
           

     

       255
        
           if entry.author:

     

       256
        
               author_info = []

     

       257
        
               if "name" in entry.author:

     
···

       260
        
                   author_info.append(f"<{entry.author['email']}>")

     

       261
        
               if author_info:

     

       262
        
                   print(f"Author\t{' '.join(author_info)}")

     

       263
       -
           

     

       264
        
           if entry.content_type:

     

       265
        
               print(f"Content Type\t{entry.content_type}")

     

       266
       -
           

     

       267
        
           if entry.rights:

     

       268
        
               print(f"Rights\t{entry.rights}")

     

       269
       -
           

     

       270
        
           if entry.source:

     

       271
        
               print(f"Source Feed\t{entry.source}")

     

       272
       -
           

     

       273
        
           # Add links info from entry fields

     

       274
       -
           outbound_links = getattr(entry, 'links', [])

     

       275
       -
           backlinks = getattr(entry, 'backlinks', [])

     

       276
       -
           

     

       277
        
           if outbound_links or backlinks:

     

       278
        
               print(f"Outbound Links\t{len(outbound_links)}")

     

       279
        
               print(f"Backlinks\t{len(backlinks)}")

     

       280
       -
               

     

       281
        
               # Show each link

     

       282
        
               for link in outbound_links:

     

       283
        
                   print(f"→ Link\t{link}")

     

       284
       -
               

     

       285
        
               for backlink_id in backlinks:

     

       286
        
                   print(f"← Backlink\t{backlink_id}")

     

       287
       -
           

     

       288
        
           # Show content if requested

     

       289
        
           if show_content and entry.content:

     

       290
        
               # Escape tabs and newlines in content

     

       291
       -
               content = entry.content.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       292
       -
               print(f"Content\t{content}")

···

       7
        
       from rich.console import Console

     

       8
        
       from rich.panel import Panel

     

       9
        
       from rich.table import Table

     

       0
        
       
     

       10
        
       

     

       11
        
       from ...core.git_store import GitStore

     

       12
        
       from ..main import app

     

       13
       +
       from ..utils import get_tsv_mode, load_config

     

       14
        
       

     

       15
        
       console = Console()

     

       16
        
       

     
···

       18
        
       @app.command()

     

       19
        
       def info(

     

       20
        
           identifier: str = typer.Argument(

     

       21
       +
               ..., help="The atom ID or URL of the entry to display information about"

     

       0
        
       
     

       22
        
           ),

     

       23
        
           username: Optional[str] = typer.Option(

     

       24
        
               None,

     

       25
        
               "--username",

     

       26
        
               "-u",

     

       27
       +
               help="Username to search for the entry (if not provided, searches all users)",

     

       28
        
           ),

     

       29
        
           config_file: Optional[Path] = typer.Option(

     

       30
        
               Path("thicket.yaml"),

     
···

       33
        
               help="Path to configuration file",

     

       34
        
           ),

     

       35
        
           show_content: bool = typer.Option(

     

       36
       +
               False, "--content", help="Include the full content of the entry in the output"

     

       0
        
       
     

       0
        
       
     

       37
        
           ),

     

       38
        
       ) -> None:

     

       39
        
           """Display detailed information about a specific atom entry.

     

       40
       +
       

     

       41
        
           You can specify the entry using either its atom ID or URL.

     

       42
        
           Shows all metadata for the given entry, including title, dates, categories,

     

       43
        
           and summarizes all inbound and outbound links to/from other posts.

     
···

       45
        
           try:

     

       46
        
               # Load configuration

     

       47
        
               config = load_config(config_file)

     

       48
       +
       

     

       49
        
               # Initialize Git store

     

       50
        
               git_store = GitStore(config.git_store)

     

       51
       +
       

     

       52
        
               # Find the entry

     

       53
        
               entry = None

     

       54
        
               found_username = None

     

       55
       +
       

     

       56
        
               # Check if identifier looks like a URL

     

       57
       +
               is_url = identifier.startswith(("http://", "https://"))

     

       58
       +
       

     

       59
        
               if username:

     

       60
        
                   # Search specific username

     

       61
        
                   if is_url:

     
···

       91
        
                           if entry:

     

       92
        
                               found_username = user

     

       93
        
                               break

     

       94
       +
       

     

       95
        
               if not entry or not found_username:

     

       96
        
                   if username:

     

       97
       +
                       console.print(

     

       98
       +
                           f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found for user '{username}'[/red]"

     

       99
       +
                       )

     

       100
        
                   else:

     

       101
       +
                       console.print(

     

       102
       +
                           f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found in any user's entries[/red]"

     

       103
       +
                       )

     

       104
        
                   raise typer.Exit(1)

     

       105
       +
       

     

       106
        
               # Display information

     

       107
        
               if get_tsv_mode():

     

       108
        
                   _display_entry_info_tsv(entry, found_username, show_content)

     

       109
        
               else:

     

       110
        
                   _display_entry_info(entry, found_username)

     

       111
       +
       

     

       112
        
                   # Display links and backlinks from entry fields

     

       113
        
                   _display_link_info(entry, found_username, git_store)

     

       114
       +
       

     

       115
        
                   # Optionally display content

     

       116
        
                   if show_content and entry.content:

     

       117
        
                       _display_content(entry.content)

     

       118
       +
       

     

       119
        
           except Exception as e:

     

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

     

       121
       +
               raise typer.Exit(1) from e

     

       122
        
       

     

       123
        
       

     

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

     

       125
        
           """Display basic entry information in a structured format."""

     

       126
       +
       

     

       127
        
           # Create main info panel

     

       128
        
           info_table = Table.grid(padding=(0, 2))

     

       129
        
           info_table.add_column("Field", style="cyan bold", width=15)

     

       130
        
           info_table.add_column("Value", style="white")

     

       131
       +
       

     

       132
        
           info_table.add_row("User", f"[green]{username}[/green]")

     

       133
        
           info_table.add_row("Atom ID", f"[blue]{entry.id}[/blue]")

     

       134
        
           info_table.add_row("Title", entry.title)

     

       135
        
           info_table.add_row("Link", str(entry.link))

     

       136
       +
       

     

       137
        
           if entry.published:

     

       138
       +
               info_table.add_row(

     

       139
       +
                   "Published", entry.published.strftime("%Y-%m-%d %H:%M:%S UTC")

     

       140
       +
               )

     

       141
       +
       

     

       142
        
           info_table.add_row("Updated", entry.updated.strftime("%Y-%m-%d %H:%M:%S UTC"))

     

       143
       +
       

     

       144
        
           if entry.summary:

     

       145
        
               # Truncate long summaries

     

       146
       +
               summary = (

     

       147
       +
                   entry.summary[:200] + "..." if len(entry.summary) > 200 else entry.summary

     

       148
       +
               )

     

       149
        
               info_table.add_row("Summary", summary)

     

       150
       +
       

     

       151
        
           if entry.categories:

     

       152
        
               categories_text = ", ".join(entry.categories)

     

       153
        
               info_table.add_row("Categories", categories_text)

     

       154
       +
       

     

       155
        
           if entry.author:

     

       156
        
               author_info = []

     

       157
        
               if "name" in entry.author:

     
···

       160
        
                   author_info.append(f"<{entry.author['email']}>")

     

       161
        
               if author_info:

     

       162
        
                   info_table.add_row("Author", " ".join(author_info))

     

       163
       +
       

     

       164
        
           if entry.content_type:

     

       165
        
               info_table.add_row("Content Type", entry.content_type)

     

       166
       +
       

     

       167
        
           if entry.rights:

     

       168
        
               info_table.add_row("Rights", entry.rights)

     

       169
       +
       

     

       170
        
           if entry.source:

     

       171
        
               info_table.add_row("Source Feed", entry.source)

     

       172
       +
       

     

       173
        
           panel = Panel(

     

       174
       +
               info_table, title="[bold]Entry Information[/bold]", border_style="blue"

     

       0
        
       
     

       0
        
       
     

       175
        
           )

     

       176
       +
       

     

       177
        
           console.print(panel)

     

       178
        
       

     

       179
        
       

     

       180
        
       def _display_link_info(entry, username: str, git_store: GitStore) -> None:

     

       181
        
           """Display inbound and outbound link information."""

     

       182
       +
       

     

       183
        
           # Get links from entry fields

     

       184
       +
           outbound_links = getattr(entry, "links", [])

     

       185
       +
           backlinks = getattr(entry, "backlinks", [])

     

       186
       +
       

     

       187
        
           if not outbound_links and not backlinks:

     

       188
        
               console.print("\n[dim]No cross-references found for this entry.[/dim]")

     

       189
        
               return

     

       190
       +
       

     

       191
        
           # Create links table

     

       192
        
           links_table = Table(title="Cross-References")

     

       193
        
           links_table.add_column("Direction", style="cyan", width=10)

     

       194
        
           links_table.add_column("Target/Source", style="green", width=30)

     

       195
        
           links_table.add_column("URL/ID", style="blue", width=60)

     

       196
       +
       

     

       197
        
           # Add outbound links

     

       198
        
           for link in outbound_links:

     

       199
        
               links_table.add_row("→ Out", "External/Other", link)

     

       200
       +
       

     

       201
        
           # Add backlinks (inbound references)

     

       202
        
           for backlink_id in backlinks:

     

       203
        
               # Try to find which user this entry belongs to

     

       204
        
               source_info = backlink_id

     

       205
        
               # Could enhance this by looking up the actual entry to get username

     

       206
        
               links_table.add_row("← In", "Entry", source_info)

     

       207
       +
       

     

       208
        
           console.print()

     

       209
        
           console.print(links_table)

     

       210
       +
       

     

       211
        
           # Summary

     

       212
       +
           console.print(

     

       213
       +
               f"\n[bold]Summary:[/bold] {len(outbound_links)} outbound links, {len(backlinks)} inbound backlinks"

     

       214
       +
           )

     

       215
        
       

     

       216
        
       

     

       217
        
       def _display_content(content: str) -> None:

     

       218
        
           """Display the full content of the entry."""

     

       219
       +
       

     

       220
        
           # Truncate very long content

     

       221
        
           display_content = content

     

       222
        
           if len(content) > 5000:

     

       223
        
               display_content = content[:5000] + "\n\n[... content truncated ...]"

     

       224
       +
       

     

       225
        
           panel = Panel(

     

       226
        
               display_content,

     

       227
        
               title="[bold]Entry Content[/bold]",

     

       228
        
               border_style="green",

     

       229
       +
               expand=False,

     

       230
        
           )

     

       231
       +
       

     

       232
        
           console.print()

     

       233
        
           console.print(panel)

     

       234
        
       

     

       235
        
       

     

       236
        
       def _display_entry_info_tsv(entry, username: str, show_content: bool) -> None:

     

       237
        
           """Display entry information in TSV format."""

     

       238
       +
       

     

       239
        
           # Basic info

     

       240
        
           print("Field\tValue")

     

       241
        
           print(f"User\t{username}")

     

       242
        
           print(f"Atom ID\t{entry.id}")

     

       243
       +
           print(

     

       244
       +
               f"Title\t{entry.title.replace(chr(9), ' ').replace(chr(10), ' ').replace(chr(13), ' ')}"

     

       245
       +
           )

     

       246
        
           print(f"Link\t{entry.link}")

     

       247
       +
       

     

       248
        
           if entry.published:

     

       249
        
               print(f"Published\t{entry.published.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       250
       +
       

     

       251
        
           print(f"Updated\t{entry.updated.strftime('%Y-%m-%d %H:%M:%S UTC')}")

     

       252
       +
       

     

       253
        
           if entry.summary:

     

       254
        
               # Escape tabs and newlines in summary

     

       255
       +
               summary = entry.summary.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       256
        
               print(f"Summary\t{summary}")

     

       257
       +
       

     

       258
        
           if entry.categories:

     

       259
        
               print(f"Categories\t{', '.join(entry.categories)}")

     

       260
       +
       

     

       261
        
           if entry.author:

     

       262
        
               author_info = []

     

       263
        
               if "name" in entry.author:

     
···

       266
        
                   author_info.append(f"<{entry.author['email']}>")

     

       267
        
               if author_info:

     

       268
        
                   print(f"Author\t{' '.join(author_info)}")

     

       269
       +
       

     

       270
        
           if entry.content_type:

     

       271
        
               print(f"Content Type\t{entry.content_type}")

     

       272
       +
       

     

       273
        
           if entry.rights:

     

       274
        
               print(f"Rights\t{entry.rights}")

     

       275
       +
       

     

       276
        
           if entry.source:

     

       277
        
               print(f"Source Feed\t{entry.source}")

     

       278
       +
       

     

       279
        
           # Add links info from entry fields

     

       280
       +
           outbound_links = getattr(entry, "links", [])

     

       281
       +
           backlinks = getattr(entry, "backlinks", [])

     

       282
       +
       

     

       283
        
           if outbound_links or backlinks:

     

       284
        
               print(f"Outbound Links\t{len(outbound_links)}")

     

       285
        
               print(f"Backlinks\t{len(backlinks)}")

     

       286
       +
       

     

       287
        
               # Show each link

     

       288
        
               for link in outbound_links:

     

       289
        
                   print(f"→ Link\t{link}")

     

       290
       +
       

     

       291
        
               for backlink_id in backlinks:

     

       292
        
                   print(f"← Backlink\t{backlink_id}")

     

       293
       +
       

     

       294
        
           # Show content if requested

     

       295
        
           if show_content and entry.content:

     

       296
        
               # Escape tabs and newlines in content

     

       297
       +
               content = entry.content.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       298
       +
               print(f"Content\t{content}")

+5 -6

src/thicket/cli/commands/init.py

···

       14
        
       

     

       15
        
       @app.command()

     

       16
        
       def init(

     

       17
       -
           git_store: Path = typer.Argument(..., help="Path to Git repository for storing feeds"),

     

       0
        
       
     

       0
        
       
     

       18
        
           cache_dir: Optional[Path] = typer.Option(

     

       19
        
               None, "--cache-dir", "-c", help="Cache directory (default: ~/.cache/thicket)"

     

       20
        
           ),

     
···

       30
        
           # Set default paths

     

       31
        
           if cache_dir is None:

     

       32
        
               from platformdirs import user_cache_dir

     

       0
        
       
     

       33
        
               cache_dir = Path(user_cache_dir("thicket"))

     

       34
        
       

     

       35
        
           if config_file is None:

     
···

       54
        
       

     

       55
        
           # Create configuration

     

       56
        
           try:

     

       57
       -
               config = ThicketConfig(

     

       58
       -
                   git_store=git_store,

     

       59
       -
                   cache_dir=cache_dir,

     

       60
       -
                   users=[]

     

       61
       -
               )

     

       62
        
       

     

       63
        
               save_config(config, config_file)

     

       64
        
               print_success(f"Created configuration file: {config_file}")

···

       14
        
       

     

       15
        
       @app.command()

     

       16
        
       def init(

     

       17
       +
           git_store: Path = typer.Argument(

     

       18
       +
               ..., help="Path to Git repository for storing feeds"

     

       19
       +
           ),

     

       20
        
           cache_dir: Optional[Path] = typer.Option(

     

       21
        
               None, "--cache-dir", "-c", help="Cache directory (default: ~/.cache/thicket)"

     

       22
        
           ),

     
···

       32
        
           # Set default paths

     

       33
        
           if cache_dir is None:

     

       34
        
               from platformdirs import user_cache_dir

     

       35
       +
       

     

       36
        
               cache_dir = Path(user_cache_dir("thicket"))

     

       37
        
       

     

       38
        
           if config_file is None:

     
···

       57
        
       

     

       58
        
           # Create configuration

     

       59
        
           try:

     

       60
       +
               config = ThicketConfig(git_store=git_store, cache_dir=cache_dir, users=[])

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       61
        
       

     

       62
        
               save_config(config, config_file)

     

       63
        
               print_success(f"Created configuration file: {config_file}")

-331

src/thicket/cli/commands/links_cmd.py

···

       1
       -
       """CLI command for extracting and categorizing all outbound links from blog entries."""

     

       2
       -
       

     

       3
       -
       import re

     

       4
       -
       from pathlib import Path

     

       5
       -
       from typing import Any, Optional

     

       6
       -
       from urllib.parse import urljoin, urlparse

     

       7
       -
       

     

       8
       -
       import typer

     

       9
       -
       from rich.console import Console

     

       10
       -
       from rich.progress import (

     

       11
       -
           BarColumn,

     

       12
       -
           Progress,

     

       13
       -
           SpinnerColumn,

     

       14
       -
           TaskProgressColumn,

     

       15
       -
           TextColumn,

     

       16
       -
       )

     

       17
       -
       from rich.table import Table

     

       18
       -
       

     

       19
       -
       from ...core.git_store import GitStore

     

       20
       -
       from ..main import app

     

       21
       -
       from ..utils import get_tsv_mode, load_config

     

       22
       -
       

     

       23
       -
       console = Console()

     

       24
       -
       

     

       25
       -
       

     

       26
       -
       class LinkExtractor:

     

       27
       -
           """Extracts and resolves links from blog entries."""

     

       28
       -
       

     

       29
       -
           def __init__(self) -> None:

     

       30
       -
               # Pattern for extracting links from HTML

     

       31
       -
               self.link_pattern = re.compile(

     

       32
       -
                   r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL

     

       33
       -
               )

     

       34
       -
               self.url_pattern = re.compile(r'https?://[^\s<>"]+')

     

       35
       -
       

     

       36
       -
           def extract_links_from_html(

     

       37
       -
               self, html_content: str, base_url: str

     

       38
       -
           ) -> list[tuple[str, str]]:

     

       39
       -
               """Extract all links from HTML content and resolve them against base URL."""

     

       40
       -
               links = []

     

       41
       -
       

     

       42
       -
               # Extract links from <a> tags

     

       43
       -
               for match in self.link_pattern.finditer(html_content):

     

       44
       -
                   url = match.group(1)

     

       45
       -
                   text = re.sub(

     

       46
       -
                       r"<[^>]+>", "", match.group(2)

     

       47
       -
                   ).strip()  # Remove HTML tags from link text

     

       48
       -
       

     

       49
       -
                   # Resolve relative URLs against base URL

     

       50
       -
                   resolved_url = urljoin(base_url, url)

     

       51
       -
                   links.append((resolved_url, text))

     

       52
       -
       

     

       53
       -
               return links

     

       54
       -
       

     

       55
       -
           def extract_links_from_entry(

     

       56
       -
               self, entry: Any, username: str, base_url: str

     

       57
       -
           ) -> list[str]:

     

       58
       -
               """Extract all links from a blog entry."""

     

       59
       -
               links = []

     

       60
       -
       

     

       61
       -
               # Combine all text content for analysis

     

       62
       -
               content_to_search = []

     

       63
       -
               if entry.content:

     

       64
       -
                   content_to_search.append(entry.content)

     

       65
       -
               if entry.summary:

     

       66
       -
                   content_to_search.append(entry.summary)

     

       67
       -
       

     

       68
       -
               for content in content_to_search:

     

       69
       -
                   extracted_links = self.extract_links_from_html(content, base_url)

     

       70
       -
       

     

       71
       -
                   for url, _link_text in extracted_links:

     

       72
       -
                       # Skip empty URLs

     

       73
       -
                       if not url or url.startswith("#"):

     

       74
       -
                           continue

     

       75
       -
       

     

       76
       -
                       links.append(url)

     

       77
       -
       

     

       78
       -
               return links

     

       79
       -
       

     

       80
       -
       

     

       81
       -
       @app.command()

     

       82
       -
       def links(

     

       83
       -
           config_file: Optional[Path] = typer.Option(

     

       84
       -
               Path("thicket.yaml"),

     

       85
       -
               "--config",

     

       86
       -
               "-c",

     

       87
       -
               help="Path to configuration file",

     

       88
       -
           ),

     

       89
       -
           verbose: bool = typer.Option(

     

       90
       -
               False,

     

       91
       -
               "--verbose",

     

       92
       -
               "-v",

     

       93
       -
               help="Show detailed progress information",

     

       94
       -
           ),

     

       95
       -
       ) -> None:

     

       96
       -
           """Extract and store outbound links and backlinks in blog entry JSON files.

     

       97
       -
       

     

       98
       -
           This command analyzes all blog entries to extract outbound links,

     

       99
       -
           resolve them properly with respect to the feed's base URL, and

     

       100
       -
           store them in each entry's JSON file in a 'links' field.

     

       101
       -
       

     

       102
       -
           It also builds backlinks by finding all entries that link to each entry

     

       103
       -
           and storing the referring entry IDs in a 'backlinks' field.

     

       104
       -
           """

     

       105
       -
           try:

     

       106
       -
               # Load configuration

     

       107
       -
               config = load_config(config_file)

     

       108
       -
       

     

       109
       -
               # Initialize Git store

     

       110
       -
               git_store = GitStore(config.git_store)

     

       111
       -
       

     

       112
       -
               # Build user domain mapping

     

       113
       -
               if verbose:

     

       114
       -
                   console.print("Building user domain mapping...")

     

       115
       -
       

     

       116
       -
               index = git_store._load_index()

     

       117
       -
               user_domains = {}

     

       118
       -
       

     

       119
       -
               for username, user_metadata in index.users.items():

     

       120
       -
                   domains = set()

     

       121
       -
       

     

       122
       -
                   # Add domains from feeds

     

       123
       -
                   for feed_url in user_metadata.feeds:

     

       124
       -
                       domain = urlparse(feed_url).netloc.lower()

     

       125
       -
                       if domain:

     

       126
       -
                           domains.add(domain)

     

       127
       -
       

     

       128
       -
                   # Add domain from homepage

     

       129
       -
                   if user_metadata.homepage:

     

       130
       -
                       domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       131
       -
                       if domain:

     

       132
       -
                           domains.add(domain)

     

       133
       -
       

     

       134
       -
                   user_domains[username] = domains

     

       135
       -
       

     

       136
       -
               if verbose:

     

       137
       -
                   console.print(

     

       138
       -
                       f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains"

     

       139
       -
                   )

     

       140
       -
       

     

       141
       -
               # Initialize components

     

       142
       -
               link_extractor = LinkExtractor()

     

       143
       -
       

     

       144
       -
               # Get all users

     

       145
       -
               users = list(index.users.keys())

     

       146
       -
       

     

       147
       -
               if not users:

     

       148
       -
                   console.print("[yellow]No users found in Git store[/yellow]")

     

       149
       -
                   raise typer.Exit(0)

     

       150
       -
       

     

       151
       -
               # First pass: collect all entries and build URL mapping

     

       152
       -
               all_entries = []  # List of (username, entry) tuples

     

       153
       -
               url_to_entry = {}  # Map URL to (username, entry_id)

     

       154
       -
       

     

       155
       -
               with Progress(

     

       156
       -
                   SpinnerColumn(),

     

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

     

       158
       -
                   BarColumn(),

     

       159
       -
                   TaskProgressColumn(),

     

       160
       -
                   console=console,

     

       161
       -
               ) as progress:

     

       162
       -
                   # Count total entries first

     

       163
       -
                   counting_task = progress.add_task("Counting entries...", total=len(users))

     

       164
       -
                   total_entries = 0

     

       165
       -
       

     

       166
       -
                   for username in users:

     

       167
       -
                       entries = git_store.list_entries(username)

     

       168
       -
                       total_entries += len(entries)

     

       169
       -
                       for entry in entries:

     

       170
       -
                           all_entries.append((username, entry))

     

       171
       -
                           # Map entry's permalink URL to the entry

     

       172
       -
                           if hasattr(entry, "link") and entry.link:

     

       173
       -
                               url_to_entry[str(entry.link)] = (username, entry.id)

     

       174
       -
                       progress.advance(counting_task)

     

       175
       -
       

     

       176
       -
                   progress.remove_task(counting_task)

     

       177
       -
       

     

       178
       -
                   if verbose:

     

       179
       -
                       console.print(f"Built URL mapping for {len(url_to_entry)} entry URLs")

     

       180
       -
       

     

       181
       -
                   # Second pass: process links for each entry

     

       182
       -
                   processing_task = progress.add_task(

     

       183
       -
                       f"Processing {total_entries} entries for links...", total=total_entries

     

       184
       -
                   )

     

       185
       -
       

     

       186
       -
                   updated_entries = 0

     

       187
       -
                   total_links_found = 0

     

       188
       -
                   link_mapping = {}  # entry_id -> list of linked URLs

     

       189
       -
       

     

       190
       -
                   for username, entry in all_entries:

     

       191
       -
                       user_metadata = index.users[username]

     

       192
       -
       

     

       193
       -
                       # Get base URL for this user (use first feed URL)

     

       194
       -
                       base_url = (

     

       195
       -
                           str(user_metadata.feeds[0])

     

       196
       -
                           if user_metadata.feeds

     

       197
       -
                           else "https://example.com"

     

       198
       -
                       )

     

       199
       -
       

     

       200
       -
                       # Extract links from this entry

     

       201
       -
                       extracted_urls = link_extractor.extract_links_from_entry(

     

       202
       -
                           entry, username, base_url

     

       203
       -
                       )

     

       204
       -
       

     

       205
       -
                       # Remove duplicates while preserving order

     

       206
       -
                       unique_urls = []

     

       207
       -
                       seen_urls = set()

     

       208
       -
       

     

       209
       -
                       for url in extracted_urls:

     

       210
       -
                           if url not in seen_urls:

     

       211
       -
                               unique_urls.append(url)

     

       212
       -
                               seen_urls.add(url)

     

       213
       -
       

     

       214
       -
                       # Store the links in our mapping for backlink processing

     

       215
       -
                       link_mapping[entry.id] = unique_urls

     

       216
       -
       

     

       217
       -
                       # Update entry with links

     

       218
       -
                       entry.links = unique_urls

     

       219
       -
                       if unique_urls:

     

       220
       -
                           updated_entries += 1

     

       221
       -
                           total_links_found += len(unique_urls)

     

       222
       -
       

     

       223
       -
                           if verbose:

     

       224
       -
                               console.print(

     

       225
       -
                                   f"  Updated {username}:{entry.title[:50]}... with {len(unique_urls)} links"

     

       226
       -
                               )

     

       227
       -
       

     

       228
       -
                       progress.advance(processing_task)

     

       229
       -
       

     

       230
       -
                   progress.remove_task(processing_task)

     

       231
       -
       

     

       232
       -
                   # Third pass: process backlinks

     

       233
       -
                   backlink_task = progress.add_task(

     

       234
       -
                       f"Processing backlinks for {total_entries} entries...",

     

       235
       -
                       total=total_entries,

     

       236
       -
                   )

     

       237
       -
       

     

       238
       -
                   # Initialize backlinks for all entries

     

       239
       -
                   for _username, entry in all_entries:

     

       240
       -
                       entry.backlinks = []

     

       241
       -
       

     

       242
       -
                   # Build backlinks by examining all the links

     

       243
       -
                   for _username, entry in all_entries:

     

       244
       -
                       source_entry_id = entry.id

     

       245
       -
                       for linked_url in link_mapping.get(source_entry_id, []):

     

       246
       -
                           # Check if this URL corresponds to an entry we know about

     

       247
       -
                           if linked_url in url_to_entry:

     

       248
       -
                               target_username, target_entry_id = url_to_entry[linked_url]

     

       249
       -
                               # Find the target entry and add this source as a backlink

     

       250
       -
                               for target_user, target_entry in all_entries:

     

       251
       -
                                   if (

     

       252
       -
                                       target_user == target_username

     

       253
       -
                                       and target_entry.id == target_entry_id

     

       254
       -
                                   ):

     

       255
       -
                                       if source_entry_id not in target_entry.backlinks:

     

       256
       -
                                           target_entry.backlinks.append(source_entry_id)

     

       257
       -
                                       break

     

       258
       -
       

     

       259
       -
                       progress.advance(backlink_task)

     

       260
       -
       

     

       261
       -
                   progress.remove_task(backlink_task)

     

       262
       -
       

     

       263
       -
                   # Final pass: save all updated entries

     

       264
       -
                   saving_task = progress.add_task(

     

       265
       -
                       f"Saving {total_entries} updated entries...", total=total_entries

     

       266
       -
                   )

     

       267
       -
       

     

       268
       -
                   backlinks_updated = 0

     

       269
       -
                   for username, entry in all_entries:

     

       270
       -
                       # Count entries that have backlinks

     

       271
       -
                       if entry.backlinks:

     

       272
       -
                           backlinks_updated += 1

     

       273
       -
       

     

       274
       -
                       # Store the updated entry back to the git store

     

       275
       -
                       git_store.store_entry(username, entry)

     

       276
       -
                       progress.advance(saving_task)

     

       277
       -
       

     

       278
       -
               # Show summary

     

       279
       -
               if not get_tsv_mode():

     

       280
       -
                   console.print("\n[green]✓ Links extraction completed successfully[/green]")

     

       281
       -
       

     

       282
       -
               # Create summary table or TSV output

     

       283
       -
               if get_tsv_mode():

     

       284
       -
                   print("Metric\tValue\tDescription")

     

       285
       -
                   print(

     

       286
       -
                       f"Entries Updated\t{updated_entries}\tBlog entries updated with links"

     

       287
       -
                   )

     

       288
       -
                   print(

     

       289
       -
                       f"Total Links\t{total_links_found}\tTotal unique links found across all entries"

     

       290
       -
                   )

     

       291
       -
                   print(

     

       292
       -
                       f"Entries with Backlinks\t{backlinks_updated}\tEntries that have backlinks from other entries"

     

       293
       -
                   )

     

       294
       -
                   print(f"Total Entries\t{total_entries}\tTotal entries processed")

     

       295
       -
               else:

     

       296
       -
                   table = Table(title="Links & Backlinks Processing Summary")

     

       297
       -
                   table.add_column("Metric", style="cyan")

     

       298
       -
                   table.add_column("Value", style="green")

     

       299
       -
                   table.add_column("Description", style="white")

     

       300
       -
       

     

       301
       -
                   table.add_row(

     

       302
       -
                       "Entries Updated",

     

       303
       -
                       str(updated_entries),

     

       304
       -
                       "Blog entries updated with links",

     

       305
       -
                   )

     

       306
       -
                   table.add_row(

     

       307
       -
                       "Total Links",

     

       308
       -
                       str(total_links_found),

     

       309
       -
                       "Total unique links found across all entries",

     

       310
       -
                   )

     

       311
       -
                   table.add_row(

     

       312
       -
                       "Entries with Backlinks",

     

       313
       -
                       str(backlinks_updated),

     

       314
       -
                       "Entries that have backlinks from other entries",

     

       315
       -
                   )

     

       316
       -
                   table.add_row(

     

       317
       -
                       "Total Entries", str(total_entries), "Total entries processed"

     

       318
       -
                   )

     

       319
       -
       

     

       320
       -
                   console.print(table)

     

       321
       -
       

     

       322
       -
               if not get_tsv_mode():

     

       323
       -
                   console.print(

     

       324
       -
                       "\nLinks and backlinks have been stored in individual entry JSON files in the git repository."

     

       325
       -
                   )

     

       326
       -
       

     

       327
       -
           except Exception as e:

     

       328
       -
               console.print(f"[red]Error extracting links: {e}[/red]")

     

       329
       -
               if verbose:

     

       330
       -
                   console.print_exception()

     

       331
       -
               raise typer.Exit(1) from e

+11 -11

src/thicket/cli/commands/list_cmd.py

···

       11
        
       from ..main import app

     

       12
        
       from ..utils import (

     

       13
        
           console,

     

       0
        
       
     

       14
        
           load_config,

     

       0
        
       
     

       15
        
           print_error,

     

       16
       -
           print_feeds_table,

     

       17
        
           print_feeds_table_from_git,

     

       18
        
           print_info,

     

       19
       -
           print_users_table,

     

       20
        
           print_users_table_from_git,

     

       21
       -
           print_entries_tsv,

     

       22
       -
           get_tsv_mode,

     

       23
        
       )

     

       24
        
       

     

       25
        
       

     
···

       60
        
           """List all users."""

     

       61
        
           index = git_store._load_index()

     

       62
        
           users = list(index.users.values())

     

       63
       -
           

     

       64
        
           if not users:

     

       65
        
               print_info("No users configured")

     

       66
        
               return

     
···

       83
        
           print_feeds_table_from_git(git_store, username)

     

       84
        
       

     

       85
        
       

     

       86
       -
       def list_entries(git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None) -> None:

     

       0
        
       
     

       0
        
       
     

       87
        
           """List entries, optionally filtered by user."""

     

       88
        
       

     

       89
        
           if username:

     
···

       123
        
           """Clean HTML content for display in table."""

     

       124
        
           if not content:

     

       125
        
               return ""

     

       126
       -
           

     

       127
        
           # Remove HTML tags

     

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

     

       129
        
           # Replace multiple whitespace with single space

     

       130
       -
           clean_text = re.sub(r'\s+', ' ', clean_text)

     

       131
        
           # Strip and limit length

     

       132
        
           clean_text = clean_text.strip()

     

       133
        
           if len(clean_text) > 100:

     

       134
        
               clean_text = clean_text[:97] + "..."

     

       135
       -
           

     

       136
        
           return clean_text

     

       137
        
       

     

       138
        
       

     
···

       141
        
           if get_tsv_mode():

     

       142
        
               print_entries_tsv(entries_by_user, usernames)

     

       143
        
               return

     

       144
       -
               

     

       145
        
           table = Table(title="Feed Entries")

     

       146
        
           table.add_column("User", style="cyan", no_wrap=True)

     

       147
        
           table.add_column("Title", style="bold")

···

       11
        
       from ..main import app

     

       12
        
       from ..utils import (

     

       13
        
           console,

     

       14
       +
           get_tsv_mode,

     

       15
        
           load_config,

     

       16
       +
           print_entries_tsv,

     

       17
        
           print_error,

     

       0
        
       
     

       18
        
           print_feeds_table_from_git,

     

       19
        
           print_info,

     

       0
        
       
     

       20
        
           print_users_table_from_git,

     

       0
        
       
     

       0
        
       
     

       21
        
       )

     

       22
        
       

     

       23
        
       

     
···

       58
        
           """List all users."""

     

       59
        
           index = git_store._load_index()

     

       60
        
           users = list(index.users.values())

     

       61
       +
       

     

       62
        
           if not users:

     

       63
        
               print_info("No users configured")

     

       64
        
               return

     
···

       81
        
           print_feeds_table_from_git(git_store, username)

     

       82
        
       

     

       83
        
       

     

       84
       +
       def list_entries(

     

       85
       +
           git_store: GitStore, username: Optional[str] = None, limit: Optional[int] = None

     

       86
       +
       ) -> None:

     

       87
        
           """List entries, optionally filtered by user."""

     

       88
        
       

     

       89
        
           if username:

     
···

       123
        
           """Clean HTML content for display in table."""

     

       124
        
           if not content:

     

       125
        
               return ""

     

       126
       +
       

     

       127
        
           # Remove HTML tags

     

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

     

       129
        
           # Replace multiple whitespace with single space

     

       130
       +
           clean_text = re.sub(r"\s+", " ", clean_text)

     

       131
        
           # Strip and limit length

     

       132
        
           clean_text = clean_text.strip()

     

       133
        
           if len(clean_text) > 100:

     

       134
        
               clean_text = clean_text[:97] + "..."

     

       135
       +
       

     

       136
        
           return clean_text

     

       137
        
       

     

       138
        
       

     
···

       141
        
           if get_tsv_mode():

     

       142
        
               print_entries_tsv(entries_by_user, usernames)

     

       143
        
               return

     

       144
       +
       

     

       145
        
           table = Table(title="Feed Entries")

     

       146
        
           table.add_column("User", style="cyan", no_wrap=True)

     

       147
        
           table.add_column("Title", style="bold")

+301

src/thicket/cli/commands/search.py

···

       1
       +
       """Search command for thicket CLI."""

     

       2
       +
       

     

       3
       +
       import logging

     

       4
       +
       from pathlib import Path

     

       5
       +
       from typing import Optional

     

       6
       +
       

     

       7
       +
       import typer

     

       8
       +
       from rich.console import Console

     

       9
       +
       from rich.table import Table

     

       10
       +
       

     

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

     

       12
       +
       from ..main import app

     

       13
       +
       

     

       14
       +
       console = Console()

     

       15
       +
       logger = logging.getLogger(__name__)

     

       16
       +
       

     

       17
       +
       

     

       18
       +
       def _load_typesense_config() -> tuple[Optional[str], Optional[str]]:

     

       19
       +
           """Load Typesense URL and API key from ~/.typesense directory."""

     

       20
       +
           typesense_dir = Path.home() / ".typesense"

     

       21
       +
           url_file = typesense_dir / "url"

     

       22
       +
           key_file = typesense_dir / "api_key"

     

       23
       +
       

     

       24
       +
           url = None

     

       25
       +
           api_key = None

     

       26
       +
       

     

       27
       +
           try:

     

       28
       +
               if url_file.exists():

     

       29
       +
                   url = url_file.read_text().strip()

     

       30
       +
           except Exception as e:

     

       31
       +
               logger.debug(f"Could not read Typesense URL from {url_file}: {e}")

     

       32
       +
       

     

       33
       +
           try:

     

       34
       +
               if key_file.exists():

     

       35
       +
                   api_key = key_file.read_text().strip()

     

       36
       +
           except Exception as e:

     

       37
       +
               logger.debug(f"Could not read Typesense API key from {key_file}: {e}")

     

       38
       +
       

     

       39
       +
           return url, api_key

     

       40
       +
       

     

       41
       +
       

     

       42
       +
       @app.command("search")

     

       43
       +
       def search_command(

     

       44
       +
           query: str = typer.Argument(..., help="Search query"),

     

       45
       +
           typesense_url: Optional[str] = typer.Option(

     

       46
       +
               None,

     

       47
       +
               "--typesense-url",

     

       48
       +
               "-u",

     

       49
       +
               help="Typesense server URL (e.g., http://localhost:8108). Defaults to ~/.typesense/url",

     

       50
       +
           ),

     

       51
       +
           api_key: Optional[str] = typer.Option(

     

       52
       +
               None,

     

       53
       +
               "--api-key",

     

       54
       +
               "-k",

     

       55
       +
               help="Typesense API key. Defaults to ~/.typesense/api_key",

     

       56
       +
               hide_input=True,

     

       57
       +
           ),

     

       58
       +
           collection_name: str = typer.Option(

     

       59
       +
               "thicket",

     

       60
       +
               "--collection",

     

       61
       +
               "-c",

     

       62
       +
               help="Typesense collection name",

     

       63
       +
           ),

     

       64
       +
           config_path: Optional[str] = typer.Option(

     

       65
       +
               None,

     

       66
       +
               "--config",

     

       67
       +
               "-C",

     

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

     

       69
       +
           ),

     

       70
       +
           limit: int = typer.Option(

     

       71
       +
               20,

     

       72
       +
               "--limit",

     

       73
       +
               "-l",

     

       74
       +
               help="Maximum number of results to display",

     

       75
       +
           ),

     

       76
       +
           user: Optional[str] = typer.Option(

     

       77
       +
               None,

     

       78
       +
               "--user",

     

       79
       +
               help="Filter results by specific user",

     

       80
       +
           ),

     

       81
       +
           timeout: int = typer.Option(

     

       82
       +
               10,

     

       83
       +
               "--timeout",

     

       84
       +
               "-t",

     

       85
       +
               help="Connection timeout in seconds",

     

       86
       +
           ),

     

       87
       +
           raw: bool = typer.Option(

     

       88
       +
               False,

     

       89
       +
               "--raw",

     

       90
       +
               help="Display raw JSON output instead of formatted table",

     

       91
       +
           ),

     

       92
       +
       ) -> None:

     

       93
       +
           """Search thicket entries using Typesense full-text and semantic search.

     

       94
       +
       

     

       95
       +
           This command searches through all entries in the Typesense collection

     

       96
       +
           using the provided query. The search covers entry titles, content,

     

       97
       +
           summaries, user information, and metadata.

     

       98
       +
       

     

       99
       +
           Examples:

     

       100
       +
       

     

       101
       +
               # Basic search

     

       102
       +
               thicket search "machine learning"

     

       103
       +
       

     

       104
       +
               # Search with user filter

     

       105
       +
               thicket search "python programming" --user avsm

     

       106
       +
       

     

       107
       +
               # Limit results

     

       108
       +
               thicket search "web development" --limit 10

     

       109
       +
       

     

       110
       +
               # Get raw JSON output

     

       111
       +
               thicket search "database" --raw

     

       112
       +
           """

     

       113
       +
           try:

     

       114
       +
               # Load Typesense configuration from defaults if not provided

     

       115
       +
               default_url, default_api_key = _load_typesense_config()

     

       116
       +
       

     

       117
       +
               # Use provided values or defaults

     

       118
       +
               final_url = typesense_url or default_url

     

       119
       +
               final_api_key = api_key or default_api_key

     

       120
       +
       

     

       121
       +
               # Check that we have required configuration

     

       122
       +
               if not final_url:

     

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

     

       124
       +
                   console.print(

     

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

     

       126
       +
                   )

     

       127
       +
                   raise typer.Exit(1)

     

       128
       +
       

     

       129
       +
               if not final_api_key:

     

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

     

       131
       +
                   console.print(

     

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

     

       133
       +
                   )

     

       134
       +
                   raise typer.Exit(1)

     

       135
       +
       

     

       136
       +
               # Create Typesense configuration

     

       137
       +
               typesense_config = TypesenseConfig.from_url(

     

       138
       +
                   final_url, final_api_key, collection_name

     

       139
       +
               )

     

       140
       +
               typesense_config.connection_timeout = timeout

     

       141
       +
       

     

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

     

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

     

       144
       +
               if user:

     

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

     

       146
       +
       

     

       147
       +
               # Initialize Typesense client

     

       148
       +
               typesense_client = TypesenseClient(typesense_config)

     

       149
       +
       

     

       150
       +
               # Prepare search parameters

     

       151
       +
               search_params = {

     

       152
       +
                   "per_page": limit,

     

       153
       +
               }

     

       154
       +
       

     

       155
       +
               # Add user filter if specified

     

       156
       +
               if user:

     

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

     

       158
       +
       

     

       159
       +
               # Perform search

     

       160
       +
               try:

     

       161
       +
                   results = typesense_client.search(query, search_params)

     

       162
       +
       

     

       163
       +
                   if raw:

     

       164
       +
                       import json

     

       165
       +
       

     

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

     

       167
       +
                       return

     

       168
       +
       

     

       169
       +
                   # Display results

     

       170
       +
                   _display_search_results(results, query)

     

       171
       +
       

     

       172
       +
               except Exception as e:

     

       173
       +
                   console.print(f"[red]❌ Search failed: {e}[/red]")

     

       174
       +
                   raise typer.Exit(1) from e

     

       175
       +
       

     

       176
       +
           except Exception as e:

     

       177
       +
               logger.error(f"Search failed: {e}")

     

       178
       +
               console.print(f"[red]Error: {e}[/red]")

     

       179
       +
               raise typer.Exit(1) from e

     

       180
       +
       

     

       181
       +
       

     

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

     

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

     

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

     

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

     

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

     

       187
       +
       

     

       188
       +
           if not hits:

     

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

     

       190
       +
               return

     

       191
       +
       

     

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

     

       193
       +
       

     

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

     

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

     

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

     

       197
       +
           table.add_column("Title", style="bold", width=45)

     

       198
       +
           table.add_column("Updated", style="blue", width=12, no_wrap=True)

     

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

     

       200
       +
       

     

       201
       +
           for hit in hits:

     

       202
       +
               doc = hit["document"]

     

       203
       +
       

     

       204
       +
               # Format score

     

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

     

       206
       +
       

     

       207
       +
               # Format user

     

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

     

       209
       +
               if len(user_display) > 12:

     

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

     

       211
       +
       

     

       212
       +
               # Format title

     

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

     

       214
       +
               if len(title) > 40:

     

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

     

       216
       +
       

     

       217
       +
               # Format date

     

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

     

       219
       +
               if updated_timestamp:

     

       220
       +
                   from datetime import datetime

     

       221
       +
       

     

       222
       +
                   updated_date = datetime.fromtimestamp(updated_timestamp)

     

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

     

       224
       +
               else:

     

       225
       +
                   updated_str = "Unknown"

     

       226
       +
       

     

       227
       +
               # Format summary

     

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

     

       229
       +
               if summary:

     

       230
       +
                   # Remove HTML tags and truncate

     

       231
       +
                   import re

     

       232
       +
       

     

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

     

       234
       +
                   summary = summary.strip()

     

       235
       +
                   if len(summary) > 60:

     

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

     

       237
       +
               else:

     

       238
       +
                   summary = ""

     

       239
       +
       

     

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

     

       241
       +
       

     

       242
       +
           console.print(table)

     

       243
       +
       

     

       244
       +
           # Show additional info

     

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

     

       246
       +
           if len(hits) < found:

     

       247
       +
               console.print(

     

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

     

       249
       +
               )

     

       250
       +
       

     

       251
       +
       

     

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

     

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

     

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

     

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

     

       256
       +
       

     

       257
       +
           if not hits:

     

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

     

       259
       +
               return

     

       260
       +
       

     

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

     

       262
       +
       

     

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

     

       264
       +
               doc = hit["document"]

     

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

     

       266
       +
       

     

       267
       +
               # Header with score and user

     

       268
       +
               user = doc.get("user_display_name", doc.get("username", "Unknown"))

     

       269
       +
               console.print(

     

       270
       +
                   f"[green]{i:2d}.[/green] [cyan]{user}[/cyan] [dim](score: {score:.2f})[/dim]"

     

       271
       +
               )

     

       272
       +
       

     

       273
       +
               # Title

     

       274
       +
               title = doc.get("title", "Untitled")

     

       275
       +
               console.print(f"    [bold]{title}[/bold]")

     

       276
       +
       

     

       277
       +
               # Date and link

     

       278
       +
               updated_timestamp = doc.get("updated", 0)

     

       279
       +
               if updated_timestamp:

     

       280
       +
                   from datetime import datetime

     

       281
       +
       

     

       282
       +
                   updated_date = datetime.fromtimestamp(updated_timestamp)

     

       283
       +
                   updated_str = updated_date.strftime("%Y-%m-%d %H:%M")

     

       284
       +
               else:

     

       285
       +
                   updated_str = "Unknown date"

     

       286
       +
       

     

       287
       +
               link = doc.get("link", "")

     

       288
       +
               console.print(f"    [blue]{updated_str}[/blue] - [link={link}]{link}[/link]")

     

       289
       +
       

     

       290
       +
               # Summary

     

       291
       +
               summary = doc.get("summary") or doc.get("content", "")

     

       292
       +
               if summary:

     

       293
       +
                   import re

     

       294
       +
       

     

       295
       +
                   summary = re.sub(r"<[^>]+>", "", summary)

     

       296
       +
                   summary = summary.strip()

     

       297
       +
                   if len(summary) > 150:

     

       298
       +
                       summary = summary[:147] + "..."

     

       299
       +
                   console.print(f"    [dim]{summary}[/dim]")

     

       300
       +
       

     

       301
       +
               console.print()  # Empty line between results

+37 -7

src/thicket/cli/commands/sync.py

···

       5
        
       from typing import Optional

     

       6
        
       

     

       7
        
       import typer

     

       0
        
       
     

       8
        
       from rich.progress import track

     

       9
        
       

     

       10
        
       from ...core.feed_parser import FeedParser

     

       11
        
       from ...core.git_store import GitStore

     

       0
        
       
     

       12
        
       from ..main import app

     

       13
        
       from ..utils import (

     

       14
        
           load_config,

     
···

       71
        
               user_updated_entries = 0

     

       72
        
       

     

       73
        
               # Sync each feed for the user

     

       74
       -
               for feed_url in track(user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"):

     

       0
        
       
     

       0
        
       
     

       75
        
                   try:

     

       76
        
                       new_entries, updated_entries = asyncio.run(

     

       77
        
                           sync_feed(git_store, user_metadata.username, feed_url, dry_run)

     
···

       83
        
                       print_error(f"Failed to sync feed {feed_url}: {e}")

     

       84
        
                       continue

     

       85
        
       

     

       86
       -
               print_info(f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated")

     

       0
        
       
     

       0
        
       
     

       87
        
               total_new_entries += user_new_entries

     

       88
        
               total_updated_entries += user_updated_entries

     

       89
        
       

     
···

       93
        
               git_store.commit_changes(commit_message)

     

       94
        
               print_success(f"Committed changes: {commit_message}")

     

       95
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
           # Summary

     

       97
        
           if dry_run:

     

       98
       -
               print_info(f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated")

     

       0
        
       
     

       0
        
       
     

       99
        
           else:

     

       100
       -
               print_success(f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated")

     

       0
        
       
     

       0
        
       
     

       101
        
       

     

       102
        
       

     

       103
       -
       async def sync_feed(git_store: GitStore, username: str, feed_url, dry_run: bool) -> tuple[int, int]:

     

       0
        
       
     

       0
        
       
     

       104
        
           """Sync a single feed for a user."""

     

       105
        
       

     

       106
        
           parser = FeedParser()

     

       107
        
       

     

       108
        
           try:

     

       109
        
               # Fetch and parse feed

     

       110
       -
               content = await parser.fetch_feed(feed_url)

     

       111
       -
               metadata, entries = parser.parse_feed(content, feed_url)

     

       0
        
       
     

       112
        
       

     

       113
        
               new_entries = 0

     

       114
        
               updated_entries = 0

···

       5
        
       from typing import Optional

     

       6
        
       

     

       7
        
       import typer

     

       8
       +
       from pydantic import HttpUrl

     

       9
        
       from rich.progress import track

     

       10
        
       

     

       11
        
       from ...core.feed_parser import FeedParser

     

       12
        
       from ...core.git_store import GitStore

     

       13
       +
       from ...core.opml_generator import OPMLGenerator

     

       14
        
       from ..main import app

     

       15
        
       from ..utils import (

     

       16
        
           load_config,

     
···

       73
        
               user_updated_entries = 0

     

       74
        
       

     

       75
        
               # Sync each feed for the user

     

       76
       +
               for feed_url in track(

     

       77
       +
                   user_metadata.feeds, description=f"Syncing {user_metadata.username}'s feeds"

     

       78
       +
               ):

     

       79
        
                   try:

     

       80
        
                       new_entries, updated_entries = asyncio.run(

     

       81
        
                           sync_feed(git_store, user_metadata.username, feed_url, dry_run)

     
···

       87
        
                       print_error(f"Failed to sync feed {feed_url}: {e}")

     

       88
        
                       continue

     

       89
        
       

     

       90
       +
               print_info(

     

       91
       +
                   f"User {user_metadata.username}: {user_new_entries} new, {user_updated_entries} updated"

     

       92
       +
               )

     

       93
        
               total_new_entries += user_new_entries

     

       94
        
               total_updated_entries += user_updated_entries

     

       95
        
       

     
···

       99
        
               git_store.commit_changes(commit_message)

     

       100
        
               print_success(f"Committed changes: {commit_message}")

     

       101
        
       

     

       102
       +
           # Generate OPML file with all feeds

     

       103
       +
           if not dry_run:

     

       104
       +
               try:

     

       105
       +
                   opml_generator = OPMLGenerator()

     

       106
       +
                   index = git_store._load_index()

     

       107
       +
                   opml_path = config.git_store / "index.opml"

     

       108
       +
       

     

       109
       +
                   opml_generator.generate_opml(

     

       110
       +
                       users=index.users,

     

       111
       +
                       title="Thicket Feed Collection",

     

       112
       +
                       output_path=opml_path,

     

       113
       +
                   )

     

       114
       +
                   print_info(f"Generated OPML file: {opml_path}")

     

       115
       +
       

     

       116
       +
               except Exception as e:

     

       117
       +
                   print_error(f"Failed to generate OPML file: {e}")

     

       118
       +
       

     

       119
        
           # Summary

     

       120
        
           if dry_run:

     

       121
       +
               print_info(

     

       122
       +
                   f"Dry run complete: would sync {total_new_entries} new entries, {total_updated_entries} updated"

     

       123
       +
               )

     

       124
        
           else:

     

       125
       +
               print_success(

     

       126
       +
                   f"Sync complete: {total_new_entries} new entries, {total_updated_entries} updated"

     

       127
       +
               )

     

       128
        
       

     

       129
        
       

     

       130
       +
       async def sync_feed(

     

       131
       +
           git_store: GitStore, username: str, feed_url: str, dry_run: bool

     

       132
       +
       ) -> tuple[int, int]:

     

       133
        
           """Sync a single feed for a user."""

     

       134
        
       

     

       135
        
           parser = FeedParser()

     

       136
        
       

     

       137
        
           try:

     

       138
        
               # Fetch and parse feed

     

       139
       +
               validated_feed_url = HttpUrl(feed_url)

     

       140
       +
               content = await parser.fetch_feed(validated_feed_url)

     

       141
       +
               metadata, entries = parser.parse_feed(content, validated_feed_url)

     

       142
        
       

     

       143
        
               new_entries = 0

     

       144
        
               updated_entries = 0

-1111

src/thicket/cli/commands/threads_cmd.py

···

       1
       -
       """CLI command for displaying and browsing thread-graphs of blog posts."""

     

       2
       -
       

     

       3
       -
       from dataclasses import dataclass, field

     

       4
       -
       from datetime import datetime

     

       5
       -
       from enum import Enum

     

       6
       -
       from pathlib import Path

     

       7
       -
       from typing import Dict, List, Optional, Set, Tuple

     

       8
       -
       

     

       9
       -
       import typer

     

       10
       -
       from rich.console import Console

     

       11
       -
       import json

     

       12
       -
       import webbrowser

     

       13
       -
       import threading

     

       14
       -
       import time

     

       15
       -
       from flask import Flask, render_template_string, jsonify

     

       16
       -
       from textual import events

     

       17
       -
       from textual.app import App, ComposeResult

     

       18
       -
       from textual.containers import Container, Horizontal, Vertical

     

       19
       -
       from textual.reactive import reactive

     

       20
       -
       from textual.widget import Widget

     

       21
       -
       from textual.widgets import Footer, Header, Label, Static

     

       22
       -
       

     

       23
       -
       from ...core.git_store import GitStore

     

       24
       -
       from ...models import AtomEntry

     

       25
       -
       from ..main import app

     

       26
       -
       from ..utils import get_tsv_mode, load_config

     

       27
       -
       

     

       28
       -
       console = Console()

     

       29
       -
       

     

       30
       -
       

     

       31
       -
       class LinkType(Enum):

     

       32
       -
           """Types of links between entries."""

     

       33
       -
       

     

       34
       -
           SELF_REFERENCE = "self"  # Link to same user's content

     

       35
       -
           USER_REFERENCE = "user"  # Link to another tracked user

     

       36
       -
           EXTERNAL = "external"  # Link to external content

     

       37
       -
       

     

       38
       -
       

     

       39
       -
       @dataclass

     

       40
       -
       class ThreadNode:

     

       41
       -
           """Represents a node in the thread graph."""

     

       42
       -
       

     

       43
       -
           entry_id: str

     

       44
       -
           username: str

     

       45
       -
           entry: AtomEntry

     

       46
       -
           outbound_links: List[Tuple[str, LinkType]] = field(

     

       47
       -
               default_factory=list

     

       48
       -
           )  # (url, type)

     

       49
       -
           inbound_backlinks: List[str] = field(default_factory=list)  # entry_ids

     

       50
       -
       

     

       51
       -
           @property

     

       52
       -
           def published_date(self) -> datetime:

     

       53
       -
               """Get the published or updated date for sorting."""

     

       54
       -
               return self.entry.published or self.entry.updated

     

       55
       -
       

     

       56
       -
           @property

     

       57
       -
           def title(self) -> str:

     

       58
       -
               """Get the entry title."""

     

       59
       -
               return self.entry.title

     

       60
       -
       

     

       61
       -
           @property

     

       62
       -
           def summary(self) -> str:

     

       63
       -
               """Get a short summary of the entry."""

     

       64
       -
               if self.entry.summary:

     

       65
       -
                   return (

     

       66
       -
                       self.entry.summary[:100] + "..."

     

       67
       -
                       if len(self.entry.summary) > 100

     

       68
       -
                       else self.entry.summary

     

       69
       -
                   )

     

       70
       -
               return ""

     

       71
       -
       

     

       72
       -
       

     

       73
       -
       @dataclass

     

       74
       -
       class ThreadGraph:

     

       75
       -
           """Represents the full thread graph of interconnected posts."""

     

       76
       -
       

     

       77
       -
           nodes: Dict[str, ThreadNode] = field(default_factory=dict)  # entry_id -> ThreadNode

     

       78
       -
           user_entries: Dict[str, List[str]] = field(

     

       79
       -
               default_factory=dict

     

       80
       -
           )  # username -> [entry_ids]

     

       81
       -
           url_to_entry: Dict[str, str] = field(default_factory=dict)  # url -> entry_id

     

       82
       -
       

     

       83
       -
           def add_node(self, node: ThreadNode) -> None:

     

       84
       -
               """Add a node to the graph."""

     

       85
       -
               self.nodes[node.entry_id] = node

     

       86
       -
       

     

       87
       -
               # Update user entries index

     

       88
       -
               if node.username not in self.user_entries:

     

       89
       -
                   self.user_entries[node.username] = []

     

       90
       -
               self.user_entries[node.username].append(node.entry_id)

     

       91
       -
       

     

       92
       -
               # Update URL mapping

     

       93
       -
               if node.entry.link:

     

       94
       -
                   self.url_to_entry[str(node.entry.link)] = node.entry_id

     

       95
       -
       

     

       96
       -
           def get_connected_components(self) -> List[Set[str]]:

     

       97
       -
               """Find all connected components in the graph (threads)."""

     

       98
       -
               visited: Set[str] = set()

     

       99
       -
               components: List[Set[str]] = []

     

       100
       -
       

     

       101
       -
               for entry_id in self.nodes:

     

       102
       -
                   if entry_id not in visited:

     

       103
       -
                       component: Set[str] = set()

     

       104
       -
                       self._dfs(entry_id, visited, component)

     

       105
       -
                       components.append(component)

     

       106
       -
       

     

       107
       -
               return components

     

       108
       -
       

     

       109
       -
           def _dfs(self, entry_id: str, visited: Set[str], component: Set[str]) -> None:

     

       110
       -
               """Depth-first search to find connected components."""

     

       111
       -
               if entry_id in visited:

     

       112
       -
                   return

     

       113
       -
       

     

       114
       -
               visited.add(entry_id)

     

       115
       -
               component.add(entry_id)

     

       116
       -
       

     

       117
       -
               node = self.nodes.get(entry_id)

     

       118
       -
               if not node:

     

       119
       -
                   return

     

       120
       -
       

     

       121
       -
               # Follow outbound links

     

       122
       -
               for url, link_type in node.outbound_links:

     

       123
       -
                   if url in self.url_to_entry:

     

       124
       -
                       target_id = self.url_to_entry[url]

     

       125
       -
                       self._dfs(target_id, visited, component)

     

       126
       -
       

     

       127
       -
               # Follow backlinks

     

       128
       -
               for backlink_id in node.inbound_backlinks:

     

       129
       -
                   self._dfs(backlink_id, visited, component)

     

       130
       -
       

     

       131
       -
           def get_standalone_entries(self) -> List[str]:

     

       132
       -
               """Get entries with no connections."""

     

       133
       -
               standalone = []

     

       134
       -
               for entry_id, node in self.nodes.items():

     

       135
       -
                   if not node.outbound_links and not node.inbound_backlinks:

     

       136
       -
                       standalone.append(entry_id)

     

       137
       -
               return standalone

     

       138
       -
       

     

       139
       -
           def sort_component_chronologically(self, component: Set[str]) -> List[str]:

     

       140
       -
               """Sort a component by published date."""

     

       141
       -
               nodes = [

     

       142
       -
                   self.nodes[entry_id] for entry_id in component if entry_id in self.nodes

     

       143
       -
               ]

     

       144
       -
               nodes.sort(key=lambda n: n.published_date)

     

       145
       -
               return [n.entry_id for n in nodes]

     

       146
       -
       

     

       147
       -
       

     

       148
       -
       def build_thread_graph(git_store: GitStore) -> ThreadGraph:

     

       149
       -
           """Build the thread graph from all entries in the git store."""

     

       150
       -
           graph = ThreadGraph()

     

       151
       -
       

     

       152
       -
           # Get all users from index

     

       153
       -
           index = git_store._load_index()

     

       154
       -
           user_domains = {}

     

       155
       -
       

     

       156
       -
           # Build user domain mapping

     

       157
       -
           for username, user_metadata in index.users.items():

     

       158
       -
               domains = set()

     

       159
       -
       

     

       160
       -
               # Add domains from feeds

     

       161
       -
               for feed_url in user_metadata.feeds:

     

       162
       -
                   from urllib.parse import urlparse

     

       163
       -
       

     

       164
       -
                   domain = urlparse(str(feed_url)).netloc.lower()

     

       165
       -
                   if domain:

     

       166
       -
                       domains.add(domain)

     

       167
       -
       

     

       168
       -
               # Add domain from homepage

     

       169
       -
               if user_metadata.homepage:

     

       170
       -
                   domain = urlparse(str(user_metadata.homepage)).netloc.lower()

     

       171
       -
                   if domain:

     

       172
       -
                       domains.add(domain)

     

       173
       -
       

     

       174
       -
               user_domains[username] = domains

     

       175
       -
       

     

       176
       -
           # Process all entries

     

       177
       -
           for username in index.users:

     

       178
       -
               entries = git_store.list_entries(username)

     

       179
       -
       

     

       180
       -
               for entry in entries:

     

       181
       -
                   # Create node

     

       182
       -
                   node = ThreadNode(entry_id=entry.id, username=username, entry=entry)

     

       183
       -
       

     

       184
       -
                   # Process outbound links

     

       185
       -
                   for link in getattr(entry, "links", []):

     

       186
       -
                       link_type = categorize_link(link, username, user_domains)

     

       187
       -
                       node.outbound_links.append((link, link_type))

     

       188
       -
       

     

       189
       -
                   # Copy backlinks

     

       190
       -
                   node.inbound_backlinks = getattr(entry, "backlinks", [])

     

       191
       -
       

     

       192
       -
                   # Add to graph

     

       193
       -
                   graph.add_node(node)

     

       194
       -
       

     

       195
       -
           return graph

     

       196
       -
       

     

       197
       -
       

     

       198
       -
       def categorize_link(

     

       199
       -
           url: str, source_username: str, user_domains: Dict[str, Set[str]]

     

       200
       -
       ) -> LinkType:

     

       201
       -
           """Categorize a link as self-reference, user reference, or external."""

     

       202
       -
           from urllib.parse import urlparse

     

       203
       -
       

     

       204
       -
           try:

     

       205
       -
               parsed = urlparse(url)

     

       206
       -
               domain = parsed.netloc.lower()

     

       207
       -
       

     

       208
       -
               # Check if it's a self-reference

     

       209
       -
               if domain in user_domains.get(source_username, set()):

     

       210
       -
                   return LinkType.SELF_REFERENCE

     

       211
       -
       

     

       212
       -
               # Check if it's a reference to another tracked user

     

       213
       -
               for username, domains in user_domains.items():

     

       214
       -
                   if username != source_username and domain in domains:

     

       215
       -
                       return LinkType.USER_REFERENCE

     

       216
       -
       

     

       217
       -
               # Otherwise it's external

     

       218
       -
               return LinkType.EXTERNAL

     

       219
       -
       

     

       220
       -
           except Exception:

     

       221
       -
               return LinkType.EXTERNAL

     

       222
       -
       

     

       223
       -
       

     

       224
       -
       class ThreadTreeWidget(Static):

     

       225
       -
           """Widget for displaying a thread as a tree."""

     

       226
       -
       

     

       227
       -
           def __init__(self, component: Set[str], graph: ThreadGraph, **kwargs):

     

       228
       -
               super().__init__(**kwargs)

     

       229
       -
               self.component = component

     

       230
       -
               self.graph = graph

     

       231
       -
       

     

       232
       -
           def compose(self) -> ComposeResult:

     

       233
       -
               """Create the tree display."""

     

       234
       -
               # Sort entries chronologically

     

       235
       -
               sorted_ids = self.graph.sort_component_chronologically(self.component)

     

       236
       -
       

     

       237
       -
               # Build tree structure as text

     

       238
       -
               content_lines = ["Thread:"]

     

       239
       -
               added_nodes: Set[str] = set()

     

       240
       -
       

     

       241
       -
               # Add nodes in chronological order, showing connections

     

       242
       -
               for entry_id in sorted_ids:

     

       243
       -
                   if entry_id not in added_nodes:

     

       244
       -
                       self._add_node_to_text(content_lines, entry_id, added_nodes, 0)

     

       245
       -
       

     

       246
       -
               # Join all lines into content

     

       247
       -
               content = "\n".join(content_lines)

     

       248
       -
               

     

       249
       -
               # Create a Static widget with the content

     

       250
       -
               yield Static(content, id="thread-content")

     

       251
       -
       

     

       252
       -
           def _add_node_to_text(

     

       253
       -
               self, content_lines: List[str], entry_id: str, added_nodes: Set[str], indent: int = 0

     

       254
       -
           ):

     

       255
       -
               """Recursively add nodes to the text display."""

     

       256
       -
               if entry_id in added_nodes:

     

       257
       -
                   # Show cycle reference

     

       258
       -
                   node = self.graph.nodes.get(entry_id)

     

       259
       -
                   if node:

     

       260
       -
                       prefix = "  " * indent

     

       261
       -
                       content_lines.append(f"{prefix}↻ {node.username}: {node.title}")

     

       262
       -
                   return

     

       263
       -
       

     

       264
       -
               added_nodes.add(entry_id)

     

       265
       -
               node = self.graph.nodes.get(entry_id)

     

       266
       -
               if not node:

     

       267
       -
                   return

     

       268
       -
       

     

       269
       -
               # Format node display

     

       270
       -
               prefix = "  " * indent

     

       271
       -
               date_str = node.published_date.strftime("%Y-%m-%d")

     

       272
       -
               node_label = f"{prefix}• {node.username}: {node.title} ({date_str})"

     

       273
       -
               content_lines.append(node_label)

     

       274
       -
       

     

       275
       -
               # Add connections info

     

       276
       -
               if node.outbound_links:

     

       277
       -
                   links_by_type: Dict[LinkType, List[str]] = {}

     

       278
       -
                   for url, link_type in node.outbound_links:

     

       279
       -
                       if link_type not in links_by_type:

     

       280
       -
                           links_by_type[link_type] = []

     

       281
       -
                       links_by_type[link_type].append(url)

     

       282
       -
       

     

       283
       -
                   for link_type, urls in links_by_type.items():

     

       284
       -
                       type_label = f"{prefix}  → {link_type.value}: {len(urls)} link(s)"

     

       285
       -
                       content_lines.append(type_label)

     

       286
       -
       

     

       287
       -
               if node.inbound_backlinks:

     

       288
       -
                   backlink_label = f"{prefix}  ← backlinks: {len(node.inbound_backlinks)}"

     

       289
       -
                   content_lines.append(backlink_label)

     

       290
       -
       

     

       291
       -
       

     

       292
       -
       class ThreadBrowserApp(App):

     

       293
       -
           """Terminal UI for browsing threads."""

     

       294
       -
       

     

       295
       -
           CSS = """

     

       296
       -
           ThreadBrowserApp {

     

       297
       -
               background: $surface;

     

       298
       -
           }

     

       299
       -
           

     

       300
       -
           #thread-list {

     

       301
       -
               width: 1fr;

     

       302
       -
               height: 1fr;

     

       303
       -
               border: solid $primary;

     

       304
       -
               overflow-y: scroll;

     

       305
       -
           }

     

       306
       -
           

     

       307
       -
           #entry-detail {

     

       308
       -
               width: 1fr;

     

       309
       -
               height: 1fr;

     

       310
       -
               border: solid $secondary;

     

       311
       -
               overflow-y: scroll;

     

       312
       -
               padding: 1;

     

       313
       -
           }

     

       314
       -
           """

     

       315
       -
       

     

       316
       -
           BINDINGS = [

     

       317
       -
               ("q", "quit", "Quit"),

     

       318
       -
               ("j", "next_thread", "Next Thread"),

     

       319
       -
               ("k", "prev_thread", "Previous Thread"),

     

       320
       -
               ("enter", "select_thread", "View Thread"),

     

       321
       -
           ]

     

       322
       -
       

     

       323
       -
           def __init__(self, graph: ThreadGraph):

     

       324
       -
               super().__init__()

     

       325
       -
               self.graph = graph

     

       326
       -
               self.threads = []

     

       327
       -
               self.current_thread_index = 0

     

       328
       -
               self._build_thread_list()

     

       329
       -
       

     

       330
       -
           def _build_thread_list(self):

     

       331
       -
               """Build the list of threads to display."""

     

       332
       -
               # Get connected components (actual threads)

     

       333
       -
               components = self.graph.get_connected_components()

     

       334
       -
       

     

       335
       -
               # Sort components by the earliest date in each

     

       336
       -
               sorted_components = []

     

       337
       -
               for component in components:

     

       338
       -
                   if len(component) > 1:  # Only show actual threads

     

       339
       -
                       sorted_ids = self.graph.sort_component_chronologically(component)

     

       340
       -
                       if sorted_ids:

     

       341
       -
                           first_node = self.graph.nodes.get(sorted_ids[0])

     

       342
       -
                           if first_node:

     

       343
       -
                               sorted_components.append((first_node.published_date, component))

     

       344
       -
       

     

       345
       -
               sorted_components.sort(key=lambda x: x[0], reverse=True)

     

       346
       -
               self.threads = [comp for _, comp in sorted_components]

     

       347
       -
       

     

       348
       -
           def compose(self) -> ComposeResult:

     

       349
       -
               """Create the UI layout."""

     

       350
       -
               yield Header()

     

       351
       -
       

     

       352
       -
               with Horizontal():

     

       353
       -
                   with Vertical(id="thread-list"):

     

       354
       -
                       yield Label("Threads", classes="title")

     

       355
       -
                       for i, thread in enumerate(self.threads):

     

       356
       -
                           # Get thread summary

     

       357
       -
                           sorted_ids = self.graph.sort_component_chronologically(thread)

     

       358
       -
                           if sorted_ids:

     

       359
       -
                               first_node = self.graph.nodes.get(sorted_ids[0])

     

       360
       -
                               if first_node:

     

       361
       -
                                   label = f"{i + 1}. {first_node.title} ({len(thread)} posts)"

     

       362
       -
                                   yield Label(label, classes="thread-item")

     

       363
       -
       

     

       364
       -
                   with Vertical(id="entry-detail"):

     

       365
       -
                       if self.threads:

     

       366
       -
                           yield ThreadTreeWidget(self.threads[0], self.graph)

     

       367
       -
       

     

       368
       -
               yield Footer()

     

       369
       -
       

     

       370
       -
           def action_next_thread(self) -> None:

     

       371
       -
               """Move to next thread."""

     

       372
       -
               if self.current_thread_index < len(self.threads) - 1:

     

       373
       -
                   self.current_thread_index += 1

     

       374
       -
                   self.update_display()

     

       375
       -
       

     

       376
       -
           def action_prev_thread(self) -> None:

     

       377
       -
               """Move to previous thread."""

     

       378
       -
               if self.current_thread_index > 0:

     

       379
       -
                   self.current_thread_index -= 1

     

       380
       -
                   self.update_display()

     

       381
       -
       

     

       382
       -
           def action_select_thread(self) -> None:

     

       383
       -
               """View detailed thread."""

     

       384
       -
               # In a real implementation, this could show more detail

     

       385
       -
               pass

     

       386
       -
       

     

       387
       -
           def update_display(self) -> None:

     

       388
       -
               """Update the thread display."""

     

       389
       -
               detail_view = self.query_one("#entry-detail")

     

       390
       -
               detail_view.remove_children()

     

       391
       -
       

     

       392
       -
               if self.threads and self.current_thread_index < len(self.threads):

     

       393
       -
                   widget = ThreadTreeWidget(

     

       394
       -
                       self.threads[self.current_thread_index], self.graph

     

       395
       -
                   )

     

       396
       -
                   detail_view.mount(widget)

     

       397
       -
       

     

       398
       -
       

     

       399
       -
       @app.command()

     

       400
       -
       def threads(

     

       401
       -
           config_file: Optional[Path] = typer.Option(

     

       402
       -
               Path("thicket.yaml"),

     

       403
       -
               "--config",

     

       404
       -
               "-c",

     

       405
       -
               help="Path to configuration file",

     

       406
       -
           ),

     

       407
       -
           interactive: bool = typer.Option(

     

       408
       -
               True,

     

       409
       -
               "--interactive/--no-interactive",

     

       410
       -
               "-i/-n",

     

       411
       -
               help="Launch interactive terminal UI",

     

       412
       -
           ),

     

       413
       -
           web: bool = typer.Option(

     

       414
       -
               False,

     

       415
       -
               "--web",

     

       416
       -
               "-w",

     

       417
       -
               help="Launch web server with D3 force graph visualization",

     

       418
       -
           ),

     

       419
       -
           port: int = typer.Option(

     

       420
       -
               8080,

     

       421
       -
               "--port",

     

       422
       -
               "-p",

     

       423
       -
               help="Port for web server",

     

       424
       -
           ),

     

       425
       -
       ) -> None:

     

       426
       -
           """Browse and visualize thread-graphs of interconnected blog posts.

     

       427
       -
       

     

       428
       -
           This command analyzes all blog entries and their links/backlinks to build

     

       429
       -
           a graph of conversations and references between posts. Threads are displayed

     

       430
       -
           as connected components in the link graph.

     

       431
       -
           """

     

       432
       -
           try:

     

       433
       -
               # Load configuration

     

       434
       -
               config = load_config(config_file)

     

       435
       -
       

     

       436
       -
               # Initialize Git store

     

       437
       -
               git_store = GitStore(config.git_store)

     

       438
       -
       

     

       439
       -
               # Build thread graph

     

       440
       -
               console.print("Building thread graph...")

     

       441
       -
               graph = build_thread_graph(git_store)

     

       442
       -
       

     

       443
       -
               # Get statistics

     

       444
       -
               components = graph.get_connected_components()

     

       445
       -
               threads = [c for c in components if len(c) > 1]

     

       446
       -
               standalone = graph.get_standalone_entries()

     

       447
       -
       

     

       448
       -
               console.print(

     

       449
       -
                   f"\n[green]Found {len(threads)} threads and {len(standalone)} standalone posts[/green]"

     

       450
       -
               )

     

       451
       -
       

     

       452
       -
               if web:

     

       453
       -
                   # Launch web server with D3 visualization

     

       454
       -
                   _launch_web_server(graph, port)

     

       455
       -
               elif interactive and threads:

     

       456
       -
                   # Launch terminal UI

     

       457
       -
                   app = ThreadBrowserApp(graph)

     

       458
       -
                   app.run()

     

       459
       -
               else:

     

       460
       -
                   # Display in console

     

       461
       -
                   if get_tsv_mode():

     

       462
       -
                       _display_threads_tsv(graph, threads)

     

       463
       -
                   else:

     

       464
       -
                       _display_threads_rich(graph, threads)

     

       465
       -
       

     

       466
       -
           except Exception as e:

     

       467
       -
               console.print(f"[red]Error building threads: {e}[/red]")

     

       468
       -
               raise typer.Exit(1)

     

       469
       -
       

     

       470
       -
       

     

       471
       -
       def _display_threads_rich(graph: ThreadGraph, threads: List[Set[str]]) -> None:

     

       472
       -
           """Display threads using rich formatting."""

     

       473
       -
           for i, thread in enumerate(threads[:10]):  # Show first 10 threads

     

       474
       -
               sorted_ids = graph.sort_component_chronologically(thread)

     

       475
       -
       

     

       476
       -
               console.print(f"\n[bold]Thread {i + 1}[/bold] ({len(thread)} posts)")

     

       477
       -
       

     

       478
       -
               for j, entry_id in enumerate(sorted_ids):

     

       479
       -
                   node = graph.nodes.get(entry_id)

     

       480
       -
                   if node:

     

       481
       -
                       date_str = node.published_date.strftime("%Y-%m-%d")

     

       482
       -
                       indent = "  " * min(j, 3)  # Max 3 levels of indent

     

       483
       -
                       console.print(f"{indent}• [{node.username}] {node.title} ({date_str})")

     

       484
       -
       

     

       485
       -
                       # Show link types

     

       486
       -
                       if node.outbound_links:

     

       487
       -
                           link_summary = {}

     

       488
       -
                           for _, link_type in node.outbound_links:

     

       489
       -
                               link_summary[link_type] = link_summary.get(link_type, 0) + 1

     

       490
       -
       

     

       491
       -
                           link_str = ", ".join(

     

       492
       -
                               [f"{t.value}:{c}" for t, c in link_summary.items()]

     

       493
       -
                           )

     

       494
       -
                           console.print(f"{indent}  → Links: {link_str}")

     

       495
       -
       

     

       496
       -
       

     

       497
       -
       def _display_threads_tsv(graph: ThreadGraph, threads: List[Set[str]]) -> None:

     

       498
       -
           """Display threads in TSV format."""

     

       499
       -
           print("Thread\tSize\tFirst Post\tLast Post\tUsers")

     

       500
       -
       

     

       501
       -
           for i, thread in enumerate(threads):

     

       502
       -
               sorted_ids = graph.sort_component_chronologically(thread)

     

       503
       -
       

     

       504
       -
               if sorted_ids:

     

       505
       -
                   first_node = graph.nodes.get(sorted_ids[0])

     

       506
       -
                   last_node = graph.nodes.get(sorted_ids[-1])

     

       507
       -
       

     

       508
       -
                   users = set()

     

       509
       -
                   for entry_id in thread:

     

       510
       -
                       node = graph.nodes.get(entry_id)

     

       511
       -
                       if node:

     

       512
       -
                           users.add(node.username)

     

       513
       -
       

     

       514
       -
                   if first_node and last_node:

     

       515
       -
                       print(

     

       516
       -
                           f"{i + 1}\t{len(thread)}\t{first_node.published_date.strftime('%Y-%m-%d')}\t{last_node.published_date.strftime('%Y-%m-%d')}\t{','.join(users)}"

     

       517
       -
                       )

     

       518
       -
       

     

       519
       -
       

     

       520
       -
       def _build_graph_json(graph: ThreadGraph) -> dict:

     

       521
       -
           """Convert ThreadGraph to JSON format for D3 visualization."""

     

       522
       -
           nodes = []

     

       523
       -
           links = []

     

       524
       -
           

     

       525
       -
           # Color mapping for different users

     

       526
       -
           user_colors = {}

     

       527
       -
           colors = [

     

       528
       -
               "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", 

     

       529
       -
               "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf",

     

       530
       -
               "#aec7e8", "#ffbb78", "#98df8a", "#ff9896", "#c5b0d5"

     

       531
       -
           ]

     

       532
       -
           

     

       533
       -
           # Assign colors to users

     

       534
       -
           for i, username in enumerate(set(node.username for node in graph.nodes.values())):

     

       535
       -
               user_colors[username] = colors[i % len(colors)]

     

       536
       -
           

     

       537
       -
           # Create nodes

     

       538
       -
           for entry_id, node in graph.nodes.items():

     

       539
       -
               nodes.append({

     

       540
       -
                   "id": entry_id,

     

       541
       -
                   "title": node.title,

     

       542
       -
                   "username": node.username,

     

       543
       -
                   "date": node.published_date.strftime("%Y-%m-%d"),

     

       544
       -
                   "summary": node.summary,

     

       545
       -
                   "color": user_colors[node.username],

     

       546
       -
                   "outbound_count": len(node.outbound_links),

     

       547
       -
                   "backlink_count": len(node.inbound_backlinks),

     

       548
       -
                   "link_types": {

     

       549
       -
                       "self": len([l for l in node.outbound_links if l[1] == LinkType.SELF_REFERENCE]),

     

       550
       -
                       "user": len([l for l in node.outbound_links if l[1] == LinkType.USER_REFERENCE]),

     

       551
       -
                       "external": len([l for l in node.outbound_links if l[1] == LinkType.EXTERNAL])

     

       552
       -
                   }

     

       553
       -
               })

     

       554
       -
           

     

       555
       -
           # Create links (only for links between tracked entries)

     

       556
       -
           for entry_id, node in graph.nodes.items():

     

       557
       -
               for url, link_type in node.outbound_links:

     

       558
       -
                   if url in graph.url_to_entry:

     

       559
       -
                       target_id = graph.url_to_entry[url]

     

       560
       -
                       if target_id in graph.nodes:

     

       561
       -
                           links.append({

     

       562
       -
                               "source": entry_id,

     

       563
       -
                               "target": target_id,

     

       564
       -
                               "type": link_type.value,

     

       565
       -
                               "url": url

     

       566
       -
                           })

     

       567
       -
           

     

       568
       -
           return {

     

       569
       -
               "nodes": nodes,

     

       570
       -
               "links": links,

     

       571
       -
               "stats": {

     

       572
       -
                   "total_nodes": len(nodes),

     

       573
       -
                   "total_links": len(links),

     

       574
       -
                   "users": list(user_colors.keys()),

     

       575
       -
                   "user_colors": user_colors

     

       576
       -
               }

     

       577
       -
           }

     

       578
       -
       

     

       579
       -
       

     

       580
       -
       def _launch_web_server(graph: ThreadGraph, port: int) -> None:

     

       581
       -
           """Launch Flask web server with D3 force graph visualization."""

     

       582
       -
           flask_app = Flask(__name__)

     

       583
       -
           

     

       584
       -
           # Store graph data globally for the Flask app

     

       585
       -
           graph_data = _build_graph_json(graph)

     

       586
       -
           

     

       587
       -
           @flask_app.route('/')

     

       588
       -
           def index():

     

       589
       -
               """Serve the main visualization page."""

     

       590
       -
               return render_template_string(HTML_TEMPLATE, port=port)

     

       591
       -
           

     

       592
       -
           @flask_app.route('/api/graph')

     

       593
       -
           def api_graph():

     

       594
       -
               """API endpoint to serve graph data as JSON."""

     

       595
       -
               return jsonify(graph_data)

     

       596
       -
           

     

       597
       -
           # Disable Flask logging in development mode

     

       598
       -
           import logging

     

       599
       -
           log = logging.getLogger('werkzeug')

     

       600
       -
           log.setLevel(logging.ERROR)

     

       601
       -
           

     

       602
       -
           def open_browser():

     

       603
       -
               """Open browser after a short delay."""

     

       604
       -
               time.sleep(1.5)

     

       605
       -
               webbrowser.open(f'http://localhost:{port}')

     

       606
       -
           

     

       607
       -
           # Start browser in a separate thread

     

       608
       -
           browser_thread = threading.Thread(target=open_browser)

     

       609
       -
           browser_thread.daemon = True

     

       610
       -
           browser_thread.start()

     

       611
       -
           

     

       612
       -
           console.print(f"\n[green]Starting web server at http://localhost:{port}[/green]")

     

       613
       -
           console.print("[yellow]Press Ctrl+C to stop the server[/yellow]")

     

       614
       -
           

     

       615
       -
           try:

     

       616
       -
               flask_app.run(host='0.0.0.0', port=port, debug=False)

     

       617
       -
           except KeyboardInterrupt:

     

       618
       -
               console.print("\n[green]Server stopped[/green]")

     

       619
       -
       

     

       620
       -
       

     

       621
       -
       # HTML template for D3 force graph visualization

     

       622
       -
       HTML_TEMPLATE = """

     

       623
       -
       <!DOCTYPE html>

     

       624
       -
       <html lang="en">

     

       625
       -
       <head>

     

       626
       -
           <meta charset="UTF-8">

     

       627
       -
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       628
       -
           <title>Thicket Thread Graph Visualization</title>

     

       629
       -
           <script src="https://d3js.org/d3.v7.min.js"></script>

     

       630
       -
           <style>

     

       631
       -
               body {

     

       632
       -
                   font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;

     

       633
       -
                   margin: 0;

     

       634
       -
                   padding: 20px;

     

       635
       -
                   background-color: #f5f5f5;

     

       636
       -
               }

     

       637
       -
               

     

       638
       -
               .header {

     

       639
       -
                   text-align: center;

     

       640
       -
                   margin-bottom: 20px;

     

       641
       -
               }

     

       642
       -
               

     

       643
       -
               h1 {

     

       644
       -
                   color: #333;

     

       645
       -
                   margin-bottom: 10px;

     

       646
       -
               }

     

       647
       -
               

     

       648
       -
               .controls {

     

       649
       -
                   display: flex;

     

       650
       -
                   justify-content: center;

     

       651
       -
                   gap: 15px;

     

       652
       -
                   margin-bottom: 20px;

     

       653
       -
                   flex-wrap: wrap;

     

       654
       -
               }

     

       655
       -
               

     

       656
       -
               .control-group {

     

       657
       -
                   display: flex;

     

       658
       -
                   align-items: center;

     

       659
       -
                   gap: 5px;

     

       660
       -
               }

     

       661
       -
               

     

       662
       -
               select, input[type="range"] {

     

       663
       -
                   padding: 5px;

     

       664
       -
                   border: 1px solid #ddd;

     

       665
       -
                   border-radius: 4px;

     

       666
       -
               }

     

       667
       -
               

     

       668
       -
               .stats {

     

       669
       -
                   display: flex;

     

       670
       -
                   justify-content: center;

     

       671
       -
                   gap: 20px;

     

       672
       -
                   margin-bottom: 20px;

     

       673
       -
                   font-size: 14px;

     

       674
       -
                   color: #666;

     

       675
       -
               }

     

       676
       -
               

     

       677
       -
               .stat-item {

     

       678
       -
                   background: white;

     

       679
       -
                   padding: 10px 15px;

     

       680
       -
                   border-radius: 6px;

     

       681
       -
                   box-shadow: 0 2px 4px rgba(0,0,0,0.1);

     

       682
       -
               }

     

       683
       -
               

     

       684
       -
               #graph-container {

     

       685
       -
                   background: white;

     

       686
       -
                   border-radius: 8px;

     

       687
       -
                   box-shadow: 0 4px 6px rgba(0,0,0,0.1);

     

       688
       -
                   overflow: hidden;

     

       689
       -
               }

     

       690
       -
               

     

       691
       -
               #graph {

     

       692
       -
                   cursor: grab;

     

       693
       -
               }

     

       694
       -
               

     

       695
       -
               #graph:active {

     

       696
       -
                   cursor: grabbing;

     

       697
       -
               }

     

       698
       -
               

     

       699
       -
               .node {

     

       700
       -
                   stroke: #fff;

     

       701
       -
                   stroke-width: 1.5px;

     

       702
       -
                   cursor: pointer;

     

       703
       -
               }

     

       704
       -
               

     

       705
       -
               .node:hover {

     

       706
       -
                   stroke: #333;

     

       707
       -
                   stroke-width: 2px;

     

       708
       -
               }

     

       709
       -
               

     

       710
       -
               .link {

     

       711
       -
                   stroke: #999;

     

       712
       -
                   stroke-opacity: 0.6;

     

       713
       -
                   stroke-width: 1px;

     

       714
       -
               }

     

       715
       -
               

     

       716
       -
               .link.self-link {

     

       717
       -
                   stroke: #2ca02c;

     

       718
       -
               }

     

       719
       -
               

     

       720
       -
               .link.user-link {

     

       721
       -
                   stroke: #ff7f0e;

     

       722
       -
               }

     

       723
       -
               

     

       724
       -
               .link.external-link {

     

       725
       -
                   stroke: #d62728;

     

       726
       -
               }

     

       727
       -
               

     

       728
       -
               .tooltip {

     

       729
       -
                   position: absolute;

     

       730
       -
                   background: rgba(0, 0, 0, 0.9);

     

       731
       -
                   color: white;

     

       732
       -
                   padding: 10px;

     

       733
       -
                   border-radius: 4px;

     

       734
       -
                   font-size: 12px;

     

       735
       -
                   line-height: 1.4;

     

       736
       -
                   pointer-events: none;

     

       737
       -
                   z-index: 1000;

     

       738
       -
                   max-width: 300px;

     

       739
       -
               }

     

       740
       -
               

     

       741
       -
               .legend {

     

       742
       -
                   position: fixed;

     

       743
       -
                   top: 20px;

     

       744
       -
                   right: 20px;

     

       745
       -
                   background: white;

     

       746
       -
                   padding: 15px;

     

       747
       -
                   border-radius: 6px;

     

       748
       -
                   box-shadow: 0 2px 8px rgba(0,0,0,0.15);

     

       749
       -
                   font-size: 12px;

     

       750
       -
                   z-index: 100;

     

       751
       -
               }

     

       752
       -
               

     

       753
       -
               .legend h3 {

     

       754
       -
                   margin: 0 0 10px 0;

     

       755
       -
                   font-size: 14px;

     

       756
       -
                   color: #333;

     

       757
       -
               }

     

       758
       -
               

     

       759
       -
               .legend-item {

     

       760
       -
                   display: flex;

     

       761
       -
                   align-items: center;

     

       762
       -
                   margin-bottom: 5px;

     

       763
       -
               }

     

       764
       -
               

     

       765
       -
               .legend-color {

     

       766
       -
                   width: 12px;

     

       767
       -
                   height: 12px;

     

       768
       -
                   margin-right: 8px;

     

       769
       -
                   border-radius: 2px;

     

       770
       -
               }

     

       771
       -
               

     

       772
       -
               .legend-line {

     

       773
       -
                   width: 20px;

     

       774
       -
                   height: 2px;

     

       775
       -
                   margin-right: 8px;

     

       776
       -
               }

     

       777
       -
           </style>

     

       778
       -
       </head>

     

       779
       -
       <body>

     

       780
       -
           <div class="header">

     

       781
       -
               <h1>Thicket Thread Graph Visualization</h1>

     

       782
       -
               <p>Interactive visualization of blog post connections and conversations</p>

     

       783
       -
           </div>

     

       784
       -
           

     

       785
       -
           <div class="controls">

     

       786
       -
               <div class="control-group">

     

       787
       -
                   <label for="userFilter">Filter by user:</label>

     

       788
       -
                   <select id="userFilter">

     

       789
       -
                       <option value="all">All Users</option>

     

       790
       -
                   </select>

     

       791
       -
               </div>

     

       792
       -
               

     

       793
       -
               <div class="control-group">

     

       794
       -
                   <label for="linkFilter">Show links:</label>

     

       795
       -
                   <select id="linkFilter">

     

       796
       -
                       <option value="all">All Links</option>

     

       797
       -
                       <option value="user">User Links Only</option>

     

       798
       -
                       <option value="self">Self Links Only</option>

     

       799
       -
                       <option value="external">External Links Only</option>

     

       800
       -
                   </select>

     

       801
       -
               </div>

     

       802
       -
               

     

       803
       -
               <div class="control-group">

     

       804
       -
                   <label for="forceStrength">Force Strength:</label>

     

       805
       -
                   <input type="range" id="forceStrength" min="0.1" max="2" step="0.1" value="0.3">

     

       806
       -
               </div>

     

       807
       -
               

     

       808
       -
               <div class="control-group">

     

       809
       -
                   <label for="nodeSize">Node Size:</label>

     

       810
       -
                   <input type="range" id="nodeSize" min="3" max="15" step="1" value="6">

     

       811
       -
               </div>

     

       812
       -
           </div>

     

       813
       -
           

     

       814
       -
           <div class="stats" id="stats"></div>

     

       815
       -
           

     

       816
       -
           <div id="graph-container">

     

       817
       -
               <svg id="graph"></svg>

     

       818
       -
           </div>

     

       819
       -
           

     

       820
       -
           <div class="legend">

     

       821
       -
               <h3>Link Types</h3>

     

       822
       -
               <div class="legend-item">

     

       823
       -
                   <div class="legend-line" style="background: #2ca02c;"></div>

     

       824
       -
                   <span>Self References</span>

     

       825
       -
               </div>

     

       826
       -
               <div class="legend-item">

     

       827
       -
                   <div class="legend-line" style="background: #ff7f0e;"></div>

     

       828
       -
                   <span>User References</span>

     

       829
       -
               </div>

     

       830
       -
               <div class="legend-item">

     

       831
       -
                   <div class="legend-line" style="background: #d62728;"></div>

     

       832
       -
                   <span>External References</span>

     

       833
       -
               </div>

     

       834
       -
               

     

       835
       -
               <h3 style="margin-top: 15px;">Interactions</h3>

     

       836
       -
               <div style="font-size: 11px; color: #666;">

     

       837
       -
                   • Hover: Show details<br>

     

       838
       -
                   • Click: Pin/unpin node<br>

     

       839
       -
                   • Drag: Move nodes<br>

     

       840
       -
                   • Zoom: Mouse wheel

     

       841
       -
               </div>

     

       842
       -
           </div>

     

       843
       -
           

     

       844
       -
           <div class="tooltip" id="tooltip" style="display: none;"></div>

     

       845
       -
       

     

       846
       -
           <script>

     

       847
       -
               let graphData;

     

       848
       -
               let simulation;

     

       849
       -
               let svg, g, link, node;

     

       850
       -
               let width = window.innerWidth - 40;

     

       851
       -
               let height = window.innerHeight - 200;

     

       852
       -
               

     

       853
       -
               // Initialize the visualization

     

       854
       -
               async function init() {

     

       855
       -
                   // Fetch graph data

     

       856
       -
                   const response = await fetch('/api/graph');

     

       857
       -
                   graphData = await response.json();

     

       858
       -
                   

     

       859
       -
                   // Set up SVG

     

       860
       -
                   svg = d3.select("#graph")

     

       861
       -
                       .attr("width", width)

     

       862
       -
                       .attr("height", height);

     

       863
       -
                       

     

       864
       -
                   // Add zoom behavior

     

       865
       -
                   const zoom = d3.zoom()

     

       866
       -
                       .scaleExtent([0.1, 4])

     

       867
       -
                       .on("zoom", (event) => {

     

       868
       -
                           g.attr("transform", event.transform);

     

       869
       -
                       });

     

       870
       -
                   

     

       871
       -
                   svg.call(zoom);

     

       872
       -
                   

     

       873
       -
                   // Create main group for all elements

     

       874
       -
                   g = svg.append("g");

     

       875
       -
                   

     

       876
       -
                   // Set up controls

     

       877
       -
                   setupControls();

     

       878
       -
                   

     

       879
       -
                   // Initial render

     

       880
       -
                   updateVisualization();

     

       881
       -
                   

     

       882
       -
                   // Update stats

     

       883
       -
                   updateStats();

     

       884
       -
                   

     

       885
       -
                   // Handle window resize

     

       886
       -
                   window.addEventListener('resize', () => {

     

       887
       -
                       width = window.innerWidth - 40;

     

       888
       -
                       height = window.innerHeight - 200;

     

       889
       -
                       svg.attr("width", width).attr("height", height);

     

       890
       -
                       simulation.force("center", d3.forceCenter(width / 2, height / 2));

     

       891
       -
                       simulation.restart();

     

       892
       -
                   });

     

       893
       -
               }

     

       894
       -
               

     

       895
       -
               function setupControls() {

     

       896
       -
                   // Populate user filter

     

       897
       -
                   const userFilter = d3.select("#userFilter");

     

       898
       -
                   graphData.stats.users.forEach(user => {

     

       899
       -
                       userFilter.append("option").attr("value", user).text(user);

     

       900
       -
                   });

     

       901
       -
                   

     

       902
       -
                   // Add event listeners

     

       903
       -
                   d3.select("#userFilter").on("change", updateVisualization);

     

       904
       -
                   d3.select("#linkFilter").on("change", updateVisualization);

     

       905
       -
                   d3.select("#forceStrength").on("input", updateForces);

     

       906
       -
                   d3.select("#nodeSize").on("input", updateNodeSizes);

     

       907
       -
               }

     

       908
       -
               

     

       909
       -
               function updateVisualization() {

     

       910
       -
                   // Filter data based on controls

     

       911
       -
                   const userFilter = d3.select("#userFilter").property("value");

     

       912
       -
                   const linkFilter = d3.select("#linkFilter").property("value");

     

       913
       -
                   

     

       914
       -
                   let filteredNodes = graphData.nodes;

     

       915
       -
                   let filteredLinks = graphData.links;

     

       916
       -
                   

     

       917
       -
                   if (userFilter !== "all") {

     

       918
       -
                       filteredNodes = graphData.nodes.filter(n => n.username === userFilter);

     

       919
       -
                       const nodeIds = new Set(filteredNodes.map(n => n.id));

     

       920
       -
                       filteredLinks = graphData.links.filter(l => 

     

       921
       -
                           nodeIds.has(l.source.id || l.source) && nodeIds.has(l.target.id || l.target)

     

       922
       -
                       );

     

       923
       -
                   }

     

       924
       -
                   

     

       925
       -
                   if (linkFilter !== "all") {

     

       926
       -
                       filteredLinks = filteredLinks.filter(l => l.type === linkFilter);

     

       927
       -
                   }

     

       928
       -
                   

     

       929
       -
                   // Clear existing elements

     

       930
       -
                   g.selectAll(".link").remove();

     

       931
       -
                   g.selectAll(".node").remove();

     

       932
       -
                   

     

       933
       -
                   // Create force simulation

     

       934
       -
                   simulation = d3.forceSimulation(filteredNodes)

     

       935
       -
                       .force("link", d3.forceLink(filteredLinks).id(d => d.id)

     

       936
       -
                           .distance(d => {

     

       937
       -
                               // Get source and target nodes

     

       938
       -
                               const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source));

     

       939
       -
                               const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target));

     

       940
       -
                               

     

       941
       -
                               // If nodes are from different users, make them attract more (shorter distance)

     

       942
       -
                               if (sourceNode && targetNode && sourceNode.username !== targetNode.username) {

     

       943
       -
                                   return 30; // Shorter distance = stronger attraction

     

       944
       -
                               }

     

       945
       -
                               

     

       946
       -
                               // Same user posts have normal distance

     

       947
       -
                               return 60;

     

       948
       -
                           })

     

       949
       -
                           .strength(d => {

     

       950
       -
                               // Get source and target nodes

     

       951
       -
                               const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source));

     

       952
       -
                               const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target));

     

       953
       -
                               

     

       954
       -
                               // If nodes are from different users, make the link stronger

     

       955
       -
                               if (sourceNode && targetNode && sourceNode.username !== targetNode.username) {

     

       956
       -
                                   return 1.5; // Stronger link force

     

       957
       -
                               }

     

       958
       -
                               

     

       959
       -
                               // Same user posts have normal strength

     

       960
       -
                               return 1.0;

     

       961
       -
                           }))

     

       962
       -
                       .force("charge", d3.forceManyBody().strength(-200))

     

       963
       -
                       .force("center", d3.forceCenter(width / 2, height / 2))

     

       964
       -
                       .force("collision", d3.forceCollide().radius(15));

     

       965
       -
                   

     

       966
       -
                   // Create links

     

       967
       -
                   link = g.append("g")

     

       968
       -
                       .selectAll(".link")

     

       969
       -
                       .data(filteredLinks)

     

       970
       -
                       .enter().append("line")

     

       971
       -
                       .attr("class", d => `link ${d.type}-link`)

     

       972
       -
                       .attr("stroke-width", d => {

     

       973
       -
                           // Get source and target nodes

     

       974
       -
                           const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source));

     

       975
       -
                           const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target));

     

       976
       -
                           

     

       977
       -
                           // If nodes are from different users, make the line thicker

     

       978
       -
                           if (sourceNode && targetNode && sourceNode.username !== targetNode.username) {

     

       979
       -
                               return 2.5; // Thicker line for cross-user connections

     

       980
       -
                           }

     

       981
       -
                           

     

       982
       -
                           // Same user posts have normal thickness

     

       983
       -
                           return 1;

     

       984
       -
                       });

     

       985
       -
                   

     

       986
       -
                   // Create nodes

     

       987
       -
                   node = g.append("g")

     

       988
       -
                       .selectAll(".node")

     

       989
       -
                       .data(filteredNodes)

     

       990
       -
                       .enter().append("circle")

     

       991
       -
                       .attr("class", "node")

     

       992
       -
                       .attr("r", d => Math.max(4, Math.log(d.outbound_count + d.backlink_count + 1) * 3))

     

       993
       -
                       .attr("fill", d => d.color)

     

       994
       -
                       .call(d3.drag()

     

       995
       -
                           .on("start", dragstarted)

     

       996
       -
                           .on("drag", dragged)

     

       997
       -
                           .on("end", dragended))

     

       998
       -
                       .on("mouseover", showTooltip)

     

       999
       -
                       .on("mouseout", hideTooltip)

     

       1000
       -
                       .on("click", togglePin);

     

       1001
       -
                   

     

       1002
       -
                   // Update force simulation

     

       1003
       -
                   simulation.on("tick", () => {

     

       1004
       -
                       link

     

       1005
       -
                           .attr("x1", d => d.source.x)

     

       1006
       -
                           .attr("y1", d => d.source.y)

     

       1007
       -
                           .attr("x2", d => d.target.x)

     

       1008
       -
                           .attr("y2", d => d.target.y);

     

       1009
       -
                       

     

       1010
       -
                       node

     

       1011
       -
                           .attr("cx", d => d.x)

     

       1012
       -
                           .attr("cy", d => d.y);

     

       1013
       -
                   });

     

       1014
       -
                   

     

       1015
       -
                   updateStats(filteredNodes, filteredLinks);

     

       1016
       -
               }

     

       1017
       -
               

     

       1018
       -
               function updateForces() {

     

       1019
       -
                   const strength = +d3.select("#forceStrength").property("value");

     

       1020
       -
                   if (simulation) {

     

       1021
       -
                       simulation.force("charge").strength(-200 * strength);

     

       1022
       -
                       simulation.alpha(0.3).restart();

     

       1023
       -
                   }

     

       1024
       -
               }

     

       1025
       -
               

     

       1026
       -
               function updateNodeSizes() {

     

       1027
       -
                   const size = +d3.select("#nodeSize").property("value");

     

       1028
       -
                   if (node) {

     

       1029
       -
                       node.attr("r", d => Math.max(size * 0.5, Math.log(d.outbound_count + d.backlink_count + 1) * size * 0.5));

     

       1030
       -
                   }

     

       1031
       -
               }

     

       1032
       -
               

     

       1033
       -
               function dragstarted(event, d) {

     

       1034
       -
                   if (!event.active) simulation.alphaTarget(0.3).restart();

     

       1035
       -
                   d.fx = d.x;

     

       1036
       -
                   d.fy = d.y;

     

       1037
       -
               }

     

       1038
       -
               

     

       1039
       -
               function dragged(event, d) {

     

       1040
       -
                   d.fx = event.x;

     

       1041
       -
                   d.fy = event.y;

     

       1042
       -
               }

     

       1043
       -
               

     

       1044
       -
               function dragended(event, d) {

     

       1045
       -
                   if (!event.active) simulation.alphaTarget(0);

     

       1046
       -
                   if (!d.pinned) {

     

       1047
       -
                       d.fx = null;

     

       1048
       -
                       d.fy = null;

     

       1049
       -
                   }

     

       1050
       -
               }

     

       1051
       -
               

     

       1052
       -
               function togglePin(event, d) {

     

       1053
       -
                   d.pinned = !d.pinned;

     

       1054
       -
                   if (d.pinned) {

     

       1055
       -
                       d.fx = d.x;

     

       1056
       -
                       d.fy = d.y;

     

       1057
       -
                   } else {

     

       1058
       -
                       d.fx = null;

     

       1059
       -
                       d.fy = null;

     

       1060
       -
                   }

     

       1061
       -
               }

     

       1062
       -
               

     

       1063
       -
               function showTooltip(event, d) {

     

       1064
       -
                   const tooltip = d3.select("#tooltip");

     

       1065
       -
                   tooltip.style("display", "block")

     

       1066
       -
                       .html(`

     

       1067
       -
                           <strong>${d.title}</strong><br>

     

       1068
       -
                           <strong>User:</strong> ${d.username}<br>

     

       1069
       -
                           <strong>Date:</strong> ${d.date}<br>

     

       1070
       -
                           <strong>Outbound Links:</strong> ${d.outbound_count}<br>

     

       1071
       -
                           <strong>Backlinks:</strong> ${d.backlink_count}<br>

     

       1072
       -
                           <strong>Link Types:</strong> Self: ${d.link_types.self}, User: ${d.link_types.user}, External: ${d.link_types.external}

     

       1073
       -
                           ${d.summary ? '<br><br>' + d.summary : ''}

     

       1074
       -
                       `)

     

       1075
       -
                       .style("left", (event.pageX + 10) + "px")

     

       1076
       -
                       .style("top", (event.pageY - 10) + "px");

     

       1077
       -
               }

     

       1078
       -
               

     

       1079
       -
               function hideTooltip() {

     

       1080
       -
                   d3.select("#tooltip").style("display", "none");

     

       1081
       -
               }

     

       1082
       -
               

     

       1083
       -
               function updateStats(nodes = graphData.nodes, links = graphData.links) {

     

       1084
       -
                   const stats = d3.select("#stats");

     

       1085
       -
                   const userCounts = {};

     

       1086
       -
                   nodes.forEach(n => {

     

       1087
       -
                       userCounts[n.username] = (userCounts[n.username] || 0) + 1;

     

       1088
       -
                   });

     

       1089
       -
                   

     

       1090
       -
                   stats.html(`

     

       1091
       -
                       <div class="stat-item">

     

       1092
       -
                           <strong>${nodes.length}</strong> Nodes

     

       1093
       -
                       </div>

     

       1094
       -
                       <div class="stat-item">

     

       1095
       -
                           <strong>${links.length}</strong> Links

     

       1096
       -
                       </div>

     

       1097
       -
                       <div class="stat-item">

     

       1098
       -
                           <strong>${Object.keys(userCounts).length}</strong> Users

     

       1099
       -
                       </div>

     

       1100
       -
                       <div class="stat-item">

     

       1101
       -
                           Users: ${Object.entries(userCounts).map(([user, count]) => `${user} (${count})`).join(', ')}

     

       1102
       -
                       </div>

     

       1103
       -
                   `);

     

       1104
       -
               }

     

       1105
       -
               

     

       1106
       -
               // Initialize when page loads

     

       1107
       -
               init();

     

       1108
       -
           </script>

     

       1109
       -
       </body>

     

       1110
       -
       </html>

     

       1111
       -
       """

+323

src/thicket/cli/commands/upload.py

···

       1
       +
       """Upload command for thicket CLI."""

     

       2
       +
       

     

       3
       +
       import logging

     

       4
       +
       from pathlib import Path

     

       5
       +
       from typing import Optional

     

       6
       +
       

     

       7
       +
       import typer

     

       8
       +
       from rich.console import Console

     

       9
       +
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       10
       +
       

     

       11
       +
       from ...core.git_store import GitStore

     

       12
       +
       from ...core.typesense_client import TypesenseClient, TypesenseConfig

     

       13
       +
       from ...models.config import ThicketConfig

     

       14
       +
       from ..main import app

     

       15
       +
       from ..utils import load_config

     

       16
       +
       

     

       17
       +
       console = Console()

     

       18
       +
       logger = logging.getLogger(__name__)

     

       19
       +
       

     

       20
       +
       

     

       21
       +
       def _load_typesense_config() -> tuple[Optional[str], Optional[str]]:

     

       22
       +
           """Load Typesense URL and API key from ~/.typesense directory."""

     

       23
       +
           typesense_dir = Path.home() / ".typesense"

     

       24
       +
           url_file = typesense_dir / "url"

     

       25
       +
           key_file = typesense_dir / "api_key"

     

       26
       +
       

     

       27
       +
           url = None

     

       28
       +
           api_key = None

     

       29
       +
       

     

       30
       +
           try:

     

       31
       +
               if url_file.exists():

     

       32
       +
                   url = url_file.read_text().strip()

     

       33
       +
           except Exception as e:

     

       34
       +
               logger.debug(f"Could not read Typesense URL from {url_file}: {e}")

     

       35
       +
       

     

       36
       +
           try:

     

       37
       +
               if key_file.exists():

     

       38
       +
                   api_key = key_file.read_text().strip()

     

       39
       +
           except Exception as e:

     

       40
       +
               logger.debug(f"Could not read Typesense API key from {key_file}: {e}")

     

       41
       +
       

     

       42
       +
           return url, api_key

     

       43
       +
       

     

       44
       +
       

     

       45
       +
       def _save_typesense_config(

     

       46
       +
           url: Optional[str] = None, api_key: Optional[str] = None

     

       47
       +
       ) -> None:

     

       48
       +
           """Save Typesense URL and API key to ~/.typesense directory."""

     

       49
       +
           typesense_dir = Path.home() / ".typesense"

     

       50
       +
           typesense_dir.mkdir(exist_ok=True, mode=0o700)  # Secure permissions

     

       51
       +
       

     

       52
       +
           if url:

     

       53
       +
               url_file = typesense_dir / "url"

     

       54
       +
               url_file.write_text(url)

     

       55
       +
               url_file.chmod(0o600)

     

       56
       +
       

     

       57
       +
           if api_key:

     

       58
       +
               key_file = typesense_dir / "api_key"

     

       59
       +
               key_file.write_text(api_key)

     

       60
       +
               key_file.chmod(0o600)  # Keep API key secure

     

       61
       +
       

     

       62
       +
       

     

       63
       +
       @app.command("upload")

     

       64
       +
       def upload_command(

     

       65
       +
           typesense_url: Optional[str] = typer.Option(

     

       66
       +
               None,

     

       67
       +
               "--typesense-url",

     

       68
       +
               "-u",

     

       69
       +
               help="Typesense server URL (e.g., http://localhost:8108). Defaults to ~/.typesense/url",

     

       70
       +
           ),

     

       71
       +
           api_key: Optional[str] = typer.Option(

     

       72
       +
               None,

     

       73
       +
               "--api-key",

     

       74
       +
               "-k",

     

       75
       +
               help="Typesense API key. Defaults to ~/.typesense/api_key",

     

       76
       +
               hide_input=True,

     

       77
       +
           ),

     

       78
       +
           collection_name: str = typer.Option(

     

       79
       +
               "thicket_entries",

     

       80
       +
               "--collection",

     

       81
       +
               "-c",

     

       82
       +
               help="Typesense collection name",

     

       83
       +
           ),

     

       84
       +
           config_path: Optional[str] = typer.Option(

     

       85
       +
               None,

     

       86
       +
               "--config",

     

       87
       +
               "-C",

     

       88
       +
               help="Path to thicket configuration file",

     

       89
       +
           ),

     

       90
       +
           git_store_path: Optional[str] = typer.Option(

     

       91
       +
               None,

     

       92
       +
               "--git-store",

     

       93
       +
               "-g",

     

       94
       +
               help="Path to Git store (overrides config)",

     

       95
       +
           ),

     

       96
       +
           timeout: int = typer.Option(

     

       97
       +
               10,

     

       98
       +
               "--timeout",

     

       99
       +
               "-t",

     

       100
       +
               help="Connection timeout in seconds",

     

       101
       +
           ),

     

       102
       +
           dry_run: bool = typer.Option(

     

       103
       +
               False,

     

       104
       +
               "--dry-run",

     

       105
       +
               help="Show what would be uploaded without actually uploading",

     

       106
       +
           ),

     

       107
       +
       ) -> None:

     

       108
       +
           """Upload thicket entries to a Typesense search engine.

     

       109
       +
       

     

       110
       +
           This command uploads all entries from the Git store to a Typesense server

     

       111
       +
           for full-text and semantic search capabilities. The uploaded data includes

     

       112
       +
           entry content, metadata, user information, and searchable text fields

     

       113
       +
           optimized for embedding-based queries.

     

       114
       +
       

     

       115
       +
           Configuration defaults can be stored in ~/.typesense/ directory:

     

       116
       +
           - URL in ~/.typesense/url

     

       117
       +
           - API key in ~/.typesense/api_key

     

       118
       +
       

     

       119
       +
           Examples:

     

       120
       +
       

     

       121
       +
               # Upload using saved defaults (first run will save config)

     

       122
       +
               thicket upload -u http://localhost:8108 -k your-api-key

     

       123
       +
       

     

       124
       +
               # Subsequent runs can omit URL and key if saved

     

       125
       +
               thicket upload

     

       126
       +
       

     

       127
       +
               # Upload to remote server with custom collection name

     

       128
       +
               thicket upload -u https://search.example.com -k api-key -c my_blog_entries

     

       129
       +
       

     

       130
       +
               # Dry run to see what would be uploaded

     

       131
       +
               thicket upload --dry-run

     

       132
       +
           """

     

       133
       +
           try:

     

       134
       +
               # Load Typesense configuration from defaults if not provided

     

       135
       +
               default_url, default_api_key = _load_typesense_config()

     

       136
       +
       

     

       137
       +
               # Use provided values or defaults

     

       138
       +
               final_url = typesense_url or default_url

     

       139
       +
               final_api_key = api_key or default_api_key

     

       140
       +
       

     

       141
       +
               # Check that we have required configuration

     

       142
       +
               if not final_url:

     

       143
       +
                   console.print("[red]Error: Typesense URL is required[/red]")

     

       144
       +
                   console.print(

     

       145
       +
                       "Either provide --typesense-url or create ~/.typesense/url file"

     

       146
       +
                   )

     

       147
       +
                   raise typer.Exit(1)

     

       148
       +
       

     

       149
       +
               if not final_api_key:

     

       150
       +
                   console.print("[red]Error: Typesense API key is required[/red]")

     

       151
       +
                   console.print(

     

       152
       +
                       "Either provide --api-key or create ~/.typesense/api_key file"

     

       153
       +
                   )

     

       154
       +
                   raise typer.Exit(1)

     

       155
       +
       

     

       156
       +
               # Save configuration if provided via command line (for future use)

     

       157
       +
               if typesense_url or api_key:

     

       158
       +
                   _save_typesense_config(typesense_url, api_key)

     

       159
       +
       

     

       160
       +
               # Load thicket configuration

     

       161
       +
               config_path_obj = Path(config_path) if config_path else None

     

       162
       +
               config = load_config(config_path_obj)

     

       163
       +
       

     

       164
       +
               # Override git store path if provided

     

       165
       +
               if git_store_path:

     

       166
       +
                   config.git_store = Path(git_store_path)

     

       167
       +
       

     

       168
       +
               console.print("[bold blue]Thicket Typesense Upload[/bold blue]")

     

       169
       +
               console.print(f"Git store: {config.git_store}")

     

       170
       +
               console.print(f"Typesense URL: {final_url}")

     

       171
       +
       

     

       172
       +
               # Show where config is loaded from

     

       173
       +
               if not typesense_url and default_url:

     

       174
       +
                   console.print("[dim]  (URL loaded from ~/.typesense/url)[/dim]")

     

       175
       +
               if not api_key and default_api_key:

     

       176
       +
                   console.print("[dim]  (API key loaded from ~/.typesense/api_key)[/dim]")

     

       177
       +
       

     

       178
       +
               console.print(f"Collection: {collection_name}")

     

       179
       +
       

     

       180
       +
               if dry_run:

     

       181
       +
                   console.print("[yellow]DRY RUN MODE - No data will be uploaded[/yellow]")

     

       182
       +
       

     

       183
       +
               # Initialize Git store

     

       184
       +
               git_store = GitStore(config.git_store)

     

       185
       +
               if not git_store.repo or not config.git_store.exists():

     

       186
       +
                   console.print("[red]Error: Git store is not valid or not initialized[/red]")

     

       187
       +
                   console.print("Run 'thicket init' first to set up the Git store.")

     

       188
       +
                   raise typer.Exit(1)

     

       189
       +
       

     

       190
       +
               # Create Typesense configuration

     

       191
       +
               typesense_config = TypesenseConfig.from_url(

     

       192
       +
                   final_url, final_api_key, collection_name

     

       193
       +
               )

     

       194
       +
               typesense_config.connection_timeout = timeout

     

       195
       +
       

     

       196
       +
               if dry_run:

     

       197
       +
                   _dry_run_upload(git_store, config, typesense_config)

     

       198
       +
               else:

     

       199
       +
                   _perform_upload(git_store, config, typesense_config)

     

       200
       +
       

     

       201
       +
           except Exception as e:

     

       202
       +
               logger.error(f"Upload failed: {e}")

     

       203
       +
               console.print(f"[red]Error: {e}[/red]")

     

       204
       +
               raise typer.Exit(1) from e

     

       205
       +
       

     

       206
       +
       

     

       207
       +
       def _dry_run_upload(

     

       208
       +
           git_store: GitStore, config: ThicketConfig, typesense_config: TypesenseConfig

     

       209
       +
       ) -> None:

     

       210
       +
           """Perform a dry run showing what would be uploaded."""

     

       211
       +
           console.print("\n[bold]Dry run analysis:[/bold]")

     

       212
       +
       

     

       213
       +
           index = git_store._load_index()

     

       214
       +
           total_entries = 0

     

       215
       +
       

     

       216
       +
           for username, user_metadata in index.users.items():

     

       217
       +
               try:

     

       218
       +
                   user_dir = git_store.repo_path / user_metadata.directory

     

       219
       +
                   if not user_dir.exists():

     

       220
       +
                       console.print(f"  ⚠️  User {username}: Directory not found")

     

       221
       +
                       continue

     

       222
       +
       

     

       223
       +
                   entry_files = list(user_dir.glob("*.json"))

     

       224
       +
                   total_entries += len(entry_files)

     

       225
       +
                   console.print(

     

       226
       +
                       f"  ✅ User {username}: {len(entry_files)} entries would be uploaded"

     

       227
       +
                   )

     

       228
       +
               except Exception as e:

     

       229
       +
                   console.print(f"  ❌ User {username}: Error loading entries - {e}")

     

       230
       +
       

     

       231
       +
           console.print("\n[bold]Summary:[/bold]")

     

       232
       +
           console.print(f"  • Total users: {len(index.users)}")

     

       233
       +
           console.print(f"  • Total entries to upload: {total_entries}")

     

       234
       +
           console.print(f"  • Target collection: {typesense_config.collection_name}")

     

       235
       +
           console.print(

     

       236
       +
               f"  • Typesense server: {typesense_config.protocol}://{typesense_config.host}:{typesense_config.port}"

     

       237
       +
           )

     

       238
       +
       

     

       239
       +
           if total_entries > 0:

     

       240
       +
               console.print("\n[green]Ready to upload! Remove --dry-run to proceed.[/green]")

     

       241
       +
           else:

     

       242
       +
               console.print("\n[yellow]No entries found to upload.[/yellow]")

     

       243
       +
       

     

       244
       +
       

     

       245
       +
       def _perform_upload(

     

       246
       +
           git_store: GitStore, config: ThicketConfig, typesense_config: TypesenseConfig

     

       247
       +
       ) -> None:

     

       248
       +
           """Perform the actual upload to Typesense."""

     

       249
       +
           with Progress(

     

       250
       +
               SpinnerColumn(),

     

       251
       +
               TextColumn("[progress.description]{task.description}"),

     

       252
       +
               console=console,

     

       253
       +
           ) as progress:

     

       254
       +
               # Test connection

     

       255
       +
               progress.add_task("Testing Typesense connection...", total=None)

     

       256
       +
       

     

       257
       +
               try:

     

       258
       +
                   typesense_client = TypesenseClient(typesense_config)

     

       259
       +
                   # Test connection by attempting to list collections

     

       260
       +
                   typesense_client.client.collections.retrieve()

     

       261
       +
                   progress.stop()

     

       262
       +
                   console.print("[green]✅ Connected to Typesense server[/green]")

     

       263
       +
               except Exception as e:

     

       264
       +
                   progress.stop()

     

       265
       +
                   console.print(f"[red]❌ Failed to connect to Typesense: {e}[/red]")

     

       266
       +
                   raise typer.Exit(1) from e

     

       267
       +
       

     

       268
       +
               # Perform upload

     

       269
       +
               with Progress(

     

       270
       +
                   SpinnerColumn(),

     

       271
       +
                   TextColumn("[progress.description]{task.description}"),

     

       272
       +
                   console=console,

     

       273
       +
               ) as upload_progress:

     

       274
       +
                   upload_progress.add_task("Uploading entries to Typesense...", total=None)

     

       275
       +
       

     

       276
       +
                   try:

     

       277
       +
                       result = typesense_client.upload_from_git_store(git_store, config)

     

       278
       +
                       upload_progress.stop()

     

       279
       +
       

     

       280
       +
                       # Parse results if available

     

       281
       +
                       if result:

     

       282
       +
                           if isinstance(result, list):

     

       283
       +
                               # Batch import results

     

       284
       +
                               success_count = sum(1 for r in result if r.get("success"))

     

       285
       +
                               total_count = len(result)

     

       286
       +
                               console.print(

     

       287
       +
                                   f"[green]✅ Upload completed: {success_count}/{total_count} documents uploaded successfully[/green]"

     

       288
       +
                               )

     

       289
       +
       

     

       290
       +
                               # Show any errors

     

       291
       +
                               errors = [r for r in result if not r.get("success")]

     

       292
       +
                               if errors:

     

       293
       +
                                   console.print(

     

       294
       +
                                       f"[yellow]⚠️  {len(errors)} documents had errors[/yellow]"

     

       295
       +
                                   )

     

       296
       +
                                   for i, error in enumerate(

     

       297
       +
                                       errors[:5]

     

       298
       +
                                   ):  # Show first 5 errors

     

       299
       +
                                       console.print(f"  Error {i + 1}: {error}")

     

       300
       +
                                   if len(errors) > 5:

     

       301
       +
                                       console.print(

     

       302
       +
                                           f"  ... and {len(errors) - 5} more errors"

     

       303
       +
                                       )

     

       304
       +
                           else:

     

       305
       +
                               console.print("[green]✅ Upload completed successfully[/green]")

     

       306
       +
                       else:

     

       307
       +
                           console.print(

     

       308
       +
                               "[yellow]⚠️  Upload completed but no result data available[/yellow]"

     

       309
       +
                           )

     

       310
       +
       

     

       311
       +
                       console.print("\n[bold]Collection information:[/bold]")

     

       312
       +
                       console.print(

     

       313
       +
                           f"  • Server: {typesense_config.protocol}://{typesense_config.host}:{typesense_config.port}"

     

       314
       +
                       )

     

       315
       +
                       console.print(f"  • Collection: {typesense_config.collection_name}")

     

       316
       +
                       console.print(

     

       317
       +
                           "\n[dim]You can now search your entries using the Typesense API or dashboard.[/dim]"

     

       318
       +
                       )

     

       319
       +
       

     

       320
       +
                   except Exception as e:

     

       321
       +
                       upload_progress.stop()

     

       322
       +
                       console.print(f"[red]❌ Upload failed: {e}[/red]")

     

       323
       +
                       raise typer.Exit(1) from e

+268

src/thicket/cli/commands/zulip.py

···

       1
       +
       """Zulip association management commands for thicket."""

     

       2
       +
       

     

       3
       +
       from pathlib import Path

     

       4
       +
       from typing import Optional

     

       5
       +
       

     

       6
       +
       import typer

     

       7
       +
       from rich.console import Console

     

       8
       +
       from rich.table import Table

     

       9
       +
       

     

       10
       +
       from ...core.git_store import GitStore

     

       11
       +
       from ..main import app

     

       12
       +
       from ..utils import load_config, print_error, print_info, print_success

     

       13
       +
       

     

       14
       +
       console = Console()

     

       15
       +
       

     

       16
       +
       

     

       17
       +
       @app.command()

     

       18
       +
       def zulip_add(

     

       19
       +
           username: str = typer.Argument(..., help="Username to associate with Zulip"),

     

       20
       +
           server: str = typer.Argument(

     

       21
       +
               ..., help="Zulip server (e.g., yourorg.zulipchat.com)"

     

       22
       +
           ),

     

       23
       +
           user_id: str = typer.Argument(..., help="Zulip user ID or email for @mentions"),

     

       24
       +
           config_file: Path = typer.Option(

     

       25
       +
               Path("thicket.yaml"),

     

       26
       +
               "--config",

     

       27
       +
               "-c",

     

       28
       +
               help="Path to thicket configuration file",

     

       29
       +
           ),

     

       30
       +
       ) -> None:

     

       31
       +
           """Add a Zulip association for a user.

     

       32
       +
       

     

       33
       +
           This associates a thicket user with their Zulip identity, enabling

     

       34
       +
           @mentions when the bot posts their articles.

     

       35
       +
       

     

       36
       +
           Example:

     

       37
       +
               thicket zulip-add alice myorg.zulipchat.com alice@example.com

     

       38
       +
           """

     

       39
       +
           try:

     

       40
       +
               config = load_config(config_file)

     

       41
       +
               git_store = GitStore(config.git_store)

     

       42
       +
       

     

       43
       +
               # Check if user exists

     

       44
       +
               user = git_store.get_user(username)

     

       45
       +
               if not user:

     

       46
       +
                   print_error(f"User '{username}' not found")

     

       47
       +
                   raise typer.Exit(1)

     

       48
       +
       

     

       49
       +
               # Add association

     

       50
       +
               if git_store.add_zulip_association(username, server, user_id):

     

       51
       +
                   print_success(f"Added Zulip association for {username}: {user_id}@{server}")

     

       52
       +
                   git_store.commit_changes(f"Add Zulip association for {username}")

     

       53
       +
               else:

     

       54
       +
                   print_info(f"Association already exists for {username}: {user_id}@{server}")

     

       55
       +
       

     

       56
       +
           except Exception as e:

     

       57
       +
               print_error(f"Failed to add Zulip association: {e}")

     

       58
       +
               raise typer.Exit(1) from e

     

       59
       +
       

     

       60
       +
       

     

       61
       +
       @app.command()

     

       62
       +
       def zulip_remove(

     

       63
       +
           username: str = typer.Argument(..., help="Username to remove association from"),

     

       64
       +
           server: str = typer.Argument(..., help="Zulip server"),

     

       65
       +
           user_id: str = typer.Argument(..., help="Zulip user ID or email"),

     

       66
       +
           config_file: Path = typer.Option(

     

       67
       +
               Path("thicket.yaml"),

     

       68
       +
               "--config",

     

       69
       +
               "-c",

     

       70
       +
               help="Path to thicket configuration file",

     

       71
       +
           ),

     

       72
       +
       ) -> None:

     

       73
       +
           """Remove a Zulip association from a user.

     

       74
       +
       

     

       75
       +
           Example:

     

       76
       +
               thicket zulip-remove alice myorg.zulipchat.com alice@example.com

     

       77
       +
           """

     

       78
       +
           try:

     

       79
       +
               config = load_config(config_file)

     

       80
       +
               git_store = GitStore(config.git_store)

     

       81
       +
       

     

       82
       +
               # Check if user exists

     

       83
       +
               user = git_store.get_user(username)

     

       84
       +
               if not user:

     

       85
       +
                   print_error(f"User '{username}' not found")

     

       86
       +
                   raise typer.Exit(1)

     

       87
       +
       

     

       88
       +
               # Remove association

     

       89
       +
               if git_store.remove_zulip_association(username, server, user_id):

     

       90
       +
                   print_success(

     

       91
       +
                       f"Removed Zulip association for {username}: {user_id}@{server}"

     

       92
       +
                   )

     

       93
       +
                   git_store.commit_changes(f"Remove Zulip association for {username}")

     

       94
       +
               else:

     

       95
       +
                   print_error(f"Association not found for {username}: {user_id}@{server}")

     

       96
       +
                   raise typer.Exit(1)

     

       97
       +
       

     

       98
       +
           except Exception as e:

     

       99
       +
               print_error(f"Failed to remove Zulip association: {e}")

     

       100
       +
               raise typer.Exit(1) from e

     

       101
       +
       

     

       102
       +
       

     

       103
       +
       @app.command()

     

       104
       +
       def zulip_list(

     

       105
       +
           username: Optional[str] = typer.Argument(

     

       106
       +
               None, help="Username to list associations for"

     

       107
       +
           ),

     

       108
       +
           config_file: Path = typer.Option(

     

       109
       +
               Path("thicket.yaml"),

     

       110
       +
               "--config",

     

       111
       +
               "-c",

     

       112
       +
               help="Path to thicket configuration file",

     

       113
       +
           ),

     

       114
       +
       ) -> None:

     

       115
       +
           """List Zulip associations for users.

     

       116
       +
       

     

       117
       +
           If no username is provided, lists associations for all users.

     

       118
       +
       

     

       119
       +
           Examples:

     

       120
       +
               thicket zulip-list          # List all associations

     

       121
       +
               thicket zulip-list alice    # List associations for alice

     

       122
       +
           """

     

       123
       +
           try:

     

       124
       +
               config = load_config(config_file)

     

       125
       +
               git_store = GitStore(config.git_store)

     

       126
       +
       

     

       127
       +
               # Create table

     

       128
       +
               table = Table(title="Zulip Associations")

     

       129
       +
               table.add_column("Username", style="cyan")

     

       130
       +
               table.add_column("Server", style="green")

     

       131
       +
               table.add_column("User ID", style="yellow")

     

       132
       +
       

     

       133
       +
               if username:

     

       134
       +
                   # List for specific user

     

       135
       +
                   user = git_store.get_user(username)

     

       136
       +
                   if not user:

     

       137
       +
                       print_error(f"User '{username}' not found")

     

       138
       +
                       raise typer.Exit(1)

     

       139
       +
       

     

       140
       +
                   if not user.zulip_associations:

     

       141
       +
                       print_info(f"No Zulip associations for {username}")

     

       142
       +
                       return

     

       143
       +
       

     

       144
       +
                   for assoc in user.zulip_associations:

     

       145
       +
                       table.add_row(username, assoc.server, assoc.user_id)

     

       146
       +
               else:

     

       147
       +
                   # List for all users

     

       148
       +
                   index = git_store._load_index()

     

       149
       +
                   has_associations = False

     

       150
       +
       

     

       151
       +
                   for username, user in index.users.items():

     

       152
       +
                       for assoc in user.zulip_associations:

     

       153
       +
                           table.add_row(username, assoc.server, assoc.user_id)

     

       154
       +
                           has_associations = True

     

       155
       +
       

     

       156
       +
                   if not has_associations:

     

       157
       +
                       print_info("No Zulip associations found")

     

       158
       +
                       return

     

       159
       +
       

     

       160
       +
               console.print(table)

     

       161
       +
       

     

       162
       +
           except Exception as e:

     

       163
       +
               print_error(f"Failed to list Zulip associations: {e}")

     

       164
       +
               raise typer.Exit(1) from e

     

       165
       +
       

     

       166
       +
       

     

       167
       +
       @app.command()

     

       168
       +
       def zulip_import(

     

       169
       +
           csv_file: Path = typer.Argument(..., help="CSV file with username,server,user_id"),

     

       170
       +
           config_file: Path = typer.Option(

     

       171
       +
               Path("thicket.yaml"),

     

       172
       +
               "--config",

     

       173
       +
               "-c",

     

       174
       +
               help="Path to thicket configuration file",

     

       175
       +
           ),

     

       176
       +
           dry_run: bool = typer.Option(

     

       177
       +
               False,

     

       178
       +
               "--dry-run",

     

       179
       +
               help="Show what would be imported without making changes",

     

       180
       +
           ),

     

       181
       +
       ) -> None:

     

       182
       +
           """Import Zulip associations from a CSV file.

     

       183
       +
       

     

       184
       +
           CSV format (no header):

     

       185
       +
               username,server,user_id

     

       186
       +
               alice,myorg.zulipchat.com,alice@example.com

     

       187
       +
               bob,myorg.zulipchat.com,bob.smith

     

       188
       +
       

     

       189
       +
           Example:

     

       190
       +
               thicket zulip-import associations.csv

     

       191
       +
           """

     

       192
       +
           import csv

     

       193
       +
       

     

       194
       +
           try:

     

       195
       +
               config = load_config(config_file)

     

       196
       +
               git_store = GitStore(config.git_store)

     

       197
       +
       

     

       198
       +
               if not csv_file.exists():

     

       199
       +
                   print_error(f"CSV file not found: {csv_file}")

     

       200
       +
                   raise typer.Exit(1)

     

       201
       +
       

     

       202
       +
               added = 0

     

       203
       +
               skipped = 0

     

       204
       +
               errors = 0

     

       205
       +
       

     

       206
       +
               with open(csv_file) as f:

     

       207
       +
                   reader = csv.reader(f)

     

       208
       +
                   for row_num, row in enumerate(reader, 1):

     

       209
       +
                       if len(row) != 3:

     

       210
       +
                           print_error(f"Line {row_num}: Invalid format (expected 3 columns)")

     

       211
       +
                           errors += 1

     

       212
       +
                           continue

     

       213
       +
       

     

       214
       +
                       username, server, user_id = [col.strip() for col in row]

     

       215
       +
       

     

       216
       +
                       # Skip empty lines

     

       217
       +
                       if not username:

     

       218
       +
                           continue

     

       219
       +
       

     

       220
       +
                       # Check if user exists

     

       221
       +
                       user = git_store.get_user(username)

     

       222
       +
                       if not user:

     

       223
       +
                           print_error(f"Line {row_num}: User '{username}' not found")

     

       224
       +
                           errors += 1

     

       225
       +
                           continue

     

       226
       +
       

     

       227
       +
                       if dry_run:

     

       228
       +
                           # Check if association would be added

     

       229
       +
                           exists = any(

     

       230
       +
                               a.server == server and a.user_id == user_id

     

       231
       +
                               for a in user.zulip_associations

     

       232
       +
                           )

     

       233
       +
                           if exists:

     

       234
       +
                               print_info(

     

       235
       +
                                   f"Would skip existing: {username} -> {user_id}@{server}"

     

       236
       +
                               )

     

       237
       +
                               skipped += 1

     

       238
       +
                           else:

     

       239
       +
                               print_info(f"Would add: {username} -> {user_id}@{server}")

     

       240
       +
                               added += 1

     

       241
       +
                       else:

     

       242
       +
                           # Actually add association

     

       243
       +
                           if git_store.add_zulip_association(username, server, user_id):

     

       244
       +
                               print_success(f"Added: {username} -> {user_id}@{server}")

     

       245
       +
                               added += 1

     

       246
       +
                           else:

     

       247
       +
                               print_info(

     

       248
       +
                                   f"Skipped existing: {username} -> {user_id}@{server}"

     

       249
       +
                               )

     

       250
       +
                               skipped += 1

     

       251
       +
       

     

       252
       +
               # Summary

     

       253
       +
               console.print()

     

       254
       +
               if dry_run:

     

       255
       +
                   console.print("[bold]Dry run summary:[/bold]")

     

       256
       +
                   console.print(f"  Would add: {added}")

     

       257
       +
               else:

     

       258
       +
                   console.print("[bold]Import summary:[/bold]")

     

       259
       +
                   console.print(f"  Added: {added}")

     

       260
       +
                   if not dry_run and added > 0:

     

       261
       +
                       git_store.commit_changes(f"Import {added} Zulip associations from CSV")

     

       262
       +
       

     

       263
       +
               console.print(f"  Skipped: {skipped}")

     

       264
       +
               console.print(f"  Errors: {errors}")

     

       265
       +
       

     

       266
       +
           except Exception as e:

     

       267
       +
               print_error(f"Failed to import Zulip associations: {e}")

     

       268
       +
               raise typer.Exit(1) from e

+9 -1

src/thicket/cli/main.py

···

       47
        
       

     

       48
        
       

     

       49
        
       # Import commands to register them

     

       50
       -
       from .commands import add, duplicates, info_cmd, init, links_cmd, list_cmd, sync, threads_cmd

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
       

     

       52
        
       if __name__ == "__main__":

     

       53
        
           app()

···

       47
        
       

     

       48
        
       

     

       49
        
       # Import commands to register them

     

       50
       +
       from .commands import (  # noqa: F401, E402

     

       51
       +
           add,

     

       52
       +
           duplicates,

     

       53
       +
           info_cmd,

     

       54
       +
           init,

     

       55
       +
           list_cmd,

     

       56
       +
           sync,

     

       57
       +
           upload,

     

       58
       +
       )

     

       59
        
       

     

       60
        
       if __name__ == "__main__":

     

       61
        
           app()

+32 -20

src/thicket/cli/utils.py

···

       8
        
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       9
        
       from rich.table import Table

     

       10
        
       

     

       11
       -
       from ..models import ThicketConfig, UserMetadata

     

       12
        
       from ..core.git_store import GitStore

     

       0
        
       
     

       13
        
       

     

       14
        
       console = Console()

     

       15
        
       

     
···

       17
        
       def get_tsv_mode() -> bool:

     

       18
        
           """Get the global TSV mode setting."""

     

       19
        
           from .main import tsv_mode

     

       0
        
       
     

       20
        
           return tsv_mode

     

       21
        
       

     

       22
        
       

     
···

       37
        
               default_config = Path("thicket.yaml")

     

       38
        
               if default_config.exists():

     

       39
        
                   import yaml

     

       0
        
       
     

       40
        
                   with open(default_config) as f:

     

       41
        
                       config_data = yaml.safe_load(f)

     

       42
        
                   return ThicketConfig(**config_data)

     

       43
       -
               

     

       44
        
               # Fall back to environment variables

     

       45
        
               return ThicketConfig()

     

       46
        
           except Exception as e:

     

       47
        
               console.print(f"[red]Error loading configuration: {e}[/red]")

     

       48
       -
               console.print("[yellow]Run 'thicket init' to create a new configuration.[/yellow]")

     

       0
        
       
     

       0
        
       
     

       49
        
               raise typer.Exit(1) from e

     

       50
        
       

     

       51
        
       

     
···

       78
        
           if get_tsv_mode():

     

       79
        
               print_users_tsv(config)

     

       80
        
               return

     

       81
       -
               

     

       82
        
           table = Table(title="Users and Feeds")

     

       83
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       84
        
           table.add_column("Display Name", style="magenta")

     
···

       104
        
           if get_tsv_mode():

     

       105
        
               print_feeds_tsv(config, username)

     

       106
        
               return

     

       107
       -
               

     

       108
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       109
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       110
        
           table.add_column("Feed URL", style="blue")

     
···

       154
        
           if get_tsv_mode():

     

       155
        
               print_users_tsv_from_git(users)

     

       156
        
               return

     

       157
       -
               

     

       158
        
           table = Table(title="Users and Feeds")

     

       159
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       160
        
           table.add_column("Display Name", style="magenta")

     
···

       175
        
           console.print(table)

     

       176
        
       

     

       177
        
       

     

       178
       -
       def print_feeds_table_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       0
        
       
     

       0
        
       
     

       179
        
           """Print a table of feeds from git repository."""

     

       180
        
           if get_tsv_mode():

     

       181
        
               print_feeds_tsv_from_git(git_store, username)

     

       182
        
               return

     

       183
       -
               

     

       184
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       185
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       186
        
           table.add_column("Feed URL", style="blue")

     
···

       209
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       210
        
           for user in config.users:

     

       211
        
               feeds_str = ",".join(str(feed) for feed in user.feeds)

     

       212
       -
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       0
        
       
     

       0
        
       
     

       213
        
       

     

       214
        
       

     

       215
        
       def print_users_tsv_from_git(users: list[UserMetadata]) -> None:

     
···

       217
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       218
        
           for user in users:

     

       219
        
               feeds_str = ",".join(user.feeds)

     

       220
       -
               print(f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}")

     

       0
        
       
     

       0
        
       
     

       221
        
       

     

       222
        
       

     

       223
        
       def print_feeds_tsv(config: ThicketConfig, username: Optional[str] = None) -> None:

     
···

       225
        
           print("Username\tFeed URL\tStatus")

     

       226
        
           users = [config.find_user(username)] if username else config.users

     

       227
        
           users = [u for u in users if u is not None]

     

       228
       -
           

     

       229
        
           for user in users:

     

       230
        
               for feed in user.feeds:

     

       231
        
                   print(f"{user.username}\t{feed}\tActive")

     

       232
        
       

     

       233
        
       

     

       234
       -
       def print_feeds_tsv_from_git(git_store: GitStore, username: Optional[str] = None) -> None:

     

       0
        
       
     

       0
        
       
     

       235
        
           """Print feeds from git repository in TSV format."""

     

       236
        
           print("Username\tFeed URL\tStatus")

     

       237
       -
           

     

       238
        
           if username:

     

       239
        
               user = git_store.get_user(username)

     

       240
        
               users = [user] if user else []

     

       241
        
           else:

     

       242
        
               index = git_store._load_index()

     

       243
        
               users = list(index.users.values())

     

       244
       -
           

     

       245
        
           for user in users:

     

       246
        
               for feed in user.feeds:

     

       247
        
                   print(f"{user.username}\t{feed}\tActive")

     
···

       250
        
       def print_entries_tsv(entries_by_user: list[list], usernames: list[str]) -> None:

     

       251
        
           """Print entries in TSV format."""

     

       252
        
           print("User\tAtom ID\tTitle\tUpdated\tURL")

     

       253
       -
           

     

       254
        
           # Combine all entries with usernames

     

       255
        
           all_entries = []

     

       256
        
           for entries, username in zip(entries_by_user, usernames):

     

       257
        
               for entry in entries:

     

       258
        
                   all_entries.append((username, entry))

     

       259
       -
           

     

       260
        
           # Sort by updated time (newest first)

     

       261
        
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       262
       -
           

     

       263
        
           for username, entry in all_entries:

     

       264
        
               # Format updated time

     

       265
        
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       266
       -
               

     

       267
        
               # Escape tabs and newlines in title to preserve TSV format

     

       268
       -
               title = entry.title.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ')

     

       269
       -
               

     

       270
        
               print(f"{username}\t{entry.id}\t{title}\t{updated_str}\t{entry.link}")

···

       8
        
       from rich.progress import Progress, SpinnerColumn, TextColumn

     

       9
        
       from rich.table import Table

     

       10
        
       

     

       0
        
       
     

       11
        
       from ..core.git_store import GitStore

     

       12
       +
       from ..models import ThicketConfig, UserMetadata

     

       13
        
       

     

       14
        
       console = Console()

     

       15
        
       

     
···

       17
        
       def get_tsv_mode() -> bool:

     

       18
        
           """Get the global TSV mode setting."""

     

       19
        
           from .main import tsv_mode

     

       20
       +
       

     

       21
        
           return tsv_mode

     

       22
        
       

     

       23
        
       

     
···

       38
        
               default_config = Path("thicket.yaml")

     

       39
        
               if default_config.exists():

     

       40
        
                   import yaml

     

       41
       +
       

     

       42
        
                   with open(default_config) as f:

     

       43
        
                       config_data = yaml.safe_load(f)

     

       44
        
                   return ThicketConfig(**config_data)

     

       45
       +
       

     

       46
        
               # Fall back to environment variables

     

       47
        
               return ThicketConfig()

     

       48
        
           except Exception as e:

     

       49
        
               console.print(f"[red]Error loading configuration: {e}[/red]")

     

       50
       +
               console.print(

     

       51
       +
                   "[yellow]Run 'thicket init' to create a new configuration.[/yellow]"

     

       52
       +
               )

     

       53
        
               raise typer.Exit(1) from e

     

       54
        
       

     

       55
        
       

     
···

       82
        
           if get_tsv_mode():

     

       83
        
               print_users_tsv(config)

     

       84
        
               return

     

       85
       +
       

     

       86
        
           table = Table(title="Users and Feeds")

     

       87
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       88
        
           table.add_column("Display Name", style="magenta")

     
···

       108
        
           if get_tsv_mode():

     

       109
        
               print_feeds_tsv(config, username)

     

       110
        
               return

     

       111
       +
       

     

       112
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       113
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       114
        
           table.add_column("Feed URL", style="blue")

     
···

       158
        
           if get_tsv_mode():

     

       159
        
               print_users_tsv_from_git(users)

     

       160
        
               return

     

       161
       +
       

     

       162
        
           table = Table(title="Users and Feeds")

     

       163
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       164
        
           table.add_column("Display Name", style="magenta")

     
···

       179
        
           console.print(table)

     

       180
        
       

     

       181
        
       

     

       182
       +
       def print_feeds_table_from_git(

     

       183
       +
           git_store: GitStore, username: Optional[str] = None

     

       184
       +
       ) -> None:

     

       185
        
           """Print a table of feeds from git repository."""

     

       186
        
           if get_tsv_mode():

     

       187
        
               print_feeds_tsv_from_git(git_store, username)

     

       188
        
               return

     

       189
       +
       

     

       190
        
           table = Table(title=f"Feeds{f' for {username}' if username else ''}")

     

       191
        
           table.add_column("Username", style="cyan", no_wrap=True)

     

       192
        
           table.add_column("Feed URL", style="blue")

     
···

       215
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       216
        
           for user in config.users:

     

       217
        
               feeds_str = ",".join(str(feed) for feed in user.feeds)

     

       218
       +
               print(

     

       219
       +
                   f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}"

     

       220
       +
               )

     

       221
        
       

     

       222
        
       

     

       223
        
       def print_users_tsv_from_git(users: list[UserMetadata]) -> None:

     
···

       225
        
           print("Username\tDisplay Name\tEmail\tHomepage\tFeeds")

     

       226
        
           for user in users:

     

       227
        
               feeds_str = ",".join(user.feeds)

     

       228
       +
               print(

     

       229
       +
                   f"{user.username}\t{user.display_name or ''}\t{user.email or ''}\t{user.homepage or ''}\t{feeds_str}"

     

       230
       +
               )

     

       231
        
       

     

       232
        
       

     

       233
        
       def print_feeds_tsv(config: ThicketConfig, username: Optional[str] = None) -> None:

     
···

       235
        
           print("Username\tFeed URL\tStatus")

     

       236
        
           users = [config.find_user(username)] if username else config.users

     

       237
        
           users = [u for u in users if u is not None]

     

       238
       +
       

     

       239
        
           for user in users:

     

       240
        
               for feed in user.feeds:

     

       241
        
                   print(f"{user.username}\t{feed}\tActive")

     

       242
        
       

     

       243
        
       

     

       244
       +
       def print_feeds_tsv_from_git(

     

       245
       +
           git_store: GitStore, username: Optional[str] = None

     

       246
       +
       ) -> None:

     

       247
        
           """Print feeds from git repository in TSV format."""

     

       248
        
           print("Username\tFeed URL\tStatus")

     

       249
       +
       

     

       250
        
           if username:

     

       251
        
               user = git_store.get_user(username)

     

       252
        
               users = [user] if user else []

     

       253
        
           else:

     

       254
        
               index = git_store._load_index()

     

       255
        
               users = list(index.users.values())

     

       256
       +
       

     

       257
        
           for user in users:

     

       258
        
               for feed in user.feeds:

     

       259
        
                   print(f"{user.username}\t{feed}\tActive")

     
···

       262
        
       def print_entries_tsv(entries_by_user: list[list], usernames: list[str]) -> None:

     

       263
        
           """Print entries in TSV format."""

     

       264
        
           print("User\tAtom ID\tTitle\tUpdated\tURL")

     

       265
       +
       

     

       266
        
           # Combine all entries with usernames

     

       267
        
           all_entries = []

     

       268
        
           for entries, username in zip(entries_by_user, usernames):

     

       269
        
               for entry in entries:

     

       270
        
                   all_entries.append((username, entry))

     

       271
       +
       

     

       272
        
           # Sort by updated time (newest first)

     

       273
        
           all_entries.sort(key=lambda x: x[1].updated, reverse=True)

     

       274
       +
       

     

       275
        
           for username, entry in all_entries:

     

       276
        
               # Format updated time

     

       277
        
               updated_str = entry.updated.strftime("%Y-%m-%d %H:%M")

     

       278
       +
       

     

       279
        
               # Escape tabs and newlines in title to preserve TSV format

     

       280
       +
               title = entry.title.replace("\t", " ").replace("\n", " ").replace("\r", " ")

     

       281
       +
       

     

       282
        
               print(f"{username}\t{entry.id}\t{title}\t{updated_str}\t{entry.link}")

+84 -55

src/thicket/core/feed_parser.py

···

       19
        
               """Initialize the feed parser."""

     

       20
        
               self.user_agent = user_agent

     

       21
        
               self.allowed_tags = [

     

       22
       -
                   "a", "abbr", "acronym", "b", "blockquote", "br", "code", "em",

     

       23
       -
                   "i", "li", "ol", "p", "pre", "strong", "ul", "h1", "h2", "h3",

     

       24
       -
                   "h4", "h5", "h6", "img", "div", "span",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
               ]

     

       26
        
               self.allowed_attributes = {

     

       27
        
                   "a": ["href", "title"],

     
···

       43
        
                   response.raise_for_status()

     

       44
        
                   return response.text

     

       45
        
       

     

       46
       -
           def parse_feed(self, content: str, source_url: Optional[HttpUrl] = None) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       0
        
       
     

       0
        
       
     

       47
        
               """Parse feed content and return metadata and entries."""

     

       48
        
               parsed = feedparser.parse(content)

     

       49
        
       

     
···

       74
        
               author_email = None

     

       75
        
               author_uri = None

     

       76
        
       

     

       77
       -
               if hasattr(feed, 'author_detail'):

     

       78
       -
                   author_name = feed.author_detail.get('name')

     

       79
       -
                   author_email = feed.author_detail.get('email')

     

       80
       -
                   author_uri = feed.author_detail.get('href')

     

       81
       -
               elif hasattr(feed, 'author'):

     

       82
        
                   author_name = feed.author

     

       83
        
       

     

       84
        
               # Parse managing editor for RSS feeds

     

       85
       -
               if not author_email and hasattr(feed, 'managingEditor'):

     

       86
        
                   author_email = feed.managingEditor

     

       87
        
       

     

       88
        
               # Parse feed link

     

       89
        
               feed_link = None

     

       90
       -
               if hasattr(feed, 'link'):

     

       91
        
                   try:

     

       92
        
                       feed_link = HttpUrl(feed.link)

     

       93
        
                   except ValidationError:

     
···

       98
        
               icon = None

     

       99
        
               image_url = None

     

       100
        
       

     

       101
       -
               if hasattr(feed, 'image'):

     

       102
        
                   try:

     

       103
       -
                       image_url = HttpUrl(feed.image.get('href', feed.image.get('url', '')))

     

       104
        
                   except (ValidationError, AttributeError):

     

       105
        
                       pass

     

       106
        
       

     

       107
       -
               if hasattr(feed, 'icon'):

     

       108
        
                   try:

     

       109
        
                       icon = HttpUrl(feed.icon)

     

       110
        
                   except ValidationError:

     

       111
        
                       pass

     

       112
        
       

     

       113
       -
               if hasattr(feed, 'logo'):

     

       114
        
                   try:

     

       115
        
                       logo = HttpUrl(feed.logo)

     

       116
        
                   except ValidationError:

     

       117
        
                       pass

     

       118
        
       

     

       119
        
               return FeedMetadata(

     

       120
       -
                   title=getattr(feed, 'title', None),

     

       121
        
                   author_name=author_name,

     

       122
        
                   author_email=author_email,

     

       123
        
                   author_uri=HttpUrl(author_uri) if author_uri else None,

     
···

       125
        
                   logo=logo,

     

       126
        
                   icon=icon,

     

       127
        
                   image_url=image_url,

     

       128
       -
                   description=getattr(feed, 'description', None),

     

       129
        
               )

     

       130
        
       

     

       131
       -
           def _normalize_entry(self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None) -> AtomEntry:

     

       0
        
       
     

       0
        
       
     

       132
        
               """Normalize an entry to Atom format."""

     

       133
        
               # Parse timestamps

     

       134
       -
               updated = self._parse_timestamp(entry.get('updated_parsed') or entry.get('published_parsed'))

     

       135
       -
               published = self._parse_timestamp(entry.get('published_parsed'))

     

       0
        
       
     

       0
        
       
     

       136
        
       

     

       137
        
               # Parse content

     

       138
        
               content = self._extract_content(entry)

     
···

       143
        
       

     

       144
        
               # Parse categories/tags

     

       145
        
               categories = []

     

       146
       -
               if hasattr(entry, 'tags'):

     

       147
       -
                   categories = [tag.get('term', '') for tag in entry.tags if tag.get('term')]

     

       148
        
       

     

       149
        
               # Sanitize HTML content

     

       150
        
               if content:

     

       151
        
                   content = self._sanitize_html(content)

     

       152
        
       

     

       153
       -
               summary = entry.get('summary', '')

     

       154
        
               if summary:

     

       155
        
                   summary = self._sanitize_html(summary)

     

       156
        
       

     

       157
        
               return AtomEntry(

     

       158
       -
                   id=entry.get('id', entry.get('link', '')),

     

       159
       -
                   title=entry.get('title', ''),

     

       160
       -
                   link=HttpUrl(entry.get('link', '')),

     

       161
        
                   updated=updated,

     

       162
        
                   published=published,

     

       163
        
                   summary=summary or None,

     
···

       165
        
                   content_type=content_type,

     

       166
        
                   author=author,

     

       167
        
                   categories=categories,

     

       168
       -
                   rights=entry.get('rights', None),

     

       169
        
                   source=str(source_url) if source_url else None,

     

       170
        
               )

     

       171
        
       

     
···

       178
        
           def _extract_content(self, entry: feedparser.FeedParserDict) -> Optional[str]:

     

       179
        
               """Extract the best content from an entry."""

     

       180
        
               # Prefer content over summary

     

       181
       -
               if hasattr(entry, 'content') and entry.content:

     

       182
        
                   # Find the best content (prefer text/html, then text/plain)

     

       183
        
                   for content_item in entry.content:

     

       184
       -
                       if content_item.get('type') in ['text/html', 'html']:

     

       185
       -
                           return content_item.get('value', '')

     

       186
       -
                       elif content_item.get('type') in ['text/plain', 'text']:

     

       187
       -
                           return content_item.get('value', '')

     

       188
        
                   # Fallback to first content item

     

       189
       -
                   return entry.content[0].get('value', '')

     

       190
        
       

     

       191
        
               # Fallback to summary

     

       192
       -
               return entry.get('summary', '')

     

       193
        
       

     

       194
        
           def _extract_content_type(self, entry: feedparser.FeedParserDict) -> str:

     

       195
        
               """Extract content type from entry."""

     

       196
       -
               if hasattr(entry, 'content') and entry.content:

     

       197
       -
                   content_type = entry.content[0].get('type', 'html')

     

       198
        
                   # Normalize content type

     

       199
       -
                   if content_type in ['text/html', 'html']:

     

       200
       -
                       return 'html'

     

       201
       -
                   elif content_type in ['text/plain', 'text']:

     

       202
       -
                       return 'text'

     

       203
       -
                   elif content_type == 'xhtml':

     

       204
       -
                       return 'xhtml'

     

       205
       -
               return 'html'

     

       206
        
       

     

       207
        
           def _extract_author(self, entry: feedparser.FeedParserDict) -> Optional[dict]:

     

       208
        
               """Extract author information from entry."""

     

       209
        
               author = {}

     

       210
        
       

     

       211
       -
               if hasattr(entry, 'author_detail'):

     

       212
       -
                   author.update({

     

       213
       -
                       'name': entry.author_detail.get('name'),

     

       214
       -
                       'email': entry.author_detail.get('email'),

     

       215
       -
                       'uri': entry.author_detail.get('href'),

     

       216
       -
                   })

     

       217
       -
               elif hasattr(entry, 'author'):

     

       218
       -
                   author['name'] = entry.author

     

       0
        
       
     

       0
        
       
     

       219
        
       

     

       220
        
               return author if author else None

     

       221
        
       

     
···

       236
        
               # Start with the path component

     

       237
        
               if parsed.path:

     

       238
        
                   # Remove leading slash and replace problematic characters

     

       239
       -
                   safe_id = parsed.path.lstrip('/').replace('/', '_').replace('\\', '_')

     

       240
        
               else:

     

       241
        
                   # Use the entire ID as fallback

     

       242
        
                   safe_id = entry_id

     
···

       244
        
               # Replace problematic characters

     

       245
        
               safe_chars = []

     

       246
        
               for char in safe_id:

     

       247
       -
                   if char.isalnum() or char in '-_.':

     

       248
        
                       safe_chars.append(char)

     

       249
        
                   else:

     

       250
       -
                       safe_chars.append('_')

     

       251
        
       

     

       252
       -
               safe_id = ''.join(safe_chars)

     

       253
        
       

     

       254
        
               # Ensure it's not too long (max 200 chars)

     

       255
        
               if len(safe_id) > 200:

···

       19
        
               """Initialize the feed parser."""

     

       20
        
               self.user_agent = user_agent

     

       21
        
               self.allowed_tags = [

     

       22
       +
                   "a",

     

       23
       +
                   "abbr",

     

       24
       +
                   "acronym",

     

       25
       +
                   "b",

     

       26
       +
                   "blockquote",

     

       27
       +
                   "br",

     

       28
       +
                   "code",

     

       29
       +
                   "em",

     

       30
       +
                   "i",

     

       31
       +
                   "li",

     

       32
       +
                   "ol",

     

       33
       +
                   "p",

     

       34
       +
                   "pre",

     

       35
       +
                   "strong",

     

       36
       +
                   "ul",

     

       37
       +
                   "h1",

     

       38
       +
                   "h2",

     

       39
       +
                   "h3",

     

       40
       +
                   "h4",

     

       41
       +
                   "h5",

     

       42
       +
                   "h6",

     

       43
       +
                   "img",

     

       44
       +
                   "div",

     

       45
       +
                   "span",

     

       46
        
               ]

     

       47
        
               self.allowed_attributes = {

     

       48
        
                   "a": ["href", "title"],

     
···

       64
        
                   response.raise_for_status()

     

       65
        
                   return response.text

     

       66
        
       

     

       67
       +
           def parse_feed(

     

       68
       +
               self, content: str, source_url: Optional[HttpUrl] = None

     

       69
       +
           ) -> tuple[FeedMetadata, list[AtomEntry]]:

     

       70
        
               """Parse feed content and return metadata and entries."""

     

       71
        
               parsed = feedparser.parse(content)

     

       72
        
       

     
···

       97
        
               author_email = None

     

       98
        
               author_uri = None

     

       99
        
       

     

       100
       +
               if hasattr(feed, "author_detail"):

     

       101
       +
                   author_name = feed.author_detail.get("name")

     

       102
       +
                   author_email = feed.author_detail.get("email")

     

       103
       +
                   author_uri = feed.author_detail.get("href")

     

       104
       +
               elif hasattr(feed, "author"):

     

       105
        
                   author_name = feed.author

     

       106
        
       

     

       107
        
               # Parse managing editor for RSS feeds

     

       108
       +
               if not author_email and hasattr(feed, "managingEditor"):

     

       109
        
                   author_email = feed.managingEditor

     

       110
        
       

     

       111
        
               # Parse feed link

     

       112
        
               feed_link = None

     

       113
       +
               if hasattr(feed, "link"):

     

       114
        
                   try:

     

       115
        
                       feed_link = HttpUrl(feed.link)

     

       116
        
                   except ValidationError:

     
···

       121
        
               icon = None

     

       122
        
               image_url = None

     

       123
        
       

     

       124
       +
               if hasattr(feed, "image"):

     

       125
        
                   try:

     

       126
       +
                       image_url = HttpUrl(feed.image.get("href", feed.image.get("url", "")))

     

       127
        
                   except (ValidationError, AttributeError):

     

       128
        
                       pass

     

       129
        
       

     

       130
       +
               if hasattr(feed, "icon"):

     

       131
        
                   try:

     

       132
        
                       icon = HttpUrl(feed.icon)

     

       133
        
                   except ValidationError:

     

       134
        
                       pass

     

       135
        
       

     

       136
       +
               if hasattr(feed, "logo"):

     

       137
        
                   try:

     

       138
        
                       logo = HttpUrl(feed.logo)

     

       139
        
                   except ValidationError:

     

       140
        
                       pass

     

       141
        
       

     

       142
        
               return FeedMetadata(

     

       143
       +
                   title=getattr(feed, "title", None),

     

       144
        
                   author_name=author_name,

     

       145
        
                   author_email=author_email,

     

       146
        
                   author_uri=HttpUrl(author_uri) if author_uri else None,

     
···

       148
        
                   logo=logo,

     

       149
        
                   icon=icon,

     

       150
        
                   image_url=image_url,

     

       151
       +
                   description=getattr(feed, "description", None),

     

       152
        
               )

     

       153
        
       

     

       154
       +
           def _normalize_entry(

     

       155
       +
               self, entry: feedparser.FeedParserDict, source_url: Optional[HttpUrl] = None

     

       156
       +
           ) -> AtomEntry:

     

       157
        
               """Normalize an entry to Atom format."""

     

       158
        
               # Parse timestamps

     

       159
       +
               updated = self._parse_timestamp(

     

       160
       +
                   entry.get("updated_parsed") or entry.get("published_parsed")

     

       161
       +
               )

     

       162
       +
               published = self._parse_timestamp(entry.get("published_parsed"))

     

       163
        
       

     

       164
        
               # Parse content

     

       165
        
               content = self._extract_content(entry)

     
···

       170
        
       

     

       171
        
               # Parse categories/tags

     

       172
        
               categories = []

     

       173
       +
               if hasattr(entry, "tags"):

     

       174
       +
                   categories = [tag.get("term", "") for tag in entry.tags if tag.get("term")]

     

       175
        
       

     

       176
        
               # Sanitize HTML content

     

       177
        
               if content:

     

       178
        
                   content = self._sanitize_html(content)

     

       179
        
       

     

       180
       +
               summary = entry.get("summary", "")

     

       181
        
               if summary:

     

       182
        
                   summary = self._sanitize_html(summary)

     

       183
        
       

     

       184
        
               return AtomEntry(

     

       185
       +
                   id=entry.get("id", entry.get("link", "")),

     

       186
       +
                   title=entry.get("title", ""),

     

       187
       +
                   link=HttpUrl(entry.get("link", "")),

     

       188
        
                   updated=updated,

     

       189
        
                   published=published,

     

       190
        
                   summary=summary or None,

     
···

       192
        
                   content_type=content_type,

     

       193
        
                   author=author,

     

       194
        
                   categories=categories,

     

       195
       +
                   rights=entry.get("rights", None),

     

       196
        
                   source=str(source_url) if source_url else None,

     

       197
        
               )

     

       198
        
       

     
···

       205
        
           def _extract_content(self, entry: feedparser.FeedParserDict) -> Optional[str]:

     

       206
        
               """Extract the best content from an entry."""

     

       207
        
               # Prefer content over summary

     

       208
       +
               if hasattr(entry, "content") and entry.content:

     

       209
        
                   # Find the best content (prefer text/html, then text/plain)

     

       210
        
                   for content_item in entry.content:

     

       211
       +
                       if content_item.get("type") in ["text/html", "html"]:

     

       212
       +
                           return content_item.get("value", "")

     

       213
       +
                       elif content_item.get("type") in ["text/plain", "text"]:

     

       214
       +
                           return content_item.get("value", "")

     

       215
        
                   # Fallback to first content item

     

       216
       +
                   return entry.content[0].get("value", "")

     

       217
        
       

     

       218
        
               # Fallback to summary

     

       219
       +
               return entry.get("summary", "")

     

       220
        
       

     

       221
        
           def _extract_content_type(self, entry: feedparser.FeedParserDict) -> str:

     

       222
        
               """Extract content type from entry."""

     

       223
       +
               if hasattr(entry, "content") and entry.content:

     

       224
       +
                   content_type = entry.content[0].get("type", "html")

     

       225
        
                   # Normalize content type

     

       226
       +
                   if content_type in ["text/html", "html"]:

     

       227
       +
                       return "html"

     

       228
       +
                   elif content_type in ["text/plain", "text"]:

     

       229
       +
                       return "text"

     

       230
       +
                   elif content_type == "xhtml":

     

       231
       +
                       return "xhtml"

     

       232
       +
               return "html"

     

       233
        
       

     

       234
        
           def _extract_author(self, entry: feedparser.FeedParserDict) -> Optional[dict]:

     

       235
        
               """Extract author information from entry."""

     

       236
        
               author = {}

     

       237
        
       

     

       238
       +
               if hasattr(entry, "author_detail"):

     

       239
       +
                   author.update(

     

       240
       +
                       {

     

       241
       +
                           "name": entry.author_detail.get("name"),

     

       242
       +
                           "email": entry.author_detail.get("email"),

     

       243
       +
                           "uri": entry.author_detail.get("href"),

     

       244
       +
                       }

     

       245
       +
                   )

     

       246
       +
               elif hasattr(entry, "author"):

     

       247
       +
                   author["name"] = entry.author

     

       248
        
       

     

       249
        
               return author if author else None

     

       250
        
       

     
···

       265
        
               # Start with the path component

     

       266
        
               if parsed.path:

     

       267
        
                   # Remove leading slash and replace problematic characters

     

       268
       +
                   safe_id = parsed.path.lstrip("/").replace("/", "_").replace("\\", "_")

     

       269
        
               else:

     

       270
        
                   # Use the entire ID as fallback

     

       271
        
                   safe_id = entry_id

     
···

       273
        
               # Replace problematic characters

     

       274
        
               safe_chars = []

     

       275
        
               for char in safe_id:

     

       276
       +
                   if char.isalnum() or char in "-_.":

     

       277
        
                       safe_chars.append(char)

     

       278
        
                   else:

     

       279
       +
                       safe_chars.append("_")

     

       280
        
       

     

       281
       +
               safe_id = "".join(safe_chars)

     

       282
        
       

     

       283
        
               # Ensure it's not too long (max 200 chars)

     

       284
        
               if len(safe_id) > 200:

+107 -18

src/thicket/core/git_store.py

···

       53
        
               """Save the index to index.json."""

     

       54
        
               index_path = self.repo_path / "index.json"

     

       55
        
               with open(index_path, "w") as f:

     

       56
       -
                   json.dump(index.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       57
        
       

     

       58
        
           def _load_index(self) -> GitStoreIndex:

     

       59
        
               """Load the index from index.json."""

     
···

       86
        
       

     

       87
        
               return DuplicateMap(**data)

     

       88
        
       

     

       89
       -
           def add_user(self, username: str, display_name: Optional[str] = None,

     

       90
       -
                        email: Optional[str] = None, homepage: Optional[str] = None,

     

       91
       -
                        icon: Optional[str] = None, feeds: Optional[list[str]] = None) -> UserMetadata:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92
        
               """Add a new user to the Git store."""

     

       93
        
               index = self._load_index()

     

       94
        
       

     
···

       108
        
                   created=datetime.now(),

     

       109
        
                   last_updated=datetime.now(),

     

       110
        
               )

     

       111
       -
       

     

       112
        
       

     

       113
        
               # Update index

     

       114
        
               index.add_user(user_metadata)

     
···

       136
        
       

     

       137
        
               user.update_timestamp()

     

       138
        
       

     

       139
       -
       

     

       140
        
               # Update index

     

       141
        
               index.add_user(user)

     

       142
        
               self._save_index(index)

     

       143
        
       

     

       144
        
               return True

     

       145
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       146
        
           def store_entry(self, username: str, entry: AtomEntry) -> bool:

     

       147
        
               """Store an entry in the user's directory."""

     

       148
        
               user = self.get_user(username)

     
···

       151
        
       

     

       152
        
               # Sanitize entry ID for filename

     

       153
        
               from .feed_parser import FeedParser

     

       0
        
       
     

       154
        
               parser = FeedParser()

     

       155
        
               safe_id = parser.sanitize_entry_id(entry.id)

     

       156
        
       

     
···

       163
        
       

     

       164
        
               # Save entry

     

       165
        
               with open(entry_path, "w") as f:

     

       166
       -
                   json.dump(entry.model_dump(mode="json", exclude_none=True), f, indent=2, default=str)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       167
        
       

     

       168
        
               # Update user metadata if new entry

     

       169
        
               if not entry_exists:

     
···

       181
        
       

     

       182
        
               # Sanitize entry ID

     

       183
        
               from .feed_parser import FeedParser

     

       0
        
       
     

       184
        
               parser = FeedParser()

     

       185
        
               safe_id = parser.sanitize_entry_id(entry_id)

     

       186
        
       

     
···

       193
        
       

     

       194
        
               return AtomEntry(**data)

     

       195
        
       

     

       196
       -
           def list_entries(self, username: str, limit: Optional[int] = None) -> list[AtomEntry]:

     

       0
        
       
     

       0
        
       
     

       197
        
               """List entries for a user."""

     

       198
        
               user = self.get_user(username)

     

       199
        
               if not user:

     
···

       204
        
                   return []

     

       205
        
       

     

       206
        
               entries = []

     

       207
       -
               entry_files = sorted(user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)

     

       208
       -
       

     

       0
        
       
     

       209
        
       

     

       210
        
               if limit:

     

       211
        
                   entry_files = entry_files[:limit]

     
···

       260
        
                   "total_entries": index.total_entries,

     

       261
        
                   "total_duplicates": len(duplicates.duplicates),

     

       262
        
                   "last_updated": index.last_updated,

     

       263
       -
                   "repository_size": sum(f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()),

     

       0
        
       
     

       0
        
       
     

       264
        
               }

     

       265
        
       

     

       266
       -
           def search_entries(self, query: str, username: Optional[str] = None,

     

       267
       -
                             limit: Optional[int] = None) -> list[tuple[str, AtomEntry]]:

     

       0
        
       
     

       268
        
               """Search entries by content."""

     

       269
        
               results = []

     

       270
        
       

     
···

       288
        
                           entry = AtomEntry(**data)

     

       289
        
       

     

       290
        
                           # Simple text search in title, summary, and content

     

       291
       -
                           searchable_text = " ".join(filter(None, [

     

       292
       -
                               entry.title,

     

       293
       -
                               entry.summary or "",

     

       294
       -
                               entry.content or "",

     

       295
       -
                           ])).lower()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       296
        
       

     

       297
        
                           if query.lower() in searchable_text:

     

       298
        
                               results.append((user.username, entry))

     
···

       308
        
               results.sort(key=lambda x: x[1].updated, reverse=True)

     

       309
        
       

     

       310
        
               return results[:limit] if limit else results

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       53
        
               """Save the index to index.json."""

     

       54
        
               index_path = self.repo_path / "index.json"

     

       55
        
               with open(index_path, "w") as f:

     

       56
       +
                   json.dump(

     

       57
       +
                       index.model_dump(mode="json", exclude_none=True),

     

       58
       +
                       f,

     

       59
       +
                       indent=2,

     

       60
       +
                       default=str,

     

       61
       +
                   )

     

       62
        
       

     

       63
        
           def _load_index(self) -> GitStoreIndex:

     

       64
        
               """Load the index from index.json."""

     
···

       91
        
       

     

       92
        
               return DuplicateMap(**data)

     

       93
        
       

     

       94
       +
           def add_user(

     

       95
       +
               self,

     

       96
       +
               username: str,

     

       97
       +
               display_name: Optional[str] = None,

     

       98
       +
               email: Optional[str] = None,

     

       99
       +
               homepage: Optional[str] = None,

     

       100
       +
               icon: Optional[str] = None,

     

       101
       +
               feeds: Optional[list[str]] = None,

     

       102
       +
           ) -> UserMetadata:

     

       103
        
               """Add a new user to the Git store."""

     

       104
        
               index = self._load_index()

     

       105
        
       

     
···

       119
        
                   created=datetime.now(),

     

       120
        
                   last_updated=datetime.now(),

     

       121
        
               )

     

       0
        
       
     

       122
        
       

     

       123
        
               # Update index

     

       124
        
               index.add_user(user_metadata)

     
···

       146
        
       

     

       147
        
               user.update_timestamp()

     

       148
        
       

     

       0
        
       
     

       149
        
               # Update index

     

       150
        
               index.add_user(user)

     

       151
        
               self._save_index(index)

     

       152
        
       

     

       153
        
               return True

     

       154
        
       

     

       155
       +
           def add_zulip_association(self, username: str, server: str, user_id: str) -> bool:

     

       156
       +
               """Add a Zulip association to a user."""

     

       157
       +
               index = self._load_index()

     

       158
       +
               user = index.get_user(username)

     

       159
       +
       

     

       160
       +
               if not user:

     

       161
       +
                   return False

     

       162
       +
       

     

       163
       +
               result = user.add_zulip_association(server, user_id)

     

       164
       +
               if result:

     

       165
       +
                   index.add_user(user)

     

       166
       +
                   self._save_index(index)

     

       167
       +
       

     

       168
       +
               return result

     

       169
       +
       

     

       170
       +
           def remove_zulip_association(

     

       171
       +
               self, username: str, server: str, user_id: str

     

       172
       +
           ) -> bool:

     

       173
       +
               """Remove a Zulip association from a user."""

     

       174
       +
               index = self._load_index()

     

       175
       +
               user = index.get_user(username)

     

       176
       +
       

     

       177
       +
               if not user:

     

       178
       +
                   return False

     

       179
       +
       

     

       180
       +
               result = user.remove_zulip_association(server, user_id)

     

       181
       +
               if result:

     

       182
       +
                   index.add_user(user)

     

       183
       +
                   self._save_index(index)

     

       184
       +
       

     

       185
       +
               return result

     

       186
       +
       

     

       187
       +
           def get_zulip_associations(self, username: str) -> list:

     

       188
       +
               """Get all Zulip associations for a user."""

     

       189
       +
               user = self.get_user(username)

     

       190
       +
               if user:

     

       191
       +
                   return user.zulip_associations

     

       192
       +
               return []

     

       193
       +
       

     

       194
        
           def store_entry(self, username: str, entry: AtomEntry) -> bool:

     

       195
        
               """Store an entry in the user's directory."""

     

       196
        
               user = self.get_user(username)

     
···

       199
        
       

     

       200
        
               # Sanitize entry ID for filename

     

       201
        
               from .feed_parser import FeedParser

     

       202
       +
       

     

       203
        
               parser = FeedParser()

     

       204
        
               safe_id = parser.sanitize_entry_id(entry.id)

     

       205
        
       

     
···

       212
        
       

     

       213
        
               # Save entry

     

       214
        
               with open(entry_path, "w") as f:

     

       215
       +
                   json.dump(

     

       216
       +
                       entry.model_dump(mode="json", exclude_none=True),

     

       217
       +
                       f,

     

       218
       +
                       indent=2,

     

       219
       +
                       default=str,

     

       220
       +
                   )

     

       221
        
       

     

       222
        
               # Update user metadata if new entry

     

       223
        
               if not entry_exists:

     
···

       235
        
       

     

       236
        
               # Sanitize entry ID

     

       237
        
               from .feed_parser import FeedParser

     

       238
       +
       

     

       239
        
               parser = FeedParser()

     

       240
        
               safe_id = parser.sanitize_entry_id(entry_id)

     

       241
        
       

     
···

       248
        
       

     

       249
        
               return AtomEntry(**data)

     

       250
        
       

     

       251
       +
           def list_entries(

     

       252
       +
               self, username: str, limit: Optional[int] = None

     

       253
       +
           ) -> list[AtomEntry]:

     

       254
        
               """List entries for a user."""

     

       255
        
               user = self.get_user(username)

     

       256
        
               if not user:

     
···

       261
        
                   return []

     

       262
        
       

     

       263
        
               entries = []

     

       264
       +
               entry_files = sorted(

     

       265
       +
                   user_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True

     

       266
       +
               )

     

       267
        
       

     

       268
        
               if limit:

     

       269
        
                   entry_files = entry_files[:limit]

     
···

       318
        
                   "total_entries": index.total_entries,

     

       319
        
                   "total_duplicates": len(duplicates.duplicates),

     

       320
        
                   "last_updated": index.last_updated,

     

       321
       +
                   "repository_size": sum(

     

       322
       +
                       f.stat().st_size for f in self.repo_path.rglob("*") if f.is_file()

     

       323
       +
                   ),

     

       324
        
               }

     

       325
        
       

     

       326
       +
           def search_entries(

     

       327
       +
               self, query: str, username: Optional[str] = None, limit: Optional[int] = None

     

       328
       +
           ) -> list[tuple[str, AtomEntry]]:

     

       329
        
               """Search entries by content."""

     

       330
        
               results = []

     

       331
        
       

     
···

       349
        
                           entry = AtomEntry(**data)

     

       350
        
       

     

       351
        
                           # Simple text search in title, summary, and content

     

       352
       +
                           searchable_text = " ".join(

     

       353
       +
                               filter(

     

       354
       +
                                   None,

     

       355
       +
                                   [

     

       356
       +
                                       entry.title,

     

       357
       +
                                       entry.summary or "",

     

       358
       +
                                       entry.content or "",

     

       359
       +
                                   ],

     

       360
       +
                               )

     

       361
       +
                           ).lower()

     

       362
        
       

     

       363
        
                           if query.lower() in searchable_text:

     

       364
        
                               results.append((user.username, entry))

     
···

       374
        
               results.sort(key=lambda x: x[1].updated, reverse=True)

     

       375
        
       

     

       376
        
               return results[:limit] if limit else results

     

       377
       +
       

     

       378
       +
           def list_users(self) -> list[str]:

     

       379
       +
               """Get list of all usernames in the git store."""

     

       380
       +
               index = self._load_index()

     

       381
       +
               return list(index.users.keys())

     

       382
       +
       

     

       383
       +
           def get_user_feeds(self, username: str) -> list[str]:

     

       384
       +
               """Get list of feed URLs for a specific user from their metadata."""

     

       385
       +
               user = self.get_user(username)

     

       386
       +
               if not user:

     

       387
       +
                   return []

     

       388
       +
       

     

       389
       +
               # Feed URLs are stored in the user metadata

     

       390
       +
               return user.feeds

     

       391
       +
       

     

       392
       +
           def list_all_users_with_feeds(self) -> list[tuple[str, list[str]]]:

     

       393
       +
               """Get all users and their feed URLs."""

     

       394
       +
               result = []

     

       395
       +
               for username in self.list_users():

     

       396
       +
                   feeds = self.get_user_feeds(username)

     

       397
       +
                   if feeds:  # Only include users that have feeds configured

     

       398
       +
                       result.append((username, feeds))

     

       399
       +
               return result

+166

src/thicket/core/opml_generator.py

···

       1
       +
       """OPML generation for thicket."""

     

       2
       +
       

     

       3
       +
       import xml.etree.ElementTree as ET

     

       4
       +
       from datetime import datetime

     

       5
       +
       from pathlib import Path

     

       6
       +
       from typing import Optional

     

       7
       +
       from xml.dom import minidom

     

       8
       +
       

     

       9
       +
       from ..models import UserMetadata

     

       10
       +
       

     

       11
       +
       

     

       12
       +
       class OPMLGenerator:

     

       13
       +
           """Generates OPML files from feed collections."""

     

       14
       +
       

     

       15
       +
           def __init__(self) -> None:

     

       16
       +
               """Initialize the OPML generator."""

     

       17
       +
               pass

     

       18
       +
       

     

       19
       +
           def generate_opml(

     

       20
       +
               self,

     

       21
       +
               users: dict[str, UserMetadata],

     

       22
       +
               title: str = "Thicket Feeds",

     

       23
       +
               output_path: Optional[Path] = None,

     

       24
       +
           ) -> str:

     

       25
       +
               """Generate OPML XML content from user metadata.

     

       26
       +
       

     

       27
       +
               Args:

     

       28
       +
                   users: Dictionary of username -> UserMetadata

     

       29
       +
                   title: Title for the OPML file

     

       30
       +
                   output_path: Optional path to write the OPML file

     

       31
       +
       

     

       32
       +
               Returns:

     

       33
       +
                   OPML XML content as string

     

       34
       +
               """

     

       35
       +
               # Create root OPML element

     

       36
       +
               opml = ET.Element("opml", version="2.0")

     

       37
       +
       

     

       38
       +
               # Create head section

     

       39
       +
               head = ET.SubElement(opml, "head")

     

       40
       +
               title_elem = ET.SubElement(head, "title")

     

       41
       +
               title_elem.text = title

     

       42
       +
       

     

       43
       +
               date_created = ET.SubElement(head, "dateCreated")

     

       44
       +
               date_created.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       45
       +
       

     

       46
       +
               date_modified = ET.SubElement(head, "dateModified")

     

       47
       +
               date_modified.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       48
       +
       

     

       49
       +
               # Create body section

     

       50
       +
               body = ET.SubElement(opml, "body")

     

       51
       +
       

     

       52
       +
               # Add each user as an outline with their feeds as sub-outlines

     

       53
       +
               for username, user_metadata in sorted(users.items()):

     

       54
       +
                   user_outline = ET.SubElement(body, "outline")

     

       55
       +
                   user_outline.set("text", user_metadata.display_name or username)

     

       56
       +
                   user_outline.set("title", user_metadata.display_name or username)

     

       57
       +
       

     

       58
       +
                   # Add user metadata as attributes if available

     

       59
       +
                   if user_metadata.homepage:

     

       60
       +
                       user_outline.set("htmlUrl", user_metadata.homepage)

     

       61
       +
                   if user_metadata.email:

     

       62
       +
                       user_outline.set("email", user_metadata.email)

     

       63
       +
       

     

       64
       +
                   # Add each feed as a sub-outline

     

       65
       +
                   for feed_url in sorted(user_metadata.feeds):

     

       66
       +
                       feed_outline = ET.SubElement(user_outline, "outline")

     

       67
       +
                       feed_outline.set("type", "rss")

     

       68
       +
                       feed_outline.set("text", feed_url)

     

       69
       +
                       feed_outline.set("title", feed_url)

     

       70
       +
                       feed_outline.set("xmlUrl", feed_url)

     

       71
       +
                       feed_outline.set("htmlUrl", feed_url)

     

       72
       +
       

     

       73
       +
               # Convert to pretty-printed XML string

     

       74
       +
               xml_str = self._prettify_xml(opml)

     

       75
       +
       

     

       76
       +
               # Write to file if path provided

     

       77
       +
               if output_path:

     

       78
       +
                   output_path.write_text(xml_str, encoding="utf-8")

     

       79
       +
       

     

       80
       +
               return xml_str

     

       81
       +
       

     

       82
       +
           def _prettify_xml(self, elem: ET.Element) -> str:

     

       83
       +
               """Return a pretty-printed XML string for the Element."""

     

       84
       +
               rough_string = ET.tostring(elem, encoding="unicode")

     

       85
       +
               reparsed = minidom.parseString(rough_string)

     

       86
       +
               return reparsed.toprettyxml(indent="  ")

     

       87
       +
       

     

       88
       +
           def generate_flat_opml(

     

       89
       +
               self,

     

       90
       +
               users: dict[str, UserMetadata],

     

       91
       +
               title: str = "Thicket Feeds (Flat)",

     

       92
       +
               output_path: Optional[Path] = None,

     

       93
       +
           ) -> str:

     

       94
       +
               """Generate a flat OPML file with all feeds at the top level.

     

       95
       +
       

     

       96
       +
               This format may be more compatible with some feed readers.

     

       97
       +
       

     

       98
       +
               Args:

     

       99
       +
                   users: Dictionary of username -> UserMetadata

     

       100
       +
                   title: Title for the OPML file

     

       101
       +
                   output_path: Optional path to write the OPML file

     

       102
       +
       

     

       103
       +
               Returns:

     

       104
       +
                   OPML XML content as string

     

       105
       +
               """

     

       106
       +
               # Create root OPML element

     

       107
       +
               opml = ET.Element("opml", version="2.0")

     

       108
       +
       

     

       109
       +
               # Create head section

     

       110
       +
               head = ET.SubElement(opml, "head")

     

       111
       +
               title_elem = ET.SubElement(head, "title")

     

       112
       +
               title_elem.text = title

     

       113
       +
       

     

       114
       +
               date_created = ET.SubElement(head, "dateCreated")

     

       115
       +
               date_created.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       116
       +
       

     

       117
       +
               date_modified = ET.SubElement(head, "dateModified")

     

       118
       +
               date_modified.text = datetime.now().strftime("%a, %d %b %Y %H:%M:%S %z")

     

       119
       +
       

     

       120
       +
               # Create body section

     

       121
       +
               body = ET.SubElement(opml, "body")

     

       122
       +
       

     

       123
       +
               # Collect all feeds with their associated user info

     

       124
       +
               all_feeds = []

     

       125
       +
               for username, user_metadata in users.items():

     

       126
       +
                   for feed_url in user_metadata.feeds:

     

       127
       +
                       all_feeds.append(

     

       128
       +
                           {

     

       129
       +
                               "url": feed_url,

     

       130
       +
                               "username": username,

     

       131
       +
                               "display_name": user_metadata.display_name or username,

     

       132
       +
                               "homepage": user_metadata.homepage,

     

       133
       +
                           }

     

       134
       +
                       )

     

       135
       +
       

     

       136
       +
               # Sort feeds by URL for consistency

     

       137
       +
               all_feeds.sort(key=lambda f: f["url"] or "")

     

       138
       +
       

     

       139
       +
               # Add each feed as a top-level outline

     

       140
       +
               for feed_info in all_feeds:

     

       141
       +
                   feed_outline = ET.SubElement(body, "outline")

     

       142
       +
                   feed_outline.set("type", "rss")

     

       143
       +
       

     

       144
       +
                   # Create a descriptive title that includes the user

     

       145
       +
                   title_text = f"{feed_info['display_name']}: {feed_info['url']}"

     

       146
       +
                   feed_outline.set("text", title_text)

     

       147
       +
                   feed_outline.set("title", title_text)

     

       148
       +
                   url = feed_info["url"] or ""

     

       149
       +
                   feed_outline.set("xmlUrl", url)

     

       150
       +
                   homepage_url = feed_info.get("homepage") or url

     

       151
       +
                   feed_outline.set("htmlUrl", homepage_url or "")

     

       152
       +
       

     

       153
       +
                   # Add custom attributes for user info

     

       154
       +
                   feed_outline.set("thicketUser", feed_info["username"] or "")

     

       155
       +
                   homepage = feed_info.get("homepage")

     

       156
       +
                   if homepage:

     

       157
       +
                       feed_outline.set("thicketHomepage", homepage)

     

       158
       +
       

     

       159
       +
               # Convert to pretty-printed XML string

     

       160
       +
               xml_str = self._prettify_xml(opml)

     

       161
       +
       

     

       162
       +
               # Write to file if path provided

     

       163
       +
               if output_path:

     

       164
       +
                   output_path.write_text(xml_str, encoding="utf-8")

     

       165
       +
       

     

       166
       +
               return xml_str

+428

src/thicket/core/typesense_client.py

···

       1
       +
       """Typesense integration for thicket."""

     

       2
       +
       

     

       3
       +
       import json

     

       4
       +
       import logging

     

       5
       +
       from datetime import datetime

     

       6
       +
       from typing import Any, Optional

     

       7
       +
       from urllib.parse import urlparse

     

       8
       +
       

     

       9
       +
       import typesense

     

       10
       +
       from pydantic import BaseModel, ConfigDict

     

       11
       +
       

     

       12
       +
       from ..models.config import ThicketConfig, UserConfig

     

       13
       +
       from ..models.feed import AtomEntry

     

       14
       +
       from ..models.user import UserMetadata

     

       15
       +
       from .git_store import GitStore

     

       16
       +
       

     

       17
       +
       logger = logging.getLogger(__name__)

     

       18
       +
       

     

       19
       +
       

     

       20
       +
       class TypesenseConfig(BaseModel):

     

       21
       +
           """Configuration for Typesense connection."""

     

       22
       +
       

     

       23
       +
           model_config = ConfigDict(str_strip_whitespace=True)

     

       24
       +
       

     

       25
       +
           host: str

     

       26
       +
           port: int = 8108

     

       27
       +
           protocol: str = "http"

     

       28
       +
           api_key: str

     

       29
       +
           connection_timeout: int = 5

     

       30
       +
           collection_name: str = "thicket_entries"

     

       31
       +
       

     

       32
       +
           @classmethod

     

       33
       +
           def from_url(

     

       34
       +
               cls, url: str, api_key: str, collection_name: str = "thicket_entries"

     

       35
       +
           ) -> "TypesenseConfig":

     

       36
       +
               """Create config from Typesense URL."""

     

       37
       +
               parsed = urlparse(url)

     

       38
       +
               return cls(

     

       39
       +
                   host=parsed.hostname or "localhost",

     

       40
       +
                   port=parsed.port or (443 if parsed.scheme == "https" else 8108),

     

       41
       +
                   protocol=parsed.scheme or "http",

     

       42
       +
                   api_key=api_key,

     

       43
       +
                   collection_name=collection_name,

     

       44
       +
               )

     

       45
       +
       

     

       46
       +
       

     

       47
       +
       class TypesenseDocument(BaseModel):

     

       48
       +
           """Document model for Typesense indexing."""

     

       49
       +
       

     

       50
       +
           model_config = ConfigDict(

     

       51
       +
               json_encoders={datetime: lambda v: int(v.timestamp())},

     

       52
       +
               str_strip_whitespace=True,

     

       53
       +
           )

     

       54
       +
       

     

       55
       +
           # Primary fields from AtomEntry

     

       56
       +
           id: str  # Sanitized entry ID

     

       57
       +
           original_id: str  # Original Atom ID

     

       58
       +
           title: str

     

       59
       +
           link: str

     

       60
       +
           updated: int  # Unix timestamp

     

       61
       +
           published: Optional[int] = None  # Unix timestamp

     

       62
       +
           summary: Optional[str] = None

     

       63
       +
           content: Optional[str] = None

     

       64
       +
           content_type: str = "html"

     

       65
       +
           categories: list[str] = []

     

       66
       +
           rights: Optional[str] = None

     

       67
       +
           source: Optional[str] = None

     

       68
       +
       

     

       69
       +
           # User/feed metadata

     

       70
       +
           username: str

     

       71
       +
           user_display_name: Optional[str] = None

     

       72
       +
           user_email: Optional[str] = None

     

       73
       +
           user_homepage: Optional[str] = None

     

       74
       +
           user_icon: Optional[str] = None

     

       75
       +
       

     

       76
       +
           # Author information from entry

     

       77
       +
           author_name: Optional[str] = None

     

       78
       +
           author_email: Optional[str] = None

     

       79
       +
           author_uri: Optional[str] = None

     

       80
       +
       

     

       81
       +
           # Searchable text fields for embedding/semantic search

     

       82
       +
           searchable_content: str  # Combined title + summary + content

     

       83
       +
           searchable_metadata: str  # Combined user info + categories + author

     

       84
       +
       

     

       85
       +
           @classmethod

     

       86
       +
           def from_atom_entry_with_metadata(

     

       87
       +
               cls,

     

       88
       +
               entry: AtomEntry,

     

       89
       +
               sanitized_id: str,

     

       90
       +
               user_metadata: "UserMetadata",  # Import will be added at top

     

       91
       +
           ) -> "TypesenseDocument":

     

       92
       +
               """Create TypesenseDocument from AtomEntry and UserMetadata from git store."""

     

       93
       +
               # Extract author information if available

     

       94
       +
               author_name = None

     

       95
       +
               author_email = None

     

       96
       +
               author_uri = None

     

       97
       +
               if entry.author:

     

       98
       +
                   author_name = entry.author.get("name")

     

       99
       +
                   author_email = entry.author.get("email")

     

       100
       +
                   author_uri = entry.author.get("uri")

     

       101
       +
       

     

       102
       +
               # Create searchable content combining all text fields

     

       103
       +
               content_parts = [entry.title]

     

       104
       +
               if entry.summary:

     

       105
       +
                   content_parts.append(entry.summary)

     

       106
       +
               if entry.content:

     

       107
       +
                   content_parts.append(entry.content)

     

       108
       +
               searchable_content = " ".join(content_parts)

     

       109
       +
       

     

       110
       +
               # Create searchable metadata

     

       111
       +
               metadata_parts = [user_metadata.username]

     

       112
       +
               if user_metadata.display_name:

     

       113
       +
                   metadata_parts.append(user_metadata.display_name)

     

       114
       +
               if author_name:

     

       115
       +
                   metadata_parts.append(author_name)

     

       116
       +
               if entry.categories:

     

       117
       +
                   metadata_parts.extend(entry.categories)

     

       118
       +
               searchable_metadata = " ".join(metadata_parts)

     

       119
       +
       

     

       120
       +
               return cls(

     

       121
       +
                   id=sanitized_id,

     

       122
       +
                   original_id=entry.id,

     

       123
       +
                   title=entry.title,

     

       124
       +
                   link=str(entry.link),

     

       125
       +
                   updated=int(entry.updated.timestamp()),

     

       126
       +
                   published=int(entry.published.timestamp()) if entry.published else None,

     

       127
       +
                   summary=entry.summary,

     

       128
       +
                   content=entry.content,

     

       129
       +
                   content_type=entry.content_type or "html",

     

       130
       +
                   categories=entry.categories,

     

       131
       +
                   rights=entry.rights,

     

       132
       +
                   source=entry.source,

     

       133
       +
                   username=user_metadata.username,

     

       134
       +
                   user_display_name=user_metadata.display_name,

     

       135
       +
                   user_email=user_metadata.email,

     

       136
       +
                   user_homepage=user_metadata.homepage,

     

       137
       +
                   user_icon=user_metadata.icon if user_metadata.icon != "None" else None,

     

       138
       +
                   author_name=author_name,

     

       139
       +
                   author_email=author_email,

     

       140
       +
                   author_uri=author_uri,

     

       141
       +
                   searchable_content=searchable_content,

     

       142
       +
                   searchable_metadata=searchable_metadata,

     

       143
       +
               )

     

       144
       +
       

     

       145
       +
           @classmethod

     

       146
       +
           def from_atom_entry(

     

       147
       +
               cls,

     

       148
       +
               entry: AtomEntry,

     

       149
       +
               sanitized_id: str,

     

       150
       +
               user_config: UserConfig,

     

       151
       +
           ) -> "TypesenseDocument":

     

       152
       +
               """Create TypesenseDocument from AtomEntry and UserConfig."""

     

       153
       +
               # Extract author information if available

     

       154
       +
               author_name = None

     

       155
       +
               author_email = None

     

       156
       +
               author_uri = None

     

       157
       +
               if entry.author:

     

       158
       +
                   author_name = entry.author.get("name")

     

       159
       +
                   author_email = entry.author.get("email")

     

       160
       +
                   author_uri = entry.author.get("uri")

     

       161
       +
       

     

       162
       +
               # Create searchable content combining all text fields

     

       163
       +
               content_parts = [entry.title]

     

       164
       +
               if entry.summary:

     

       165
       +
                   content_parts.append(entry.summary)

     

       166
       +
               if entry.content:

     

       167
       +
                   content_parts.append(entry.content)

     

       168
       +
               searchable_content = " ".join(content_parts)

     

       169
       +
       

     

       170
       +
               # Create searchable metadata

     

       171
       +
               metadata_parts = [user_config.username]

     

       172
       +
               if user_config.display_name:

     

       173
       +
                   metadata_parts.append(user_config.display_name)

     

       174
       +
               if author_name:

     

       175
       +
                   metadata_parts.append(author_name)

     

       176
       +
               if entry.categories:

     

       177
       +
                   metadata_parts.extend(entry.categories)

     

       178
       +
               searchable_metadata = " ".join(metadata_parts)

     

       179
       +
       

     

       180
       +
               return cls(

     

       181
       +
                   id=sanitized_id,

     

       182
       +
                   original_id=entry.id,

     

       183
       +
                   title=entry.title,

     

       184
       +
                   link=str(entry.link),

     

       185
       +
                   updated=int(entry.updated.timestamp()),

     

       186
       +
                   published=int(entry.published.timestamp()) if entry.published else None,

     

       187
       +
                   summary=entry.summary,

     

       188
       +
                   content=entry.content,

     

       189
       +
                   content_type=entry.content_type or "html",

     

       190
       +
                   categories=entry.categories,

     

       191
       +
                   rights=entry.rights,

     

       192
       +
                   source=entry.source,

     

       193
       +
                   username=user_config.username,

     

       194
       +
                   user_display_name=user_config.display_name,

     

       195
       +
                   user_email=str(user_config.email) if user_config.email else None,

     

       196
       +
                   user_homepage=str(user_config.homepage) if user_config.homepage else None,

     

       197
       +
                   user_icon=str(user_config.icon) if user_config.icon else None,

     

       198
       +
                   author_name=author_name,

     

       199
       +
                   author_email=author_email,

     

       200
       +
                   author_uri=author_uri,

     

       201
       +
                   searchable_content=searchable_content,

     

       202
       +
                   searchable_metadata=searchable_metadata,

     

       203
       +
               )

     

       204
       +
       

     

       205
       +
       

     

       206
       +
       class TypesenseClient:

     

       207
       +
           """Client for interacting with Typesense search engine."""

     

       208
       +
       

     

       209
       +
           def __init__(self, config: TypesenseConfig):

     

       210
       +
               """Initialize Typesense client."""

     

       211
       +
               self.config = config

     

       212
       +
               self.client = typesense.Client(

     

       213
       +
                   {

     

       214
       +
                       "nodes": [

     

       215
       +
                           {

     

       216
       +
                               "host": config.host,

     

       217
       +
                               "port": config.port,

     

       218
       +
                               "protocol": config.protocol,

     

       219
       +
                           }

     

       220
       +
                       ],

     

       221
       +
                       "api_key": config.api_key,

     

       222
       +
                       "connection_timeout_seconds": config.connection_timeout,

     

       223
       +
                   }

     

       224
       +
               )

     

       225
       +
       

     

       226
       +
           def get_collection_schema(self) -> dict[str, Any]:

     

       227
       +
               """Get the Typesense collection schema for thicket entries."""

     

       228
       +
               return {

     

       229
       +
                   "name": self.config.collection_name,

     

       230
       +
                   "fields": [

     

       231
       +
                       # Primary identifiers

     

       232
       +
                       {"name": "id", "type": "string", "facet": False},

     

       233
       +
                       {"name": "original_id", "type": "string", "facet": False},

     

       234
       +
                       # Content fields - optimized for search

     

       235
       +
                       {"name": "title", "type": "string", "facet": False},

     

       236
       +
                       {"name": "summary", "type": "string", "optional": True, "facet": False},

     

       237
       +
                       {"name": "content", "type": "string", "optional": True, "facet": False},

     

       238
       +
                       {"name": "content_type", "type": "string", "facet": True},

     

       239
       +
                       # Searchable combined fields for embeddings/semantic search

     

       240
       +
                       {"name": "searchable_content", "type": "string", "facet": False},

     

       241
       +
                       {"name": "searchable_metadata", "type": "string", "facet": False},

     

       242
       +
                       # Temporal fields

     

       243
       +
                       {"name": "updated", "type": "int64", "facet": False, "sort": True},

     

       244
       +
                       {

     

       245
       +
                           "name": "published",

     

       246
       +
                           "type": "int64",

     

       247
       +
                           "optional": True,

     

       248
       +
                           "facet": False,

     

       249
       +
                           "sort": True,

     

       250
       +
                       },

     

       251
       +
                       # Link and source

     

       252
       +
                       {"name": "link", "type": "string", "facet": False},

     

       253
       +
                       {"name": "source", "type": "string", "optional": True, "facet": False},

     

       254
       +
                       # Categories and classification

     

       255
       +
                       {

     

       256
       +
                           "name": "categories",

     

       257
       +
                           "type": "string[]",

     

       258
       +
                           "facet": True,

     

       259
       +
                           "optional": True,

     

       260
       +
                       },

     

       261
       +
                       {"name": "rights", "type": "string", "optional": True, "facet": False},

     

       262
       +
                       # User/feed metadata - facetable for filtering

     

       263
       +
                       {"name": "username", "type": "string", "facet": True},

     

       264
       +
                       {

     

       265
       +
                           "name": "user_display_name",

     

       266
       +
                           "type": "string",

     

       267
       +
                           "optional": True,

     

       268
       +
                           "facet": True,

     

       269
       +
                       },

     

       270
       +
                       {

     

       271
       +
                           "name": "user_email",

     

       272
       +
                           "type": "string",

     

       273
       +
                           "optional": True,

     

       274
       +
                           "facet": False,

     

       275
       +
                       },

     

       276
       +
                       {

     

       277
       +
                           "name": "user_homepage",

     

       278
       +
                           "type": "string",

     

       279
       +
                           "optional": True,

     

       280
       +
                           "facet": False,

     

       281
       +
                       },

     

       282
       +
                       {

     

       283
       +
                           "name": "user_icon",

     

       284
       +
                           "type": "string",

     

       285
       +
                           "optional": True,

     

       286
       +
                           "facet": False,

     

       287
       +
                       },

     

       288
       +
                       # Author information from entries

     

       289
       +
                       {

     

       290
       +
                           "name": "author_name",

     

       291
       +
                           "type": "string",

     

       292
       +
                           "optional": True,

     

       293
       +
                           "facet": True,

     

       294
       +
                       },

     

       295
       +
                       {

     

       296
       +
                           "name": "author_email",

     

       297
       +
                           "type": "string",

     

       298
       +
                           "optional": True,

     

       299
       +
                           "facet": False,

     

       300
       +
                       },

     

       301
       +
                       {

     

       302
       +
                           "name": "author_uri",

     

       303
       +
                           "type": "string",

     

       304
       +
                           "optional": True,

     

       305
       +
                           "facet": False,

     

       306
       +
                       },

     

       307
       +
                   ],

     

       308
       +
                   "default_sorting_field": "updated",

     

       309
       +
               }

     

       310
       +
       

     

       311
       +
           def create_collection(self) -> dict[str, Any]:

     

       312
       +
               """Create the Typesense collection with the appropriate schema."""

     

       313
       +
               try:

     

       314
       +
                   # Try to delete existing collection first

     

       315
       +
                   try:

     

       316
       +
                       self.client.collections[self.config.collection_name].delete()

     

       317
       +
                       logger.info(

     

       318
       +
                           f"Deleted existing collection: {self.config.collection_name}"

     

       319
       +
                       )

     

       320
       +
                   except typesense.exceptions.ObjectNotFound:

     

       321
       +
                       logger.info(

     

       322
       +
                           f"Collection {self.config.collection_name} does not exist, creating new one"

     

       323
       +
                       )

     

       324
       +
       

     

       325
       +
                   # Create new collection

     

       326
       +
                   schema = self.get_collection_schema()

     

       327
       +
                   result = self.client.collections.create(schema)

     

       328
       +
                   logger.info(f"Created collection: {self.config.collection_name}")

     

       329
       +
                   return result

     

       330
       +
       

     

       331
       +
               except Exception as e:

     

       332
       +
                   logger.error(f"Failed to create collection: {e}")

     

       333
       +
                   raise

     

       334
       +
       

     

       335
       +
           def index_documents(self, documents: list[TypesenseDocument]) -> dict[str, Any]:

     

       336
       +
               """Index a batch of documents in Typesense."""

     

       337
       +
               try:

     

       338
       +
                   # Convert documents to dict format for Typesense

     

       339
       +
                   document_dicts = [doc.model_dump() for doc in documents]

     

       340
       +
       

     

       341
       +
                   # Use import endpoint for batch indexing

     

       342
       +
                   result = self.client.collections[

     

       343
       +
                       self.config.collection_name

     

       344
       +
                   ].documents.import_(

     

       345
       +
                       document_dicts,

     

       346
       +
                       {"action": "upsert"},  # Update if exists, insert if not

     

       347
       +
                   )

     

       348
       +
       

     

       349
       +
                   logger.info(f"Indexed {len(documents)} documents")

     

       350
       +
                   return result

     

       351
       +
       

     

       352
       +
               except Exception as e:

     

       353
       +
                   logger.error(f"Failed to index documents: {e}")

     

       354
       +
                   raise

     

       355
       +
       

     

       356
       +
           def upload_from_git_store(

     

       357
       +
               self, git_store: GitStore, config: ThicketConfig

     

       358
       +
           ) -> dict[str, Any]:

     

       359
       +
               """Upload all entries from the Git store to Typesense."""

     

       360
       +
               logger.info("Starting Typesense upload from Git store")

     

       361
       +
       

     

       362
       +
               # Create collection

     

       363
       +
               self.create_collection()

     

       364
       +
       

     

       365
       +
               documents = []

     

       366
       +
               index = git_store._load_index()

     

       367
       +
       

     

       368
       +
               for username, user_metadata in index.users.items():

     

       369
       +
                   logger.info(f"Processing entries for user: {username}")

     

       370
       +
       

     

       371
       +
                   # Load user entries from directory

     

       372
       +
                   try:

     

       373
       +
                       user_dir = git_store.repo_path / user_metadata.directory

     

       374
       +
                       if not user_dir.exists():

     

       375
       +
                           logger.warning(

     

       376
       +
                               f"Directory not found for user {username}: {user_dir}"

     

       377
       +
                           )

     

       378
       +
                           continue

     

       379
       +
       

     

       380
       +
                       entry_files = list(user_dir.glob("*.json"))

     

       381
       +
                       logger.info(f"Found {len(entry_files)} entry files for {username}")

     

       382
       +
       

     

       383
       +
                       for entry_file in entry_files:

     

       384
       +
                           try:

     

       385
       +
                               with open(entry_file) as f:

     

       386
       +
                                   data = json.load(f)

     

       387
       +
       

     

       388
       +
                               entry = AtomEntry(**data)

     

       389
       +
                               sanitized_id = entry_file.stem  # filename without extension

     

       390
       +
       

     

       391
       +
                               doc = TypesenseDocument.from_atom_entry_with_metadata(

     

       392
       +
                                   entry, sanitized_id, user_metadata

     

       393
       +
                               )

     

       394
       +
                               documents.append(doc)

     

       395
       +
                           except Exception as e:

     

       396
       +
                               logger.error(

     

       397
       +
                                   f"Failed to convert entry {entry_file} to document: {e}"

     

       398
       +
                               )

     

       399
       +
       

     

       400
       +
                   except Exception as e:

     

       401
       +
                       logger.error(f"Failed to load entries for user {username}: {e}")

     

       402
       +
       

     

       403
       +
               if documents:

     

       404
       +
                   logger.info(f"Uploading {len(documents)} documents to Typesense")

     

       405
       +
                   result = self.index_documents(documents)

     

       406
       +
                   logger.info("Upload completed successfully")

     

       407
       +
                   return result

     

       408
       +
               else:

     

       409
       +
                   logger.warning("No documents to upload")

     

       410
       +
                   return {}

     

       411
       +
       

     

       412
       +
           def search(

     

       413
       +
               self, query: str, search_parameters: Optional[dict[str, Any]] = None

     

       414
       +
           ) -> dict[str, Any]:

     

       415
       +
               """Search the collection."""

     

       416
       +
               default_params = {

     

       417
       +
                   "q": query,

     

       418
       +
                   "query_by": "title,searchable_content,searchable_metadata",

     

       419
       +
                   "sort_by": "updated:desc",

     

       420
       +
                   "per_page": 20,

     

       421
       +
               }

     

       422
       +
       

     

       423
       +
               if search_parameters:

     

       424
       +
                   default_params.update(search_parameters)

     

       425
       +
       

     

       426
       +
               return self.client.collections[self.config.collection_name].documents.search(

     

       427
       +
                   default_params

     

       428
       +
               )

+2 -1

src/thicket/models/__init__.py

···

       2
        
       

     

       3
        
       from .config import ThicketConfig, UserConfig

     

       4
        
       from .feed import AtomEntry, DuplicateMap, FeedMetadata

     

       5
       -
       from .user import GitStoreIndex, UserMetadata

     

       6
        
       

     

       7
        
       __all__ = [

     

       8
        
           "ThicketConfig",

     
···

       12
        
           "FeedMetadata",

     

       13
        
           "GitStoreIndex",

     

       14
        
           "UserMetadata",

     

       0
        
       
     

       15
        
       ]

···

       2
        
       

     

       3
        
       from .config import ThicketConfig, UserConfig

     

       4
        
       from .feed import AtomEntry, DuplicateMap, FeedMetadata

     

       5
       +
       from .user import GitStoreIndex, UserMetadata, ZulipAssociation

     

       6
        
       

     

       7
        
       __all__ = [

     

       8
        
           "ThicketConfig",

     
···

       12
        
           "FeedMetadata",

     

       13
        
           "GitStoreIndex",

     

       14
        
           "UserMetadata",

     

       15
       +
           "ZulipAssociation",

     

       16
        
       ]

+24

src/thicket/models/config.py

···

       31
        
           git_store: Path

     

       32
        
           cache_dir: Path

     

       33
        
           users: list[UserConfig] = []

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       31
        
           git_store: Path

     

       32
        
           cache_dir: Path

     

       33
        
           users: list[UserConfig] = []

     

       34
       +
       

     

       35
       +
           def find_user(self, username: str) -> Optional[UserConfig]:

     

       36
       +
               """Find a user by username."""

     

       37
       +
               for user in self.users:

     

       38
       +
                   if user.username == username:

     

       39
       +
                       return user

     

       40
       +
               return None

     

       41
       +
       

     

       42
       +
           def add_user(self, user: UserConfig) -> bool:

     

       43
       +
               """Add a user to the configuration. Returns True if added, False if already exists."""

     

       44
       +
               if self.find_user(user.username) is not None:

     

       45
       +
                   return False

     

       46
       +
               self.users.append(user)

     

       47
       +
               return True

     

       48
       +
       

     

       49
       +
           def add_feed_to_user(self, username: str, feed_url: HttpUrl) -> bool:

     

       50
       +
               """Add a feed to an existing user. Returns True if added, False if user not found or feed already exists."""

     

       51
       +
               user = self.find_user(username)

     

       52
       +
               if user is None:

     

       53
       +
                   return False

     

       54
       +
               if feed_url in user.feeds:

     

       55
       +
                   return False

     

       56
       +
               user.feeds.append(feed_url)

     

       57
       +
               return True

-2

src/thicket/models/feed.py

···

       29
        
           categories: list[str] = []

     

       30
        
           rights: Optional[str] = None  # Copyright info

     

       31
        
           source: Optional[str] = None  # Source feed URL

     

       32
       -
           links: list[str] = []  # URLs mentioned in this entry

     

       33
       -
           backlinks: list[str] = []  # Entry IDs that link to this entry

     

       34
        
       

     

       35
        
       

     

       36
        
       class FeedMetadata(BaseModel):

···

       29
        
           categories: list[str] = []

     

       30
        
           rights: Optional[str] = None  # Copyright info

     

       31
        
           source: Optional[str] = None  # Source feed URL

     

       0
        
       
     

       0
        
       
     

       32
        
       

     

       33
        
       

     

       34
        
       class FeedMetadata(BaseModel):

+41 -4

src/thicket/models/user.py

···

       3
        
       from datetime import datetime

     

       4
        
       from typing import Optional

     

       5
        
       

     

       6
       -
       from pydantic import BaseModel, ConfigDict

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
       

     

       8
        
       

     

       9
        
       class UserMetadata(BaseModel):

     
···

       20
        
           homepage: Optional[str] = None

     

       21
        
           icon: Optional[str] = None

     

       22
        
           feeds: list[str] = []

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
           directory: str  # Directory name in Git store

     

       24
        
           created: datetime

     

       25
        
           last_updated: datetime

     
···

       34
        
               self.entry_count += count

     

       35
        
               self.update_timestamp()

     

       36
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
       

     

       38
        
       class GitStoreIndex(BaseModel):

     

       39
        
           """Index of all users and their directories in the Git store."""

     

       40
        
       

     

       41
       -
           model_config = ConfigDict(

     

       42
       -
               json_encoders={datetime: lambda v: v.isoformat()}

     

       43
       -
           )

     

       44
        
       

     

       45
        
           users: dict[str, UserMetadata] = {}  # username -> UserMetadata

     

       46
        
           created: datetime

···

       3
        
       from datetime import datetime

     

       4
        
       from typing import Optional

     

       5
        
       

     

       6
       +
       from pydantic import BaseModel, ConfigDict, Field

     

       7
       +
       

     

       8
       +
       

     

       9
       +
       class ZulipAssociation(BaseModel):

     

       10
       +
           """Association between a user and their Zulip identity."""

     

       11
       +
       

     

       12
       +
           server: str  # Zulip server URL (e.g., "yourorg.zulipchat.com")

     

       13
       +
           user_id: str  # Zulip user ID or email for @mentions

     

       14
       +
       

     

       15
       +
           def __hash__(self) -> int:

     

       16
       +
               """Make hashable for use in sets."""

     

       17
       +
               return hash((self.server, self.user_id))

     

       18
        
       

     

       19
        
       

     

       20
        
       class UserMetadata(BaseModel):

     
···

       31
        
           homepage: Optional[str] = None

     

       32
        
           icon: Optional[str] = None

     

       33
        
           feeds: list[str] = []

     

       34
       +
           zulip_associations: list[ZulipAssociation] = Field(

     

       35
       +
               default_factory=list

     

       36
       +
           )  # Zulip server/user pairs

     

       37
        
           directory: str  # Directory name in Git store

     

       38
        
           created: datetime

     

       39
        
           last_updated: datetime

     
···

       48
        
               self.entry_count += count

     

       49
        
               self.update_timestamp()

     

       50
        
       

     

       51
       +
           def add_zulip_association(self, server: str, user_id: str) -> bool:

     

       52
       +
               """Add a Zulip association if it doesn't exist. Returns True if added."""

     

       53
       +
               association = ZulipAssociation(server=server, user_id=user_id)

     

       54
       +
               if association not in self.zulip_associations:

     

       55
       +
                   self.zulip_associations.append(association)

     

       56
       +
                   self.update_timestamp()

     

       57
       +
                   return True

     

       58
       +
               return False

     

       59
       +
       

     

       60
       +
           def remove_zulip_association(self, server: str, user_id: str) -> bool:

     

       61
       +
               """Remove a Zulip association. Returns True if removed."""

     

       62
       +
               association = ZulipAssociation(server=server, user_id=user_id)

     

       63
       +
               if association in self.zulip_associations:

     

       64
       +
                   self.zulip_associations.remove(association)

     

       65
       +
                   self.update_timestamp()

     

       66
       +
                   return True

     

       67
       +
               return False

     

       68
       +
       

     

       69
       +
           def get_zulip_mention(self, server: str) -> Optional[str]:

     

       70
       +
               """Get the Zulip user_id for @mentions on a specific server."""

     

       71
       +
               for association in self.zulip_associations:

     

       72
       +
                   if association.server == server:

     

       73
       +
                       return association.user_id

     

       74
       +
               return None

     

       75
       +
       

     

       76
        
       

     

       77
        
       class GitStoreIndex(BaseModel):

     

       78
        
           """Index of all users and their directories in the Git store."""

     

       79
        
       

     

       80
       +
           model_config = ConfigDict(json_encoders={datetime: lambda v: v.isoformat()})

     

       0
        
       
     

       0
        
       
     

       81
        
       

     

       82
        
           users: dict[str, UserMetadata] = {}  # username -> UserMetadata

     

       83
        
           created: datetime

+297

tests/test_bot.py

···

       1
       +
       """Tests for the Thicket Zulip bot."""

     

       2
       +
       

     

       3
       +
       import pytest

     

       4
       +
       

     

       5
       +
       from thicket.bots.test_bot import (

     

       6
       +
           BotTester,

     

       7
       +
           MockBotHandler,

     

       8
       +
           create_test_entry,

     

       9
       +
           create_test_message,

     

       10
       +
       )

     

       11
       +
       from thicket.bots.thicket_bot import ThicketBotHandler

     

       12
       +
       

     

       13
       +
       

     

       14
       +
       class TestThicketBot:

     

       15
       +
           """Test suite for ThicketBotHandler."""

     

       16
       +
       

     

       17
       +
           def setup_method(self) -> None:

     

       18
       +
               """Set up test environment."""

     

       19
       +
               self.bot = ThicketBotHandler()

     

       20
       +
               self.handler = MockBotHandler()

     

       21
       +
       

     

       22
       +
           def test_usage(self) -> None:

     

       23
       +
               """Test bot usage message."""

     

       24
       +
               usage = self.bot.usage()

     

       25
       +
               assert "Thicket Feed Bot" in usage

     

       26
       +
               assert "@thicket status" in usage

     

       27
       +
               assert "@thicket config" in usage

     

       28
       +
       

     

       29
       +
           def test_help_command(self) -> None:

     

       30
       +
               """Test help command response."""

     

       31
       +
               message = create_test_message("@thicket help")

     

       32
       +
               self.bot.handle_message(message, self.handler)

     

       33
       +
       

     

       34
       +
               assert len(self.handler.sent_messages) == 1

     

       35
       +
               response = self.handler.sent_messages[0]["content"]

     

       36
       +
               assert "Thicket Feed Bot" in response

     

       37
       +
       

     

       38
       +
           def test_status_command_unconfigured(self) -> None:

     

       39
       +
               """Test status command when bot is not configured."""

     

       40
       +
               message = create_test_message("@thicket status")

     

       41
       +
               self.bot.handle_message(message, self.handler)

     

       42
       +
       

     

       43
       +
               assert len(self.handler.sent_messages) == 1

     

       44
       +
               response = self.handler.sent_messages[0]["content"]

     

       45
       +
               assert "Not configured" in response

     

       46
       +
               assert "Stream:" in response

     

       47
       +
               assert "Topic:" in response

     

       48
       +
       

     

       49
       +
           def test_config_stream_command(self) -> None:

     

       50
       +
               """Test setting stream configuration."""

     

       51
       +
               message = create_test_message("@thicket config stream general")

     

       52
       +
               self.bot.handle_message(message, self.handler)

     

       53
       +
       

     

       54
       +
               assert len(self.handler.sent_messages) == 1

     

       55
       +
               response = self.handler.sent_messages[0]["content"]

     

       56
       +
               assert "Stream set to: **general**" in response

     

       57
       +
               assert self.bot.stream_name == "general"

     

       58
       +
       

     

       59
       +
           def test_config_topic_command(self) -> None:

     

       60
       +
               """Test setting topic configuration."""

     

       61
       +
               message = create_test_message("@thicket config topic 'Feed Updates'")

     

       62
       +
               self.bot.handle_message(message, self.handler)

     

       63
       +
       

     

       64
       +
               assert len(self.handler.sent_messages) == 1

     

       65
       +
               response = self.handler.sent_messages[0]["content"]

     

       66
       +
               assert "Topic set to:" in response and "Feed Updates" in response

     

       67
       +
               assert self.bot.topic_name == "'Feed Updates'"

     

       68
       +
       

     

       69
       +
           def test_config_interval_command(self) -> None:

     

       70
       +
               """Test setting sync interval."""

     

       71
       +
               message = create_test_message("@thicket config interval 600")

     

       72
       +
               self.bot.handle_message(message, self.handler)

     

       73
       +
       

     

       74
       +
               assert len(self.handler.sent_messages) == 1

     

       75
       +
               response = self.handler.sent_messages[0]["content"]

     

       76
       +
               assert "Sync interval set to: **600s**" in response

     

       77
       +
               assert self.bot.sync_interval == 600

     

       78
       +
       

     

       79
       +
           def test_config_interval_too_small(self) -> None:

     

       80
       +
               """Test setting sync interval that's too small."""

     

       81
       +
               message = create_test_message("@thicket config interval 30")

     

       82
       +
               self.bot.handle_message(message, self.handler)

     

       83
       +
       

     

       84
       +
               assert len(self.handler.sent_messages) == 1

     

       85
       +
               response = self.handler.sent_messages[0]["content"]

     

       86
       +
               assert "must be at least 60 seconds" in response

     

       87
       +
               assert self.bot.sync_interval != 30

     

       88
       +
       

     

       89
       +
           def test_config_path_nonexistent(self) -> None:

     

       90
       +
               """Test setting config path that doesn't exist."""

     

       91
       +
               message = create_test_message("@thicket config path /nonexistent/config.yaml")

     

       92
       +
               self.bot.handle_message(message, self.handler)

     

       93
       +
       

     

       94
       +
               assert len(self.handler.sent_messages) == 1

     

       95
       +
               response = self.handler.sent_messages[0]["content"]

     

       96
       +
               assert "Config file not found" in response

     

       97
       +
       

     

       98
       +
           def test_unknown_command(self) -> None:

     

       99
       +
               """Test unknown command handling."""

     

       100
       +
               message = create_test_message("@thicket unknown")

     

       101
       +
               self.bot.handle_message(message, self.handler)

     

       102
       +
       

     

       103
       +
               assert len(self.handler.sent_messages) == 1

     

       104
       +
               response = self.handler.sent_messages[0]["content"]

     

       105
       +
               assert "Unknown command: unknown" in response

     

       106
       +
       

     

       107
       +
           def test_config_persistence(self) -> None:

     

       108
       +
               """Test that configuration is persisted."""

     

       109
       +
               # Set some config

     

       110
       +
               self.bot.stream_name = "test-stream"

     

       111
       +
               self.bot.topic_name = "test-topic"

     

       112
       +
               self.bot.sync_interval = 600

     

       113
       +
       

     

       114
       +
               # Save config

     

       115
       +
               self.bot._save_bot_config(self.handler)

     

       116
       +
       

     

       117
       +
               # Create new bot instance

     

       118
       +
               new_bot = ThicketBotHandler()

     

       119
       +
               new_bot._load_bot_config(self.handler)

     

       120
       +
       

     

       121
       +
               # Check config was loaded

     

       122
       +
               assert new_bot.stream_name == "test-stream"

     

       123
       +
               assert new_bot.topic_name == "test-topic"

     

       124
       +
               assert new_bot.sync_interval == 600

     

       125
       +
       

     

       126
       +
           def test_posted_entries_persistence(self) -> None:

     

       127
       +
               """Test that posted entries are persisted."""

     

       128
       +
               # Add some entries

     

       129
       +
               self.bot.posted_entries = {"user1:entry1", "user2:entry2"}

     

       130
       +
       

     

       131
       +
               # Save entries

     

       132
       +
               self.bot._save_posted_entries(self.handler)

     

       133
       +
       

     

       134
       +
               # Create new bot instance

     

       135
       +
               new_bot = ThicketBotHandler()

     

       136
       +
               new_bot._load_posted_entries(self.handler)

     

       137
       +
       

     

       138
       +
               # Check entries were loaded

     

       139
       +
               assert new_bot.posted_entries == {"user1:entry1", "user2:entry2"}

     

       140
       +
       

     

       141
       +
           def test_mention_detection(self) -> None:

     

       142
       +
               """Test bot mention detection."""

     

       143
       +
               assert self.bot._is_mentioned("@Thicket Bot help", self.handler)

     

       144
       +
               assert self.bot._is_mentioned("@thicket status", self.handler)

     

       145
       +
               assert not self.bot._is_mentioned("regular message", self.handler)

     

       146
       +
       

     

       147
       +
           def test_mention_cleaning(self) -> None:

     

       148
       +
               """Test cleaning mentions from messages."""

     

       149
       +
               cleaned = self.bot._clean_mention("@Thicket Bot status", self.handler)

     

       150
       +
               assert cleaned == "status"

     

       151
       +
       

     

       152
       +
               cleaned = self.bot._clean_mention("@thicket help", self.handler)

     

       153
       +
               assert cleaned == "help"

     

       154
       +
       

     

       155
       +
           def test_sync_now_uninitialized(self) -> None:

     

       156
       +
               """Test sync now command when not initialized."""

     

       157
       +
               message = create_test_message("@thicket sync now")

     

       158
       +
               self.bot.handle_message(message, self.handler)

     

       159
       +
       

     

       160
       +
               assert len(self.handler.sent_messages) == 1

     

       161
       +
               response = self.handler.sent_messages[0]["content"]

     

       162
       +
               assert "not initialized" in response.lower()

     

       163
       +
       

     

       164
       +
           def test_debug_mode_initialization(self) -> None:

     

       165
       +
               """Test debug mode initialization."""

     

       166
       +
               import os

     

       167
       +
       

     

       168
       +
               # Mock environment variable

     

       169
       +
               os.environ["THICKET_DEBUG_USER"] = "testuser"

     

       170
       +
       

     

       171
       +
               try:

     

       172
       +
                   bot = ThicketBotHandler()

     

       173
       +
                   # Simulate initialize call

     

       174
       +
                   bot.debug_user = os.getenv("THICKET_DEBUG_USER")

     

       175
       +
       

     

       176
       +
                   assert bot.debug_user == "testuser"

     

       177
       +
                   assert bot.debug_zulip_user_id is None  # Not validated yet

     

       178
       +
               finally:

     

       179
       +
                   # Clean up

     

       180
       +
                   if "THICKET_DEBUG_USER" in os.environ:

     

       181
       +
                       del os.environ["THICKET_DEBUG_USER"]

     

       182
       +
       

     

       183
       +
           def test_debug_mode_status(self) -> None:

     

       184
       +
               """Test status command in debug mode."""

     

       185
       +
               self.bot.debug_user = "testuser"

     

       186
       +
               self.bot.debug_zulip_user_id = "test.user"

     

       187
       +
       

     

       188
       +
               message = create_test_message("@thicket status")

     

       189
       +
               self.bot.handle_message(message, self.handler)

     

       190
       +
       

     

       191
       +
               assert len(self.handler.sent_messages) == 1

     

       192
       +
               response = self.handler.sent_messages[0]["content"]

     

       193
       +
               assert "**Debug Mode:** ENABLED" in response

     

       194
       +
               assert "**Debug User:** testuser" in response

     

       195
       +
               assert "**Debug Zulip ID:** test.user" in response

     

       196
       +
       

     

       197
       +
           def test_debug_mode_check_initialization(self) -> None:

     

       198
       +
               """Test initialization check in debug mode."""

     

       199
       +
               from unittest.mock import Mock

     

       200
       +
       

     

       201
       +
               # Setup mock git store and config

     

       202
       +
               self.bot.git_store = Mock()

     

       203
       +
               self.bot.config = Mock()

     

       204
       +
               self.bot.debug_user = "testuser"

     

       205
       +
               self.bot.debug_zulip_user_id = "test.user"

     

       206
       +
       

     

       207
       +
               message = create_test_message("@thicket sync now")

     

       208
       +
       

     

       209
       +
               # Should pass with debug mode properly set up

     

       210
       +
               result = self.bot._check_initialization(message, self.handler)

     

       211
       +
               assert result is True

     

       212
       +
       

     

       213
       +
               # Should fail if debug_zulip_user_id is missing

     

       214
       +
               self.bot.debug_zulip_user_id = None

     

       215
       +
               result = self.bot._check_initialization(message, self.handler)

     

       216
       +
               assert result is False

     

       217
       +
               assert len(self.handler.sent_messages) == 1

     

       218
       +
               assert (

     

       219
       +
                   "Debug mode validation failed" in self.handler.sent_messages[0]["content"]

     

       220
       +
               )

     

       221
       +
       

     

       222
       +
           def test_debug_mode_dm_posting(self) -> None:

     

       223
       +
               """Test that debug mode posts DMs instead of stream messages."""

     

       224
       +
               from unittest.mock import Mock

     

       225
       +
       

     

       226
       +
               # Setup bot in debug mode

     

       227
       +
               self.bot.debug_user = "testuser"

     

       228
       +
               self.bot.debug_zulip_user_id = "test.user@example.com"

     

       229
       +
               self.bot.git_store = Mock()

     

       230
       +
       

     

       231
       +
               # Create a test entry

     

       232
       +
               entry = create_test_entry()

     

       233
       +
       

     

       234
       +
               # Mock the handler config

     

       235
       +
               self.handler.config_info = {

     

       236
       +
                   "full_name": "Thicket Bot",

     

       237
       +
                   "email": "thicket-bot@example.com",

     

       238
       +
                   "site": "https://example.zulipchat.com",

     

       239
       +
               }

     

       240
       +
       

     

       241
       +
               # Mock git store user

     

       242
       +
               mock_user = Mock()

     

       243
       +
               mock_user.get_zulip_mention.return_value = "author.user"

     

       244
       +
               self.bot.git_store.get_user.return_value = mock_user

     

       245
       +
       

     

       246
       +
               # Post entry

     

       247
       +
               self.bot._post_entry_to_zulip(entry, self.handler, "testauthor")

     

       248
       +
       

     

       249
       +
               # Check that a DM was sent

     

       250
       +
               assert len(self.handler.sent_messages) == 1

     

       251
       +
               message = self.handler.sent_messages[0]

     

       252
       +
       

     

       253
       +
               # Verify it's a DM

     

       254
       +
               assert message["type"] == "private"

     

       255
       +
               assert message["to"] == ["test.user@example.com"]

     

       256
       +
               assert "DEBUG:" in message["content"]

     

       257
       +
               assert entry.title in message["content"]

     

       258
       +
               assert "@**author.user** posted:" in message["content"]

     

       259
       +
       

     

       260
       +
       

     

       261
       +
       class TestBotTester:

     

       262
       +
           """Test the bot testing utilities."""

     

       263
       +
       

     

       264
       +
           def test_bot_tester_basic(self) -> None:

     

       265
       +
               """Test basic bot tester functionality."""

     

       266
       +
               tester = BotTester()

     

       267
       +
       

     

       268
       +
               # Test help command

     

       269
       +
               responses = tester.send_command("help")

     

       270
       +
               assert len(responses) == 1

     

       271
       +
               assert "Thicket Feed Bot" in tester.get_last_response_content()

     

       272
       +
       

     

       273
       +
           def test_bot_tester_config(self) -> None:

     

       274
       +
               """Test bot tester configuration."""

     

       275
       +
               tester = BotTester()

     

       276
       +
       

     

       277
       +
               # Configure stream

     

       278
       +
               tester.send_command("config stream general")

     

       279
       +
               tester.assert_response_contains("Stream set to")

     

       280
       +
       

     

       281
       +
               # Configure topic

     

       282
       +
               tester.send_command("config topic test")

     

       283
       +
               tester.assert_response_contains("Topic set to")

     

       284
       +
       

     

       285
       +
           def test_assert_response_contains(self) -> None:

     

       286
       +
               """Test response assertion helper."""

     

       287
       +
               tester = BotTester()

     

       288
       +
       

     

       289
       +
               # Send command

     

       290
       +
               tester.send_command("help")

     

       291
       +
       

     

       292
       +
               # This should pass

     

       293
       +
               tester.assert_response_contains("Thicket Feed Bot")

     

       294
       +
       

     

       295
       +
               # This should fail

     

       296
       +
               with pytest.raises(AssertionError):

     

       297
       +
                   tester.assert_response_contains("nonexistent text")

+2 -1

tests/test_feed_parser.py

···

       100
        
               html_with_attrs = '<a href="https://example.com" onclick="alert()">Link</a>'

     

       101
        
               sanitized = parser._sanitize_html(html_with_attrs)

     

       102
        
               assert 'href="https://example.com"' in sanitized

     

       103
       -
               assert 'onclick' not in sanitized

     

       104
        
       

     

       105
        
           def test_extract_feed_metadata(self):

     

       106
        
               """Test feed metadata extraction."""

     
···

       108
        
       

     

       109
        
               # Test with feedparser parsed data

     

       110
        
               import feedparser

     

       0
        
       
     

       111
        
               parsed = feedparser.parse("""<?xml version="1.0" encoding="utf-8"?>

     

       112
        
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       113
        
         <title>Test Feed</title>

···

       100
        
               html_with_attrs = '<a href="https://example.com" onclick="alert()">Link</a>'

     

       101
        
               sanitized = parser._sanitize_html(html_with_attrs)

     

       102
        
               assert 'href="https://example.com"' in sanitized

     

       103
       +
               assert "onclick" not in sanitized

     

       104
        
       

     

       105
        
           def test_extract_feed_metadata(self):

     

       106
        
               """Test feed metadata extraction."""

     
···

       108
        
       

     

       109
        
               # Test with feedparser parsed data

     

       110
        
               import feedparser

     

       111
       +
       

     

       112
        
               parsed = feedparser.parse("""<?xml version="1.0" encoding="utf-8"?>

     

       113
        
       <feed xmlns="http://www.w3.org/2005/Atom">

     

       114
        
         <title>Test Feed</title>

+7 -2

tests/test_git_store.py

···

       191
        
               duplicates = store.get_duplicates()

     

       192
        
               assert len(duplicates.duplicates) == 1

     

       193
        
               assert duplicates.is_duplicate("https://example.com/dup")

     

       194
       -
               assert duplicates.get_canonical("https://example.com/dup") == "https://example.com/canonical"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       195
        
       

     

       196
        
               # Remove duplicate

     

       197
        
               result = store.remove_duplicate("https://example.com/dup")

     
···

       220
        
                   entry = AtomEntry(

     

       221
        
                       id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",

     

       222
        
                       title=title,

     

       223
       -
                       link=HttpUrl(f"https://example.com/entry/{title.lower().replace(' ', '-')}"),

     

       0
        
       
     

       0
        
       
     

       224
        
                       updated=datetime.now(),

     

       225
        
                       summary=summary,

     

       226
        
                   )

···

       191
        
               duplicates = store.get_duplicates()

     

       192
        
               assert len(duplicates.duplicates) == 1

     

       193
        
               assert duplicates.is_duplicate("https://example.com/dup")

     

       194
       +
               assert (

     

       195
       +
                   duplicates.get_canonical("https://example.com/dup")

     

       196
       +
                   == "https://example.com/canonical"

     

       197
       +
               )

     

       198
        
       

     

       199
        
               # Remove duplicate

     

       200
        
               result = store.remove_duplicate("https://example.com/dup")

     
···

       223
        
                   entry = AtomEntry(

     

       224
        
                       id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",

     

       225
        
                       title=title,

     

       226
       +
                       link=HttpUrl(

     

       227
       +
                           f"https://example.com/entry/{title.lower().replace(' ', '-')}"

     

       228
       +
                       ),

     

       229
        
                       updated=datetime.now(),

     

       230
        
                       summary=summary,

     

       231
        
                   )

+88 -4

tests/test_models.py

···

       12
        
           ThicketConfig,

     

       13
        
           UserConfig,

     

       14
        
           UserMetadata,

     

       0
        
       
     

       15
        
       )

     

       16
        
       

     

       17
        
       

     
···

       126
        
                   git_store=temp_dir / "git_store",

     

       127
        
                   cache_dir=temp_dir / "cache",

     

       128
        
                   users=[

     

       129
       -
                       UserConfig(username="testuser", feeds=["https://example.com/feed1.xml"]),

     

       0
        
       
     

       0
        
       
     

       130
        
                   ],

     

       131
        
               )

     

       132
        
       

     

       133
       -
               result = config.add_feed_to_user("testuser", HttpUrl("https://example.com/feed2.xml"))

     

       0
        
       
     

       0
        
       
     

       134
        
               assert result is True

     

       135
        
       

     

       136
        
               user = config.find_user("testuser")

     
···

       138
        
               assert HttpUrl("https://example.com/feed2.xml") in user.feeds

     

       139
        
       

     

       140
        
               # Test adding to non-existent user

     

       141
       -
               result = config.add_feed_to_user("nonexistent", HttpUrl("https://example.com/feed.xml"))

     

       0
        
       
     

       0
        
       
     

       142
        
               assert result is False

     

       143
        
       

     

       144
        
       

     
···

       293
        
               user_config = metadata.to_user_config("testuser", feed_url)

     

       294
        
       

     

       295
        
               assert user_config.display_name == "Test Feed"  # Falls back to title

     

       296
       -
               assert user_config.homepage == HttpUrl("https://example.com")  # Falls back to link

     

       0
        
       
     

       0
        
       
     

       297
        
               assert user_config.icon == HttpUrl("https://example.com/icon.png")

     

       298
        
               assert user_config.email is None

     

       299
        
       

     
···

       350
        
       

     

       351
        
               assert metadata.entry_count == original_count + 3

     

       352
        
               assert metadata.last_updated > original_time

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       12
        
           ThicketConfig,

     

       13
        
           UserConfig,

     

       14
        
           UserMetadata,

     

       15
       +
           ZulipAssociation,

     

       16
        
       )

     

       17
        
       

     

       18
        
       

     
···

       127
        
                   git_store=temp_dir / "git_store",

     

       128
        
                   cache_dir=temp_dir / "cache",

     

       129
        
                   users=[

     

       130
       +
                       UserConfig(

     

       131
       +
                           username="testuser", feeds=["https://example.com/feed1.xml"]

     

       132
       +
                       ),

     

       133
        
                   ],

     

       134
        
               )

     

       135
        
       

     

       136
       +
               result = config.add_feed_to_user(

     

       137
       +
                   "testuser", HttpUrl("https://example.com/feed2.xml")

     

       138
       +
               )

     

       139
        
               assert result is True

     

       140
        
       

     

       141
        
               user = config.find_user("testuser")

     
···

       143
        
               assert HttpUrl("https://example.com/feed2.xml") in user.feeds

     

       144
        
       

     

       145
        
               # Test adding to non-existent user

     

       146
       +
               result = config.add_feed_to_user(

     

       147
       +
                   "nonexistent", HttpUrl("https://example.com/feed.xml")

     

       148
       +
               )

     

       149
        
               assert result is False

     

       150
        
       

     

       151
        
       

     
···

       300
        
               user_config = metadata.to_user_config("testuser", feed_url)

     

       301
        
       

     

       302
        
               assert user_config.display_name == "Test Feed"  # Falls back to title

     

       303
       +
               assert user_config.homepage == HttpUrl(

     

       304
       +
                   "https://example.com"

     

       305
       +
               )  # Falls back to link

     

       306
        
               assert user_config.icon == HttpUrl("https://example.com/icon.png")

     

       307
        
               assert user_config.email is None

     

       308
        
       

     
···

       359
        
       

     

       360
        
               assert metadata.entry_count == original_count + 3

     

       361
        
               assert metadata.last_updated > original_time

     

       362
       +
       

     

       363
       +
           def test_zulip_associations(self):

     

       364
       +
               """Test Zulip association methods."""

     

       365
       +
               metadata = UserMetadata(

     

       366
       +
                   username="testuser",

     

       367
       +
                   directory="testuser",

     

       368
       +
                   created=datetime.now(),

     

       369
       +
                   last_updated=datetime.now(),

     

       370
       +
               )

     

       371
       +
       

     

       372
       +
               # Test adding association

     

       373
       +
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       374
       +
               assert result is True

     

       375
       +
               assert len(metadata.zulip_associations) == 1

     

       376
       +
               assert metadata.zulip_associations[0].server == "example.zulipchat.com"

     

       377
       +
               assert metadata.zulip_associations[0].user_id == "alice"

     

       378
       +
       

     

       379
       +
               # Test adding duplicate association

     

       380
       +
               result = metadata.add_zulip_association("example.zulipchat.com", "alice")

     

       381
       +
               assert result is False

     

       382
       +
               assert len(metadata.zulip_associations) == 1

     

       383
       +
       

     

       384
       +
               # Test adding different association

     

       385
       +
               result = metadata.add_zulip_association("other.zulipchat.com", "alice")

     

       386
       +
               assert result is True

     

       387
       +
               assert len(metadata.zulip_associations) == 2

     

       388
       +
       

     

       389
       +
               # Test get_zulip_mention

     

       390
       +
               mention = metadata.get_zulip_mention("example.zulipchat.com")

     

       391
       +
               assert mention == "alice"

     

       392
       +
       

     

       393
       +
               mention = metadata.get_zulip_mention("other.zulipchat.com")

     

       394
       +
               assert mention == "alice"

     

       395
       +
       

     

       396
       +
               mention = metadata.get_zulip_mention("nonexistent.zulipchat.com")

     

       397
       +
               assert mention is None

     

       398
       +
       

     

       399
       +
               # Test removing association

     

       400
       +
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       401
       +
               assert result is True

     

       402
       +
               assert len(metadata.zulip_associations) == 1

     

       403
       +
       

     

       404
       +
               # Test removing non-existent association

     

       405
       +
               result = metadata.remove_zulip_association("example.zulipchat.com", "alice")

     

       406
       +
               assert result is False

     

       407
       +
               assert len(metadata.zulip_associations) == 1

     

       408
       +
       

     

       409
       +
       

     

       410
       +
       class TestZulipAssociation:

     

       411
       +
           """Test ZulipAssociation model."""

     

       412
       +
       

     

       413
       +
           def test_valid_association(self):

     

       414
       +
               """Test creating valid Zulip association."""

     

       415
       +
               assoc = ZulipAssociation(

     

       416
       +
                   server="example.zulipchat.com", user_id="alice@example.com"

     

       417
       +
               )

     

       418
       +
       

     

       419
       +
               assert assoc.server == "example.zulipchat.com"

     

       420
       +
               assert assoc.user_id == "alice@example.com"

     

       421
       +
       

     

       422
       +
           def test_association_hash(self):

     

       423
       +
               """Test that associations are hashable."""

     

       424
       +
               assoc1 = ZulipAssociation(server="example.zulipchat.com", user_id="alice")

     

       425
       +
               assoc2 = ZulipAssociation(server="example.zulipchat.com", user_id="alice")

     

       426
       +
               assoc3 = ZulipAssociation(server="other.zulipchat.com", user_id="alice")

     

       427
       +
       

     

       428
       +
               # Same associations should have same hash

     

       429
       +
               assert hash(assoc1) == hash(assoc2)

     

       430
       +
       

     

       431
       +
               # Different associations should have different hash

     

       432
       +
               assert hash(assoc1) != hash(assoc3)

     

       433
       +
       

     

       434
       +
               # Can be used in sets

     

       435
       +
               assoc_set = {assoc1, assoc2, assoc3}

     

       436
       +
               assert len(assoc_set) == 2  # assoc1 and assoc2 are considered the same

+299 -165

uv.lock

···

       1
        
       version = 1

     

       2
       -
       revision = 2

     

       3
        
       requires-python = ">=3.9"

     

       4
        
       resolution-markers = [

     

       5
        
           "python_full_version >= '3.10'",

     
···

       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
        
       wheels = [

     

       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" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
       ]

     

       32
        
       

     

       33
        
       [[package]]

     
···

       82
        
       ]

     

       83
        
       

     

       84
        
       [[package]]

     

       85
       -
       name = "blinker"

     

       86
       -
       version = "1.9.0"

     

       87
        
       source = { registry = "https://pypi.org/simple" }

     

       88
       -
       sdist = { url = "https://files.pythonhosted.org/packages/21/28/9b3f50ce0e048515135495f198351908d99540d69bfdc8c1d15b73dc55ce/blinker-1.9.0.tar.gz", hash = "sha256:b4ce2265a7abece45e7cc896e98dbebe6cead56bcf805a3d23136d145f5445bf", size = 22460, upload-time = "2024-11-08T17:25:47.436Z" }

     

       89
        
       wheels = [

     

       90
       -
           { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458, upload-time = "2024-11-08T17:25:46.184Z" },

     

       91
        
       ]

     

       92
        
       

     

       93
        
       [[package]]

     

       94
       -
       name = "certifi"

     

       95
       -
       version = "2025.7.14"

     

       96
        
       source = { registry = "https://pypi.org/simple" }

     

       97
       -
       sdist = { url = "https://files.pythonhosted.org/packages/b3/76/52c535bcebe74590f296d6c77c86dabf761c41980e1347a2422e4aa2ae41/certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995", size = 163981, upload-time = "2025-07-14T03:29:28.449Z" }

     

       98
        
       wheels = [

     

       99
       -
           { url = "https://files.pythonhosted.org/packages/4f/52/34c6cf5bb9285074dc3531c437b3919e825d976fde097a7a73f79e726d03/certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2", size = 162722, upload-time = "2025-07-14T03:29:26.863Z" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       100
        
       ]

     

       101
        
       

     

       102
        
       [[package]]

     
···

       218
        
       ]

     

       219
        
       

     

       220
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       221
        
       name = "dnspython"

     

       222
        
       version = "2.7.0"

     

       223
        
       source = { registry = "https://pypi.org/simple" }

     
···

       264
        
       ]

     

       265
        
       

     

       266
        
       [[package]]

     

       267
       -
       name = "flask"

     

       268
       -
       version = "3.1.1"

     

       269
       -
       source = { registry = "https://pypi.org/simple" }

     

       270
       -
       dependencies = [

     

       271
       -
           { name = "blinker" },

     

       272
       -
           { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },

     

       273
       -
           { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },

     

       274
       -
           { name = "importlib-metadata", marker = "python_full_version < '3.10'" },

     

       275
       -
           { name = "itsdangerous" },

     

       276
       -
           { name = "jinja2" },

     

       277
       -
           { name = "markupsafe" },

     

       278
       -
           { name = "werkzeug" },

     

       279
       -
       ]

     

       280
       -
       sdist = { url = "https://files.pythonhosted.org/packages/c0/de/e47735752347f4128bcf354e0da07ef311a78244eba9e3dc1d4a5ab21a98/flask-3.1.1.tar.gz", hash = "sha256:284c7b8f2f58cb737f0cf1c30fd7eaf0ccfcde196099d24ecede3fc2005aa59e", size = 753440, upload-time = "2025-05-13T15:01:17.447Z" }

     

       281
       -
       wheels = [

     

       282
       -
           { url = "https://files.pythonhosted.org/packages/3d/68/9d4508e893976286d2ead7f8f571314af6c2037af34853a30fd769c02e9d/flask-3.1.1-py3-none-any.whl", hash = "sha256:07aae2bb5eaf77993ef57e357491839f5fd9f4dc281593a81a9e4d79a24f295c", size = 103305, upload-time = "2025-05-13T15:01:15.591Z" },

     

       283
       -
       ]

     

       284
       -
       

     

       285
       -
       [[package]]

     

       286
        
       name = "gitdb"

     

       287
        
       version = "4.0.12"

     

       288
        
       source = { registry = "https://pypi.org/simple" }

     
···

       316
        
       ]

     

       317
        
       

     

       318
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       319
        
       name = "httpcore"

     

       320
        
       version = "1.0.9"

     

       321
        
       source = { registry = "https://pypi.org/simple" }

     
···

       357
        
       version = "8.7.0"

     

       358
        
       source = { registry = "https://pypi.org/simple" }

     

       359
        
       dependencies = [

     

       360
       -
           { name = "zipp", marker = "python_full_version < '3.10'" },

     

       361
        
       ]

     

       362
        
       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" }

     

       363
        
       wheels = [

     
···

       374
        
       ]

     

       375
        
       

     

       376
        
       [[package]]

     

       377
       -
       name = "itsdangerous"

     

       378
       -
       version = "2.2.0"

     

       379
       -
       source = { registry = "https://pypi.org/simple" }

     

       380
       -
       sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" }

     

       381
       -
       wheels = [

     

       382
       -
           { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" },

     

       383
       -
       ]

     

       384
       -
       

     

       385
       -
       [[package]]

     

       386
       -
       name = "jinja2"

     

       387
       -
       version = "3.1.6"

     

       388
        
       source = { registry = "https://pypi.org/simple" }

     

       389
       -
       dependencies = [

     

       390
       -
           { name = "markupsafe" },

     

       391
       -
       ]

     

       392
       -
       sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }

     

       393
        
       wheels = [

     

       394
       -
           { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },

     

       395
       -
       ]

     

       396
       -
       

     

       397
       -
       [[package]]

     

       398
       -
       name = "linkify-it-py"

     

       399
       -
       version = "2.0.3"

     

       400
       -
       source = { registry = "https://pypi.org/simple" }

     

       401
       -
       dependencies = [

     

       402
       -
           { name = "uc-micro-py" },

     

       403
       -
       ]

     

       404
       -
       sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" }

     

       405
       -
       wheels = [

     

       406
       -
           { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       407
        
       ]

     

       408
        
       

     

       409
        
       [[package]]

     
···

       418
        
           { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },

     

       419
        
       ]

     

       420
        
       

     

       421
       -
       [package.optional-dependencies]

     

       422
       -
       linkify = [

     

       423
       -
           { name = "linkify-it-py" },

     

       424
       -
       ]

     

       425
       -
       plugins = [

     

       426
       -
           { name = "mdit-py-plugins" },

     

       427
       -
       ]

     

       428
       -
       

     

       429
        
       [[package]]

     

       430
       -
       name = "markupsafe"

     

       431
       -
       version = "3.0.2"

     

       432
       -
       source = { registry = "https://pypi.org/simple" }

     

       433
       -
       sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" }

     

       434
       -
       wheels = [

     

       435
       -
           { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357, upload-time = "2024-10-18T15:20:51.44Z" },

     

       436
       -
           { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393, upload-time = "2024-10-18T15:20:52.426Z" },

     

       437
       -
           { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732, upload-time = "2024-10-18T15:20:53.578Z" },

     

       438
       -
           { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866, upload-time = "2024-10-18T15:20:55.06Z" },

     

       439
       -
           { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964, upload-time = "2024-10-18T15:20:55.906Z" },

     

       440
       -
           { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977, upload-time = "2024-10-18T15:20:57.189Z" },

     

       441
       -
           { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366, upload-time = "2024-10-18T15:20:58.235Z" },

     

       442
       -
           { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091, upload-time = "2024-10-18T15:20:59.235Z" },

     

       443
       -
           { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065, upload-time = "2024-10-18T15:21:00.307Z" },

     

       444
       -
           { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514, upload-time = "2024-10-18T15:21:01.122Z" },

     

       445
       -
           { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353, upload-time = "2024-10-18T15:21:02.187Z" },

     

       446
       -
           { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392, upload-time = "2024-10-18T15:21:02.941Z" },

     

       447
       -
           { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984, upload-time = "2024-10-18T15:21:03.953Z" },

     

       448
       -
           { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120, upload-time = "2024-10-18T15:21:06.495Z" },

     

       449
       -
           { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032, upload-time = "2024-10-18T15:21:07.295Z" },

     

       450
       -
           { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057, upload-time = "2024-10-18T15:21:08.073Z" },

     

       451
       -
           { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359, upload-time = "2024-10-18T15:21:09.318Z" },

     

       452
       -
           { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306, upload-time = "2024-10-18T15:21:10.185Z" },

     

       453
       -
           { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094, upload-time = "2024-10-18T15:21:11.005Z" },

     

       454
       -
           { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521, upload-time = "2024-10-18T15:21:12.911Z" },

     

       455
       -
           { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" },

     

       456
       -
           { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" },

     

       457
       -
           { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" },

     

       458
       -
           { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" },

     

       459
       -
           { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" },

     

       460
       -
           { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" },

     

       461
       -
           { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" },

     

       462
       -
           { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" },

     

       463
       -
           { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" },

     

       464
       -
           { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" },

     

       465
       -
           { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" },

     

       466
       -
           { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" },

     

       467
       -
           { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" },

     

       468
       -
           { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" },

     

       469
       -
           { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" },

     

       470
       -
           { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" },

     

       471
       -
           { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" },

     

       472
       -
           { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" },

     

       473
       -
           { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" },

     

       474
       -
           { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" },

     

       475
       -
           { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" },

     

       476
       -
           { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" },

     

       477
       -
           { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" },

     

       478
       -
           { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" },

     

       479
       -
           { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" },

     

       480
       -
           { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" },

     

       481
       -
           { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" },

     

       482
       -
           { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" },

     

       483
       -
           { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" },

     

       484
       -
           { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" },

     

       485
       -
           { url = "https://files.pythonhosted.org/packages/a7/ea/9b1530c3fdeeca613faeb0fb5cbcf2389d816072fab72a71b45749ef6062/MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a", size = 14344, upload-time = "2024-10-18T15:21:43.721Z" },

     

       486
       -
           { url = "https://files.pythonhosted.org/packages/4b/c2/fbdbfe48848e7112ab05e627e718e854d20192b674952d9042ebd8c9e5de/MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff", size = 12389, upload-time = "2024-10-18T15:21:44.666Z" },

     

       487
       -
           { url = "https://files.pythonhosted.org/packages/f0/25/7a7c6e4dbd4f867d95d94ca15449e91e52856f6ed1905d58ef1de5e211d0/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13", size = 21607, upload-time = "2024-10-18T15:21:45.452Z" },

     

       488
       -
           { url = "https://files.pythonhosted.org/packages/53/8f/f339c98a178f3c1e545622206b40986a4c3307fe39f70ccd3d9df9a9e425/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144", size = 20728, upload-time = "2024-10-18T15:21:46.295Z" },

     

       489
       -
           { url = "https://files.pythonhosted.org/packages/1a/03/8496a1a78308456dbd50b23a385c69b41f2e9661c67ea1329849a598a8f9/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29", size = 20826, upload-time = "2024-10-18T15:21:47.134Z" },

     

       490
       -
           { url = "https://files.pythonhosted.org/packages/e6/cf/0a490a4bd363048c3022f2f475c8c05582179bb179defcee4766fb3dcc18/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0", size = 21843, upload-time = "2024-10-18T15:21:48.334Z" },

     

       491
       -
           { url = "https://files.pythonhosted.org/packages/19/a3/34187a78613920dfd3cdf68ef6ce5e99c4f3417f035694074beb8848cd77/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0", size = 21219, upload-time = "2024-10-18T15:21:49.587Z" },

     

       492
       -
           { url = "https://files.pythonhosted.org/packages/17/d8/5811082f85bb88410ad7e452263af048d685669bbbfb7b595e8689152498/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178", size = 20946, upload-time = "2024-10-18T15:21:50.441Z" },

     

       493
       -
           { url = "https://files.pythonhosted.org/packages/7c/31/bd635fb5989440d9365c5e3c47556cfea121c7803f5034ac843e8f37c2f2/MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f", size = 15063, upload-time = "2024-10-18T15:21:51.385Z" },

     

       494
       -
           { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506, upload-time = "2024-10-18T15:21:52.974Z" },

     

       495
       -
       ]

     

       496
       -
       

     

       497
       -
       [[package]]

     

       498
       -
       name = "mdit-py-plugins"

     

       499
       -
       version = "0.4.2"

     

       500
        
       source = { registry = "https://pypi.org/simple" }

     

       501
        
       dependencies = [

     

       502
       -
           { name = "markdown-it-py" },

     

       0
        
       
     

       503
        
       ]

     

       504
       -
       sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542, upload-time = "2024-09-09T20:27:49.564Z" }

     

       505
        
       wheels = [

     

       506
       -
           { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316, upload-time = "2024-09-09T20:27:48.397Z" },

     

       507
        
       ]

     

       508
        
       

     

       509
        
       [[package]]

     
···

       663
        
       ]

     

       664
        
       

     

       665
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       666
        
       name = "platformdirs"

     

       667
        
       version = "4.3.8"

     

       668
        
       source = { registry = "https://pypi.org/simple" }

     
···

       947
        
       ]

     

       948
        
       

     

       949
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       950
        
       name = "rich"

     

       951
        
       version = "14.0.0"

     

       952
        
       source = { registry = "https://pypi.org/simple" }

     
···

       1028
        
       ]

     

       1029
        
       

     

       1030
        
       [[package]]

     

       1031
       -
       name = "textual"

     

       1032
       -
       version = "4.0.0"

     

       1033
        
       source = { registry = "https://pypi.org/simple" }

     

       1034
       -
       dependencies = [

     

       1035
       -
           { name = "markdown-it-py", extra = ["linkify", "plugins"] },

     

       1036
       -
           { name = "platformdirs" },

     

       1037
       -
           { name = "rich" },

     

       1038
       -
           { name = "typing-extensions" },

     

       1039
       -
       ]

     

       1040
       -
       sdist = { url = "https://files.pythonhosted.org/packages/f1/22/a2812ab1e5b0cb3a327a4ea79b430234c2271ba13462b989f435b40a247d/textual-4.0.0.tar.gz", hash = "sha256:1cab4ea3cfc0e47ae773405cdd6bc2a17ed76ff7b648379ac8017ea89c5ad28c", size = 1606128, upload-time = "2025-07-12T09:41:20.812Z" }

     

       1041
        
       wheels = [

     

       1042
       -
           { url = "https://files.pythonhosted.org/packages/d8/e4/ebe27c54d2534cc41d00ea1d78b783763f97abf3e3d6dd41e5536daa52a5/textual-4.0.0-py3-none-any.whl", hash = "sha256:214051640f890676a670aa7d29cd2a37d27cfe6b2cf866e9d5abc3b6c89c5800", size = 692382, upload-time = "2025-07-12T09:41:18.828Z" },

     

       1043
        
       ]

     

       1044
        
       

     

       1045
        
       [[package]]

     
···

       1049
        
           { name = "bleach" },

     

       1050
        
           { name = "email-validator" },

     

       1051
        
           { name = "feedparser" },

     

       1052
       -
           { name = "flask" },

     

       1053
        
           { name = "gitpython" },

     

       1054
        
           { name = "httpx" },

     

       0
        
       
     

       0
        
       
     

       1055
        
           { name = "pendulum" },

     

       1056
        
           { name = "platformdirs" },

     

       1057
        
           { name = "pydantic" },

     

       1058
        
           { name = "pydantic-settings" },

     

       1059
        
           { name = "pyyaml" },

     

       1060
        
           { name = "rich" },

     

       1061
       -
           { name = "textual" },

     

       1062
        
           { name = "typer" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1063
        
       ]

     

       1064
        
       

     

       1065
        
       [package.optional-dependencies]

     
···

       1073
        
           { name = "types-pyyaml" },

     

       1074
        
       ]

     

       1075
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1076
        
       [package.metadata]

     

       1077
        
       requires-dist = [

     

       1078
        
           { name = "black", marker = "extra == 'dev'", specifier = ">=24.0.0" },

     

       1079
        
           { name = "bleach", specifier = ">=6.0.0" },

     

       1080
        
           { name = "email-validator" },

     

       1081
        
           { name = "feedparser", specifier = ">=6.0.11" },

     

       1082
       -
           { name = "flask", specifier = ">=3.1.1" },

     

       1083
        
           { name = "gitpython", specifier = ">=3.1.40" },

     

       1084
        
           { name = "httpx", specifier = ">=0.28.0" },

     

       0
        
       
     

       0
        
       
     

       1085
        
           { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13.0" },

     

       1086
        
           { name = "pendulum", specifier = ">=3.0.0" },

     

       1087
        
           { name = "platformdirs", specifier = ">=4.0.0" },

     
···

       1093
        
           { name = "pyyaml", specifier = ">=6.0.0" },

     

       1094
        
           { name = "rich", specifier = ">=13.0.0" },

     

       1095
        
           { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },

     

       1096
       -
           { name = "textual", specifier = ">=4.0.0" },

     

       1097
        
           { name = "typer", specifier = ">=0.15.0" },

     

       1098
        
           { name = "types-pyyaml", marker = "extra == 'dev'", specifier = ">=6.0.0" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1099
        
       ]

     

       1100
        
       provides-extras = ["dev"]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1101
        
       

     

       1102
        
       [[package]]

     

       1103
        
       name = "tomli"

     
···

       1164
        
       ]

     

       1165
        
       

     

       1166
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1167
        
       name = "typing-extensions"

     

       1168
        
       version = "4.14.1"

     

       1169
        
       source = { registry = "https://pypi.org/simple" }

     
···

       1194
        
       ]

     

       1195
        
       

     

       1196
        
       [[package]]

     

       1197
       -
       name = "uc-micro-py"

     

       1198
       -
       version = "1.0.3"

     

       1199
        
       source = { registry = "https://pypi.org/simple" }

     

       1200
       -
       sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" }

     

       1201
        
       wheels = [

     

       1202
       -
           { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" },

     

       1203
        
       ]

     

       1204
        
       

     

       1205
        
       [[package]]

     
···

       1212
        
       ]

     

       1213
        
       

     

       1214
        
       [[package]]

     

       1215
       -
       name = "werkzeug"

     

       1216
       -
       version = "3.1.3"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1217
        
       source = { registry = "https://pypi.org/simple" }

     

       1218
        
       dependencies = [

     

       1219
       -
           { name = "markupsafe" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1220
        
       ]

     

       1221
       -
       sdist = { url = "https://files.pythonhosted.org/packages/9f/69/83029f1f6300c5fb2471d621ab06f6ec6b3324685a2ce0f9777fd4a8b71e/werkzeug-3.1.3.tar.gz", hash = "sha256:60723ce945c19328679790e3282cc758aa4a6040e4bb330f53d30fa546d44746", size = 806925, upload-time = "2024-11-08T15:52:18.093Z" }

     

       1222
        
       wheels = [

     

       1223
       -
           { url = "https://files.pythonhosted.org/packages/52/24/ab44c871b0f07f491e5d2ad12c9bd7358e527510618cb1b803a88e986db1/werkzeug-3.1.3-py3-none-any.whl", hash = "sha256:54b78bf3716d19a65be4fceccc0d1d7b89e608834989dfae50ea87564639213e", size = 224498, upload-time = "2024-11-08T15:52:16.132Z" },

     

       1224
        
       ]

     

       1225
        
       

     

       1226
        
       [[package]]

     

       1227
       -
       name = "zipp"

     

       1228
       -
       version = "3.23.0"

     

       1229
        
       source = { registry = "https://pypi.org/simple" }

     

       1230
       -
       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" }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1231
        
       wheels = [

     

       1232
       -
           { 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" },

     

       1233
        
       ]

···

       1
        
       version = 1

     

       2
       +
       revision = 3

     

       3
        
       requires-python = ">=3.9"

     

       4
        
       resolution-markers = [

     

       5
        
           "python_full_version >= '3.10'",

     
···

       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
        
       wheels = [

     

       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
       +
       ]

     

       32
       +
       

     

       33
       +
       [[package]]

     

       34
       +
       name = "beautifulsoup4"

     

       35
       +
       version = "4.13.4"

     

       36
       +
       source = { registry = "https://pypi.org/simple" }

     

       37
       +
       dependencies = [

     

       38
       +
           { name = "soupsieve" },

     

       39
       +
           { name = "typing-extensions" },

     

       40
       +
       ]

     

       41
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d8/e4/0c4c39e18fd76d6a628d4dd8da40543d136ce2d1752bd6eeeab0791f4d6b/beautifulsoup4-4.13.4.tar.gz", hash = "sha256:dbb3c4e1ceae6aefebdaf2423247260cd062430a410e38c66f2baa50a8437195", size = 621067, upload-time = "2025-04-15T17:05:13.836Z" }

     

       42
       +
       wheels = [

     

       43
       +
           { url = "https://files.pythonhosted.org/packages/50/cd/30110dc0ffcf3b131156077b90e9f60ed75711223f306da4db08eff8403b/beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b", size = 187285, upload-time = "2025-04-15T17:05:12.221Z" },

     

       44
        
       ]

     

       45
        
       

     

       46
        
       [[package]]

     
···

       95
        
       ]

     

       96
        
       

     

       97
        
       [[package]]

     

       98
       +
       name = "certifi"

     

       99
       +
       version = "2025.7.14"

     

       100
        
       source = { registry = "https://pypi.org/simple" }

     

       101
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b3/76/52c535bcebe74590f296d6c77c86dabf761c41980e1347a2422e4aa2ae41/certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995", size = 163981, upload-time = "2025-07-14T03:29:28.449Z" }

     

       102
        
       wheels = [

     

       103
       +
           { url = "https://files.pythonhosted.org/packages/4f/52/34c6cf5bb9285074dc3531c437b3919e825d976fde097a7a73f79e726d03/certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2", size = 162722, upload-time = "2025-07-14T03:29:26.863Z" },

     

       104
        
       ]

     

       105
        
       

     

       106
        
       [[package]]

     

       107
       +
       name = "charset-normalizer"

     

       108
       +
       version = "3.4.3"

     

       109
        
       source = { registry = "https://pypi.org/simple" }

     

       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
        
       wheels = [

     

       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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
       +
           { 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
        
       ]

     

       180
        
       

     

       181
        
       [[package]]

     
···

       297
        
       ]

     

       298
        
       

     

       299
        
       [[package]]

     

       300
       +
       name = "distro"

     

       301
       +
       version = "1.9.0"

     

       302
       +
       source = { registry = "https://pypi.org/simple" }

     

       303
       +
       sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }

     

       304
       +
       wheels = [

     

       305
       +
           { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },

     

       306
       +
       ]

     

       307
       +
       

     

       308
       +
       [[package]]

     

       309
        
       name = "dnspython"

     

       310
        
       version = "2.7.0"

     

       311
        
       source = { registry = "https://pypi.org/simple" }

     
···

       352
        
       ]

     

       353
        
       

     

       354
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       355
        
       name = "gitdb"

     

       356
        
       version = "4.0.12"

     

       357
        
       source = { registry = "https://pypi.org/simple" }

     
···

       385
        
       ]

     

       386
        
       

     

       387
        
       [[package]]

     

       388
       +
       name = "html2text"

     

       389
       +
       version = "2025.4.15"

     

       390
       +
       source = { registry = "https://pypi.org/simple" }

     

       391
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f8/27/e158d86ba1e82967cc2f790b0cb02030d4a8bef58e0c79a8590e9678107f/html2text-2025.4.15.tar.gz", hash = "sha256:948a645f8f0bc3abe7fd587019a2197a12436cd73d0d4908af95bfc8da337588", size = 64316, upload-time = "2025-04-15T04:02:30.045Z" }

     

       392
       +
       wheels = [

     

       393
       +
           { url = "https://files.pythonhosted.org/packages/1d/84/1a0f9555fd5f2b1c924ff932d99b40a0f8a6b12f6dd625e2a47f415b00ea/html2text-2025.4.15-py3-none-any.whl", hash = "sha256:00569167ffdab3d7767a4cdf589b7f57e777a5ed28d12907d8c58769ec734acc", size = 34656, upload-time = "2025-04-15T04:02:28.44Z" },

     

       394
       +
       ]

     

       395
       +
       

     

       396
       +
       [[package]]

     

       397
        
       name = "httpcore"

     

       398
        
       version = "1.0.9"

     

       399
        
       source = { registry = "https://pypi.org/simple" }

     
···

       435
        
       version = "8.7.0"

     

       436
        
       source = { registry = "https://pypi.org/simple" }

     

       437
        
       dependencies = [

     

       438
       +
           { name = "zipp" },

     

       439
        
       ]

     

       440
        
       sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }

     

       441
        
       wheels = [

     
···

       452
        
       ]

     

       453
        
       

     

       454
        
       [[package]]

     

       455
       +
       name = "lxml"

     

       456
       +
       version = "6.0.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       457
        
       source = { registry = "https://pypi.org/simple" }

     

       458
       +
       sdist = { url = "https://files.pythonhosted.org/packages/c5/ed/60eb6fa2923602fba988d9ca7c5cdbd7cf25faa795162ed538b527a35411/lxml-6.0.0.tar.gz", hash = "sha256:032e65120339d44cdc3efc326c9f660f5f7205f3a535c1fdbf898b29ea01fb72", size = 4096938, upload-time = "2025-06-26T16:28:19.373Z" }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       459
        
       wheels = [

     

       460
       +
           { url = "https://files.pythonhosted.org/packages/4b/e9/9c3ca02fbbb7585116c2e274b354a2d92b5c70561687dd733ec7b2018490/lxml-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:35bc626eec405f745199200ccb5c6b36f202675d204aa29bb52e27ba2b71dea8", size = 8399057, upload-time = "2025-06-26T16:25:02.169Z" },

     

       461
       +
           { url = "https://files.pythonhosted.org/packages/86/25/10a6e9001191854bf283515020f3633b1b1f96fd1b39aa30bf8fff7aa666/lxml-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:246b40f8a4aec341cbbf52617cad8ab7c888d944bfe12a6abd2b1f6cfb6f6082", size = 4569676, upload-time = "2025-06-26T16:25:05.431Z" },

     

       462
       +
           { url = "https://files.pythonhosted.org/packages/f5/a5/378033415ff61d9175c81de23e7ad20a3ffb614df4ffc2ffc86bc6746ffd/lxml-6.0.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2793a627e95d119e9f1e19720730472f5543a6d84c50ea33313ce328d870f2dd", size = 5291361, upload-time = "2025-06-26T16:25:07.901Z" },

     

       463
       +
           { url = "https://files.pythonhosted.org/packages/5a/a6/19c87c4f3b9362b08dc5452a3c3bce528130ac9105fc8fff97ce895ce62e/lxml-6.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:46b9ed911f36bfeb6338e0b482e7fe7c27d362c52fde29f221fddbc9ee2227e7", size = 5008290, upload-time = "2025-06-28T18:47:13.196Z" },

     

       464
       +
           { url = "https://files.pythonhosted.org/packages/09/d1/e9b7ad4b4164d359c4d87ed8c49cb69b443225cb495777e75be0478da5d5/lxml-6.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b4790b558bee331a933e08883c423f65bbcd07e278f91b2272489e31ab1e2b4", size = 5163192, upload-time = "2025-06-28T18:47:17.279Z" },

     

       465
       +
           { url = "https://files.pythonhosted.org/packages/56/d6/b3eba234dc1584744b0b374a7f6c26ceee5dc2147369a7e7526e25a72332/lxml-6.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2030956cf4886b10be9a0285c6802e078ec2391e1dd7ff3eb509c2c95a69b76", size = 5076973, upload-time = "2025-06-26T16:25:10.936Z" },

     

       466
       +
           { url = "https://files.pythonhosted.org/packages/8e/47/897142dd9385dcc1925acec0c4afe14cc16d310ce02c41fcd9010ac5d15d/lxml-6.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d23854ecf381ab1facc8f353dcd9adeddef3652268ee75297c1164c987c11dc", size = 5297795, upload-time = "2025-06-26T16:25:14.282Z" },

     

       467
       +
           { url = "https://files.pythonhosted.org/packages/fb/db/551ad84515c6f415cea70193a0ff11d70210174dc0563219f4ce711655c6/lxml-6.0.0-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:43fe5af2d590bf4691531b1d9a2495d7aab2090547eaacd224a3afec95706d76", size = 4776547, upload-time = "2025-06-26T16:25:17.123Z" },

     

       468
       +
           { url = "https://files.pythonhosted.org/packages/e0/14/c4a77ab4f89aaf35037a03c472f1ccc54147191888626079bd05babd6808/lxml-6.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74e748012f8c19b47f7d6321ac929a9a94ee92ef12bc4298c47e8b7219b26541", size = 5124904, upload-time = "2025-06-26T16:25:19.485Z" },

     

       469
       +
           { url = "https://files.pythonhosted.org/packages/70/b4/12ae6a51b8da106adec6a2e9c60f532350a24ce954622367f39269e509b1/lxml-6.0.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:43cfbb7db02b30ad3926e8fceaef260ba2fb7df787e38fa2df890c1ca7966c3b", size = 4805804, upload-time = "2025-06-26T16:25:21.949Z" },

     

       470
       +
           { url = "https://files.pythonhosted.org/packages/a9/b6/2e82d34d49f6219cdcb6e3e03837ca5fb8b7f86c2f35106fb8610ac7f5b8/lxml-6.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34190a1ec4f1e84af256495436b2d196529c3f2094f0af80202947567fdbf2e7", size = 5323477, upload-time = "2025-06-26T16:25:24.475Z" },

     

       471
       +
           { url = "https://files.pythonhosted.org/packages/a1/e6/b83ddc903b05cd08a5723fefd528eee84b0edd07bdf87f6c53a1fda841fd/lxml-6.0.0-cp310-cp310-win32.whl", hash = "sha256:5967fe415b1920a3877a4195e9a2b779249630ee49ece22021c690320ff07452", size = 3613840, upload-time = "2025-06-26T16:25:27.345Z" },

     

       472
       +
           { url = "https://files.pythonhosted.org/packages/40/af/874fb368dd0c663c030acb92612341005e52e281a102b72a4c96f42942e1/lxml-6.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:f3389924581d9a770c6caa4df4e74b606180869043b9073e2cec324bad6e306e", size = 3993584, upload-time = "2025-06-26T16:25:29.391Z" },

     

       473
       +
           { url = "https://files.pythonhosted.org/packages/4a/f4/d296bc22c17d5607653008f6dd7b46afdfda12efd31021705b507df652bb/lxml-6.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:522fe7abb41309e9543b0d9b8b434f2b630c5fdaf6482bee642b34c8c70079c8", size = 3681400, upload-time = "2025-06-26T16:25:31.421Z" },

     

       474
       +
           { url = "https://files.pythonhosted.org/packages/7c/23/828d4cc7da96c611ec0ce6147bbcea2fdbde023dc995a165afa512399bbf/lxml-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4ee56288d0df919e4aac43b539dd0e34bb55d6a12a6562038e8d6f3ed07f9e36", size = 8438217, upload-time = "2025-06-26T16:25:34.349Z" },

     

       475
       +
           { url = "https://files.pythonhosted.org/packages/f1/33/5ac521212c5bcb097d573145d54b2b4a3c9766cda88af5a0e91f66037c6e/lxml-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b8dd6dd0e9c1992613ccda2bcb74fc9d49159dbe0f0ca4753f37527749885c25", size = 4590317, upload-time = "2025-06-26T16:25:38.103Z" },

     

       476
       +
           { url = "https://files.pythonhosted.org/packages/2b/2e/45b7ca8bee304c07f54933c37afe7dd4d39ff61ba2757f519dcc71bc5d44/lxml-6.0.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:d7ae472f74afcc47320238b5dbfd363aba111a525943c8a34a1b657c6be934c3", size = 5221628, upload-time = "2025-06-26T16:25:40.878Z" },

     

       477
       +
           { url = "https://files.pythonhosted.org/packages/32/23/526d19f7eb2b85da1f62cffb2556f647b049ebe2a5aa8d4d41b1fb2c7d36/lxml-6.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5592401cdf3dc682194727c1ddaa8aa0f3ddc57ca64fd03226a430b955eab6f6", size = 4949429, upload-time = "2025-06-28T18:47:20.046Z" },

     

       478
       +
           { url = "https://files.pythonhosted.org/packages/ac/cc/f6be27a5c656a43a5344e064d9ae004d4dcb1d3c9d4f323c8189ddfe4d13/lxml-6.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58ffd35bd5425c3c3b9692d078bf7ab851441434531a7e517c4984d5634cd65b", size = 5087909, upload-time = "2025-06-28T18:47:22.834Z" },

     

       479
       +
           { url = "https://files.pythonhosted.org/packages/3b/e6/8ec91b5bfbe6972458bc105aeb42088e50e4b23777170404aab5dfb0c62d/lxml-6.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f720a14aa102a38907c6d5030e3d66b3b680c3e6f6bc95473931ea3c00c59967", size = 5031713, upload-time = "2025-06-26T16:25:43.226Z" },

     

       480
       +
           { url = "https://files.pythonhosted.org/packages/33/cf/05e78e613840a40e5be3e40d892c48ad3e475804db23d4bad751b8cadb9b/lxml-6.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c2a5e8d207311a0170aca0eb6b160af91adc29ec121832e4ac151a57743a1e1e", size = 5232417, upload-time = "2025-06-26T16:25:46.111Z" },

     

       481
       +
           { url = "https://files.pythonhosted.org/packages/ac/8c/6b306b3e35c59d5f0b32e3b9b6b3b0739b32c0dc42a295415ba111e76495/lxml-6.0.0-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:2dd1cc3ea7e60bfb31ff32cafe07e24839df573a5e7c2d33304082a5019bcd58", size = 4681443, upload-time = "2025-06-26T16:25:48.837Z" },

     

       482
       +
           { url = "https://files.pythonhosted.org/packages/59/43/0bd96bece5f7eea14b7220476835a60d2b27f8e9ca99c175f37c085cb154/lxml-6.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cfcf84f1defed7e5798ef4f88aa25fcc52d279be731ce904789aa7ccfb7e8d2", size = 5074542, upload-time = "2025-06-26T16:25:51.65Z" },

     

       483
       +
           { url = "https://files.pythonhosted.org/packages/e2/3d/32103036287a8ca012d8518071f8852c68f2b3bfe048cef2a0202eb05910/lxml-6.0.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:a52a4704811e2623b0324a18d41ad4b9fabf43ce5ff99b14e40a520e2190c851", size = 4729471, upload-time = "2025-06-26T16:25:54.571Z" },

     

       484
       +
           { url = "https://files.pythonhosted.org/packages/ca/a8/7be5d17df12d637d81854bd8648cd329f29640a61e9a72a3f77add4a311b/lxml-6.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c16304bba98f48a28ae10e32a8e75c349dd742c45156f297e16eeb1ba9287a1f", size = 5256285, upload-time = "2025-06-26T16:25:56.997Z" },

     

       485
       +
           { url = "https://files.pythonhosted.org/packages/cd/d0/6cb96174c25e0d749932557c8d51d60c6e292c877b46fae616afa23ed31a/lxml-6.0.0-cp311-cp311-win32.whl", hash = "sha256:f8d19565ae3eb956d84da3ef367aa7def14a2735d05bd275cd54c0301f0d0d6c", size = 3612004, upload-time = "2025-06-26T16:25:59.11Z" },

     

       486
       +
           { url = "https://files.pythonhosted.org/packages/ca/77/6ad43b165dfc6dead001410adeb45e88597b25185f4479b7ca3b16a5808f/lxml-6.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b2d71cdefda9424adff9a3607ba5bbfc60ee972d73c21c7e3c19e71037574816", size = 4003470, upload-time = "2025-06-26T16:26:01.655Z" },

     

       487
       +
           { url = "https://files.pythonhosted.org/packages/a0/bc/4c50ec0eb14f932a18efc34fc86ee936a66c0eb5f2fe065744a2da8a68b2/lxml-6.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:8a2e76efbf8772add72d002d67a4c3d0958638696f541734304c7f28217a9cab", size = 3682477, upload-time = "2025-06-26T16:26:03.808Z" },

     

       488
       +
           { url = "https://files.pythonhosted.org/packages/89/c3/d01d735c298d7e0ddcedf6f028bf556577e5ab4f4da45175ecd909c79378/lxml-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78718d8454a6e928470d511bf8ac93f469283a45c354995f7d19e77292f26108", size = 8429515, upload-time = "2025-06-26T16:26:06.776Z" },

     

       489
       +
           { url = "https://files.pythonhosted.org/packages/06/37/0e3eae3043d366b73da55a86274a590bae76dc45aa004b7042e6f97803b1/lxml-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:84ef591495ffd3f9dcabffd6391db7bb70d7230b5c35ef5148354a134f56f2be", size = 4601387, upload-time = "2025-06-26T16:26:09.511Z" },

     

       490
       +
           { url = "https://files.pythonhosted.org/packages/a3/28/e1a9a881e6d6e29dda13d633885d13acb0058f65e95da67841c8dd02b4a8/lxml-6.0.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2930aa001a3776c3e2601cb8e0a15d21b8270528d89cc308be4843ade546b9ab", size = 5228928, upload-time = "2025-06-26T16:26:12.337Z" },

     

       491
       +
           { url = "https://files.pythonhosted.org/packages/9a/55/2cb24ea48aa30c99f805921c1c7860c1f45c0e811e44ee4e6a155668de06/lxml-6.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:219e0431ea8006e15005767f0351e3f7f9143e793e58519dc97fe9e07fae5563", size = 4952289, upload-time = "2025-06-28T18:47:25.602Z" },

     

       492
       +
           { url = "https://files.pythonhosted.org/packages/31/c0/b25d9528df296b9a3306ba21ff982fc5b698c45ab78b94d18c2d6ae71fd9/lxml-6.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bd5913b4972681ffc9718bc2d4c53cde39ef81415e1671ff93e9aa30b46595e7", size = 5111310, upload-time = "2025-06-28T18:47:28.136Z" },

     

       493
       +
           { url = "https://files.pythonhosted.org/packages/e9/af/681a8b3e4f668bea6e6514cbcb297beb6de2b641e70f09d3d78655f4f44c/lxml-6.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:390240baeb9f415a82eefc2e13285016f9c8b5ad71ec80574ae8fa9605093cd7", size = 5025457, upload-time = "2025-06-26T16:26:15.068Z" },

     

       494
       +
           { url = "https://files.pythonhosted.org/packages/99/b6/3a7971aa05b7be7dfebc7ab57262ec527775c2c3c5b2f43675cac0458cad/lxml-6.0.0-cp312-cp312-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d6e200909a119626744dd81bae409fc44134389e03fbf1d68ed2a55a2fb10991", size = 5657016, upload-time = "2025-07-03T19:19:06.008Z" },

     

       495
       +
           { url = "https://files.pythonhosted.org/packages/69/f8/693b1a10a891197143c0673fcce5b75fc69132afa81a36e4568c12c8faba/lxml-6.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca50bd612438258a91b5b3788c6621c1f05c8c478e7951899f492be42defc0da", size = 5257565, upload-time = "2025-06-26T16:26:17.906Z" },

     

       496
       +
           { url = "https://files.pythonhosted.org/packages/a8/96/e08ff98f2c6426c98c8964513c5dab8d6eb81dadcd0af6f0c538ada78d33/lxml-6.0.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:c24b8efd9c0f62bad0439283c2c795ef916c5a6b75f03c17799775c7ae3c0c9e", size = 4713390, upload-time = "2025-06-26T16:26:20.292Z" },

     

       497
       +
           { url = "https://files.pythonhosted.org/packages/a8/83/6184aba6cc94d7413959f6f8f54807dc318fdcd4985c347fe3ea6937f772/lxml-6.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afd27d8629ae94c5d863e32ab0e1d5590371d296b87dae0a751fb22bf3685741", size = 5066103, upload-time = "2025-06-26T16:26:22.765Z" },

     

       498
       +
           { url = "https://files.pythonhosted.org/packages/ee/01/8bf1f4035852d0ff2e36a4d9aacdbcc57e93a6cd35a54e05fa984cdf73ab/lxml-6.0.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:54c4855eabd9fc29707d30141be99e5cd1102e7d2258d2892314cf4c110726c3", size = 4791428, upload-time = "2025-06-26T16:26:26.461Z" },

     

       499
       +
           { url = "https://files.pythonhosted.org/packages/29/31/c0267d03b16954a85ed6b065116b621d37f559553d9339c7dcc4943a76f1/lxml-6.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c907516d49f77f6cd8ead1322198bdfd902003c3c330c77a1c5f3cc32a0e4d16", size = 5678523, upload-time = "2025-07-03T19:19:09.837Z" },

     

       500
       +
           { url = "https://files.pythonhosted.org/packages/5c/f7/5495829a864bc5f8b0798d2b52a807c89966523140f3d6fa3a58ab6720ea/lxml-6.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36531f81c8214e293097cd2b7873f178997dae33d3667caaae8bdfb9666b76c0", size = 5281290, upload-time = "2025-06-26T16:26:29.406Z" },

     

       501
       +
           { url = "https://files.pythonhosted.org/packages/79/56/6b8edb79d9ed294ccc4e881f4db1023af56ba451909b9ce79f2a2cd7c532/lxml-6.0.0-cp312-cp312-win32.whl", hash = "sha256:690b20e3388a7ec98e899fd54c924e50ba6693874aa65ef9cb53de7f7de9d64a", size = 3613495, upload-time = "2025-06-26T16:26:31.588Z" },

     

       502
       +
           { url = "https://files.pythonhosted.org/packages/0b/1e/cc32034b40ad6af80b6fd9b66301fc0f180f300002e5c3eb5a6110a93317/lxml-6.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:310b719b695b3dd442cdfbbe64936b2f2e231bb91d998e99e6f0daf991a3eba3", size = 4014711, upload-time = "2025-06-26T16:26:33.723Z" },

     

       503
       +
           { url = "https://files.pythonhosted.org/packages/55/10/dc8e5290ae4c94bdc1a4c55865be7e1f31dfd857a88b21cbba68b5fea61b/lxml-6.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:8cb26f51c82d77483cdcd2b4a53cda55bbee29b3c2f3ddeb47182a2a9064e4eb", size = 3674431, upload-time = "2025-06-26T16:26:35.959Z" },

     

       504
       +
           { url = "https://files.pythonhosted.org/packages/79/21/6e7c060822a3c954ff085e5e1b94b4a25757c06529eac91e550f3f5cd8b8/lxml-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6da7cd4f405fd7db56e51e96bff0865b9853ae70df0e6720624049da76bde2da", size = 8414372, upload-time = "2025-06-26T16:26:39.079Z" },

     

       505
       +
           { url = "https://files.pythonhosted.org/packages/a4/f6/051b1607a459db670fc3a244fa4f06f101a8adf86cda263d1a56b3a4f9d5/lxml-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b34339898bb556a2351a1830f88f751679f343eabf9cf05841c95b165152c9e7", size = 4593940, upload-time = "2025-06-26T16:26:41.891Z" },

     

       506
       +
           { url = "https://files.pythonhosted.org/packages/8e/74/dd595d92a40bda3c687d70d4487b2c7eff93fd63b568acd64fedd2ba00fe/lxml-6.0.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:51a5e4c61a4541bd1cd3ba74766d0c9b6c12d6a1a4964ef60026832aac8e79b3", size = 5214329, upload-time = "2025-06-26T16:26:44.669Z" },

     

       507
       +
           { url = "https://files.pythonhosted.org/packages/52/46/3572761efc1bd45fcafb44a63b3b0feeb5b3f0066886821e94b0254f9253/lxml-6.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d18a25b19ca7307045581b18b3ec9ead2b1db5ccd8719c291f0cd0a5cec6cb81", size = 4947559, upload-time = "2025-06-28T18:47:31.091Z" },

     

       508
       +
           { url = "https://files.pythonhosted.org/packages/94/8a/5e40de920e67c4f2eef9151097deb9b52d86c95762d8ee238134aff2125d/lxml-6.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d4f0c66df4386b75d2ab1e20a489f30dc7fd9a06a896d64980541506086be1f1", size = 5102143, upload-time = "2025-06-28T18:47:33.612Z" },

     

       509
       +
           { url = "https://files.pythonhosted.org/packages/7c/4b/20555bdd75d57945bdabfbc45fdb1a36a1a0ff9eae4653e951b2b79c9209/lxml-6.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f4b481b6cc3a897adb4279216695150bbe7a44c03daba3c894f49d2037e0a24", size = 5021931, upload-time = "2025-06-26T16:26:47.503Z" },

     

       510
       +
           { url = "https://files.pythonhosted.org/packages/b6/6e/cf03b412f3763d4ca23b25e70c96a74cfece64cec3addf1c4ec639586b13/lxml-6.0.0-cp313-cp313-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a78d6c9168f5bcb20971bf3329c2b83078611fbe1f807baadc64afc70523b3a", size = 5645469, upload-time = "2025-07-03T19:19:13.32Z" },

     

       511
       +
           { url = "https://files.pythonhosted.org/packages/d4/dd/39c8507c16db6031f8c1ddf70ed95dbb0a6d466a40002a3522c128aba472/lxml-6.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae06fbab4f1bb7db4f7c8ca9897dc8db4447d1a2b9bee78474ad403437bcc29", size = 5247467, upload-time = "2025-06-26T16:26:49.998Z" },

     

       512
       +
           { url = "https://files.pythonhosted.org/packages/4d/56/732d49def0631ad633844cfb2664563c830173a98d5efd9b172e89a4800d/lxml-6.0.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:1fa377b827ca2023244a06554c6e7dc6828a10aaf74ca41965c5d8a4925aebb4", size = 4720601, upload-time = "2025-06-26T16:26:52.564Z" },

     

       513
       +
           { url = "https://files.pythonhosted.org/packages/8f/7f/6b956fab95fa73462bca25d1ea7fc8274ddf68fb8e60b78d56c03b65278e/lxml-6.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1676b56d48048a62ef77a250428d1f31f610763636e0784ba67a9740823988ca", size = 5060227, upload-time = "2025-06-26T16:26:55.054Z" },

     

       514
       +
           { url = "https://files.pythonhosted.org/packages/97/06/e851ac2924447e8b15a294855caf3d543424364a143c001014d22c8ca94c/lxml-6.0.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:0e32698462aacc5c1cf6bdfebc9c781821b7e74c79f13e5ffc8bfe27c42b1abf", size = 4790637, upload-time = "2025-06-26T16:26:57.384Z" },

     

       515
       +
           { url = "https://files.pythonhosted.org/packages/06/d4/fd216f3cd6625022c25b336c7570d11f4a43adbaf0a56106d3d496f727a7/lxml-6.0.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4d6036c3a296707357efb375cfc24bb64cd955b9ec731abf11ebb1e40063949f", size = 5662049, upload-time = "2025-07-03T19:19:16.409Z" },

     

       516
       +
           { url = "https://files.pythonhosted.org/packages/52/03/0e764ce00b95e008d76b99d432f1807f3574fb2945b496a17807a1645dbd/lxml-6.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7488a43033c958637b1a08cddc9188eb06d3ad36582cebc7d4815980b47e27ef", size = 5272430, upload-time = "2025-06-26T16:27:00.031Z" },

     

       517
       +
           { url = "https://files.pythonhosted.org/packages/5f/01/d48cc141bc47bc1644d20fe97bbd5e8afb30415ec94f146f2f76d0d9d098/lxml-6.0.0-cp313-cp313-win32.whl", hash = "sha256:5fcd7d3b1d8ecb91445bd71b9c88bdbeae528fefee4f379895becfc72298d181", size = 3612896, upload-time = "2025-06-26T16:27:04.251Z" },

     

       518
       +
           { url = "https://files.pythonhosted.org/packages/f4/87/6456b9541d186ee7d4cb53bf1b9a0d7f3b1068532676940fdd594ac90865/lxml-6.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:2f34687222b78fff795feeb799a7d44eca2477c3d9d3a46ce17d51a4f383e32e", size = 4013132, upload-time = "2025-06-26T16:27:06.415Z" },

     

       519
       +
           { url = "https://files.pythonhosted.org/packages/b7/42/85b3aa8f06ca0d24962f8100f001828e1f1f1a38c954c16e71154ed7d53a/lxml-6.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:21db1ec5525780fd07251636eb5f7acb84003e9382c72c18c542a87c416ade03", size = 3672642, upload-time = "2025-06-26T16:27:09.888Z" },

     

       520
       +
           { url = "https://files.pythonhosted.org/packages/dc/04/a53941fb0d7c60eed08301942c70aa63650a59308d15e05eb823acbce41d/lxml-6.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:85b14a4689d5cff426c12eefe750738648706ea2753b20c2f973b2a000d3d261", size = 8407699, upload-time = "2025-06-26T16:27:28.167Z" },

     

       521
       +
           { url = "https://files.pythonhosted.org/packages/44/d2/e1d4526e903afebe147f858322f1c0b36e44969d5c87e5d243c23f81987f/lxml-6.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f64ccf593916e93b8d36ed55401bb7fe9c7d5de3180ce2e10b08f82a8f397316", size = 4574678, upload-time = "2025-06-26T16:27:30.888Z" },

     

       522
       +
           { url = "https://files.pythonhosted.org/packages/61/aa/b0a8ee233c00f2f437dbb6e7bd2df115a996d8211b7d03f4ab029b8e3378/lxml-6.0.0-cp39-cp39-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:b372d10d17a701b0945f67be58fae4664fd056b85e0ff0fbc1e6c951cdbc0512", size = 5292694, upload-time = "2025-06-26T16:27:34.037Z" },

     

       523
       +
           { url = "https://files.pythonhosted.org/packages/53/7f/e6f377489b2ac4289418b879c34ed664e5a1174b2a91590936ec4174e773/lxml-6.0.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a674c0948789e9136d69065cc28009c1b1874c6ea340253db58be7622ce6398f", size = 5009177, upload-time = "2025-06-28T18:47:39.377Z" },

     

       524
       +
           { url = "https://files.pythonhosted.org/packages/c6/05/ae239e997374680741b768044545251a29abc21ada42248638dbed749a0a/lxml-6.0.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:edf6e4c8fe14dfe316939711e3ece3f9a20760aabf686051b537a7562f4da91a", size = 5163787, upload-time = "2025-06-28T18:47:42.452Z" },

     

       525
       +
           { url = "https://files.pythonhosted.org/packages/2a/da/4f27222570d008fd2386e19d6923af6e64c317ee6116bbb2b98247f98f31/lxml-6.0.0-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:048a930eb4572829604982e39a0c7289ab5dc8abc7fc9f5aabd6fbc08c154e93", size = 5075755, upload-time = "2025-06-26T16:27:36.611Z" },

     

       526
       +
           { url = "https://files.pythonhosted.org/packages/1f/65/12552caf7b3e3b9b9aba12349370dc53a36d4058e4ed482811f1d262deee/lxml-6.0.0-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0b5fa5eda84057a4f1bbb4bb77a8c28ff20ae7ce211588d698ae453e13c6281", size = 5297070, upload-time = "2025-06-26T16:27:39.232Z" },

     

       527
       +
           { url = "https://files.pythonhosted.org/packages/3e/6a/f053a8369fdf4e3b8127a6ffb079c519167e684e956a1281392c5c3679b6/lxml-6.0.0-cp39-cp39-manylinux_2_31_armv7l.whl", hash = "sha256:c352fc8f36f7e9727db17adbf93f82499457b3d7e5511368569b4c5bd155a922", size = 4779864, upload-time = "2025-06-26T16:27:41.713Z" },

     

       528
       +
           { url = "https://files.pythonhosted.org/packages/df/7b/b2a392ad34ce37a17d1cf3aec303e15125768061cf0e355a92d292d20d37/lxml-6.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8db5dc617cb937ae17ff3403c3a70a7de9df4852a046f93e71edaec678f721d0", size = 5122039, upload-time = "2025-06-26T16:27:44.252Z" },

     

       529
       +
           { url = "https://files.pythonhosted.org/packages/80/0e/6459ff8ae7d87188e1f99f11691d0f32831caa6429599c3b289de9f08b21/lxml-6.0.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:2181e4b1d07dde53986023482673c0f1fba5178ef800f9ab95ad791e8bdded6a", size = 4805117, upload-time = "2025-06-26T16:27:46.769Z" },

     

       530
       +
           { url = "https://files.pythonhosted.org/packages/ca/78/4186f573805ff623d28a8736788a3b29eeaf589afdcf0233de2c9bb9fc50/lxml-6.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b3c98d5b24c6095e89e03d65d5c574705be3d49c0d8ca10c17a8a4b5201b72f5", size = 5322300, upload-time = "2025-06-26T16:27:49.278Z" },

     

       531
       +
           { url = "https://files.pythonhosted.org/packages/e8/97/352e07992901473529c8e19dbfdba6430ba6a37f6b46a4d0fa93321f8fee/lxml-6.0.0-cp39-cp39-win32.whl", hash = "sha256:04d67ceee6db4bcb92987ccb16e53bef6b42ced872509f333c04fb58a3315256", size = 3615832, upload-time = "2025-06-26T16:27:51.728Z" },

     

       532
       +
           { url = "https://files.pythonhosted.org/packages/71/93/8f3b880e2618e548fb0ca157349abb526d81cb4f01ef5ea3a0f22bd4d0df/lxml-6.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:e0b1520ef900e9ef62e392dd3d7ae4f5fa224d1dd62897a792cf353eb20b6cae", size = 4038551, upload-time = "2025-06-26T16:27:54.193Z" },

     

       533
       +
           { url = "https://files.pythonhosted.org/packages/e7/8a/046cbf5b262dd2858c6e65833339100fd5f1c017b37b26bc47c92d4584d7/lxml-6.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:e35e8aaaf3981489f42884b59726693de32dabfc438ac10ef4eb3409961fd402", size = 3684237, upload-time = "2025-06-26T16:27:57.117Z" },

     

       534
       +
           { url = "https://files.pythonhosted.org/packages/66/e1/2c22a3cff9e16e1d717014a1e6ec2bf671bf56ea8716bb64466fcf820247/lxml-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:dbdd7679a6f4f08152818043dbb39491d1af3332128b3752c3ec5cebc0011a72", size = 3898804, upload-time = "2025-06-26T16:27:59.751Z" },

     

       535
       +
           { url = "https://files.pythonhosted.org/packages/2b/3a/d68cbcb4393a2a0a867528741fafb7ce92dac5c9f4a1680df98e5e53e8f5/lxml-6.0.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:40442e2a4456e9910875ac12951476d36c0870dcb38a68719f8c4686609897c4", size = 4216406, upload-time = "2025-06-28T18:47:45.518Z" },

     

       536
       +
           { url = "https://files.pythonhosted.org/packages/15/8f/d9bfb13dff715ee3b2a1ec2f4a021347ea3caf9aba93dea0cfe54c01969b/lxml-6.0.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db0efd6bae1c4730b9c863fc4f5f3c0fa3e8f05cae2c44ae141cb9dfc7d091dc", size = 4326455, upload-time = "2025-06-28T18:47:48.411Z" },

     

       537
       +
           { url = "https://files.pythonhosted.org/packages/01/8b/fde194529ee8a27e6f5966d7eef05fa16f0567e4a8e8abc3b855ef6b3400/lxml-6.0.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ab542c91f5a47aaa58abdd8ea84b498e8e49fe4b883d67800017757a3eb78e8", size = 4268788, upload-time = "2025-06-26T16:28:02.776Z" },

     

       538
       +
           { url = "https://files.pythonhosted.org/packages/99/a8/3b8e2581b4f8370fc9e8dc343af4abdfadd9b9229970fc71e67bd31c7df1/lxml-6.0.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:013090383863b72c62a702d07678b658fa2567aa58d373d963cca245b017e065", size = 4411394, upload-time = "2025-06-26T16:28:05.179Z" },

     

       539
       +
           { url = "https://files.pythonhosted.org/packages/e7/a5/899a4719e02ff4383f3f96e5d1878f882f734377f10dfb69e73b5f223e44/lxml-6.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c86df1c9af35d903d2b52d22ea3e66db8058d21dc0f59842ca5deb0595921141", size = 3517946, upload-time = "2025-06-26T16:28:07.665Z" },

     

       540
       +
           { url = "https://files.pythonhosted.org/packages/93/e3/ef14f1d23aea1dec1eccbe2c07a93b6d0be693fd9d5f248a47155e436701/lxml-6.0.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4337e4aec93b7c011f7ee2e357b0d30562edd1955620fdd4aeab6aacd90d43c5", size = 3892325, upload-time = "2025-06-26T16:28:10.024Z" },

     

       541
       +
           { url = "https://files.pythonhosted.org/packages/09/8a/1410b9e1ec43f606f9aac0661d09892509d86032e229711798906e1b5e7a/lxml-6.0.0-pp39-pypy39_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ae74f7c762270196d2dda56f8dd7309411f08a4084ff2dfcc0b095a218df2e06", size = 4210839, upload-time = "2025-06-28T18:47:50.768Z" },

     

       542
       +
           { url = "https://files.pythonhosted.org/packages/79/cb/6696ce0d1712c5ae94b18bdf225086a5fb04b23938ac4d2011b323b3860b/lxml-6.0.0-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:059c4cbf3973a621b62ea3132934ae737da2c132a788e6cfb9b08d63a0ef73f9", size = 4321235, upload-time = "2025-06-28T18:47:53.338Z" },

     

       543
       +
           { url = "https://files.pythonhosted.org/packages/f3/98/04997f61d720cf320a0daee66b3096e3a3b57453e15549c14b87058c2acd/lxml-6.0.0-pp39-pypy39_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:17f090a9bc0ce8da51a5632092f98a7e7f84bca26f33d161a98b57f7fb0004ca", size = 4265071, upload-time = "2025-06-26T16:28:12.367Z" },

     

       544
       +
           { url = "https://files.pythonhosted.org/packages/e6/86/e5f6fa80154a5f5bf2c1e89d6265892299942edeb115081ca72afe7c7199/lxml-6.0.0-pp39-pypy39_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9da022c14baeec36edfcc8daf0e281e2f55b950249a455776f0d1adeeada4734", size = 4406816, upload-time = "2025-06-26T16:28:14.744Z" },

     

       545
       +
           { url = "https://files.pythonhosted.org/packages/18/a6/ae69e0e6f5fb6293eb8cbfbf8a259e37d71608bbae3658a768dd26b69f3e/lxml-6.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a55da151d0b0c6ab176b4e761670ac0e2667817a1e0dadd04a01d0561a219349", size = 3515499, upload-time = "2025-06-26T16:28:17.035Z" },

     

       546
        
       ]

     

       547
        
       

     

       548
        
       [[package]]

     
···

       557
        
           { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },

     

       558
        
       ]

     

       559
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       560
        
       [[package]]

     

       561
       +
       name = "markdownify"

     

       562
       +
       version = "1.2.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       563
        
       source = { registry = "https://pypi.org/simple" }

     

       564
        
       dependencies = [

     

       565
       +
           { name = "beautifulsoup4" },

     

       566
       +
           { name = "six" },

     

       567
        
       ]

     

       568
       +
       sdist = { url = "https://files.pythonhosted.org/packages/83/1b/6f2697b51eaca81f08852fd2734745af15718fea10222a1d40f8a239c4ea/markdownify-1.2.0.tar.gz", hash = "sha256:f6c367c54eb24ee953921804dfe6d6575c5e5b42c643955e7242034435de634c", size = 18771, upload-time = "2025-08-09T17:44:15.302Z" }

     

       569
        
       wheels = [

     

       570
       +
           { url = "https://files.pythonhosted.org/packages/6a/e2/7af643acb4cae0741dffffaa7f3f7c9e7ab4046724543ba1777c401d821c/markdownify-1.2.0-py3-none-any.whl", hash = "sha256:48e150a1c4993d4d50f282f725c0111bd9eb25645d41fa2f543708fd44161351", size = 15561, upload-time = "2025-08-09T17:44:14.074Z" },

     

       571
        
       ]

     

       572
        
       

     

       573
        
       [[package]]

     
···

       727
        
       ]

     

       728
        
       

     

       729
        
       [[package]]

     

       730
       +
       name = "pip"

     

       731
       +
       version = "25.2"

     

       732
       +
       source = { registry = "https://pypi.org/simple" }

     

       733
       +
       sdist = { url = "https://files.pythonhosted.org/packages/20/16/650289cd3f43d5a2fadfd98c68bd1e1e7f2550a1a5326768cddfbcedb2c5/pip-25.2.tar.gz", hash = "sha256:578283f006390f85bb6282dffb876454593d637f5d1be494b5202ce4877e71f2", size = 1840021, upload-time = "2025-07-30T21:50:15.401Z" }

     

       734
       +
       wheels = [

     

       735
       +
           { url = "https://files.pythonhosted.org/packages/b7/3f/945ef7ab14dc4f9d7f40288d2df998d1837ee0888ec3659c813487572faa/pip-25.2-py3-none-any.whl", hash = "sha256:6d67a2b4e7f14d8b31b8b52648866fa717f45a1eb70e83002f4331d07e953717", size = 1752557, upload-time = "2025-07-30T21:50:13.323Z" },

     

       736
       +
       ]

     

       737
       +
       

     

       738
       +
       [[package]]

     

       739
        
       name = "platformdirs"

     

       740
        
       version = "4.3.8"

     

       741
        
       source = { registry = "https://pypi.org/simple" }

     
···

       1020
        
       ]

     

       1021
        
       

     

       1022
        
       [[package]]

     

       1023
       +
       name = "requests"

     

       1024
       +
       version = "2.32.4"

     

       1025
       +
       source = { registry = "https://pypi.org/simple" }

     

       1026
       +
       dependencies = [

     

       1027
       +
           { name = "certifi" },

     

       1028
       +
           { name = "charset-normalizer" },

     

       1029
       +
           { name = "idna" },

     

       1030
       +
           { name = "urllib3" },

     

       1031
       +
       ]

     

       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
       +
       wheels = [

     

       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
       +
       ]

     

       1036
       +
       

     

       1037
       +
       [[package]]

     

       1038
        
       name = "rich"

     

       1039
        
       version = "14.0.0"

     

       1040
        
       source = { registry = "https://pypi.org/simple" }

     
···

       1116
        
       ]

     

       1117
        
       

     

       1118
        
       [[package]]

     

       1119
       +
       name = "soupsieve"

     

       1120
       +
       version = "2.7"

     

       1121
        
       source = { registry = "https://pypi.org/simple" }

     

       1122
       +
       sdist = { url = "https://files.pythonhosted.org/packages/3f/f4/4a80cd6ef364b2e8b65b15816a843c0980f7a5a2b4dc701fc574952aa19f/soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a", size = 103418, upload-time = "2025-04-20T18:50:08.518Z" }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1123
        
       wheels = [

     

       1124
       +
           { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" },

     

       1125
        
       ]

     

       1126
        
       

     

       1127
        
       [[package]]

     
···

       1131
        
           { name = "bleach" },

     

       1132
        
           { name = "email-validator" },

     

       1133
        
           { name = "feedparser" },

     

       0
        
       
     

       1134
        
           { name = "gitpython" },

     

       1135
        
           { name = "httpx" },

     

       1136
       +
           { name = "importlib-metadata" },

     

       1137
       +
           { name = "markdownify" },

     

       1138
        
           { name = "pendulum" },

     

       1139
        
           { name = "platformdirs" },

     

       1140
        
           { name = "pydantic" },

     

       1141
        
           { name = "pydantic-settings" },

     

       1142
        
           { name = "pyyaml" },

     

       1143
        
           { name = "rich" },

     

       0
        
       
     

       1144
        
           { name = "typer" },

     

       1145
       +
           { name = "typesense" },

     

       1146
       +
           { name = "zulip" },

     

       1147
       +
           { name = "zulip-bots" },

     

       1148
        
       ]

     

       1149
        
       

     

       1150
        
       [package.optional-dependencies]

     
···

       1158
        
           { name = "types-pyyaml" },

     

       1159
        
       ]

     

       1160
        
       

     

       1161
       +
       [package.dev-dependencies]

     

       1162
       +
       dev = [

     

       1163
       +
           { name = "mypy" },

     

       1164
       +
           { name = "pytest" },

     

       1165
       +
       ]

     

       1166
       +
       

     

       1167
        
       [package.metadata]

     

       1168
        
       requires-dist = [

     

       1169
        
           { name = "black", marker = "extra == 'dev'", specifier = ">=24.0.0" },

     

       1170
        
           { name = "bleach", specifier = ">=6.0.0" },

     

       1171
        
           { name = "email-validator" },

     

       1172
        
           { name = "feedparser", specifier = ">=6.0.11" },

     

       0
        
       
     

       1173
        
           { name = "gitpython", specifier = ">=3.1.40" },

     

       1174
        
           { name = "httpx", specifier = ">=0.28.0" },

     

       1175
       +
           { name = "importlib-metadata", specifier = ">=8.7.0" },

     

       1176
       +
           { name = "markdownify", specifier = ">=1.2.0" },

     

       1177
        
           { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13.0" },

     

       1178
        
           { name = "pendulum", specifier = ">=3.0.0" },

     

       1179
        
           { name = "platformdirs", specifier = ">=4.0.0" },

     
···

       1185
        
           { name = "pyyaml", specifier = ">=6.0.0" },

     

       1186
        
           { name = "rich", specifier = ">=13.0.0" },

     

       1187
        
           { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },

     

       0
        
       
     

       1188
        
           { name = "typer", specifier = ">=0.15.0" },

     

       1189
        
           { name = "types-pyyaml", marker = "extra == 'dev'", specifier = ">=6.0.0" },

     

       1190
       +
           { name = "typesense", specifier = ">=1.1.1" },

     

       1191
       +
           { name = "zulip", specifier = ">=0.9.0" },

     

       1192
       +
           { name = "zulip-bots", specifier = ">=0.9.0" },

     

       1193
        
       ]

     

       1194
        
       provides-extras = ["dev"]

     

       1195
       +
       

     

       1196
       +
       [package.metadata.requires-dev]

     

       1197
       +
       dev = [

     

       1198
       +
           { name = "mypy", specifier = ">=1.17.0" },

     

       1199
       +
           { name = "pytest", specifier = ">=8.4.1" },

     

       1200
       +
       ]

     

       1201
        
       

     

       1202
        
       [[package]]

     

       1203
        
       name = "tomli"

     
···

       1264
        
       ]

     

       1265
        
       

     

       1266
        
       [[package]]

     

       1267
       +
       name = "typesense"

     

       1268
       +
       version = "1.1.1"

     

       1269
       +
       source = { registry = "https://pypi.org/simple" }

     

       1270
       +
       dependencies = [

     

       1271
       +
           { name = "requests" },

     

       1272
       +
       ]

     

       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
       +
       wheels = [

     

       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
       +
       ]

     

       1277
       +
       

     

       1278
       +
       [[package]]

     

       1279
        
       name = "typing-extensions"

     

       1280
        
       version = "4.14.1"

     

       1281
        
       source = { registry = "https://pypi.org/simple" }

     
···

       1306
        
       ]

     

       1307
        
       

     

       1308
        
       [[package]]

     

       1309
       +
       name = "urllib3"

     

       1310
       +
       version = "2.5.0"

     

       1311
        
       source = { registry = "https://pypi.org/simple" }

     

       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
        
       wheels = [

     

       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" },

     

       1315
        
       ]

     

       1316
        
       

     

       1317
        
       [[package]]

     
···

       1324
        
       ]

     

       1325
        
       

     

       1326
        
       [[package]]

     

       1327
       +
       name = "zipp"

     

       1328
       +
       version = "3.23.0"

     

       1329
       +
       source = { registry = "https://pypi.org/simple" }

     

       1330
       +
       sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }

     

       1331
       +
       wheels = [

     

       1332
       +
           { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },

     

       1333
       +
       ]

     

       1334
       +
       

     

       1335
       +
       [[package]]

     

       1336
       +
       name = "zulip"

     

       1337
       +
       version = "0.9.0"

     

       1338
        
       source = { registry = "https://pypi.org/simple" }

     

       1339
        
       dependencies = [

     

       1340
       +
           { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },

     

       1341
       +
           { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },

     

       1342
       +
           { name = "distro" },

     

       1343
       +
           { name = "requests" },

     

       1344
       +
           { name = "typing-extensions" },

     

       1345
        
       ]

     

       1346
       +
       sdist = { url = "https://files.pythonhosted.org/packages/7e/85/754c025bf7e5ff2622b89c555ff3e1ecc3dd501874745a7ec2c3b59fc743/zulip-0.9.0.tar.gz", hash = "sha256:7a14149e5d9e3fcc53b13e998719fd1f6ccb8289bc60fccbaa1aafcd0a9d0843", size = 134624, upload-time = "2023-11-15T00:28:39.338Z" }

     

       1347
        
       wheels = [

     

       1348
       +
           { url = "https://files.pythonhosted.org/packages/db/ed/81e42dbfe0dd538f60514d0e4849b872d949a1caa7a2c80bbe6aa4c1bae9/zulip-0.9.0-py3-none-any.whl", hash = "sha256:a315db3e990c6b94aef323540b7f386485e8fc359dbd26af526c20dbe9068217", size = 289297, upload-time = "2023-11-15T00:28:33.172Z" },

     

       1349
        
       ]

     

       1350
        
       

     

       1351
        
       [[package]]

     

       1352
       +
       name = "zulip-bots"

     

       1353
       +
       version = "0.9.0"

     

       1354
        
       source = { registry = "https://pypi.org/simple" }

     

       1355
       +
       dependencies = [

     

       1356
       +
           { name = "beautifulsoup4" },

     

       1357
       +
           { name = "html2text" },

     

       1358
       +
           { name = "importlib-metadata", marker = "python_full_version < '3.10'" },

     

       1359
       +
           { name = "lxml" },

     

       1360
       +
           { name = "pip" },

     

       1361
       +
           { name = "typing-extensions" },

     

       1362
       +
           { name = "zulip" },

     

       1363
       +
       ]

     

       1364
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a5/39/6e60bea336fbfd4ad55dbdbb5fbd6d62dc32b08ad240688f119d145a29b3/zulip_bots-0.9.0.tar.gz", hash = "sha256:94925a4bd7c3558bf0e0cc3e83021d6a2f2139824745081abaa605a3d012e37a", size = 2268775, upload-time = "2023-11-15T00:28:36.507Z" }

     

       1365
        
       wheels = [

     

       1366
       +
           { url = "https://files.pythonhosted.org/packages/e6/c9/c242abc63de86d1a20b02e5d8e507c38d4889b9c01f663a5b80eb050effd/zulip_bots-0.9.0-py3-none-any.whl", hash = "sha256:1c46b011002fdf375f27fbf0c17394149e77ea36b33aa762b58368db14229e37", size = 2317628, upload-time = "2023-11-15T00:28:26.312Z" },

     

       1367
        
       ]

Compare changes